diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/AnnotatingElementComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/AnnotatingElementComparer.cs
new file mode 100644
index 000000000..eab4d38d8
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/AnnotatingElementComparer.cs
@@ -0,0 +1,124 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AnnotatingElementComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Root.Annotations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAnnotatingElement"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAnnotatingElement"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AnnotatingElementComparer : IEqualityComparer<IAnnotatingElement>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAnnotatingElement"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAnnotatingElement"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAnnotatingElement"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAnnotatingElement"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAnnotatingElement x, IAnnotatingElement y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAnnotatingElement"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAnnotatingElement"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAnnotatingElement obj)
+        {
+            return HashCode.Combine(typeof(IAnnotatingElement), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/AssociationComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/AssociationComparer.cs
new file mode 100644
index 000000000..21a8b5bdf
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/AssociationComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AssociationComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Kernel.Associations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAssociation"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAssociation"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AssociationComparer : IEqualityComparer<IAssociation>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAssociation"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAssociation"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAssociation"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAssociation"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAssociation x, IAssociation y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAssociation"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAssociation"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAssociation obj)
+        {
+            return HashCode.Combine(typeof(IAssociation), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/DependencyComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/DependencyComparer.cs
new file mode 100644
index 000000000..5964eb41b
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/DependencyComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DependencyComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Root.Dependencies;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IDependency"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IDependency"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class DependencyComparer : IEqualityComparer<IDependency>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IDependency"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IDependency"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IDependency"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IDependency"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IDependency x, IDependency y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.Client, y.Client)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.Supplier, y.Supplier)) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IDependency"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IDependency"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IDependency obj)
+        {
+            return HashCode.Combine(typeof(IDependency), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/EnumerationDefinitionComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/EnumerationDefinitionComparer.cs
new file mode 100644
index 000000000..6df61fd39
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/EnumerationDefinitionComparer.cs
@@ -0,0 +1,130 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="EnumerationDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Enumerations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IEnumerationDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IEnumerationDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class EnumerationDefinitionComparer : IEqualityComparer<IEnumerationDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IEnumerationDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IEnumerationDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IEnumerationDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IEnumerationDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IEnumerationDefinition x, IEnumerationDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IEnumerationDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IEnumerationDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IEnumerationDefinition obj)
+        {
+            return HashCode.Combine(typeof(IEnumerationDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/FeatureComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/FeatureComparer.cs
new file mode 100644
index 000000000..9e147f764
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/FeatureComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Core.Features;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFeature"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFeature"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FeatureComparer : IEqualityComparer<IFeature>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFeature"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFeature"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFeature"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFeature"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFeature x, IFeature y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFeature"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFeature"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFeature obj)
+        {
+            return HashCode.Combine(typeof(IFeature), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/FeatureTypingComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/FeatureTypingComparer.cs
new file mode 100644
index 000000000..1ababd5e4
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/FeatureTypingComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureTypingComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Features;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFeatureTyping"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFeatureTyping"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FeatureTypingComparer : IEqualityComparer<IFeatureTyping>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFeatureTyping"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFeatureTyping"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFeatureTyping"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFeatureTyping"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFeatureTyping x, IFeatureTyping y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Type != y.Type) return false;
+
+            if (x.TypedFeature != y.TypedFeature) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFeatureTyping"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFeatureTyping"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFeatureTyping obj)
+        {
+            return HashCode.Combine(typeof(IFeatureTyping), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/FlowComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/FlowComparer.cs
new file mode 100644
index 000000000..273559e59
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/FlowComparer.cs
@@ -0,0 +1,153 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FlowComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Interactions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFlow"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFlow"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FlowComparer : IEqualityComparer<IFlow>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFlow"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFlow"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFlow"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFlow"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFlow x, IFlow y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFlow"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFlow"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFlow obj)
+        {
+            return HashCode.Combine(typeof(IFlow), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/FramedConcernMembershipComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/FramedConcernMembershipComparer.cs
new file mode 100644
index 000000000..17d8d9a1d
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/FramedConcernMembershipComparer.cs
@@ -0,0 +1,136 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FramedConcernMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.Systems.Requirements;
+    using SysML2.NET.Core.DTO.Systems.Requirements;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFramedConcernMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFramedConcernMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FramedConcernMembershipComparer : IEqualityComparer<IFramedConcernMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFramedConcernMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFramedConcernMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFramedConcernMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFramedConcernMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFramedConcernMembership x, IFramedConcernMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.Kind != y.Kind) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFramedConcernMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFramedConcernMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFramedConcernMembership obj)
+        {
+            return HashCode.Combine(typeof(IFramedConcernMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/LiteralIntegerComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/LiteralIntegerComparer.cs
new file mode 100644
index 000000000..3aca24a47
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/LiteralIntegerComparer.cs
@@ -0,0 +1,149 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LiteralIntegerComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ILiteralInteger"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ILiteralInteger"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class LiteralIntegerComparer : IEqualityComparer<ILiteralInteger>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ILiteralInteger"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ILiteralInteger"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ILiteralInteger"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ILiteralInteger"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ILiteralInteger x, ILiteralInteger y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Value != y.Value) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ILiteralInteger"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ILiteralInteger"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ILiteralInteger obj)
+        {
+            return HashCode.Combine(typeof(ILiteralInteger), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/LiteralRationalComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/LiteralRationalComparer.cs
new file mode 100644
index 000000000..03e258c17
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/LiteralRationalComparer.cs
@@ -0,0 +1,149 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LiteralRationalComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ILiteralRational"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ILiteralRational"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class LiteralRationalComparer : IEqualityComparer<ILiteralRational>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ILiteralRational"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ILiteralRational"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ILiteralRational"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ILiteralRational"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ILiteralRational x, ILiteralRational y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (FloatingPointComparer.NearlyEqual(x.Value, y.Value, FloatingPointComparer.DefaultDoubleEpsilon)) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ILiteralRational"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ILiteralRational"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ILiteralRational obj)
+        {
+            return HashCode.Combine(typeof(ILiteralRational), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/MembershipComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/MembershipComparer.cs
new file mode 100644
index 000000000..404836a4f
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/MembershipComparer.cs
@@ -0,0 +1,139 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Root.Namespaces;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class MembershipComparer : IEqualityComparer<IMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IMembership x, IMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.MemberElement != y.MemberElement) return false;
+
+            if (!OrdinalStringComparer.Equals(x.MemberName, y.MemberName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.MemberShortName, y.MemberShortName)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IMembership obj)
+        {
+            return HashCode.Combine(typeof(IMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/MultiplicityRangeComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/MultiplicityRangeComparer.cs
new file mode 100644
index 000000000..d5acd64ea
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/MultiplicityRangeComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MultiplicityRangeComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Multiplicities;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IMultiplicityRange"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IMultiplicityRange"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class MultiplicityRangeComparer : IEqualityComparer<IMultiplicityRange>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IMultiplicityRange"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IMultiplicityRange"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IMultiplicityRange"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IMultiplicityRange"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IMultiplicityRange x, IMultiplicityRange y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IMultiplicityRange"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IMultiplicityRange"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IMultiplicityRange obj)
+        {
+            return HashCode.Combine(typeof(IMultiplicityRange), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/OwningMembershipComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/OwningMembershipComparer.cs
new file mode 100644
index 000000000..b17495240
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/OwningMembershipComparer.cs
@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="OwningMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Root.Namespaces;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IOwningMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IOwningMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class OwningMembershipComparer : IEqualityComparer<IOwningMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IOwningMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IOwningMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IOwningMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IOwningMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IOwningMembership x, IOwningMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IOwningMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IOwningMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IOwningMembership obj)
+        {
+            return HashCode.Combine(typeof(IOwningMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/ReferenceSubsettingComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/ReferenceSubsettingComparer.cs
new file mode 100644
index 000000000..f7249b328
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/ReferenceSubsettingComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ReferenceSubsettingComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Features;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IReferenceSubsetting"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IReferenceSubsetting"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ReferenceSubsettingComparer : IEqualityComparer<IReferenceSubsetting>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IReferenceSubsetting"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IReferenceSubsetting"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IReferenceSubsetting"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IReferenceSubsetting"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IReferenceSubsetting x, IReferenceSubsetting y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.ReferencedFeature != y.ReferencedFeature) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IReferenceSubsetting"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IReferenceSubsetting"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IReferenceSubsetting obj)
+        {
+            return HashCode.Combine(typeof(IReferenceSubsetting), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/RequirementUsageComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/RequirementUsageComparer.cs
new file mode 100644
index 000000000..a62c7cc1f
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/RequirementUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RequirementUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Requirements;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IRequirementUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IRequirementUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class RequirementUsageComparer : IEqualityComparer<IRequirementUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IRequirementUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IRequirementUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IRequirementUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IRequirementUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IRequirementUsage x, IRequirementUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ReqId, y.ReqId)) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IRequirementUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IRequirementUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IRequirementUsage obj)
+        {
+            return HashCode.Combine(typeof(IRequirementUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/SelectExpressionComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/SelectExpressionComparer.cs
new file mode 100644
index 000000000..06113c5d2
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/SelectExpressionComparer.cs
@@ -0,0 +1,149 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SelectExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ISelectExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ISelectExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class SelectExpressionComparer : IEqualityComparer<ISelectExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ISelectExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ISelectExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ISelectExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ISelectExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ISelectExpression x, ISelectExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Operator, y.Operator)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ISelectExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ISelectExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ISelectExpression obj)
+        {
+            return HashCode.Combine(typeof(ISelectExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/SubclassificationComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/SubclassificationComparer.cs
new file mode 100644
index 000000000..f4e341b15
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/SubclassificationComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SubclassificationComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Classifiers;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ISubclassification"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ISubclassification"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class SubclassificationComparer : IEqualityComparer<ISubclassification>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ISubclassification"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ISubclassification"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ISubclassification"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ISubclassification"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ISubclassification x, ISubclassification y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Subclassifier != y.Subclassifier) return false;
+
+            if (x.Superclassifier != y.Superclassifier) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ISubclassification"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ISubclassification"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ISubclassification obj)
+        {
+            return HashCode.Combine(typeof(ISubclassification), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/TextualRepresentationComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/TextualRepresentationComparer.cs
new file mode 100644
index 000000000..1f256011b
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/TextualRepresentationComparer.cs
@@ -0,0 +1,128 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TextualRepresentationComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Root.Annotations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ITextualRepresentation"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ITextualRepresentation"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class TextualRepresentationComparer : IEqualityComparer<ITextualRepresentation>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ITextualRepresentation"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ITextualRepresentation"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ITextualRepresentation"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ITextualRepresentation"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ITextualRepresentation x, ITextualRepresentation y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Body, y.Body)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Language, y.Language)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ITextualRepresentation"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ITextualRepresentation"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ITextualRepresentation obj)
+        {
+            return HashCode.Combine(typeof(ITextualRepresentation), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/UsageComparer.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/UsageComparer.cs
new file mode 100644
index 000000000..925f3ccfc
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenDtoComparers/UsageComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="UsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class UsageComparer : IEqualityComparer<IUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IUsage x, IUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IUsage obj)
+        {
+            return HashCode.Combine(typeof(IUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator.Tests/Generators/UmlHandleBarsGenerators/UmlCoreDtoComparerGeneratorTestFixture.cs b/SysML2.NET.CodeGenerator.Tests/Generators/UmlHandleBarsGenerators/UmlCoreDtoComparerGeneratorTestFixture.cs
new file mode 100644
index 000000000..03411d3e1
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Generators/UmlHandleBarsGenerators/UmlCoreDtoComparerGeneratorTestFixture.cs
@@ -0,0 +1,79 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="UmlCoreDtoComparerGeneratorTestFixture.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;
+    using SysML2.NET.CodeGenerator.Tests.Expected.Ecore.Core;
+
+    [TestFixture]
+    public class UmlCoreDtoComparerGeneratorTestFixture
+    {
+        private DirectoryInfo umlDtoComparerDirectoryInfo;
+        private UmlCoreDtoComparerGenerator umlCoreDtoComparerGenerator;
+
+        [OneTimeSetUp]
+        public void SetUp()
+        {
+            var directoryInfo = new DirectoryInfo(TestContext.CurrentContext.TestDirectory);
+
+            var path = Path.Combine("UML", "_SysML2.NET.Core.Extensions.AutoGenDtoComparers");
+
+            this.umlDtoComparerDirectoryInfo = directoryInfo.CreateSubdirectory(path);
+            this.umlCoreDtoComparerGenerator = new UmlCoreDtoComparerGenerator();
+        }
+
+        [Test]
+        public async Task Verify_that_DataTransferObjectComparers_are_generated()
+        {
+            await Assert.ThatAsync(() => this.umlCoreDtoComparerGenerator.GenerateAsync(GeneratorSetupFixture.XmiReaderResult,
+                    this.umlDtoComparerDirectoryInfo),
+                Throws.Nothing);
+        }
+
+        [Test]
+        public async Task Verify_that_DataTransferObjectComparerProvider_is_generated()
+        {
+            await Assert.ThatAsync(() => this.umlCoreDtoComparerGenerator.GenerateDataTransferObjectComparerProviderAsync(GeneratorSetupFixture.XmiReaderResult,
+                    this.umlDtoComparerDirectoryInfo),
+                Throws.Nothing);
+        }
+
+        [Test]
+        [TestCaseSource(typeof(ExpectedConcreteClasses))]
+        [Category("Expected")]
+        public async Task Verify_that_expected_Classes_are_generated(string className)
+        {
+            var generatedCode = await this.umlCoreDtoComparerGenerator.GenerateDataTransferObjectComparerAsync(GeneratorSetupFixture.XmiReaderResult,
+                this.umlDtoComparerDirectoryInfo,
+                className);
+
+            var expected = await File.ReadAllTextAsync(Path.Combine(TestContext.CurrentContext.TestDirectory,
+                $"Expected/UML/Core/AutoGenDtoComparers/{className}Comparer.cs"));
+
+            Assert.That(generatedCode, Is.EqualTo(expected));
+        }
+    }
+}
diff --git a/SysML2.NET.CodeGenerator.Tests/SysML2.NET.CodeGenerator.Tests.csproj b/SysML2.NET.CodeGenerator.Tests/SysML2.NET.CodeGenerator.Tests.csproj
index 13417d2ba..9b3ee45aa 100644
--- a/SysML2.NET.CodeGenerator.Tests/SysML2.NET.CodeGenerator.Tests.csproj
+++ b/SysML2.NET.CodeGenerator.Tests/SysML2.NET.CodeGenerator.Tests.csproj
@@ -24,6 +24,25 @@
     </ItemGroup>
 
     <ItemGroup>
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\AnnotatingElementComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\AssociationComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\DependencyComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\EnumerationDefinitionComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\FeatureComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\FeatureTypingComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\FlowComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\FramedConcernMembershipComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\LiteralIntegerComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\LiteralRationalComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\MembershipComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\MultiplicityRangeComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\OwningMembershipComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\ReferenceSubsettingComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\RequirementUsageComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\SelectExpressionComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\SubclassificationComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\TextualRepresentationComparer.cs" />
+      <Compile Remove="Expected\UML\Core\AutoGenDtoComparers\UsageComparer.cs" />
       <Compile Remove="Expected\UML\Core\AutoGenEnumProvider\TransitionFeatureKindProvider.cs" />
       <Compile Remove="Expected\UML\Core\AutoGenEnumProvider\VisibilityKindProvider.cs" />
       <Compile Remove="Expected\UML\Core\AutoGenEnum\TransitionFeatureKind.cs" />
@@ -75,6 +94,63 @@
 
     <ItemGroup>
       <Compile Remove="Expected\UML\Core\AutoGenPoco\AnnotatingElement.cs" />
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\AnnotatingElementComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\AssociationComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\DependencyComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\EnumerationDefinitionComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\FeatureComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\FeatureTypingComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\FlowComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\FramedConcernMembershipComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\LiteralIntegerComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\LiteralRationalComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\MembershipComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\MultiplicityRangeComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\OwningMembershipComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\ReferenceSubsettingComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\RequirementUsageComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\SelectExpressionComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\SubclassificationComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\TextualRepresentationComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Include="Expected\UML\Core\AutoGenDtoComparers\UsageComparer.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
       <None Include="Expected\UML\Core\AutoGenMessagePackFormatter\AnnotatingElementMessagePackFormatter.cs">
         <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       </None>
diff --git a/SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreDtoComparerGenerator.cs b/SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreDtoComparerGenerator.cs
new file mode 100644
index 000000000..204d72175
--- /dev/null
+++ b/SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreDtoComparerGenerator.cs
@@ -0,0 +1,229 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="UmlCoreDtoComparerGenerator.cs" company="Starion Group S.A.">
+// 
+//   Copyright 2022-2025 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.UmlHandleBarHelpers;
+
+    using uml4net.Extensions;
+    using uml4net.HandleBars;
+    using uml4net.StructuredClassifiers;
+    using uml4net.xmi.Readers;
+
+    /// <summary>
+    /// A UML Handlebars based DTO comparer code generator
+    /// </summary>
+    public class UmlCoreDtoComparerGenerator : UmlHandleBarsGenerator
+    {
+        /// <summary>
+        /// Generates the SysML2 DTO comparers
+        /// </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.GenerateDataTransferObjectComparersAsync(xmiReaderResult, outputDirectory);
+            await this.GenerateDataTransferObjectComparerProviderAsync(xmiReaderResult, outputDirectory);
+        }
+
+        /// <summary>
+        /// Generates DTO Interfaces
+        /// </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 task
+        /// </returns>
+        public Task GenerateDataTransferObjectComparersAsync(XmiReaderResult xmiReaderResult, DirectoryInfo outputDirectory)
+        {
+            ArgumentNullException.ThrowIfNull(xmiReaderResult);
+            ArgumentNullException.ThrowIfNull(outputDirectory);
+
+            return this.GenerateDataTransferObjectComparersInternalAsync(xmiReaderResult, outputDirectory);
+        }
+
+        public Task GenerateDataTransferObjectComparerProviderAsync(XmiReaderResult xmiReaderResult, DirectoryInfo outputDirectory)
+        {
+            ArgumentNullException.ThrowIfNull(xmiReaderResult);
+            ArgumentNullException.ThrowIfNull(outputDirectory);
+
+            return this.GenerateDataTransferObjectComparerProviderInternalAsync(xmiReaderResult, outputDirectory);
+        }
+
+        /// <summary>
+        /// Generates DTO class
+        /// </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>
+        /// <param name="name">
+        /// The name of the DTO class to generate
+        /// </param>
+        /// <returns>
+        /// an awaitable task
+        /// </returns>
+        public Task<string> GenerateDataTransferObjectComparerAsync(XmiReaderResult xmiReaderResult, DirectoryInfo outputDirectory, string name)
+        {
+            ArgumentNullException.ThrowIfNull(xmiReaderResult);
+            ArgumentNullException.ThrowIfNull(outputDirectory);
+            ArgumentException.ThrowIfNullOrWhiteSpace(name);
+
+            return this.GenerateDataTransferObjectComparerInternalAsync(xmiReaderResult, outputDirectory, name);
+        }
+
+        /// <summary>
+        /// Register the custom helpers
+        /// </summary>
+        protected override void RegisterHelpers()
+        {
+            this.Handlebars.RegisterStringHelper();
+            this.Handlebars.RegisterEnumerableHelper();
+            this.Handlebars.RegisterClassHelper();
+            this.Handlebars.RegisterPropertyHelper();
+            this.Handlebars.RegisterGeneralizationHelper();
+            this.Handlebars.RegisterDocumentationHelper();
+            this.Handlebars.RegisterEnumHelper();
+            this.Handlebars.RegisterDecoratorHelper();
+            this.Handlebars.RegisterNamedElementHelper();
+
+            EnumerationLiteralHelper.RegisterTypeNameHelper(this.Handlebars);
+            HandleBarHelpers.ClassHelper.RegisterClassHelper(this.Handlebars);
+            HandleBarHelpers.NamedElementHelper.RegisterNamedElementHelper(this.Handlebars);
+            HandleBarHelpers.PropertyHelper.RegisterPropertyHelper(this.Handlebars);
+        }
+
+        /// <summary>
+        /// Register the code templates
+        /// </summary>
+        protected override void RegisterTemplates()
+        {
+            this.RegisterTemplate("core-dto-comparer-class-uml-template");
+            this.RegisterTemplate("core-dto-comparerprovider-uml-template");
+        }
+
+        /// <summary>
+        /// Generates DTO classes
+        /// </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 task
+        /// </returns>
+        private async Task GenerateDataTransferObjectComparersInternalAsync(XmiReaderResult xmiReaderResult, DirectoryInfo outputDirectory)
+        {
+            var template = this.Templates["core-dto-comparer-class-uml-template"];
+
+            var classes = xmiReaderResult.QueryContainedAndImported("SysML")
+                .SelectMany(x => x.PackagedElement.OfType<IClass>())
+                .Where(x => !x.IsAbstract)
+                .ToList();
+
+            foreach (var @class in classes)
+            {
+                var generatedDto = template(@class);
+
+                generatedDto = this.CodeCleanup(generatedDto);
+
+                var fileName = $"{@class.Name.CapitalizeFirstLetter()}Comparer.cs";
+
+                await WriteAsync(generatedDto, outputDirectory, fileName);
+            }
+        }
+
+        /// <summary>
+        /// Generates DTO classes
+        /// </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>
+        /// <param name="name">
+        /// The name of the DTO class to generate
+        /// </param>
+        /// <returns>
+        /// an awaitable task
+        /// </returns>
+        private async Task<string> GenerateDataTransferObjectComparerInternalAsync(XmiReaderResult xmiReaderResult, DirectoryInfo outputDirectory, string name)
+        {
+            var template = this.Templates["core-dto-comparer-class-uml-template"];
+
+            var classes = xmiReaderResult.QueryContainedAndImported("SysML")
+                .SelectMany(x => x.PackagedElement.OfType<IClass>());
+
+            var @class = classes.Single(x => x.Name == name);
+
+            var generatedDataTransferObjectClass = template(@class);
+
+            generatedDataTransferObjectClass = this.CodeCleanup(generatedDataTransferObjectClass);
+
+            var fileName = $"{@class.Name.CapitalizeFirstLetter()}Comparer.cs";
+
+            await WriteAsync(generatedDataTransferObjectClass, outputDirectory, fileName);
+
+            return generatedDataTransferObjectClass;
+        }
+
+        private async Task<string> GenerateDataTransferObjectComparerProviderInternalAsync(XmiReaderResult xmiReaderResult, DirectoryInfo outputDirectory)
+        {
+            var template = this.Templates["core-dto-comparerprovider-uml-template"];
+
+            var classes = xmiReaderResult.QueryContainedAndImported("SysML")
+                .SelectMany(x => x.PackagedElement.OfType<IClass>())
+                .Where(x => !x.IsAbstract)
+                .OrderBy(x => x.Name);
+
+            var generatedDataTransferObjectComparerProvider = template(classes);
+
+            generatedDataTransferObjectComparerProvider = template(classes);
+
+            generatedDataTransferObjectComparerProvider = this.CodeCleanup(generatedDataTransferObjectComparerProvider);
+
+            await WriteAsync(generatedDataTransferObjectComparerProvider, outputDirectory, "ComparerProvider.cs");
+
+            return generatedDataTransferObjectComparerProvider;
+        }
+    }
+}
diff --git a/SysML2.NET.CodeGenerator/HandleBarHelpers/PropertyHelper.cs b/SysML2.NET.CodeGenerator/HandleBarHelpers/PropertyHelper.cs
index c525fef78..97cda020d 100644
--- a/SysML2.NET.CodeGenerator/HandleBarHelpers/PropertyHelper.cs
+++ b/SysML2.NET.CodeGenerator/HandleBarHelpers/PropertyHelper.cs
@@ -753,6 +753,102 @@ public static void RegisterPropertyHelper(this IHandlebars handlebars)
                 writer.WriteSafeString(sb);
             });
 
+            handlebars.RegisterHelper("Property.WriteForDTOComparer", (writer, _, parameters) =>
+            {
+                if (parameters.Length != 2)
+                {
+                    throw new HandlebarsException("{{#Property.WriteForDTOComparer}} helper must have exactly two arguments");
+                }
+
+                var property = (parameters[0] as IProperty)!;
+                var classContext = (parameters[1] as IClass)!;
+
+                var sb = new StringBuilder();
+                var propertyName = StringExtensions.CapitalizeFirstLetter(property.Name);
+                var isRedefinedPropertyInContext = property.TryQueryRedefinedByProperty(classContext, out var _);
+
+                if (isRedefinedPropertyInContext)
+                {
+                    throw new InvalidOperationException("Property.WriteForDTOComparer is invalid for redefined properties");
+                }
+
+                if (property.IsDerived || property.IsDerivedUnion)
+                {
+                    throw new InvalidOperationException("Property.WriteForDTOComparer is invalid for derived or derivedunion properties");
+                }
+
+                if (property.Type is IDataType)
+                {
+                    if (property.QueryIsString())
+                    {
+                        if (property.QueryIsEnumerable())
+                        {
+                            if (property.IsOrdered)
+                            {
+                                sb.AppendLine($"if (!StringSequenceEquality.OrderedEqual(x.{propertyName}, y.{propertyName})) return false;");
+                            }
+                            else
+                            {
+                                sb.AppendLine($"if (!StringSequenceEquality.UnorderedEqual(x.{propertyName}, y.{propertyName})) return false;");
+                            }
+                        }
+                        else
+                        {
+                            sb.AppendLine($"if (!OrdinalStringComparer.Equals(x.{propertyName}, y.{propertyName})) return false;");
+                        }
+                    }
+                    else if (property.QueryIsDouble())
+                    {
+                        if (property.QueryIsNullable())
+                        {
+                            sb.AppendLine($"if (x.{propertyName}.HasValue != y.{propertyName}.HasValue) return false;");
+
+                            sb.AppendLine($"if (x.{propertyName}.HasValue && FloatingPointComparer.NearlyEqual(x.{propertyName}, y.{propertyName}, FloatingPointComparer.DefaultDoubleEpsilon)) return false;");
+                        }
+                        else
+                        {
+                            sb.AppendLine($"if (FloatingPointComparer.NearlyEqual(x.{propertyName}, y.{propertyName}, FloatingPointComparer.DefaultDoubleEpsilon)) return false;");
+                        }
+
+                    }
+                    else if (property.QueryIsFloat())
+                    {
+                        if (property.QueryIsNullable())
+                        {
+                            sb.AppendLine($"if (x.{propertyName}.HasValue != y.{propertyName}.HasValue) return false;");
+
+                            sb.AppendLine($"if (x.{propertyName}.HasValue && FloatingPointComparer.NearlyEqual(x.{propertyName}, y.{propertyName}, FloatingPointComparer.DefaultFloatEpsilon)) return false;");
+                        }
+
+                        sb.AppendLine($"if (FloatingPointComparer.NearlyEqual(x.{propertyName}, y.{propertyName}, FloatingPointComparer.DefaultDoubleEpsilon)) return false;");
+                    }
+                    else
+                    {
+                        sb.AppendLine($"if (x.{propertyName} != y.{propertyName}) return false;");
+                    }
+                }
+                else
+                {
+                    if (property.QueryIsEnumerable())
+                    {
+                        if (property.IsOrdered)
+                        {
+                            sb.AppendLine($"if (!GuidSequenceEquality.OrderedEqual(x.{propertyName}, y.{propertyName})) return false;");
+                        }
+                        else
+                        {
+                            sb.AppendLine($"if (!GuidSequenceEquality.UnorderedEqual(x.{propertyName}, y.{propertyName})) return false;");
+                        }
+                    }
+                    else
+                    {
+                        sb.AppendLine($"if (x.{propertyName} != y.{propertyName}) return false;");
+                    }
+                }
+
+                writer.WriteSafeString(sb + Environment.NewLine);
+            });
+
             handlebars.RegisterHelper("Property.IsPropertyRedefinedInClass", (context, arguments) =>
             {
                 if (context.Value is not IProperty property)
@@ -861,7 +957,7 @@ public static void RegisterPropertyHelper(this IHandlebars handlebars)
                     writer.WriteSafeString($"{variableName}.{propertyName}");
                 }
             });
-            
+
             handlebars.RegisterHelper("Property.IsOfTypeBaseElement", (_, arguments) =>
             {
                 if (arguments.Single() is not IProperty property)
diff --git a/SysML2.NET.CodeGenerator/SysML2.NET.CodeGenerator.csproj b/SysML2.NET.CodeGenerator/SysML2.NET.CodeGenerator.csproj
index f7b14396b..6ae57eb58 100644
--- a/SysML2.NET.CodeGenerator/SysML2.NET.CodeGenerator.csproj
+++ b/SysML2.NET.CodeGenerator/SysML2.NET.CodeGenerator.csproj
@@ -118,6 +118,12 @@
     <None Update="Templates\Uml\core-dto-class-uml-template.hbs">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
+    <None Update="Templates\Uml\core-dto-comparer-class-uml-template.hbs">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="Templates\Uml\core-dto-comparerprovider-uml-template.hbs">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
     <None Update="Templates\Uml\core-dto-interface-uml-template.hbs">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-dto-comparer-class-uml-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-dto-comparer-class-uml-template.hbs
new file mode 100644
index 000000000..f853ed37c
--- /dev/null
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-dto-comparer-class-uml-template.hbs
@@ -0,0 +1,116 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="{{this.Name}}Comparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    {{ #Class.WriteEnumerationNameSpaces this}}
+    using SysML2.NET.Core.DTO.{{ #NamedElement.WriteFullyQualifiedNameSpace this }};
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="I{{this.Name}}"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="I{{this.Name}}"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class {{this.Name}}Comparer : IEqualityComparer<I{{this.Name}}>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="I{{this.Name}}"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="I{{this.Name}}"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="I{{this.Name}}"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="I{{this.Name}}"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(I{{this.Name}} x, I{{this.Name}} y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            {{ #each (Class.QueryAllNonDerivedProperties this) as | property | }}
+                {{#unless (Property.IsPropertyRedefinedInClass this ../)}}
+                    {{ #Property.WriteForDTOComparer property ../ }}
+                {{/unless}}
+            {{/each}}
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="I{{this.Name}}"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="I{{this.Name}}"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(I{{this.Name}} obj)
+        {
+            return HashCode.Combine(typeof(I{{this.Name}}), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-dto-comparerprovider-uml-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-dto-comparerprovider-uml-template.hbs
new file mode 100644
index 000000000..8e4c670b6
--- /dev/null
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-dto-comparerprovider-uml-template.hbs
@@ -0,0 +1,169 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ComparerProvider.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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Common;
+
+    /// <summary>
+    /// Provides runtime access to equality comparers for DTO types.
+    /// </summary>
+    public static class ComparerProvider
+    {
+        private static readonly IReadOnlyDictionary<Type, IEqualityComparer<IData>> Comparers =
+            new Dictionary<Type, IEqualityComparer<IData>>
+            {
+                {{#each this as | class |}}
+                { typeof(SysML2.NET.Core.DTO.{{ #NamedElement.WriteFullyQualifiedNameSpace class }}.{{ class.Name }}), new Adapter<SysML2.NET.Core.DTO.{{ #NamedElement.WriteFullyQualifiedNameSpace class }}.{{ class.Name }}>(new {{ class.Name }}Comparer()) },
+                {{/each}}
+            };
+
+        /// <summary>
+        /// Resolves the equality comparer for the specified DTO runtime type.
+        /// </summary>
+        public static IEqualityComparer<IData> Resolve(Type dtoType)
+        {
+            if (dtoType == null)
+            {
+                throw new ArgumentNullException(nameof(dtoType));
+            }
+
+            if (!Comparers.TryGetValue(dtoType, out var comparer))
+            {
+                throw new NotSupportedException($"No equality comparer generated for DTO type '{dtoType.FullName}'.");
+            }
+
+            return comparer;
+        }
+
+        /// <summary>
+        /// Resolves the equality comparer for the runtime type of the given DTO.
+        /// </summary>
+        public static IEqualityComparer<IData> Resolve(IData dto)
+        {
+            if (dto == null)
+            {
+                throw new ArgumentNullException(nameof(dto));
+            }
+
+            return Resolve(dto.GetType());
+        }
+
+        /// <summary>
+        /// Adapts a strongly-typed comparer to <see cref="IEqualityComparer{IData}"/>.
+        /// This adapter exists solely to bridge generic invariance in C#.
+        /// </summary>
+        private sealed class Adapter<T> : IEqualityComparer<IData>
+            where T : class, IData
+        {
+            private readonly IEqualityComparer<T> inner;
+
+            /// <summary>
+            /// Initializes a new instance of the <see cref="Adapter{T}"/> class
+            /// wrapping the specified strongly-typed comparer.
+            /// </summary>
+            /// <param name="inner">
+            /// The generated equality comparer responsible for comparing instances
+            /// of <typeparamref name="T"/>.
+            /// </param>
+            /// <exception cref="ArgumentNullException">
+            /// Thrown when <paramref name="inner"/> is <c>null</c>.
+            /// </exception>
+            public Adapter(IEqualityComparer<T> inner)
+            {
+                this.inner = inner;
+            }
+
+            /// <summary>
+            /// Determines whether the specified <see cref="IData"/> instances are
+            /// equal by delegating to the wrapped <see cref="IEqualityComparer{T}"/>.
+            /// </summary>
+            /// <param name="x">
+            /// The first object to compare.
+            /// </param>
+            /// <param name="y">
+            /// The second object to compare.
+            /// </param>
+            /// <returns>
+            /// <c>true</c> if <paramref name="x"/> and <paramref name="y"/> are
+            /// considered equal according to the wrapped comparer; otherwise,
+            /// <c>false</c>.
+            /// </returns>
+            /// <remarks>
+            /// <para>
+            /// If both references are identical, the method returns <c>true</c>
+            /// immediately. If either reference is <c>null</c>, the method returns
+            /// <c>false</c>.
+            /// </para>
+            /// <para>
+            /// Both arguments are expected to be instances of
+            /// <typeparamref name="T"/>. This invariant is guaranteed by
+            /// <see cref="ComparerProvider"/>, which resolves adapters strictly
+            /// by the runtime type of the DTO.
+            /// </para>
+            /// </remarks>
+            public bool Equals(IData x, IData y)
+            {
+                if (ReferenceEquals(x, y)) return true;
+                if (x is null || y is null) return false;
+
+                return this.inner.Equals((T)x, (T)y);
+            }
+
+            /// <summary>
+            /// Returns a hash code for the specified <see cref="IData"/> instance
+            /// by delegating to the wrapped <see cref="IEqualityComparer{T}"/>.
+            /// </summary>
+            /// <param name="obj">
+            /// The object for which a hash code is to be returned.
+            /// </param>
+            /// <returns>
+            /// A hash code for <paramref name="obj"/>, suitable for use in hash-based
+            /// collections when combined with the corresponding equality semantics.
+            /// </returns>
+            /// <remarks>
+            /// <para>
+            /// The hash code implementation is fully delegated to the wrapped
+            /// comparer and therefore remains consistent with its
+            /// <see cref="Equals(IData, IData)"/> semantics.
+            /// </para>
+            /// <para>
+            /// The adapter does not attempt to normalize or reinterpret the hash
+            /// code in any way.
+            /// </para>
+            /// </remarks>
+            public int GetHashCode(IData obj)
+            {
+                return this.inner.GetHashCode((T)obj);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions.Tests/Comparers/FloatingPointComparerTestFixture.cs b/SysML2.NET.Extensions.Tests/Comparers/FloatingPointComparerTestFixture.cs
new file mode 100644
index 000000000..525364fe7
--- /dev/null
+++ b/SysML2.NET.Extensions.Tests/Comparers/FloatingPointComparerTestFixture.cs
@@ -0,0 +1,201 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FloatingPointComparerTestFixture.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.Extensions.Tests.Comparers
+{
+    using NUnit.Framework;
+
+    using SysML2.NET.Extensions.Comparers;
+
+    [TestFixture]
+    public class FloatingPointComparerTestFixture
+    {
+        [Test]
+        public void NearlyEqual_Double_WhenValuesAreExactlyEqual_ReturnsTrue()
+        {
+            Assert.That(FloatingPointComparer.NearlyEqual(1.234, 1.234), Is.True);
+        }
+
+        [Test]
+        public void NearlyEqual_Double_WhenValuesDifferWithinAbsoluteEpsilonNearZero_ReturnsTrue()
+        {
+            var epsilon = FloatingPointComparer.DefaultDoubleEpsilon;
+
+            Assert.That(FloatingPointComparer.NearlyEqual(0.0, epsilon * 0.5, epsilon), Is.True);
+            Assert.That(FloatingPointComparer.NearlyEqual(0.0, -epsilon * 0.5, epsilon), Is.True);
+        }
+
+        [Test]
+        public void NearlyEqual_Double_WhenValuesDifferMoreThanAbsoluteEpsilonNearZero_ReturnsFalse()
+        {
+            var epsilon = FloatingPointComparer.DefaultDoubleEpsilon;
+
+            Assert.That(FloatingPointComparer.NearlyEqual(0.0, epsilon * 2.0, epsilon), Is.False);
+            Assert.That(FloatingPointComparer.NearlyEqual(0.0, -epsilon * 2.0, epsilon), Is.False);
+        }
+
+        [Test]
+        public void NearlyEqual_Double_WhenValuesDifferWithinRelativeTolerance_ReturnsTrue()
+        {
+            // Ensure we are in the relative regime: epsilon*scale dominates epsilon.
+            // For left=1e9, right=1e9+0.5, scale≈2e9 => epsilon*scale≈2, so diff=0.5 should be true.
+            var epsilon = FloatingPointComparer.DefaultDoubleEpsilon;
+
+            var left = 1_000_000_000d;
+            var right = left + 0.5d;
+
+            Assert.That(FloatingPointComparer.NearlyEqual(left, right, epsilon), Is.True);
+        }
+
+        [Test]
+        public void NearlyEqual_Double_WhenValuesDifferOutsideRelativeTolerance_ReturnsFalse()
+        {
+            // For left=1e9, scale≈2e9 => epsilon*scale≈2, so diff=3 should be false.
+            var epsilon = FloatingPointComparer.DefaultDoubleEpsilon;
+
+            var left = 1_000_000_000d;
+            var right = left + 3d;
+
+            Assert.That(FloatingPointComparer.NearlyEqual(left, right, epsilon), Is.False);
+        }
+
+        [Test]
+        public void NearlyEqual_Double_WhenOneValueIsInfinityAndOtherIsSameInfinity_ReturnsTrue()
+        {
+            Assert.That(FloatingPointComparer.NearlyEqual(double.PositiveInfinity, double.PositiveInfinity), Is.True);
+            Assert.That(FloatingPointComparer.NearlyEqual(double.NegativeInfinity, double.NegativeInfinity), Is.True);
+        }
+
+        [Test]
+        public void NearlyEqual_Double_WhenOneValueIsInfinityAndOtherIsFinite_ReturnsFalse()
+        {
+            Assert.That(FloatingPointComparer.NearlyEqual(double.PositiveInfinity, 1.0), Is.False);
+            Assert.That(FloatingPointComparer.NearlyEqual(double.NegativeInfinity, -1.0), Is.False);
+        }
+
+        [Test]
+        public void NearlyEqual_Double_WhenEitherIsNaN_ReturnsFalse()
+        {
+            Assert.That(FloatingPointComparer.NearlyEqual(double.NaN, double.NaN), Is.False);
+            Assert.That(FloatingPointComparer.NearlyEqual(double.NaN, 0.0), Is.False);
+            Assert.That(FloatingPointComparer.NearlyEqual(0.0, double.NaN), Is.False);
+        }
+
+        [Test]
+        public void NearlyEqual_Float_WhenValuesAreExactlyEqual_ReturnsTrue()
+        {
+            Assert.That(FloatingPointComparer.NearlyEqual(1.234f, 1.234f), Is.True);
+        }
+
+        [Test]
+        public void NearlyEqual_Float_WhenValuesDifferWithinAbsoluteEpsilonNearZero_ReturnsTrue()
+        {
+            var epsilon = FloatingPointComparer.DefaultFloatEpsilon;
+
+            Assert.That(FloatingPointComparer.NearlyEqual(0f, epsilon * 0.5f, epsilon), Is.True);
+            Assert.That(FloatingPointComparer.NearlyEqual(0f, -epsilon * 0.5f, epsilon), Is.True);
+        }
+
+        [Test]
+        public void NearlyEqual_Float_WhenValuesDifferMoreThanAbsoluteEpsilonNearZero_ReturnsFalse()
+        {
+            var epsilon = FloatingPointComparer.DefaultFloatEpsilon;
+
+            Assert.That(FloatingPointComparer.NearlyEqual(0f, epsilon * 2f, epsilon), Is.False);
+            Assert.That(FloatingPointComparer.NearlyEqual(0f, -epsilon * 2f, epsilon), Is.False);
+        }
+
+        [Test]
+        public void NearlyEqual_Float_WhenValuesDifferWithinRelativeTolerance_ReturnsTrue()
+        {
+            // For left=1e6, scale≈2e6 => epsilon*scale≈2 (with epsilon=1e-6) so diff=0.5 should be true.
+            var epsilon = FloatingPointComparer.DefaultFloatEpsilon;
+
+            var left = 1_000_000f;
+            var right = left + 0.5f;
+
+            Assert.That(FloatingPointComparer.NearlyEqual(left, right, epsilon), Is.True);
+        }
+
+        [Test]
+        public void NearlyEqual_Float_WhenValuesDifferOutsideRelativeTolerance_ReturnsFalse()
+        {
+            // For left=1e6, scale≈2e6 => epsilon*scale≈2 so diff=3 should be false.
+            var epsilon = FloatingPointComparer.DefaultFloatEpsilon;
+
+            var left = 1_000_000f;
+            var right = left + 3f;
+
+            Assert.That(FloatingPointComparer.NearlyEqual(left, right, epsilon), Is.False);
+        }
+
+        [Test]
+        public void NearlyEqual_Float_WhenOneValueIsInfinityAndOtherIsSameInfinity_ReturnsTrue()
+        {
+            Assert.That(FloatingPointComparer.NearlyEqual(float.PositiveInfinity, float.PositiveInfinity), Is.True);
+            Assert.That(FloatingPointComparer.NearlyEqual(float.NegativeInfinity, float.NegativeInfinity), Is.True);
+        }
+
+        [Test]
+        public void NearlyEqual_Float_WhenOneValueIsInfinityAndOtherIsFinite_ReturnsFalse()
+        {
+            Assert.That(FloatingPointComparer.NearlyEqual(float.PositiveInfinity, 1f), Is.False);
+            Assert.That(FloatingPointComparer.NearlyEqual(float.NegativeInfinity, -1f), Is.False);
+        }
+
+        [Test]
+        public void NearlyEqual_Float_WhenEitherIsNaN_ReturnsFalse()
+        {
+            Assert.That(FloatingPointComparer.NearlyEqual(float.NaN, float.NaN), Is.False);
+            Assert.That(FloatingPointComparer.NearlyEqual(float.NaN, 0f), Is.False);
+            Assert.That(FloatingPointComparer.NearlyEqual(0f, float.NaN), Is.False);
+        }
+
+        [Test]
+        public void NearlyEqual_UsesProvidedEpsilon()
+        {
+            // Make epsilon big on purpose so the comparison returns true.
+            const double epsilon = 1e-3;
+
+            Assert.That(FloatingPointComparer.NearlyEqual(1.0, 1.0005, epsilon), Is.True);
+
+            // And small so it returns false.
+            const double smallEpsilon = 1e-9;
+
+            Assert.That(FloatingPointComparer.NearlyEqual(1.0, 1.0005, smallEpsilon), Is.False);
+        }
+
+        [Test]
+        public void NearlyEqual_IsSymmetric_ForRepresentativeValues()
+        {
+            var epsilonD = FloatingPointComparer.DefaultDoubleEpsilon;
+            var aD = 1_000_000_000d;
+            var bD = aD + 0.5d;
+
+            Assert.That(FloatingPointComparer.NearlyEqual(aD, bD, epsilonD), Is.EqualTo(FloatingPointComparer.NearlyEqual(bD, aD, epsilonD)));
+
+            var epsilonF = FloatingPointComparer.DefaultFloatEpsilon;
+            var aF = 1_000_000f;
+            var bF = aF + 0.5f;
+
+            Assert.That(FloatingPointComparer.NearlyEqual(aF, bF, epsilonF), Is.EqualTo(FloatingPointComparer.NearlyEqual(bF, aF, epsilonF)));
+        }
+    }
+}
diff --git a/SysML2.NET.Extensions.Tests/Comparers/GuidComparerTestFixture.cs b/SysML2.NET.Extensions.Tests/Comparers/GuidComparerTestFixture.cs
new file mode 100644
index 000000000..e3de342c6
--- /dev/null
+++ b/SysML2.NET.Extensions.Tests/Comparers/GuidComparerTestFixture.cs
@@ -0,0 +1,129 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="GuidComparerTestFixture.cs" company="Starion Group S.A.">
+// 
+//   Copyright 2022-2025 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.Extensions.Tests.Comparers
+{
+    using System;
+
+    using NUnit.Framework;
+
+    using SysML2.NET.Extensions.Comparers;
+
+    [TestFixture]
+    public class GuidComparerTestFixture
+    {
+        private GuidComparer comparer;
+
+        [SetUp]
+        public void SetUp()
+        {
+            this.comparer = new GuidComparer();
+        }
+
+        [Test]
+        public void Verify_that_comparing_equal_guids_returns_zero()
+        {
+            var guid = Guid.NewGuid();
+
+            var result = this.comparer.Compare(guid, guid);
+
+            Assert.That(result, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void Verify_that_comparing_two_identical_guid_values_returns_zero()
+        {
+            var guid = Guid.NewGuid();
+            var sameGuid = new Guid(guid.ToByteArray());
+
+            var result = this.comparer.Compare(guid, sameGuid);
+
+            Assert.That(result, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void Verify_that_comparing_a_smaller_guid_with_a_larger_guid_returns_a_negative_value()
+        {
+            var smaller = Guid.Parse("00000000-0000-0000-0000-000000000001");
+            var larger = Guid.Parse("00000000-0000-0000-0000-000000000002");
+
+            var result = this.comparer.Compare(smaller, larger);
+
+            Assert.That(result, Is.LessThan(0));
+        }
+
+        [Test]
+        public void Verify_that_comparing_a_larger_guid_with_a_smaller_guid_returns_a_positive_value()
+        {
+            var smaller = Guid.Parse("00000000-0000-0000-0000-000000000001");
+            var larger = Guid.Parse("00000000-0000-0000-0000-000000000002");
+
+            var result = this.comparer.Compare(larger, smaller);
+
+            Assert.That(result, Is.GreaterThan(0));
+        }
+
+        [Test]
+        public void Verify_that_guid_comparison_is_symmetric()
+        {
+            var guidA = Guid.NewGuid();
+            var guidB = Guid.NewGuid();
+
+            var ab = this.comparer.Compare(guidA, guidB);
+            var ba = this.comparer.Compare(guidB, guidA);
+
+            Assert.That(ab, Is.EqualTo(-ba));
+        }
+
+        [Test]
+        public void Verify_that_guid_comparison_is_consistent_across_multiple_calls()
+        {
+            var guidA = Guid.NewGuid();
+            var guidB = Guid.NewGuid();
+
+            var first = this.comparer.Compare(guidA, guidB);
+            var second = this.comparer.Compare(guidA, guidB);
+
+            Assert.That(first, Is.EqualTo(second));
+        }
+
+        [Test]
+        public void Verify_that_empty_guid_is_less_than_any_non_empty_guid()
+        {
+            var empty = Guid.Empty;
+            var nonEmpty = Guid.NewGuid();
+
+            var result = this.comparer.Compare(empty, nonEmpty);
+
+            Assert.That(result, Is.LessThan(0));
+        }
+
+        [Test]
+        public void Verify_that_non_empty_guid_is_greater_than_empty_guid()
+        {
+            var empty = Guid.Empty;
+            var nonEmpty = Guid.NewGuid();
+
+            var result = this.comparer.Compare(nonEmpty, empty);
+
+            Assert.That(result, Is.GreaterThan(0));
+        }
+    }
+}
diff --git a/SysML2.NET.Extensions.Tests/Comparers/GuidSequenceEqualityTestFixture.cs b/SysML2.NET.Extensions.Tests/Comparers/GuidSequenceEqualityTestFixture.cs
new file mode 100644
index 000000000..35cef47f5
--- /dev/null
+++ b/SysML2.NET.Extensions.Tests/Comparers/GuidSequenceEqualityTestFixture.cs
@@ -0,0 +1,182 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="GuidSequenceEqualityTestFixture.cs" company="Starion Group S.A.">
+// 
+//   Copyright 2022-2025 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.Extensions.Tests.Comparers
+{
+    using System;
+    using System.Collections.Generic;
+    using NUnit.Framework;
+    using SysML2.NET.Extensions.Comparers;
+
+    [TestFixture]
+    public class GuidSequenceEqualityTestFixture
+    {
+        [Test]
+        public void Verify_that_ordered_equal_returns_true_for_the_same_reference()
+        {
+            var list = new List<Guid> { Guid.NewGuid(), Guid.NewGuid() };
+
+            Assert.That(GuidSequenceEquality.OrderedEqual(list, list), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_returns_true_for_the_same_reference()
+        {
+            var list = new List<Guid> { Guid.NewGuid(), Guid.NewGuid() };
+
+            Assert.That(GuidSequenceEquality.UnorderedEqual(list, list), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_ordered_equal_returns_false_when_one_sequence_is_null()
+        {
+            var list = new List<Guid> { Guid.NewGuid() };
+
+            Assert.That(GuidSequenceEquality.OrderedEqual(list, null), Is.False);
+            Assert.That(GuidSequenceEquality.OrderedEqual(null, list), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_returns_false_when_one_sequence_is_null()
+        {
+            var list = new List<Guid> { Guid.NewGuid() };
+
+            Assert.That(GuidSequenceEquality.UnorderedEqual(list, null), Is.False);
+            Assert.That(GuidSequenceEquality.UnorderedEqual(null, list), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_ordered_equal_returns_true_for_sequences_with_same_elements_in_same_order()
+        {
+            var g1 = Guid.NewGuid();
+            var g2 = Guid.NewGuid();
+
+            var a = new List<Guid> { g1, g2 };
+            var b = new List<Guid> { g1, g2 };
+
+            Assert.That(GuidSequenceEquality.OrderedEqual(a, b), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_ordered_equal_returns_false_for_sequences_with_same_elements_in_different_order()
+        {
+            var g1 = Guid.NewGuid();
+            var g2 = Guid.NewGuid();
+
+            var a = new List<Guid> { g1, g2 };
+            var b = new List<Guid> { g2, g1 };
+
+            Assert.That(GuidSequenceEquality.OrderedEqual(a, b), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_returns_true_for_sequences_with_same_elements_in_different_order()
+        {
+            var g1 = Guid.NewGuid();
+            var g2 = Guid.NewGuid();
+
+            var a = new List<Guid> { g1, g2 };
+            var b = new List<Guid> { g2, g1 };
+
+            Assert.That(GuidSequenceEquality.UnorderedEqual(a, b), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_ordered_equal_returns_false_for_sequences_with_different_lengths()
+        {
+            var g1 = Guid.NewGuid();
+
+            var a = new List<Guid> { g1 };
+            var b = new List<Guid> { g1, Guid.NewGuid() };
+
+            Assert.That(GuidSequenceEquality.OrderedEqual(a, b), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_returns_false_for_sequences_with_different_lengths()
+        {
+            var g1 = Guid.NewGuid();
+
+            var a = new List<Guid> { g1 };
+            var b = new List<Guid> { g1, Guid.NewGuid() };
+
+            Assert.That(GuidSequenceEquality.UnorderedEqual(a, b), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_correctly_handles_duplicate_guids()
+        {
+            var g1 = Guid.NewGuid();
+            var g2 = Guid.NewGuid();
+
+            var a = new List<Guid> { g1, g1, g2 };
+            var b = new List<Guid> { g2, g1, g1 };
+
+            Assert.That(GuidSequenceEquality.UnorderedEqual(a, b), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_returns_false_when_duplicate_multiplicity_differs()
+        {
+            var g1 = Guid.NewGuid();
+
+            var a = new List<Guid> { g1, g1 };
+            var b = new List<Guid> { g1 };
+
+            Assert.That(GuidSequenceEquality.UnorderedEqual(a, b), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_ordered_equal_returns_false_when_any_element_differs()
+        {
+            var a = new List<Guid> { Guid.NewGuid(), Guid.NewGuid() };
+            var b = new List<Guid> { Guid.NewGuid(), Guid.NewGuid() };
+
+            Assert.That(GuidSequenceEquality.OrderedEqual(a, b), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_returns_false_when_any_element_differs()
+        {
+            var a = new List<Guid> { Guid.NewGuid(), Guid.NewGuid() };
+            var b = new List<Guid> { Guid.NewGuid(), Guid.NewGuid() };
+
+            Assert.That(GuidSequenceEquality.UnorderedEqual(a, b), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_empty_sequences_are_considered_equal_for_ordered_comparison()
+        {
+            var a = new List<Guid>();
+            var b = new List<Guid>();
+
+            Assert.That(GuidSequenceEquality.OrderedEqual(a, b), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_empty_sequences_are_considered_equal_for_unordered_comparison()
+        {
+            var a = new List<Guid>();
+            var b = new List<Guid>();
+
+            Assert.That(GuidSequenceEquality.UnorderedEqual(a, b), Is.True);
+        }
+    }
+}
diff --git a/SysML2.NET.Extensions.Tests/Comparers/StringSequenceEqualityTestFixture.cs b/SysML2.NET.Extensions.Tests/Comparers/StringSequenceEqualityTestFixture.cs
new file mode 100644
index 000000000..9823d4288
--- /dev/null
+++ b/SysML2.NET.Extensions.Tests/Comparers/StringSequenceEqualityTestFixture.cs
@@ -0,0 +1,204 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StringSequenceEqualityTestFixture.cs" company="Starion Group S.A.">
+// 
+//   Copyright 2022-2025 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.Extensions.Tests.Comparers
+{
+    using System;
+    using System.Collections.Generic;
+
+    using NUnit.Framework;
+
+    using SysML2.NET.Extensions.Comparers;
+
+
+    [TestFixture]
+    public class StringSequenceEqualityTestFixture
+    {
+        [Test]
+        public void Verify_that_ordered_equal_returns_true_for_the_same_reference()
+        {
+            var list = new List<string> { "a", "b" };
+
+            Assert.That(StringSequenceEquality.OrderedEqual(list, list), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_returns_true_for_the_same_reference()
+        {
+            var list = new List<string> { "a", "b" };
+
+            Assert.That(StringSequenceEquality.UnorderedEqual(list, list), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_ordered_equal_returns_false_when_one_sequence_is_null()
+        {
+            var list = new List<string> { "a" };
+
+            Assert.That(StringSequenceEquality.OrderedEqual(list, null), Is.False);
+            Assert.That(StringSequenceEquality.OrderedEqual(null, list), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_returns_false_when_one_sequence_is_null()
+        {
+            var list = new List<string> { "a" };
+
+            Assert.That(StringSequenceEquality.UnorderedEqual(list, null), Is.False);
+            Assert.That(StringSequenceEquality.UnorderedEqual(null, list), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_ordered_equal_returns_true_for_sequences_with_same_elements_in_same_order_using_default_ordinal_comparer()
+        {
+            var a = new List<string> { "Alpha", "Beta" };
+            var b = new List<string> { "Alpha", "Beta" };
+
+            Assert.That(StringSequenceEquality.OrderedEqual(a, b), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_ordered_equal_returns_false_for_sequences_with_same_elements_in_different_order()
+        {
+            var a = new List<string> { "Alpha", "Beta" };
+            var b = new List<string> { "Beta", "Alpha" };
+
+            Assert.That(StringSequenceEquality.OrderedEqual(a, b), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_returns_true_for_sequences_with_same_elements_in_different_order()
+        {
+            var a = new List<string> { "Alpha", "Beta" };
+            var b = new List<string> { "Beta", "Alpha" };
+
+            Assert.That(StringSequenceEquality.UnorderedEqual(a, b), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_ordered_equal_returns_false_for_sequences_with_different_lengths()
+        {
+            var a = new List<string> { "Alpha" };
+            var b = new List<string> { "Alpha", "Beta" };
+
+            Assert.That(StringSequenceEquality.OrderedEqual(a, b), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_returns_false_for_sequences_with_different_lengths()
+        {
+            var a = new List<string> { "Alpha" };
+            var b = new List<string> { "Alpha", "Beta" };
+
+            Assert.That(StringSequenceEquality.UnorderedEqual(a, b), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_correctly_handles_duplicate_values()
+        {
+            var a = new List<string> { "Alpha", "Alpha", "Beta" };
+            var b = new List<string> { "Beta", "Alpha", "Alpha" };
+
+            Assert.That(StringSequenceEquality.UnorderedEqual(a, b), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_returns_false_when_duplicate_multiplicity_differs()
+        {
+            var a = new List<string> { "Alpha", "Alpha" };
+            var b = new List<string> { "Alpha", "Beta" };
+
+            Assert.That(StringSequenceEquality.UnorderedEqual(a, b), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_ordered_equal_returns_false_when_any_element_differs()
+        {
+            var a = new List<string> { "Alpha", "Beta" };
+            var b = new List<string> { "Alpha", "Gamma" };
+
+            Assert.That(StringSequenceEquality.OrderedEqual(a, b), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_returns_false_when_any_element_differs()
+        {
+            var a = new List<string> { "Alpha", "Beta" };
+            var b = new List<string> { "Alpha", "Gamma" };
+
+            Assert.That(StringSequenceEquality.UnorderedEqual(a, b), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_empty_sequences_are_considered_equal_for_ordered_comparison()
+        {
+            var a = new List<string>();
+            var b = new List<string>();
+
+            Assert.That(StringSequenceEquality.OrderedEqual(a, b), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_empty_sequences_are_considered_equal_for_unordered_comparison()
+        {
+            var a = new List<string>();
+            var b = new List<string>();
+
+            Assert.That(StringSequenceEquality.UnorderedEqual(a, b), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_default_ordinal_comparison_is_case_sensitive()
+        {
+            var a = new List<string> { "alpha" };
+            var b = new List<string> { "ALPHA" };
+
+            Assert.That(StringSequenceEquality.OrderedEqual(a, b), Is.False);
+            Assert.That(StringSequenceEquality.UnorderedEqual(a, b), Is.False);
+        }
+
+        [Test]
+        public void Verify_that_a_custom_comparer_can_enable_case_insensitive_ordered_equality()
+        {
+            var a = new List<string> { "alpha", "BETA" };
+            var b = new List<string> { "ALPHA", "beta" };
+
+            Assert.That(StringSequenceEquality.OrderedEqual(a, b, StringComparer.OrdinalIgnoreCase), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_a_custom_comparer_can_enable_case_insensitive_unordered_equality()
+        {
+            var a = new List<string> { "alpha", "alpha", "BETA" };
+            var b = new List<string> { "beta", "ALPHA", "ALPHA" };
+
+            Assert.That(StringSequenceEquality.UnorderedEqual(a, b, StringComparer.OrdinalIgnoreCase), Is.True);
+        }
+
+        [Test]
+        public void Verify_that_unordered_equal_returns_false_when_case_insensitive_comparer_is_not_used_and_casing_differs()
+        {
+            var a = new List<string> { "alpha", "alpha", "BETA" };
+            var b = new List<string> { "beta", "ALPHA", "ALPHA" };
+
+            Assert.That(StringSequenceEquality.UnorderedEqual(a, b), Is.False);
+        }
+    }
+}
diff --git a/SysML2.NET.Extensions/Comparers/FloatingPointComparer.cs b/SysML2.NET.Extensions/Comparers/FloatingPointComparer.cs
new file mode 100644
index 000000000..7d8eb739b
--- /dev/null
+++ b/SysML2.NET.Extensions/Comparers/FloatingPointComparer.cs
@@ -0,0 +1,77 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FloatingPointComparer.cs" company="Starion Group S.A.">
+//
+//   Copyright (C) 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.Extensions.Comparers
+{
+    using System;
+
+    /// <summary>
+    /// Provides robust equality comparison helpers for floating-point values
+    /// using a combination of absolute and relative tolerance.
+    /// </summary>
+    public static class FloatingPointComparer
+    {
+        /// <summary>
+        /// Default epsilon for double-precision comparisons.
+        /// </summary>
+        public const double DefaultDoubleEpsilon = 1e-9;
+
+        /// <summary>
+        /// Default epsilon for single-precision comparisons.
+        /// </summary>
+        public const float DefaultFloatEpsilon = 1e-6f;
+
+        /// <summary>
+        /// Determines whether two <see cref="double"/> values are nearly equal.
+        /// </summary>
+        public static bool NearlyEqual(double left, double right, double epsilon = DefaultDoubleEpsilon)
+        {
+            if (left == right)
+            {
+                return true;
+            }
+
+            var difference = Math.Abs(left - right);
+            var scale = Math.Min(
+                Math.Abs(left) + Math.Abs(right),
+                double.MaxValue);
+
+            return difference <= Math.Max(epsilon, epsilon * scale);
+        }
+
+        /// <summary>
+        /// Determines whether two <see cref="float"/> values are nearly equal.
+        /// </summary>
+        public static bool NearlyEqual(float left, float right, float epsilon = DefaultFloatEpsilon)
+        {
+            if (left == right)
+            {
+                return true;
+            }
+
+            var difference = Math.Abs(left - right);
+            var scale = Math.Min(
+                Math.Abs(left) + Math.Abs(right),
+                float.MaxValue);
+
+            return difference <= Math.Max(epsilon, epsilon * scale);
+        }
+    }
+}
diff --git a/SysML2.NET.Extensions/Comparers/GuidSequenceEquality.cs b/SysML2.NET.Extensions/Comparers/GuidSequenceEquality.cs
new file mode 100644
index 000000000..cf8117dbc
--- /dev/null
+++ b/SysML2.NET.Extensions/Comparers/GuidSequenceEquality.cs
@@ -0,0 +1,130 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="GuidSequenceEquality.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.Extensions.Comparers
+{
+    using System;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Provides utility methods for comparing sequences of <see cref="Guid"/> values
+    /// according to ordered and unordered equality semantics.
+    /// </summary>
+    public static class GuidSequenceEquality
+    {
+        /// <summary>
+        /// Determines whether two sequences of <see cref="Guid"/> values are equal
+        /// using an ordered (positional) comparison.
+        /// </summary>
+        /// <param name="a">
+        /// The first sequence to compare. The order of elements is significant.
+        /// </param>
+        /// <param name="b">
+        /// The second sequence to compare. The order of elements is significant.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both sequences contain the same number of elements and each
+        /// element in <paramref name="a"/> is equal to the corresponding element in
+        /// <paramref name="b"/> at the same position; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a fast, allocation-free comparison and is suitable
+        /// for properties with <c>isOrdered = true</c> semantics in the metamodel.
+        /// </remarks>
+        public static bool OrderedEqual(IReadOnlyList<Guid> a, IReadOnlyList<Guid> b)
+        {
+            if (ReferenceEquals(a, b)) return true;
+            if (a is null || b is null) return false;
+
+            var count = a.Count;
+            if (count != b.Count) return false;
+
+            for (var i = 0; i < count; i++)
+            {
+                if (a[i] != b[i]) return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Determines whether two sequences of <see cref="Guid"/> values are equal
+        /// regardless of element ordering.
+        /// </summary>
+        /// <param name="a">
+        /// The first sequence to compare. Element order is ignored.
+        /// </param>
+        /// <param name="b">
+        /// The second sequence to compare. Element order is ignored.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both sequences contain the same elements with the same
+        /// multiplicities, independent of order; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method uses a hash-based comparison and correctly handles duplicate
+        /// values. It is suitable for properties with <c>isOrdered = false</c>
+        /// semantics in the metamodel.
+        /// </remarks>
+        public static bool UnorderedEqual(IReadOnlyList<Guid> a, IReadOnlyList<Guid> b)
+        {
+            if (ReferenceEquals(a, b)) return true;
+            if (a is null || b is null) return false;
+
+            var count = a.Count;
+            if (count != b.Count) return false;
+
+            var counts = new Dictionary<Guid, int>(count);
+
+            for (var i = 0; i < count; i++)
+            {
+                var key = a[i];
+                if (counts.TryGetValue(key, out var existing))
+                {
+                    counts[key] = existing + 1;
+                }
+                else
+                {
+                    counts.Add(key, 1);
+                }
+            }
+
+            for (var i = 0; i < count; i++)
+            {
+                var key = b[i];
+                if (!counts.TryGetValue(key, out var existing))
+                {
+                    return false;
+                }
+
+                if (existing == 1)
+                {
+                    counts.Remove(key);
+                }
+                else
+                {
+                    counts[key] = existing - 1;
+                }
+            }
+
+            return counts.Count == 0;
+        }
+    }
+}
diff --git a/SysML2.NET.Extensions/Comparers/StringSequenceEquality.cs b/SysML2.NET.Extensions/Comparers/StringSequenceEquality.cs
new file mode 100644
index 000000000..7d19d7d30
--- /dev/null
+++ b/SysML2.NET.Extensions/Comparers/StringSequenceEquality.cs
@@ -0,0 +1,113 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StringSequenceEquality.cs" company="Starion Group S.A.">
+// 
+//   Copyright 2022-2025 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.Extensions.Comparers
+{
+    using System;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Provides utility methods for comparing sequences of <see cref="string"/> values
+    /// using ordered and unordered equality semantics.
+    /// </summary>
+    /// <remarks>
+    /// All comparisons performed by this class use <em>ordinal</em> string semantics
+    /// by default (<see cref="StringComparer.Ordinal"/>), ensuring deterministic,
+    /// culture-independent behavior suitable for identifiers, names, and other
+    /// model-level string values.
+    /// </remarks>
+    public static class StringSequenceEquality
+    {
+        /// <summary>
+        /// Determines whether two string sequences are equal using an ordered
+        /// (positional) comparison with ordinal semantics.
+        /// </summary>
+        public static bool OrderedEqual(IReadOnlyList<string> a, IReadOnlyList<string> b, StringComparer comparer = null)
+        {
+            comparer ??= StringComparer.Ordinal;
+
+            if (ReferenceEquals(a, b)) return true;
+            if (a is null || b is null) return false;
+
+            var count = a.Count;
+            if (count != b.Count) return false;
+
+            for (var i = 0; i < count; i++)
+            {
+                if (!comparer.Equals(a[i], b[i]))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Determines whether two string sequences are equal regardless of order,
+        /// using ordinal semantics.
+        /// </summary>
+        public static bool UnorderedEqual(IReadOnlyList<string> a, IReadOnlyList<string> b, StringComparer comparer = null)
+        {
+            comparer ??= StringComparer.Ordinal;
+
+            if (ReferenceEquals(a, b)) return true;
+            if (a is null || b is null) return false;
+
+            var count = a.Count;
+            if (count != b.Count) return false;
+
+            var set = new Dictionary<string, int>(count, comparer);
+
+            for (var i = 0; i < count; i++)
+            {
+                var value = a[i];
+                if (set.TryGetValue(value, out var current))
+                {
+                    set[value] = current + 1;
+                }
+                else
+                {
+                    set[value] = 1;
+                }
+            }
+
+            for (var i = 0; i < count; i++)
+            {
+                var value = b[i];
+                if (!set.TryGetValue(value, out var current))
+                {
+                    return false;
+                }
+
+                if (current == 1)
+                {
+                    set.Remove(value);
+                }
+                else
+                {
+                    set[value] = current - 1;
+                }
+            }
+
+            return set.Count == 0;
+        }
+    }
+}
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AcceptActionUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AcceptActionUsageComparer.cs
new file mode 100644
index 000000000..ab72e1281
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AcceptActionUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AcceptActionUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAcceptActionUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAcceptActionUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AcceptActionUsageComparer : IEqualityComparer<IAcceptActionUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAcceptActionUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAcceptActionUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAcceptActionUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAcceptActionUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAcceptActionUsage x, IAcceptActionUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAcceptActionUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAcceptActionUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAcceptActionUsage obj)
+        {
+            return HashCode.Combine(typeof(IAcceptActionUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ActionDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ActionDefinitionComparer.cs
new file mode 100644
index 000000000..f0ac75e13
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ActionDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ActionDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IActionDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IActionDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ActionDefinitionComparer : IEqualityComparer<IActionDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IActionDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IActionDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IActionDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IActionDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IActionDefinition x, IActionDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IActionDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IActionDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IActionDefinition obj)
+        {
+            return HashCode.Combine(typeof(IActionDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ActionUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ActionUsageComparer.cs
new file mode 100644
index 000000000..2ff6e020c
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ActionUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ActionUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IActionUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IActionUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ActionUsageComparer : IEqualityComparer<IActionUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IActionUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IActionUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IActionUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IActionUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IActionUsage x, IActionUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IActionUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IActionUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IActionUsage obj)
+        {
+            return HashCode.Combine(typeof(IActionUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ActorMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ActorMembershipComparer.cs
new file mode 100644
index 000000000..248e487fd
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ActorMembershipComparer.cs
@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ActorMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Systems.Requirements;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IActorMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IActorMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ActorMembershipComparer : IEqualityComparer<IActorMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IActorMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IActorMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IActorMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IActorMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IActorMembership x, IActorMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IActorMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IActorMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IActorMembership obj)
+        {
+            return HashCode.Combine(typeof(IActorMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AllocationDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AllocationDefinitionComparer.cs
new file mode 100644
index 000000000..78610f3de
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AllocationDefinitionComparer.cs
@@ -0,0 +1,138 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AllocationDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Allocations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAllocationDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAllocationDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AllocationDefinitionComparer : IEqualityComparer<IAllocationDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAllocationDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAllocationDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAllocationDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAllocationDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAllocationDefinition x, IAllocationDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAllocationDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAllocationDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAllocationDefinition obj)
+        {
+            return HashCode.Combine(typeof(IAllocationDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AllocationUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AllocationUsageComparer.cs
new file mode 100644
index 000000000..02bc7025d
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AllocationUsageComparer.cs
@@ -0,0 +1,158 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AllocationUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Allocations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAllocationUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAllocationUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AllocationUsageComparer : IEqualityComparer<IAllocationUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAllocationUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAllocationUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAllocationUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAllocationUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAllocationUsage x, IAllocationUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAllocationUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAllocationUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAllocationUsage obj)
+        {
+            return HashCode.Combine(typeof(IAllocationUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AnalysisCaseDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AnalysisCaseDefinitionComparer.cs
new file mode 100644
index 000000000..d51e8e9be
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AnalysisCaseDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AnalysisCaseDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.AnalysisCases;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAnalysisCaseDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAnalysisCaseDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AnalysisCaseDefinitionComparer : IEqualityComparer<IAnalysisCaseDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAnalysisCaseDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAnalysisCaseDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAnalysisCaseDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAnalysisCaseDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAnalysisCaseDefinition x, IAnalysisCaseDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAnalysisCaseDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAnalysisCaseDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAnalysisCaseDefinition obj)
+        {
+            return HashCode.Combine(typeof(IAnalysisCaseDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AnalysisCaseUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AnalysisCaseUsageComparer.cs
new file mode 100644
index 000000000..e5a331e49
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AnalysisCaseUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AnalysisCaseUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.AnalysisCases;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAnalysisCaseUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAnalysisCaseUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AnalysisCaseUsageComparer : IEqualityComparer<IAnalysisCaseUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAnalysisCaseUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAnalysisCaseUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAnalysisCaseUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAnalysisCaseUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAnalysisCaseUsage x, IAnalysisCaseUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAnalysisCaseUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAnalysisCaseUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAnalysisCaseUsage obj)
+        {
+            return HashCode.Combine(typeof(IAnalysisCaseUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AnnotatingElementComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AnnotatingElementComparer.cs
new file mode 100644
index 000000000..eab4d38d8
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AnnotatingElementComparer.cs
@@ -0,0 +1,124 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AnnotatingElementComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Root.Annotations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAnnotatingElement"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAnnotatingElement"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AnnotatingElementComparer : IEqualityComparer<IAnnotatingElement>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAnnotatingElement"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAnnotatingElement"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAnnotatingElement"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAnnotatingElement"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAnnotatingElement x, IAnnotatingElement y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAnnotatingElement"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAnnotatingElement"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAnnotatingElement obj)
+        {
+            return HashCode.Combine(typeof(IAnnotatingElement), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AnnotationComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AnnotationComparer.cs
new file mode 100644
index 000000000..80d22db2f
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AnnotationComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AnnotationComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Root.Annotations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAnnotation"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAnnotation"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AnnotationComparer : IEqualityComparer<IAnnotation>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAnnotation"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAnnotation"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAnnotation"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAnnotation"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAnnotation x, IAnnotation y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (x.AnnotatedElement != y.AnnotatedElement) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAnnotation"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAnnotation"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAnnotation obj)
+        {
+            return HashCode.Combine(typeof(IAnnotation), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AssertConstraintUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AssertConstraintUsageComparer.cs
new file mode 100644
index 000000000..dcd4814bf
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AssertConstraintUsageComparer.cs
@@ -0,0 +1,154 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AssertConstraintUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Constraints;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAssertConstraintUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAssertConstraintUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AssertConstraintUsageComparer : IEqualityComparer<IAssertConstraintUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAssertConstraintUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAssertConstraintUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAssertConstraintUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAssertConstraintUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAssertConstraintUsage x, IAssertConstraintUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsNegated != y.IsNegated) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAssertConstraintUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAssertConstraintUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAssertConstraintUsage obj)
+        {
+            return HashCode.Combine(typeof(IAssertConstraintUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AssignmentActionUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AssignmentActionUsageComparer.cs
new file mode 100644
index 000000000..6fa054f26
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AssignmentActionUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AssignmentActionUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAssignmentActionUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAssignmentActionUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AssignmentActionUsageComparer : IEqualityComparer<IAssignmentActionUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAssignmentActionUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAssignmentActionUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAssignmentActionUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAssignmentActionUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAssignmentActionUsage x, IAssignmentActionUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAssignmentActionUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAssignmentActionUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAssignmentActionUsage obj)
+        {
+            return HashCode.Combine(typeof(IAssignmentActionUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AssociationComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AssociationComparer.cs
new file mode 100644
index 000000000..21a8b5bdf
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AssociationComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AssociationComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Kernel.Associations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAssociation"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAssociation"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AssociationComparer : IEqualityComparer<IAssociation>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAssociation"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAssociation"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAssociation"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAssociation"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAssociation x, IAssociation y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAssociation"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAssociation"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAssociation obj)
+        {
+            return HashCode.Combine(typeof(IAssociation), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AssociationStructureComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AssociationStructureComparer.cs
new file mode 100644
index 000000000..f5ef44b25
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AssociationStructureComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AssociationStructureComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Kernel.Associations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAssociationStructure"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAssociationStructure"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AssociationStructureComparer : IEqualityComparer<IAssociationStructure>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAssociationStructure"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAssociationStructure"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAssociationStructure"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAssociationStructure"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAssociationStructure x, IAssociationStructure y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAssociationStructure"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAssociationStructure"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAssociationStructure obj)
+        {
+            return HashCode.Combine(typeof(IAssociationStructure), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AttributeDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AttributeDefinitionComparer.cs
new file mode 100644
index 000000000..6ffdb83c6
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AttributeDefinitionComparer.cs
@@ -0,0 +1,130 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AttributeDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Attributes;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAttributeDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAttributeDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AttributeDefinitionComparer : IEqualityComparer<IAttributeDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAttributeDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAttributeDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAttributeDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAttributeDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAttributeDefinition x, IAttributeDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAttributeDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAttributeDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAttributeDefinition obj)
+        {
+            return HashCode.Combine(typeof(IAttributeDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AttributeUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AttributeUsageComparer.cs
new file mode 100644
index 000000000..421822dc7
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/AttributeUsageComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AttributeUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Systems.Attributes;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IAttributeUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IAttributeUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class AttributeUsageComparer : IEqualityComparer<IAttributeUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IAttributeUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IAttributeUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IAttributeUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IAttributeUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IAttributeUsage x, IAttributeUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IAttributeUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IAttributeUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IAttributeUsage obj)
+        {
+            return HashCode.Combine(typeof(IAttributeUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/BehaviorComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/BehaviorComparer.cs
new file mode 100644
index 000000000..cca506d35
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/BehaviorComparer.cs
@@ -0,0 +1,128 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="BehaviorComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Kernel.Behaviors;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IBehavior"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IBehavior"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class BehaviorComparer : IEqualityComparer<IBehavior>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IBehavior"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IBehavior"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IBehavior"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IBehavior"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IBehavior x, IBehavior y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IBehavior"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IBehavior"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IBehavior obj)
+        {
+            return HashCode.Combine(typeof(IBehavior), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/BindingConnectorAsUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/BindingConnectorAsUsageComparer.cs
new file mode 100644
index 000000000..a0b14e92a
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/BindingConnectorAsUsageComparer.cs
@@ -0,0 +1,153 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="BindingConnectorAsUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Systems.Connections;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IBindingConnectorAsUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IBindingConnectorAsUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class BindingConnectorAsUsageComparer : IEqualityComparer<IBindingConnectorAsUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IBindingConnectorAsUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IBindingConnectorAsUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IBindingConnectorAsUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IBindingConnectorAsUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IBindingConnectorAsUsage x, IBindingConnectorAsUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IBindingConnectorAsUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IBindingConnectorAsUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IBindingConnectorAsUsage obj)
+        {
+            return HashCode.Combine(typeof(IBindingConnectorAsUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/BindingConnectorComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/BindingConnectorComparer.cs
new file mode 100644
index 000000000..971212f54
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/BindingConnectorComparer.cs
@@ -0,0 +1,153 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="BindingConnectorComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Connectors;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IBindingConnector"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IBindingConnector"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class BindingConnectorComparer : IEqualityComparer<IBindingConnector>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IBindingConnector"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IBindingConnector"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IBindingConnector"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IBindingConnector"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IBindingConnector x, IBindingConnector y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IBindingConnector"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IBindingConnector"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IBindingConnector obj)
+        {
+            return HashCode.Combine(typeof(IBindingConnector), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/BooleanExpressionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/BooleanExpressionComparer.cs
new file mode 100644
index 000000000..2056e1382
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/BooleanExpressionComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="BooleanExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Functions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IBooleanExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IBooleanExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class BooleanExpressionComparer : IEqualityComparer<IBooleanExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IBooleanExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IBooleanExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IBooleanExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IBooleanExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IBooleanExpression x, IBooleanExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IBooleanExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IBooleanExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IBooleanExpression obj)
+        {
+            return HashCode.Combine(typeof(IBooleanExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CalculationDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CalculationDefinitionComparer.cs
new file mode 100644
index 000000000..ca751035d
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CalculationDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="CalculationDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Calculations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ICalculationDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ICalculationDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class CalculationDefinitionComparer : IEqualityComparer<ICalculationDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ICalculationDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ICalculationDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ICalculationDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ICalculationDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ICalculationDefinition x, ICalculationDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ICalculationDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ICalculationDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ICalculationDefinition obj)
+        {
+            return HashCode.Combine(typeof(ICalculationDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CalculationUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CalculationUsageComparer.cs
new file mode 100644
index 000000000..5894715fd
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CalculationUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="CalculationUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Calculations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ICalculationUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ICalculationUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class CalculationUsageComparer : IEqualityComparer<ICalculationUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ICalculationUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ICalculationUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ICalculationUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ICalculationUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ICalculationUsage x, ICalculationUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ICalculationUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ICalculationUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ICalculationUsage obj)
+        {
+            return HashCode.Combine(typeof(ICalculationUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CaseDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CaseDefinitionComparer.cs
new file mode 100644
index 000000000..2d20d8e5a
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CaseDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="CaseDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Cases;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ICaseDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ICaseDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class CaseDefinitionComparer : IEqualityComparer<ICaseDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ICaseDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ICaseDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ICaseDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ICaseDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ICaseDefinition x, ICaseDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ICaseDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ICaseDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ICaseDefinition obj)
+        {
+            return HashCode.Combine(typeof(ICaseDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CaseUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CaseUsageComparer.cs
new file mode 100644
index 000000000..b25da2b8d
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CaseUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="CaseUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Cases;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ICaseUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ICaseUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class CaseUsageComparer : IEqualityComparer<ICaseUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ICaseUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ICaseUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ICaseUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ICaseUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ICaseUsage x, ICaseUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ICaseUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ICaseUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ICaseUsage obj)
+        {
+            return HashCode.Combine(typeof(ICaseUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ClassComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ClassComparer.cs
new file mode 100644
index 000000000..6de09b78c
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ClassComparer.cs
@@ -0,0 +1,128 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ClassComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Kernel.Classes;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IClass"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IClass"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ClassComparer : IEqualityComparer<IClass>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IClass"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IClass"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IClass"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IClass"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IClass x, IClass y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IClass"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IClass"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IClass obj)
+        {
+            return HashCode.Combine(typeof(IClass), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ClassifierComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ClassifierComparer.cs
new file mode 100644
index 000000000..25de7b397
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ClassifierComparer.cs
@@ -0,0 +1,128 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ClassifierComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Classifiers;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IClassifier"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IClassifier"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ClassifierComparer : IEqualityComparer<IClassifier>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IClassifier"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IClassifier"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IClassifier"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IClassifier"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IClassifier x, IClassifier y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IClassifier"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IClassifier"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IClassifier obj)
+        {
+            return HashCode.Combine(typeof(IClassifier), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CollectExpressionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CollectExpressionComparer.cs
new file mode 100644
index 000000000..39f244cd2
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CollectExpressionComparer.cs
@@ -0,0 +1,149 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="CollectExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ICollectExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ICollectExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class CollectExpressionComparer : IEqualityComparer<ICollectExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ICollectExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ICollectExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ICollectExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ICollectExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ICollectExpression x, ICollectExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Operator, y.Operator)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ICollectExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ICollectExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ICollectExpression obj)
+        {
+            return HashCode.Combine(typeof(ICollectExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CommentComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CommentComparer.cs
new file mode 100644
index 000000000..2aa850d56
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CommentComparer.cs
@@ -0,0 +1,128 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="CommentComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Root.Annotations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IComment"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IComment"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class CommentComparer : IEqualityComparer<IComment>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IComment"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IComment"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IComment"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IComment"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IComment x, IComment y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Body, y.Body)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Locale, y.Locale)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IComment"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IComment"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IComment obj)
+        {
+            return HashCode.Combine(typeof(IComment), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ComparerProvider.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ComparerProvider.cs
new file mode 100644
index 000000000..9427dfcfd
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ComparerProvider.cs
@@ -0,0 +1,333 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ComparerProvider.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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Common;
+
+    /// <summary>
+    /// Provides runtime access to equality comparers for DTO types.
+    /// </summary>
+    public static class ComparerProvider
+    {
+        private static readonly IReadOnlyDictionary<Type, IEqualityComparer<IData>> Comparers =
+            new Dictionary<Type, IEqualityComparer<IData>>
+            {
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.AcceptActionUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.AcceptActionUsage>(new AcceptActionUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.ActionDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.ActionDefinition>(new ActionDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.ActionUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.ActionUsage>(new ActionUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Requirements.ActorMembership), new Adapter<SysML2.NET.Core.DTO.Systems.Requirements.ActorMembership>(new ActorMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Allocations.AllocationDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Allocations.AllocationDefinition>(new AllocationDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Allocations.AllocationUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Allocations.AllocationUsage>(new AllocationUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.AnalysisCases.AnalysisCaseDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.AnalysisCases.AnalysisCaseDefinition>(new AnalysisCaseDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.AnalysisCases.AnalysisCaseUsage), new Adapter<SysML2.NET.Core.DTO.Systems.AnalysisCases.AnalysisCaseUsage>(new AnalysisCaseUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Root.Annotations.AnnotatingElement), new Adapter<SysML2.NET.Core.DTO.Root.Annotations.AnnotatingElement>(new AnnotatingElementComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Root.Annotations.Annotation), new Adapter<SysML2.NET.Core.DTO.Root.Annotations.Annotation>(new AnnotationComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Constraints.AssertConstraintUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Constraints.AssertConstraintUsage>(new AssertConstraintUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.AssignmentActionUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.AssignmentActionUsage>(new AssignmentActionUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Associations.Association), new Adapter<SysML2.NET.Core.DTO.Kernel.Associations.Association>(new AssociationComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Associations.AssociationStructure), new Adapter<SysML2.NET.Core.DTO.Kernel.Associations.AssociationStructure>(new AssociationStructureComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Attributes.AttributeDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Attributes.AttributeDefinition>(new AttributeDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Attributes.AttributeUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Attributes.AttributeUsage>(new AttributeUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Behaviors.Behavior), new Adapter<SysML2.NET.Core.DTO.Kernel.Behaviors.Behavior>(new BehaviorComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Connectors.BindingConnector), new Adapter<SysML2.NET.Core.DTO.Kernel.Connectors.BindingConnector>(new BindingConnectorComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Connections.BindingConnectorAsUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Connections.BindingConnectorAsUsage>(new BindingConnectorAsUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Functions.BooleanExpression), new Adapter<SysML2.NET.Core.DTO.Kernel.Functions.BooleanExpression>(new BooleanExpressionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Calculations.CalculationDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Calculations.CalculationDefinition>(new CalculationDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Calculations.CalculationUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Calculations.CalculationUsage>(new CalculationUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Cases.CaseDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Cases.CaseDefinition>(new CaseDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Cases.CaseUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Cases.CaseUsage>(new CaseUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Classes.Class), new Adapter<SysML2.NET.Core.DTO.Kernel.Classes.Class>(new ClassComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Classifiers.Classifier), new Adapter<SysML2.NET.Core.DTO.Core.Classifiers.Classifier>(new ClassifierComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.CollectExpression), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.CollectExpression>(new CollectExpressionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Root.Annotations.Comment), new Adapter<SysML2.NET.Core.DTO.Root.Annotations.Comment>(new CommentComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Requirements.ConcernDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Requirements.ConcernDefinition>(new ConcernDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Requirements.ConcernUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Requirements.ConcernUsage>(new ConcernUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Ports.ConjugatedPortDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Ports.ConjugatedPortDefinition>(new ConjugatedPortDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Ports.ConjugatedPortTyping), new Adapter<SysML2.NET.Core.DTO.Systems.Ports.ConjugatedPortTyping>(new ConjugatedPortTypingComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Types.Conjugation), new Adapter<SysML2.NET.Core.DTO.Core.Types.Conjugation>(new ConjugationComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Connections.ConnectionDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Connections.ConnectionDefinition>(new ConnectionDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Connections.ConnectionUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Connections.ConnectionUsage>(new ConnectionUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Connectors.Connector), new Adapter<SysML2.NET.Core.DTO.Kernel.Connectors.Connector>(new ConnectorComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Constraints.ConstraintDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Constraints.ConstraintDefinition>(new ConstraintDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Constraints.ConstraintUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Constraints.ConstraintUsage>(new ConstraintUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.ConstructorExpression), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.ConstructorExpression>(new ConstructorExpressionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Features.CrossSubsetting), new Adapter<SysML2.NET.Core.DTO.Core.Features.CrossSubsetting>(new CrossSubsettingComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.DataTypes.DataType), new Adapter<SysML2.NET.Core.DTO.Kernel.DataTypes.DataType>(new DataTypeComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.DecisionNode), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.DecisionNode>(new DecisionNodeComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.DefinitionAndUsage.Definition), new Adapter<SysML2.NET.Core.DTO.Systems.DefinitionAndUsage.Definition>(new DefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Root.Dependencies.Dependency), new Adapter<SysML2.NET.Core.DTO.Root.Dependencies.Dependency>(new DependencyComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Types.Differencing), new Adapter<SysML2.NET.Core.DTO.Core.Types.Differencing>(new DifferencingComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Types.Disjoining), new Adapter<SysML2.NET.Core.DTO.Core.Types.Disjoining>(new DisjoiningComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Root.Annotations.Documentation), new Adapter<SysML2.NET.Core.DTO.Root.Annotations.Documentation>(new DocumentationComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Packages.ElementFilterMembership), new Adapter<SysML2.NET.Core.DTO.Kernel.Packages.ElementFilterMembership>(new ElementFilterMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Features.EndFeatureMembership), new Adapter<SysML2.NET.Core.DTO.Core.Features.EndFeatureMembership>(new EndFeatureMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Enumerations.EnumerationDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Enumerations.EnumerationDefinition>(new EnumerationDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Enumerations.EnumerationUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Enumerations.EnumerationUsage>(new EnumerationUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Occurrences.EventOccurrenceUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Occurrences.EventOccurrenceUsage>(new EventOccurrenceUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.States.ExhibitStateUsage), new Adapter<SysML2.NET.Core.DTO.Systems.States.ExhibitStateUsage>(new ExhibitStateUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Functions.Expression), new Adapter<SysML2.NET.Core.DTO.Kernel.Functions.Expression>(new ExpressionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Features.Feature), new Adapter<SysML2.NET.Core.DTO.Core.Features.Feature>(new FeatureComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.FeatureChainExpression), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.FeatureChainExpression>(new FeatureChainExpressionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Features.FeatureChaining), new Adapter<SysML2.NET.Core.DTO.Core.Features.FeatureChaining>(new FeatureChainingComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Features.FeatureInverting), new Adapter<SysML2.NET.Core.DTO.Core.Features.FeatureInverting>(new FeatureInvertingComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Types.FeatureMembership), new Adapter<SysML2.NET.Core.DTO.Core.Types.FeatureMembership>(new FeatureMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.FeatureReferenceExpression), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.FeatureReferenceExpression>(new FeatureReferenceExpressionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Features.FeatureTyping), new Adapter<SysML2.NET.Core.DTO.Core.Features.FeatureTyping>(new FeatureTypingComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.FeatureValues.FeatureValue), new Adapter<SysML2.NET.Core.DTO.Kernel.FeatureValues.FeatureValue>(new FeatureValueComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Interactions.Flow), new Adapter<SysML2.NET.Core.DTO.Kernel.Interactions.Flow>(new FlowComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Flows.FlowDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Flows.FlowDefinition>(new FlowDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Interactions.FlowEnd), new Adapter<SysML2.NET.Core.DTO.Kernel.Interactions.FlowEnd>(new FlowEndComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Flows.FlowUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Flows.FlowUsage>(new FlowUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.ForkNode), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.ForkNode>(new ForkNodeComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.ForLoopActionUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.ForLoopActionUsage>(new ForLoopActionUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Requirements.FramedConcernMembership), new Adapter<SysML2.NET.Core.DTO.Systems.Requirements.FramedConcernMembership>(new FramedConcernMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Functions.Function), new Adapter<SysML2.NET.Core.DTO.Kernel.Functions.Function>(new FunctionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.IfActionUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.IfActionUsage>(new IfActionUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.UseCases.IncludeUseCaseUsage), new Adapter<SysML2.NET.Core.DTO.Systems.UseCases.IncludeUseCaseUsage>(new IncludeUseCaseUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.IndexExpression), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.IndexExpression>(new IndexExpressionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Interactions.Interaction), new Adapter<SysML2.NET.Core.DTO.Kernel.Interactions.Interaction>(new InteractionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Interfaces.InterfaceDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Interfaces.InterfaceDefinition>(new InterfaceDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Interfaces.InterfaceUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Interfaces.InterfaceUsage>(new InterfaceUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Types.Intersecting), new Adapter<SysML2.NET.Core.DTO.Core.Types.Intersecting>(new IntersectingComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Functions.Invariant), new Adapter<SysML2.NET.Core.DTO.Kernel.Functions.Invariant>(new InvariantComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.InvocationExpression), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.InvocationExpression>(new InvocationExpressionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Items.ItemDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Items.ItemDefinition>(new ItemDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Items.ItemUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Items.ItemUsage>(new ItemUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.JoinNode), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.JoinNode>(new JoinNodeComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Packages.LibraryPackage), new Adapter<SysML2.NET.Core.DTO.Kernel.Packages.LibraryPackage>(new LibraryPackageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.LiteralBoolean), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.LiteralBoolean>(new LiteralBooleanComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.LiteralExpression), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.LiteralExpression>(new LiteralExpressionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.LiteralInfinity), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.LiteralInfinity>(new LiteralInfinityComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.LiteralInteger), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.LiteralInteger>(new LiteralIntegerComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.LiteralRational), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.LiteralRational>(new LiteralRationalComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.LiteralString), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.LiteralString>(new LiteralStringComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Root.Namespaces.Membership), new Adapter<SysML2.NET.Core.DTO.Root.Namespaces.Membership>(new MembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Views.MembershipExpose), new Adapter<SysML2.NET.Core.DTO.Systems.Views.MembershipExpose>(new MembershipExposeComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Root.Namespaces.MembershipImport), new Adapter<SysML2.NET.Core.DTO.Root.Namespaces.MembershipImport>(new MembershipImportComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.MergeNode), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.MergeNode>(new MergeNodeComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Metadata.Metaclass), new Adapter<SysML2.NET.Core.DTO.Kernel.Metadata.Metaclass>(new MetaclassComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.MetadataAccessExpression), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.MetadataAccessExpression>(new MetadataAccessExpressionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Metadata.MetadataDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Metadata.MetadataDefinition>(new MetadataDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Metadata.MetadataFeature), new Adapter<SysML2.NET.Core.DTO.Kernel.Metadata.MetadataFeature>(new MetadataFeatureComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Metadata.MetadataUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Metadata.MetadataUsage>(new MetadataUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Types.Multiplicity), new Adapter<SysML2.NET.Core.DTO.Core.Types.Multiplicity>(new MultiplicityComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Multiplicities.MultiplicityRange), new Adapter<SysML2.NET.Core.DTO.Kernel.Multiplicities.MultiplicityRange>(new MultiplicityRangeComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Root.Namespaces.Namespace), new Adapter<SysML2.NET.Core.DTO.Root.Namespaces.Namespace>(new NamespaceComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Views.NamespaceExpose), new Adapter<SysML2.NET.Core.DTO.Systems.Views.NamespaceExpose>(new NamespaceExposeComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Root.Namespaces.NamespaceImport), new Adapter<SysML2.NET.Core.DTO.Root.Namespaces.NamespaceImport>(new NamespaceImportComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.NullExpression), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.NullExpression>(new NullExpressionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Cases.ObjectiveMembership), new Adapter<SysML2.NET.Core.DTO.Systems.Cases.ObjectiveMembership>(new ObjectiveMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Occurrences.OccurrenceDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Occurrences.OccurrenceDefinition>(new OccurrenceDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Occurrences.OccurrenceUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Occurrences.OccurrenceUsage>(new OccurrenceUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.OperatorExpression), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.OperatorExpression>(new OperatorExpressionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Root.Namespaces.OwningMembership), new Adapter<SysML2.NET.Core.DTO.Root.Namespaces.OwningMembership>(new OwningMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Packages.Package), new Adapter<SysML2.NET.Core.DTO.Kernel.Packages.Package>(new PackageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Behaviors.ParameterMembership), new Adapter<SysML2.NET.Core.DTO.Kernel.Behaviors.ParameterMembership>(new ParameterMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Parts.PartDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Parts.PartDefinition>(new PartDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Parts.PartUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Parts.PartUsage>(new PartUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Interactions.PayloadFeature), new Adapter<SysML2.NET.Core.DTO.Kernel.Interactions.PayloadFeature>(new PayloadFeatureComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.PerformActionUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.PerformActionUsage>(new PerformActionUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Ports.PortConjugation), new Adapter<SysML2.NET.Core.DTO.Systems.Ports.PortConjugation>(new PortConjugationComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Ports.PortDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Ports.PortDefinition>(new PortDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Ports.PortUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Ports.PortUsage>(new PortUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Functions.Predicate), new Adapter<SysML2.NET.Core.DTO.Kernel.Functions.Predicate>(new PredicateComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Features.Redefinition), new Adapter<SysML2.NET.Core.DTO.Core.Features.Redefinition>(new RedefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Features.ReferenceSubsetting), new Adapter<SysML2.NET.Core.DTO.Core.Features.ReferenceSubsetting>(new ReferenceSubsettingComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.DefinitionAndUsage.ReferenceUsage), new Adapter<SysML2.NET.Core.DTO.Systems.DefinitionAndUsage.ReferenceUsage>(new ReferenceUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Views.RenderingDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Views.RenderingDefinition>(new RenderingDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Views.RenderingUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Views.RenderingUsage>(new RenderingUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Requirements.RequirementConstraintMembership), new Adapter<SysML2.NET.Core.DTO.Systems.Requirements.RequirementConstraintMembership>(new RequirementConstraintMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Requirements.RequirementDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Requirements.RequirementDefinition>(new RequirementDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Requirements.RequirementUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Requirements.RequirementUsage>(new RequirementUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.VerificationCases.RequirementVerificationMembership), new Adapter<SysML2.NET.Core.DTO.Systems.VerificationCases.RequirementVerificationMembership>(new RequirementVerificationMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Functions.ResultExpressionMembership), new Adapter<SysML2.NET.Core.DTO.Kernel.Functions.ResultExpressionMembership>(new ResultExpressionMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Functions.ReturnParameterMembership), new Adapter<SysML2.NET.Core.DTO.Kernel.Functions.ReturnParameterMembership>(new ReturnParameterMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Requirements.SatisfyRequirementUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Requirements.SatisfyRequirementUsage>(new SatisfyRequirementUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Expressions.SelectExpression), new Adapter<SysML2.NET.Core.DTO.Kernel.Expressions.SelectExpression>(new SelectExpressionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.SendActionUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.SendActionUsage>(new SendActionUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Types.Specialization), new Adapter<SysML2.NET.Core.DTO.Core.Types.Specialization>(new SpecializationComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Requirements.StakeholderMembership), new Adapter<SysML2.NET.Core.DTO.Systems.Requirements.StakeholderMembership>(new StakeholderMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.States.StateDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.States.StateDefinition>(new StateDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.States.StateSubactionMembership), new Adapter<SysML2.NET.Core.DTO.Systems.States.StateSubactionMembership>(new StateSubactionMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.States.StateUsage), new Adapter<SysML2.NET.Core.DTO.Systems.States.StateUsage>(new StateUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Behaviors.Step), new Adapter<SysML2.NET.Core.DTO.Kernel.Behaviors.Step>(new StepComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Structures.Structure), new Adapter<SysML2.NET.Core.DTO.Kernel.Structures.Structure>(new StructureComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Classifiers.Subclassification), new Adapter<SysML2.NET.Core.DTO.Core.Classifiers.Subclassification>(new SubclassificationComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Requirements.SubjectMembership), new Adapter<SysML2.NET.Core.DTO.Systems.Requirements.SubjectMembership>(new SubjectMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Features.Subsetting), new Adapter<SysML2.NET.Core.DTO.Core.Features.Subsetting>(new SubsettingComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Connectors.Succession), new Adapter<SysML2.NET.Core.DTO.Kernel.Connectors.Succession>(new SuccessionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Connections.SuccessionAsUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Connections.SuccessionAsUsage>(new SuccessionAsUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Kernel.Interactions.SuccessionFlow), new Adapter<SysML2.NET.Core.DTO.Kernel.Interactions.SuccessionFlow>(new SuccessionFlowComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Flows.SuccessionFlowUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Flows.SuccessionFlowUsage>(new SuccessionFlowUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.TerminateActionUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.TerminateActionUsage>(new TerminateActionUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Root.Annotations.TextualRepresentation), new Adapter<SysML2.NET.Core.DTO.Root.Annotations.TextualRepresentation>(new TextualRepresentationComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.States.TransitionFeatureMembership), new Adapter<SysML2.NET.Core.DTO.Systems.States.TransitionFeatureMembership>(new TransitionFeatureMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.States.TransitionUsage), new Adapter<SysML2.NET.Core.DTO.Systems.States.TransitionUsage>(new TransitionUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.TriggerInvocationExpression), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.TriggerInvocationExpression>(new TriggerInvocationExpressionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Types.Type), new Adapter<SysML2.NET.Core.DTO.Core.Types.Type>(new TypeComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Features.TypeFeaturing), new Adapter<SysML2.NET.Core.DTO.Core.Features.TypeFeaturing>(new TypeFeaturingComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Core.Types.Unioning), new Adapter<SysML2.NET.Core.DTO.Core.Types.Unioning>(new UnioningComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.DefinitionAndUsage.Usage), new Adapter<SysML2.NET.Core.DTO.Systems.DefinitionAndUsage.Usage>(new UsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.UseCases.UseCaseDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.UseCases.UseCaseDefinition>(new UseCaseDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.UseCases.UseCaseUsage), new Adapter<SysML2.NET.Core.DTO.Systems.UseCases.UseCaseUsage>(new UseCaseUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.DefinitionAndUsage.VariantMembership), new Adapter<SysML2.NET.Core.DTO.Systems.DefinitionAndUsage.VariantMembership>(new VariantMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.VerificationCases.VerificationCaseDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.VerificationCases.VerificationCaseDefinition>(new VerificationCaseDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.VerificationCases.VerificationCaseUsage), new Adapter<SysML2.NET.Core.DTO.Systems.VerificationCases.VerificationCaseUsage>(new VerificationCaseUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Views.ViewDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Views.ViewDefinition>(new ViewDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Views.ViewpointDefinition), new Adapter<SysML2.NET.Core.DTO.Systems.Views.ViewpointDefinition>(new ViewpointDefinitionComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Views.ViewpointUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Views.ViewpointUsage>(new ViewpointUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Views.ViewRenderingMembership), new Adapter<SysML2.NET.Core.DTO.Systems.Views.ViewRenderingMembership>(new ViewRenderingMembershipComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Views.ViewUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Views.ViewUsage>(new ViewUsageComparer()) },
+                { typeof(SysML2.NET.Core.DTO.Systems.Actions.WhileLoopActionUsage), new Adapter<SysML2.NET.Core.DTO.Systems.Actions.WhileLoopActionUsage>(new WhileLoopActionUsageComparer()) },
+            };
+
+        /// <summary>
+        /// Resolves the equality comparer for the specified DTO runtime type.
+        /// </summary>
+        public static IEqualityComparer<IData> Resolve(Type dtoType)
+        {
+            if (dtoType == null)
+            {
+                throw new ArgumentNullException(nameof(dtoType));
+            }
+
+            if (!Comparers.TryGetValue(dtoType, out var comparer))
+            {
+                throw new NotSupportedException($"No equality comparer generated for DTO type '{dtoType.FullName}'.");
+            }
+
+            return comparer;
+        }
+
+        /// <summary>
+        /// Resolves the equality comparer for the runtime type of the given DTO.
+        /// </summary>
+        public static IEqualityComparer<IData> Resolve(IData dto)
+        {
+            if (dto == null)
+            {
+                throw new ArgumentNullException(nameof(dto));
+            }
+
+            return Resolve(dto.GetType());
+        }
+
+        /// <summary>
+        /// Adapts a strongly-typed comparer to <see cref="IEqualityComparer{IData}"/>.
+        /// This adapter exists solely to bridge generic invariance in C#.
+        /// </summary>
+        private sealed class Adapter<T> : IEqualityComparer<IData>
+            where T : class, IData
+        {
+            private readonly IEqualityComparer<T> inner;
+
+            /// <summary>
+            /// Initializes a new instance of the <see cref="Adapter{T}"/> class
+            /// wrapping the specified strongly-typed comparer.
+            /// </summary>
+            /// <param name="inner">
+            /// The generated equality comparer responsible for comparing instances
+            /// of <typeparamref name="T"/>.
+            /// </param>
+            /// <exception cref="ArgumentNullException">
+            /// Thrown when <paramref name="inner"/> is <c>null</c>.
+            /// </exception>
+            public Adapter(IEqualityComparer<T> inner)
+            {
+                this.inner = inner;
+            }
+
+            /// <summary>
+            /// Determines whether the specified <see cref="IData"/> instances are
+            /// equal by delegating to the wrapped <see cref="IEqualityComparer{T}"/>.
+            /// </summary>
+            /// <param name="x">
+            /// The first object to compare.
+            /// </param>
+            /// <param name="y">
+            /// The second object to compare.
+            /// </param>
+            /// <returns>
+            /// <c>true</c> if <paramref name="x"/> and <paramref name="y"/> are
+            /// considered equal according to the wrapped comparer; otherwise,
+            /// <c>false</c>.
+            /// </returns>
+            /// <remarks>
+            /// <para>
+            /// If both references are identical, the method returns <c>true</c>
+            /// immediately. If either reference is <c>null</c>, the method returns
+            /// <c>false</c>.
+            /// </para>
+            /// <para>
+            /// Both arguments are expected to be instances of
+            /// <typeparamref name="T"/>. This invariant is guaranteed by
+            /// <see cref="ComparerProvider"/>, which resolves adapters strictly
+            /// by the runtime type of the DTO.
+            /// </para>
+            /// </remarks>
+            public bool Equals(IData x, IData y)
+            {
+                if (ReferenceEquals(x, y)) return true;
+                if (x is null || y is null) return false;
+
+                return this.inner.Equals((T)x, (T)y);
+            }
+
+            /// <summary>
+            /// Returns a hash code for the specified <see cref="IData"/> instance
+            /// by delegating to the wrapped <see cref="IEqualityComparer{T}"/>.
+            /// </summary>
+            /// <param name="obj">
+            /// The object for which a hash code is to be returned.
+            /// </param>
+            /// <returns>
+            /// A hash code for <paramref name="obj"/>, suitable for use in hash-based
+            /// collections when combined with the corresponding equality semantics.
+            /// </returns>
+            /// <remarks>
+            /// <para>
+            /// The hash code implementation is fully delegated to the wrapped
+            /// comparer and therefore remains consistent with its
+            /// <see cref="Equals(IData, IData)"/> semantics.
+            /// </para>
+            /// <para>
+            /// The adapter does not attempt to normalize or reinterpret the hash
+            /// code in any way.
+            /// </para>
+            /// </remarks>
+            public int GetHashCode(IData obj)
+            {
+                return this.inner.GetHashCode((T)obj);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConcernDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConcernDefinitionComparer.cs
new file mode 100644
index 000000000..3a5928b3f
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConcernDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConcernDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Requirements;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IConcernDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IConcernDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ConcernDefinitionComparer : IEqualityComparer<IConcernDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IConcernDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IConcernDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IConcernDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IConcernDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IConcernDefinition x, IConcernDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ReqId, y.ReqId)) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IConcernDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IConcernDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IConcernDefinition obj)
+        {
+            return HashCode.Combine(typeof(IConcernDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConcernUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConcernUsageComparer.cs
new file mode 100644
index 000000000..9f3568165
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConcernUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConcernUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Requirements;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IConcernUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IConcernUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ConcernUsageComparer : IEqualityComparer<IConcernUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IConcernUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IConcernUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IConcernUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IConcernUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IConcernUsage x, IConcernUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ReqId, y.ReqId)) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IConcernUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IConcernUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IConcernUsage obj)
+        {
+            return HashCode.Combine(typeof(IConcernUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConjugatedPortDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConjugatedPortDefinitionComparer.cs
new file mode 100644
index 000000000..3e6e50e05
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConjugatedPortDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConjugatedPortDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Ports;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IConjugatedPortDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IConjugatedPortDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ConjugatedPortDefinitionComparer : IEqualityComparer<IConjugatedPortDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IConjugatedPortDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IConjugatedPortDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IConjugatedPortDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IConjugatedPortDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IConjugatedPortDefinition x, IConjugatedPortDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IConjugatedPortDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IConjugatedPortDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IConjugatedPortDefinition obj)
+        {
+            return HashCode.Combine(typeof(IConjugatedPortDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConjugatedPortTypingComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConjugatedPortTypingComparer.cs
new file mode 100644
index 000000000..7ff27c67a
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConjugatedPortTypingComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConjugatedPortTypingComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Ports;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IConjugatedPortTyping"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IConjugatedPortTyping"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ConjugatedPortTypingComparer : IEqualityComparer<IConjugatedPortTyping>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IConjugatedPortTyping"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IConjugatedPortTyping"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IConjugatedPortTyping"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IConjugatedPortTyping"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IConjugatedPortTyping x, IConjugatedPortTyping y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (x.ConjugatedPortDefinition != y.ConjugatedPortDefinition) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.TypedFeature != y.TypedFeature) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IConjugatedPortTyping"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IConjugatedPortTyping"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IConjugatedPortTyping obj)
+        {
+            return HashCode.Combine(typeof(IConjugatedPortTyping), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConjugationComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConjugationComparer.cs
new file mode 100644
index 000000000..1044f6599
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConjugationComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConjugationComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Types;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IConjugation"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IConjugation"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ConjugationComparer : IEqualityComparer<IConjugation>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IConjugation"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IConjugation"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IConjugation"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IConjugation"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IConjugation x, IConjugation y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (x.ConjugatedType != y.ConjugatedType) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.OriginalType != y.OriginalType) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IConjugation"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IConjugation"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IConjugation obj)
+        {
+            return HashCode.Combine(typeof(IConjugation), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConnectionDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConnectionDefinitionComparer.cs
new file mode 100644
index 000000000..9fb0a6229
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConnectionDefinitionComparer.cs
@@ -0,0 +1,138 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConnectionDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Connections;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IConnectionDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IConnectionDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ConnectionDefinitionComparer : IEqualityComparer<IConnectionDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IConnectionDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IConnectionDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IConnectionDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IConnectionDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IConnectionDefinition x, IConnectionDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IConnectionDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IConnectionDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IConnectionDefinition obj)
+        {
+            return HashCode.Combine(typeof(IConnectionDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConnectionUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConnectionUsageComparer.cs
new file mode 100644
index 000000000..e6f264c4b
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConnectionUsageComparer.cs
@@ -0,0 +1,158 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConnectionUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Connections;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IConnectionUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IConnectionUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ConnectionUsageComparer : IEqualityComparer<IConnectionUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IConnectionUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IConnectionUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IConnectionUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IConnectionUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IConnectionUsage x, IConnectionUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IConnectionUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IConnectionUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IConnectionUsage obj)
+        {
+            return HashCode.Combine(typeof(IConnectionUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConnectorComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConnectorComparer.cs
new file mode 100644
index 000000000..167b967bd
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConnectorComparer.cs
@@ -0,0 +1,153 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConnectorComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Connectors;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IConnector"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IConnector"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ConnectorComparer : IEqualityComparer<IConnector>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IConnector"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IConnector"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IConnector"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IConnector"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IConnector x, IConnector y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IConnector"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IConnector"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IConnector obj)
+        {
+            return HashCode.Combine(typeof(IConnector), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConstraintDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConstraintDefinitionComparer.cs
new file mode 100644
index 000000000..43f605427
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConstraintDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConstraintDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Constraints;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IConstraintDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IConstraintDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ConstraintDefinitionComparer : IEqualityComparer<IConstraintDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IConstraintDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IConstraintDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IConstraintDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IConstraintDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IConstraintDefinition x, IConstraintDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IConstraintDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IConstraintDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IConstraintDefinition obj)
+        {
+            return HashCode.Combine(typeof(IConstraintDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConstraintUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConstraintUsageComparer.cs
new file mode 100644
index 000000000..acd160699
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConstraintUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConstraintUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Constraints;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IConstraintUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IConstraintUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ConstraintUsageComparer : IEqualityComparer<IConstraintUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IConstraintUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IConstraintUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IConstraintUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IConstraintUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IConstraintUsage x, IConstraintUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IConstraintUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IConstraintUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IConstraintUsage obj)
+        {
+            return HashCode.Combine(typeof(IConstraintUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConstructorExpressionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConstructorExpressionComparer.cs
new file mode 100644
index 000000000..e52621675
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ConstructorExpressionComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConstructorExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IConstructorExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IConstructorExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ConstructorExpressionComparer : IEqualityComparer<IConstructorExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IConstructorExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IConstructorExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IConstructorExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IConstructorExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IConstructorExpression x, IConstructorExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IConstructorExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IConstructorExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IConstructorExpression obj)
+        {
+            return HashCode.Combine(typeof(IConstructorExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CrossSubsettingComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CrossSubsettingComparer.cs
new file mode 100644
index 000000000..68727c7d2
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/CrossSubsettingComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="CrossSubsettingComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Features;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ICrossSubsetting"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ICrossSubsetting"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class CrossSubsettingComparer : IEqualityComparer<ICrossSubsetting>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ICrossSubsetting"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ICrossSubsetting"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ICrossSubsetting"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ICrossSubsetting"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ICrossSubsetting x, ICrossSubsetting y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (x.CrossedFeature != y.CrossedFeature) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ICrossSubsetting"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ICrossSubsetting"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ICrossSubsetting obj)
+        {
+            return HashCode.Combine(typeof(ICrossSubsetting), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DataTypeComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DataTypeComparer.cs
new file mode 100644
index 000000000..8d2326434
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DataTypeComparer.cs
@@ -0,0 +1,128 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DataTypeComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Kernel.DataTypes;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IDataType"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IDataType"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class DataTypeComparer : IEqualityComparer<IDataType>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IDataType"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IDataType"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IDataType"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IDataType"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IDataType x, IDataType y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IDataType"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IDataType"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IDataType obj)
+        {
+            return HashCode.Combine(typeof(IDataType), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DecisionNodeComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DecisionNodeComparer.cs
new file mode 100644
index 000000000..9d15648ed
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DecisionNodeComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DecisionNodeComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IDecisionNode"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IDecisionNode"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class DecisionNodeComparer : IEqualityComparer<IDecisionNode>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IDecisionNode"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IDecisionNode"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IDecisionNode"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IDecisionNode"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IDecisionNode x, IDecisionNode y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IDecisionNode"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IDecisionNode"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IDecisionNode obj)
+        {
+            return HashCode.Combine(typeof(IDecisionNode), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DefinitionComparer.cs
new file mode 100644
index 000000000..f85fcf9ef
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DefinitionComparer.cs
@@ -0,0 +1,130 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class DefinitionComparer : IEqualityComparer<IDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IDefinition x, IDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IDefinition obj)
+        {
+            return HashCode.Combine(typeof(IDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DependencyComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DependencyComparer.cs
new file mode 100644
index 000000000..5964eb41b
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DependencyComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DependencyComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Root.Dependencies;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IDependency"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IDependency"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class DependencyComparer : IEqualityComparer<IDependency>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IDependency"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IDependency"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IDependency"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IDependency"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IDependency x, IDependency y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.Client, y.Client)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.Supplier, y.Supplier)) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IDependency"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IDependency"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IDependency obj)
+        {
+            return HashCode.Combine(typeof(IDependency), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DifferencingComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DifferencingComparer.cs
new file mode 100644
index 000000000..b017062b5
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DifferencingComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DifferencingComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Types;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IDifferencing"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IDifferencing"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class DifferencingComparer : IEqualityComparer<IDifferencing>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IDifferencing"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IDifferencing"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IDifferencing"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IDifferencing"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IDifferencing x, IDifferencing y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.DifferencingType != y.DifferencingType) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IDifferencing"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IDifferencing"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IDifferencing obj)
+        {
+            return HashCode.Combine(typeof(IDifferencing), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DisjoiningComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DisjoiningComparer.cs
new file mode 100644
index 000000000..133b08bd0
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DisjoiningComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DisjoiningComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Types;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IDisjoining"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IDisjoining"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class DisjoiningComparer : IEqualityComparer<IDisjoining>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IDisjoining"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IDisjoining"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IDisjoining"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IDisjoining"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IDisjoining x, IDisjoining y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.DisjoiningType != y.DisjoiningType) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.TypeDisjoined != y.TypeDisjoined) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IDisjoining"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IDisjoining"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IDisjoining obj)
+        {
+            return HashCode.Combine(typeof(IDisjoining), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DocumentationComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DocumentationComparer.cs
new file mode 100644
index 000000000..d6bffcb50
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/DocumentationComparer.cs
@@ -0,0 +1,128 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DocumentationComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Root.Annotations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IDocumentation"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IDocumentation"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class DocumentationComparer : IEqualityComparer<IDocumentation>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IDocumentation"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IDocumentation"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IDocumentation"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IDocumentation"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IDocumentation x, IDocumentation y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Body, y.Body)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Locale, y.Locale)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IDocumentation"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IDocumentation"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IDocumentation obj)
+        {
+            return HashCode.Combine(typeof(IDocumentation), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ElementFilterMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ElementFilterMembershipComparer.cs
new file mode 100644
index 000000000..bdfd6dd70
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ElementFilterMembershipComparer.cs
@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ElementFilterMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Kernel.Packages;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IElementFilterMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IElementFilterMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ElementFilterMembershipComparer : IEqualityComparer<IElementFilterMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IElementFilterMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IElementFilterMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IElementFilterMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IElementFilterMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IElementFilterMembership x, IElementFilterMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IElementFilterMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IElementFilterMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IElementFilterMembership obj)
+        {
+            return HashCode.Combine(typeof(IElementFilterMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/EndFeatureMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/EndFeatureMembershipComparer.cs
new file mode 100644
index 000000000..df9f95156
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/EndFeatureMembershipComparer.cs
@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="EndFeatureMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Core.Features;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IEndFeatureMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IEndFeatureMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class EndFeatureMembershipComparer : IEqualityComparer<IEndFeatureMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IEndFeatureMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IEndFeatureMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IEndFeatureMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IEndFeatureMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IEndFeatureMembership x, IEndFeatureMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IEndFeatureMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IEndFeatureMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IEndFeatureMembership obj)
+        {
+            return HashCode.Combine(typeof(IEndFeatureMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/EnumerationDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/EnumerationDefinitionComparer.cs
new file mode 100644
index 000000000..6df61fd39
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/EnumerationDefinitionComparer.cs
@@ -0,0 +1,130 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="EnumerationDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Enumerations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IEnumerationDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IEnumerationDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class EnumerationDefinitionComparer : IEqualityComparer<IEnumerationDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IEnumerationDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IEnumerationDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IEnumerationDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IEnumerationDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IEnumerationDefinition x, IEnumerationDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IEnumerationDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IEnumerationDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IEnumerationDefinition obj)
+        {
+            return HashCode.Combine(typeof(IEnumerationDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/EnumerationUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/EnumerationUsageComparer.cs
new file mode 100644
index 000000000..1de1fdf9a
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/EnumerationUsageComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="EnumerationUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Systems.Enumerations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IEnumerationUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IEnumerationUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class EnumerationUsageComparer : IEqualityComparer<IEnumerationUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IEnumerationUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IEnumerationUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IEnumerationUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IEnumerationUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IEnumerationUsage x, IEnumerationUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IEnumerationUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IEnumerationUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IEnumerationUsage obj)
+        {
+            return HashCode.Combine(typeof(IEnumerationUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/EventOccurrenceUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/EventOccurrenceUsageComparer.cs
new file mode 100644
index 000000000..918d688ab
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/EventOccurrenceUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="EventOccurrenceUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Occurrences;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IEventOccurrenceUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IEventOccurrenceUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class EventOccurrenceUsageComparer : IEqualityComparer<IEventOccurrenceUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IEventOccurrenceUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IEventOccurrenceUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IEventOccurrenceUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IEventOccurrenceUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IEventOccurrenceUsage x, IEventOccurrenceUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IEventOccurrenceUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IEventOccurrenceUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IEventOccurrenceUsage obj)
+        {
+            return HashCode.Combine(typeof(IEventOccurrenceUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ExhibitStateUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ExhibitStateUsageComparer.cs
new file mode 100644
index 000000000..c7af48bbe
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ExhibitStateUsageComparer.cs
@@ -0,0 +1,154 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ExhibitStateUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.States;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IExhibitStateUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IExhibitStateUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ExhibitStateUsageComparer : IEqualityComparer<IExhibitStateUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IExhibitStateUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IExhibitStateUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IExhibitStateUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IExhibitStateUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IExhibitStateUsage x, IExhibitStateUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsParallel != y.IsParallel) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IExhibitStateUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IExhibitStateUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IExhibitStateUsage obj)
+        {
+            return HashCode.Combine(typeof(IExhibitStateUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ExpressionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ExpressionComparer.cs
new file mode 100644
index 000000000..176455147
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ExpressionComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Functions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ExpressionComparer : IEqualityComparer<IExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IExpression x, IExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IExpression obj)
+        {
+            return HashCode.Combine(typeof(IExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureChainExpressionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureChainExpressionComparer.cs
new file mode 100644
index 000000000..f78d99116
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureChainExpressionComparer.cs
@@ -0,0 +1,149 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureChainExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFeatureChainExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFeatureChainExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FeatureChainExpressionComparer : IEqualityComparer<IFeatureChainExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFeatureChainExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFeatureChainExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFeatureChainExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFeatureChainExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFeatureChainExpression x, IFeatureChainExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Operator, y.Operator)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFeatureChainExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFeatureChainExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFeatureChainExpression obj)
+        {
+            return HashCode.Combine(typeof(IFeatureChainExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureChainingComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureChainingComparer.cs
new file mode 100644
index 000000000..b0bedc184
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureChainingComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureChainingComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Features;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFeatureChaining"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFeatureChaining"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FeatureChainingComparer : IEqualityComparer<IFeatureChaining>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFeatureChaining"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFeatureChaining"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFeatureChaining"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFeatureChaining"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFeatureChaining x, IFeatureChaining y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (x.ChainingFeature != y.ChainingFeature) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFeatureChaining"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFeatureChaining"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFeatureChaining obj)
+        {
+            return HashCode.Combine(typeof(IFeatureChaining), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureComparer.cs
new file mode 100644
index 000000000..9e147f764
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Core.Features;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFeature"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFeature"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FeatureComparer : IEqualityComparer<IFeature>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFeature"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFeature"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFeature"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFeature"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFeature x, IFeature y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFeature"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFeature"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFeature obj)
+        {
+            return HashCode.Combine(typeof(IFeature), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureInvertingComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureInvertingComparer.cs
new file mode 100644
index 000000000..b19c62164
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureInvertingComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureInvertingComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Features;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFeatureInverting"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFeatureInverting"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FeatureInvertingComparer : IEqualityComparer<IFeatureInverting>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFeatureInverting"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFeatureInverting"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFeatureInverting"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFeatureInverting"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFeatureInverting x, IFeatureInverting y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.FeatureInverted != y.FeatureInverted) return false;
+
+            if (x.InvertingFeature != y.InvertingFeature) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFeatureInverting"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFeatureInverting"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFeatureInverting obj)
+        {
+            return HashCode.Combine(typeof(IFeatureInverting), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureMembershipComparer.cs
new file mode 100644
index 000000000..c10ecb7a9
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureMembershipComparer.cs
@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Core.Types;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFeatureMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFeatureMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FeatureMembershipComparer : IEqualityComparer<IFeatureMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFeatureMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFeatureMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFeatureMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFeatureMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFeatureMembership x, IFeatureMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFeatureMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFeatureMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFeatureMembership obj)
+        {
+            return HashCode.Combine(typeof(IFeatureMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureReferenceExpressionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureReferenceExpressionComparer.cs
new file mode 100644
index 000000000..db57d1349
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureReferenceExpressionComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureReferenceExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFeatureReferenceExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFeatureReferenceExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FeatureReferenceExpressionComparer : IEqualityComparer<IFeatureReferenceExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFeatureReferenceExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFeatureReferenceExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFeatureReferenceExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFeatureReferenceExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFeatureReferenceExpression x, IFeatureReferenceExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFeatureReferenceExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFeatureReferenceExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFeatureReferenceExpression obj)
+        {
+            return HashCode.Combine(typeof(IFeatureReferenceExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureTypingComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureTypingComparer.cs
new file mode 100644
index 000000000..1ababd5e4
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureTypingComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureTypingComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Features;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFeatureTyping"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFeatureTyping"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FeatureTypingComparer : IEqualityComparer<IFeatureTyping>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFeatureTyping"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFeatureTyping"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFeatureTyping"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFeatureTyping"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFeatureTyping x, IFeatureTyping y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Type != y.Type) return false;
+
+            if (x.TypedFeature != y.TypedFeature) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFeatureTyping"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFeatureTyping"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFeatureTyping obj)
+        {
+            return HashCode.Combine(typeof(IFeatureTyping), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureValueComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureValueComparer.cs
new file mode 100644
index 000000000..db56f9ea2
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FeatureValueComparer.cs
@@ -0,0 +1,137 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureValueComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Kernel.FeatureValues;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFeatureValue"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFeatureValue"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FeatureValueComparer : IEqualityComparer<IFeatureValue>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFeatureValue"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFeatureValue"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFeatureValue"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFeatureValue"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFeatureValue x, IFeatureValue y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsDefault != y.IsDefault) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsInitial != y.IsInitial) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFeatureValue"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFeatureValue"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFeatureValue obj)
+        {
+            return HashCode.Combine(typeof(IFeatureValue), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FlowComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FlowComparer.cs
new file mode 100644
index 000000000..273559e59
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FlowComparer.cs
@@ -0,0 +1,153 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FlowComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Interactions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFlow"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFlow"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FlowComparer : IEqualityComparer<IFlow>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFlow"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFlow"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFlow"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFlow"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFlow x, IFlow y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFlow"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFlow"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFlow obj)
+        {
+            return HashCode.Combine(typeof(IFlow), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FlowDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FlowDefinitionComparer.cs
new file mode 100644
index 000000000..89231a8fc
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FlowDefinitionComparer.cs
@@ -0,0 +1,138 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FlowDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Flows;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFlowDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFlowDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FlowDefinitionComparer : IEqualityComparer<IFlowDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFlowDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFlowDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFlowDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFlowDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFlowDefinition x, IFlowDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFlowDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFlowDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFlowDefinition obj)
+        {
+            return HashCode.Combine(typeof(IFlowDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FlowEndComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FlowEndComparer.cs
new file mode 100644
index 000000000..9828bdbf2
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FlowEndComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FlowEndComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Interactions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFlowEnd"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFlowEnd"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FlowEndComparer : IEqualityComparer<IFlowEnd>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFlowEnd"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFlowEnd"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFlowEnd"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFlowEnd"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFlowEnd x, IFlowEnd y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFlowEnd"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFlowEnd"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFlowEnd obj)
+        {
+            return HashCode.Combine(typeof(IFlowEnd), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FlowUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FlowUsageComparer.cs
new file mode 100644
index 000000000..d6d354276
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FlowUsageComparer.cs
@@ -0,0 +1,158 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FlowUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Flows;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFlowUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFlowUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FlowUsageComparer : IEqualityComparer<IFlowUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFlowUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFlowUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFlowUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFlowUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFlowUsage x, IFlowUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFlowUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFlowUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFlowUsage obj)
+        {
+            return HashCode.Combine(typeof(IFlowUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ForLoopActionUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ForLoopActionUsageComparer.cs
new file mode 100644
index 000000000..5f30b78e2
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ForLoopActionUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ForLoopActionUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IForLoopActionUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IForLoopActionUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ForLoopActionUsageComparer : IEqualityComparer<IForLoopActionUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IForLoopActionUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IForLoopActionUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IForLoopActionUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IForLoopActionUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IForLoopActionUsage x, IForLoopActionUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IForLoopActionUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IForLoopActionUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IForLoopActionUsage obj)
+        {
+            return HashCode.Combine(typeof(IForLoopActionUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ForkNodeComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ForkNodeComparer.cs
new file mode 100644
index 000000000..2a10a93e3
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ForkNodeComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ForkNodeComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IForkNode"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IForkNode"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ForkNodeComparer : IEqualityComparer<IForkNode>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IForkNode"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IForkNode"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IForkNode"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IForkNode"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IForkNode x, IForkNode y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IForkNode"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IForkNode"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IForkNode obj)
+        {
+            return HashCode.Combine(typeof(IForkNode), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FramedConcernMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FramedConcernMembershipComparer.cs
new file mode 100644
index 000000000..17d8d9a1d
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FramedConcernMembershipComparer.cs
@@ -0,0 +1,136 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FramedConcernMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.Systems.Requirements;
+    using SysML2.NET.Core.DTO.Systems.Requirements;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFramedConcernMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFramedConcernMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FramedConcernMembershipComparer : IEqualityComparer<IFramedConcernMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFramedConcernMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFramedConcernMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFramedConcernMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFramedConcernMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFramedConcernMembership x, IFramedConcernMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.Kind != y.Kind) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFramedConcernMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFramedConcernMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFramedConcernMembership obj)
+        {
+            return HashCode.Combine(typeof(IFramedConcernMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FunctionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FunctionComparer.cs
new file mode 100644
index 000000000..f285bd76d
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/FunctionComparer.cs
@@ -0,0 +1,128 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FunctionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Kernel.Functions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IFunction"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IFunction"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class FunctionComparer : IEqualityComparer<IFunction>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IFunction"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IFunction"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IFunction"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IFunction"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IFunction x, IFunction y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IFunction"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IFunction"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IFunction obj)
+        {
+            return HashCode.Combine(typeof(IFunction), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/IfActionUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/IfActionUsageComparer.cs
new file mode 100644
index 000000000..384ab1103
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/IfActionUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="IfActionUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IIfActionUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IIfActionUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class IfActionUsageComparer : IEqualityComparer<IIfActionUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IIfActionUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IIfActionUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IIfActionUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IIfActionUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IIfActionUsage x, IIfActionUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IIfActionUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IIfActionUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IIfActionUsage obj)
+        {
+            return HashCode.Combine(typeof(IIfActionUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/IncludeUseCaseUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/IncludeUseCaseUsageComparer.cs
new file mode 100644
index 000000000..a4615d9ea
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/IncludeUseCaseUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="IncludeUseCaseUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.UseCases;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IIncludeUseCaseUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IIncludeUseCaseUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class IncludeUseCaseUsageComparer : IEqualityComparer<IIncludeUseCaseUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IIncludeUseCaseUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IIncludeUseCaseUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IIncludeUseCaseUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IIncludeUseCaseUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IIncludeUseCaseUsage x, IIncludeUseCaseUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IIncludeUseCaseUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IIncludeUseCaseUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IIncludeUseCaseUsage obj)
+        {
+            return HashCode.Combine(typeof(IIncludeUseCaseUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/IndexExpressionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/IndexExpressionComparer.cs
new file mode 100644
index 000000000..313f5dc04
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/IndexExpressionComparer.cs
@@ -0,0 +1,149 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="IndexExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IIndexExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IIndexExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class IndexExpressionComparer : IEqualityComparer<IIndexExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IIndexExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IIndexExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IIndexExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IIndexExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IIndexExpression x, IIndexExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Operator, y.Operator)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IIndexExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IIndexExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IIndexExpression obj)
+        {
+            return HashCode.Combine(typeof(IIndexExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InteractionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InteractionComparer.cs
new file mode 100644
index 000000000..74a9b5288
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InteractionComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="InteractionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Kernel.Interactions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IInteraction"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IInteraction"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class InteractionComparer : IEqualityComparer<IInteraction>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IInteraction"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IInteraction"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IInteraction"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IInteraction"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IInteraction x, IInteraction y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IInteraction"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IInteraction"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IInteraction obj)
+        {
+            return HashCode.Combine(typeof(IInteraction), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InterfaceDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InterfaceDefinitionComparer.cs
new file mode 100644
index 000000000..b2701d890
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InterfaceDefinitionComparer.cs
@@ -0,0 +1,138 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="InterfaceDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Interfaces;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IInterfaceDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IInterfaceDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class InterfaceDefinitionComparer : IEqualityComparer<IInterfaceDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IInterfaceDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IInterfaceDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IInterfaceDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IInterfaceDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IInterfaceDefinition x, IInterfaceDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IInterfaceDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IInterfaceDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IInterfaceDefinition obj)
+        {
+            return HashCode.Combine(typeof(IInterfaceDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InterfaceUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InterfaceUsageComparer.cs
new file mode 100644
index 000000000..9d2d46d5b
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InterfaceUsageComparer.cs
@@ -0,0 +1,158 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="InterfaceUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Interfaces;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IInterfaceUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IInterfaceUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class InterfaceUsageComparer : IEqualityComparer<IInterfaceUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IInterfaceUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IInterfaceUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IInterfaceUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IInterfaceUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IInterfaceUsage x, IInterfaceUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IInterfaceUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IInterfaceUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IInterfaceUsage obj)
+        {
+            return HashCode.Combine(typeof(IInterfaceUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/IntersectingComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/IntersectingComparer.cs
new file mode 100644
index 000000000..7a73eb684
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/IntersectingComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="IntersectingComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Types;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IIntersecting"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IIntersecting"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class IntersectingComparer : IEqualityComparer<IIntersecting>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IIntersecting"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IIntersecting"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IIntersecting"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IIntersecting"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IIntersecting x, IIntersecting y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IntersectingType != y.IntersectingType) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IIntersecting"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IIntersecting"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IIntersecting obj)
+        {
+            return HashCode.Combine(typeof(IIntersecting), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InvariantComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InvariantComparer.cs
new file mode 100644
index 000000000..50e96fdf9
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InvariantComparer.cs
@@ -0,0 +1,149 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="InvariantComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Functions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IInvariant"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IInvariant"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class InvariantComparer : IEqualityComparer<IInvariant>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IInvariant"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IInvariant"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IInvariant"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IInvariant"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IInvariant x, IInvariant y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsNegated != y.IsNegated) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IInvariant"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IInvariant"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IInvariant obj)
+        {
+            return HashCode.Combine(typeof(IInvariant), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InvocationExpressionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InvocationExpressionComparer.cs
new file mode 100644
index 000000000..4d47c1f12
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/InvocationExpressionComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="InvocationExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IInvocationExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IInvocationExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class InvocationExpressionComparer : IEqualityComparer<IInvocationExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IInvocationExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IInvocationExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IInvocationExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IInvocationExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IInvocationExpression x, IInvocationExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IInvocationExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IInvocationExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IInvocationExpression obj)
+        {
+            return HashCode.Combine(typeof(IInvocationExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ItemDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ItemDefinitionComparer.cs
new file mode 100644
index 000000000..ba395d5d9
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ItemDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ItemDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Items;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IItemDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IItemDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ItemDefinitionComparer : IEqualityComparer<IItemDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IItemDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IItemDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IItemDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IItemDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IItemDefinition x, IItemDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IItemDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IItemDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IItemDefinition obj)
+        {
+            return HashCode.Combine(typeof(IItemDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ItemUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ItemUsageComparer.cs
new file mode 100644
index 000000000..5fa005a56
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ItemUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ItemUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Items;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IItemUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IItemUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ItemUsageComparer : IEqualityComparer<IItemUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IItemUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IItemUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IItemUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IItemUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IItemUsage x, IItemUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IItemUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IItemUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IItemUsage obj)
+        {
+            return HashCode.Combine(typeof(IItemUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/JoinNodeComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/JoinNodeComparer.cs
new file mode 100644
index 000000000..fa86b31e6
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/JoinNodeComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="JoinNodeComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IJoinNode"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IJoinNode"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class JoinNodeComparer : IEqualityComparer<IJoinNode>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IJoinNode"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IJoinNode"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IJoinNode"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IJoinNode"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IJoinNode x, IJoinNode y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IJoinNode"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IJoinNode"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IJoinNode obj)
+        {
+            return HashCode.Combine(typeof(IJoinNode), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LibraryPackageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LibraryPackageComparer.cs
new file mode 100644
index 000000000..c001b1824
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LibraryPackageComparer.cs
@@ -0,0 +1,126 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LibraryPackageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Kernel.Packages;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ILibraryPackage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ILibraryPackage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class LibraryPackageComparer : IEqualityComparer<ILibraryPackage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ILibraryPackage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ILibraryPackage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ILibraryPackage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ILibraryPackage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ILibraryPackage x, ILibraryPackage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsStandard != y.IsStandard) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ILibraryPackage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ILibraryPackage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ILibraryPackage obj)
+        {
+            return HashCode.Combine(typeof(ILibraryPackage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralBooleanComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralBooleanComparer.cs
new file mode 100644
index 000000000..5f0462381
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralBooleanComparer.cs
@@ -0,0 +1,149 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LiteralBooleanComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ILiteralBoolean"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ILiteralBoolean"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class LiteralBooleanComparer : IEqualityComparer<ILiteralBoolean>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ILiteralBoolean"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ILiteralBoolean"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ILiteralBoolean"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ILiteralBoolean"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ILiteralBoolean x, ILiteralBoolean y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Value != y.Value) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ILiteralBoolean"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ILiteralBoolean"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ILiteralBoolean obj)
+        {
+            return HashCode.Combine(typeof(ILiteralBoolean), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralExpressionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralExpressionComparer.cs
new file mode 100644
index 000000000..8ebf3de1d
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralExpressionComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LiteralExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ILiteralExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ILiteralExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class LiteralExpressionComparer : IEqualityComparer<ILiteralExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ILiteralExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ILiteralExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ILiteralExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ILiteralExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ILiteralExpression x, ILiteralExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ILiteralExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ILiteralExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ILiteralExpression obj)
+        {
+            return HashCode.Combine(typeof(ILiteralExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralInfinityComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralInfinityComparer.cs
new file mode 100644
index 000000000..57a646ed2
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralInfinityComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LiteralInfinityComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ILiteralInfinity"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ILiteralInfinity"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class LiteralInfinityComparer : IEqualityComparer<ILiteralInfinity>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ILiteralInfinity"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ILiteralInfinity"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ILiteralInfinity"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ILiteralInfinity"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ILiteralInfinity x, ILiteralInfinity y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ILiteralInfinity"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ILiteralInfinity"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ILiteralInfinity obj)
+        {
+            return HashCode.Combine(typeof(ILiteralInfinity), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralIntegerComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralIntegerComparer.cs
new file mode 100644
index 000000000..3aca24a47
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralIntegerComparer.cs
@@ -0,0 +1,149 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LiteralIntegerComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ILiteralInteger"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ILiteralInteger"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class LiteralIntegerComparer : IEqualityComparer<ILiteralInteger>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ILiteralInteger"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ILiteralInteger"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ILiteralInteger"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ILiteralInteger"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ILiteralInteger x, ILiteralInteger y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Value != y.Value) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ILiteralInteger"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ILiteralInteger"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ILiteralInteger obj)
+        {
+            return HashCode.Combine(typeof(ILiteralInteger), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralRationalComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralRationalComparer.cs
new file mode 100644
index 000000000..03e258c17
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralRationalComparer.cs
@@ -0,0 +1,149 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LiteralRationalComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ILiteralRational"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ILiteralRational"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class LiteralRationalComparer : IEqualityComparer<ILiteralRational>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ILiteralRational"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ILiteralRational"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ILiteralRational"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ILiteralRational"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ILiteralRational x, ILiteralRational y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (FloatingPointComparer.NearlyEqual(x.Value, y.Value, FloatingPointComparer.DefaultDoubleEpsilon)) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ILiteralRational"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ILiteralRational"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ILiteralRational obj)
+        {
+            return HashCode.Combine(typeof(ILiteralRational), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralStringComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralStringComparer.cs
new file mode 100644
index 000000000..c7ead324c
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/LiteralStringComparer.cs
@@ -0,0 +1,149 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LiteralStringComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ILiteralString"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ILiteralString"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class LiteralStringComparer : IEqualityComparer<ILiteralString>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ILiteralString"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ILiteralString"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ILiteralString"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ILiteralString"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ILiteralString x, ILiteralString y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Value, y.Value)) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ILiteralString"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ILiteralString"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ILiteralString obj)
+        {
+            return HashCode.Combine(typeof(ILiteralString), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MembershipComparer.cs
new file mode 100644
index 000000000..404836a4f
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MembershipComparer.cs
@@ -0,0 +1,139 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Root.Namespaces;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class MembershipComparer : IEqualityComparer<IMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IMembership x, IMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.MemberElement != y.MemberElement) return false;
+
+            if (!OrdinalStringComparer.Equals(x.MemberName, y.MemberName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.MemberShortName, y.MemberShortName)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IMembership obj)
+        {
+            return HashCode.Combine(typeof(IMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MembershipExposeComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MembershipExposeComparer.cs
new file mode 100644
index 000000000..e7e74857e
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MembershipExposeComparer.cs
@@ -0,0 +1,139 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MembershipExposeComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Systems.Views;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IMembershipExpose"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IMembershipExpose"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class MembershipExposeComparer : IEqualityComparer<IMembershipExpose>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IMembershipExpose"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IMembershipExpose"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IMembershipExpose"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IMembershipExpose"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IMembershipExpose x, IMembershipExpose y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.ImportedMembership != y.ImportedMembership) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsImportAll != y.IsImportAll) return false;
+
+            if (x.IsRecursive != y.IsRecursive) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IMembershipExpose"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IMembershipExpose"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IMembershipExpose obj)
+        {
+            return HashCode.Combine(typeof(IMembershipExpose), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MembershipImportComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MembershipImportComparer.cs
new file mode 100644
index 000000000..0c0785dd7
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MembershipImportComparer.cs
@@ -0,0 +1,139 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MembershipImportComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Root.Namespaces;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IMembershipImport"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IMembershipImport"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class MembershipImportComparer : IEqualityComparer<IMembershipImport>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IMembershipImport"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IMembershipImport"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IMembershipImport"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IMembershipImport"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IMembershipImport x, IMembershipImport y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.ImportedMembership != y.ImportedMembership) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsImportAll != y.IsImportAll) return false;
+
+            if (x.IsRecursive != y.IsRecursive) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IMembershipImport"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IMembershipImport"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IMembershipImport obj)
+        {
+            return HashCode.Combine(typeof(IMembershipImport), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MergeNodeComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MergeNodeComparer.cs
new file mode 100644
index 000000000..66b92cf24
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MergeNodeComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MergeNodeComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IMergeNode"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IMergeNode"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class MergeNodeComparer : IEqualityComparer<IMergeNode>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IMergeNode"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IMergeNode"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IMergeNode"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IMergeNode"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IMergeNode x, IMergeNode y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IMergeNode"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IMergeNode"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IMergeNode obj)
+        {
+            return HashCode.Combine(typeof(IMergeNode), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetaclassComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetaclassComparer.cs
new file mode 100644
index 000000000..426935791
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetaclassComparer.cs
@@ -0,0 +1,128 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MetaclassComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Kernel.Metadata;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IMetaclass"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IMetaclass"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class MetaclassComparer : IEqualityComparer<IMetaclass>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IMetaclass"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IMetaclass"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IMetaclass"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IMetaclass"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IMetaclass x, IMetaclass y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IMetaclass"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IMetaclass"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IMetaclass obj)
+        {
+            return HashCode.Combine(typeof(IMetaclass), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetadataAccessExpressionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetadataAccessExpressionComparer.cs
new file mode 100644
index 000000000..db168f19e
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetadataAccessExpressionComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MetadataAccessExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IMetadataAccessExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IMetadataAccessExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class MetadataAccessExpressionComparer : IEqualityComparer<IMetadataAccessExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IMetadataAccessExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IMetadataAccessExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IMetadataAccessExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IMetadataAccessExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IMetadataAccessExpression x, IMetadataAccessExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IMetadataAccessExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IMetadataAccessExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IMetadataAccessExpression obj)
+        {
+            return HashCode.Combine(typeof(IMetadataAccessExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetadataDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetadataDefinitionComparer.cs
new file mode 100644
index 000000000..781b8a49f
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetadataDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MetadataDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Metadata;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IMetadataDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IMetadataDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class MetadataDefinitionComparer : IEqualityComparer<IMetadataDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IMetadataDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IMetadataDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IMetadataDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IMetadataDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IMetadataDefinition x, IMetadataDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IMetadataDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IMetadataDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IMetadataDefinition obj)
+        {
+            return HashCode.Combine(typeof(IMetadataDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetadataFeatureComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetadataFeatureComparer.cs
new file mode 100644
index 000000000..094f454e4
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetadataFeatureComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MetadataFeatureComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Metadata;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IMetadataFeature"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IMetadataFeature"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class MetadataFeatureComparer : IEqualityComparer<IMetadataFeature>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IMetadataFeature"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IMetadataFeature"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IMetadataFeature"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IMetadataFeature"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IMetadataFeature x, IMetadataFeature y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IMetadataFeature"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IMetadataFeature"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IMetadataFeature obj)
+        {
+            return HashCode.Combine(typeof(IMetadataFeature), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetadataUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetadataUsageComparer.cs
new file mode 100644
index 000000000..86cb8c8eb
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MetadataUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MetadataUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Metadata;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IMetadataUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IMetadataUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class MetadataUsageComparer : IEqualityComparer<IMetadataUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IMetadataUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IMetadataUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IMetadataUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IMetadataUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IMetadataUsage x, IMetadataUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IMetadataUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IMetadataUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IMetadataUsage obj)
+        {
+            return HashCode.Combine(typeof(IMetadataUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MultiplicityComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MultiplicityComparer.cs
new file mode 100644
index 000000000..e10806a42
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MultiplicityComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MultiplicityComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Core.Types;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IMultiplicity"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IMultiplicity"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class MultiplicityComparer : IEqualityComparer<IMultiplicity>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IMultiplicity"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IMultiplicity"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IMultiplicity"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IMultiplicity"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IMultiplicity x, IMultiplicity y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IMultiplicity"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IMultiplicity"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IMultiplicity obj)
+        {
+            return HashCode.Combine(typeof(IMultiplicity), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MultiplicityRangeComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MultiplicityRangeComparer.cs
new file mode 100644
index 000000000..d5acd64ea
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/MultiplicityRangeComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MultiplicityRangeComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Multiplicities;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IMultiplicityRange"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IMultiplicityRange"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class MultiplicityRangeComparer : IEqualityComparer<IMultiplicityRange>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IMultiplicityRange"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IMultiplicityRange"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IMultiplicityRange"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IMultiplicityRange"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IMultiplicityRange x, IMultiplicityRange y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IMultiplicityRange"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IMultiplicityRange"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IMultiplicityRange obj)
+        {
+            return HashCode.Combine(typeof(IMultiplicityRange), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/NamespaceComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/NamespaceComparer.cs
new file mode 100644
index 000000000..ed5c7a00a
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/NamespaceComparer.cs
@@ -0,0 +1,124 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="NamespaceComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Root.Namespaces;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="INamespace"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="INamespace"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class NamespaceComparer : IEqualityComparer<INamespace>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="INamespace"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="INamespace"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="INamespace"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="INamespace"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(INamespace x, INamespace y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="INamespace"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="INamespace"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(INamespace obj)
+        {
+            return HashCode.Combine(typeof(INamespace), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/NamespaceExposeComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/NamespaceExposeComparer.cs
new file mode 100644
index 000000000..73292f960
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/NamespaceExposeComparer.cs
@@ -0,0 +1,139 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="NamespaceExposeComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Systems.Views;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="INamespaceExpose"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="INamespaceExpose"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class NamespaceExposeComparer : IEqualityComparer<INamespaceExpose>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="INamespaceExpose"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="INamespaceExpose"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="INamespaceExpose"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="INamespaceExpose"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(INamespaceExpose x, INamespaceExpose y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.ImportedNamespace != y.ImportedNamespace) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsImportAll != y.IsImportAll) return false;
+
+            if (x.IsRecursive != y.IsRecursive) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="INamespaceExpose"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="INamespaceExpose"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(INamespaceExpose obj)
+        {
+            return HashCode.Combine(typeof(INamespaceExpose), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/NamespaceImportComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/NamespaceImportComparer.cs
new file mode 100644
index 000000000..24cd60cd4
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/NamespaceImportComparer.cs
@@ -0,0 +1,139 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="NamespaceImportComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Root.Namespaces;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="INamespaceImport"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="INamespaceImport"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class NamespaceImportComparer : IEqualityComparer<INamespaceImport>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="INamespaceImport"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="INamespaceImport"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="INamespaceImport"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="INamespaceImport"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(INamespaceImport x, INamespaceImport y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.ImportedNamespace != y.ImportedNamespace) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsImportAll != y.IsImportAll) return false;
+
+            if (x.IsRecursive != y.IsRecursive) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="INamespaceImport"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="INamespaceImport"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(INamespaceImport obj)
+        {
+            return HashCode.Combine(typeof(INamespaceImport), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/NullExpressionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/NullExpressionComparer.cs
new file mode 100644
index 000000000..ac3e974d2
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/NullExpressionComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="NullExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="INullExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="INullExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class NullExpressionComparer : IEqualityComparer<INullExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="INullExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="INullExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="INullExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="INullExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(INullExpression x, INullExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="INullExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="INullExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(INullExpression obj)
+        {
+            return HashCode.Combine(typeof(INullExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ObjectiveMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ObjectiveMembershipComparer.cs
new file mode 100644
index 000000000..54fda7704
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ObjectiveMembershipComparer.cs
@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ObjectiveMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Systems.Cases;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IObjectiveMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IObjectiveMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ObjectiveMembershipComparer : IEqualityComparer<IObjectiveMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IObjectiveMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IObjectiveMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IObjectiveMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IObjectiveMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IObjectiveMembership x, IObjectiveMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IObjectiveMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IObjectiveMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IObjectiveMembership obj)
+        {
+            return HashCode.Combine(typeof(IObjectiveMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/OccurrenceDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/OccurrenceDefinitionComparer.cs
new file mode 100644
index 000000000..129109248
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/OccurrenceDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="OccurrenceDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Occurrences;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IOccurrenceDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IOccurrenceDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class OccurrenceDefinitionComparer : IEqualityComparer<IOccurrenceDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IOccurrenceDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IOccurrenceDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IOccurrenceDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IOccurrenceDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IOccurrenceDefinition x, IOccurrenceDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IOccurrenceDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IOccurrenceDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IOccurrenceDefinition obj)
+        {
+            return HashCode.Combine(typeof(IOccurrenceDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/OccurrenceUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/OccurrenceUsageComparer.cs
new file mode 100644
index 000000000..e3cc35221
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/OccurrenceUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="OccurrenceUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Occurrences;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IOccurrenceUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IOccurrenceUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class OccurrenceUsageComparer : IEqualityComparer<IOccurrenceUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IOccurrenceUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IOccurrenceUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IOccurrenceUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IOccurrenceUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IOccurrenceUsage x, IOccurrenceUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IOccurrenceUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IOccurrenceUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IOccurrenceUsage obj)
+        {
+            return HashCode.Combine(typeof(IOccurrenceUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/OperatorExpressionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/OperatorExpressionComparer.cs
new file mode 100644
index 000000000..50f1072d4
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/OperatorExpressionComparer.cs
@@ -0,0 +1,149 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="OperatorExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IOperatorExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IOperatorExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class OperatorExpressionComparer : IEqualityComparer<IOperatorExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IOperatorExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IOperatorExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IOperatorExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IOperatorExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IOperatorExpression x, IOperatorExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Operator, y.Operator)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IOperatorExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IOperatorExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IOperatorExpression obj)
+        {
+            return HashCode.Combine(typeof(IOperatorExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/OwningMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/OwningMembershipComparer.cs
new file mode 100644
index 000000000..b17495240
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/OwningMembershipComparer.cs
@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="OwningMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Root.Namespaces;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IOwningMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IOwningMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class OwningMembershipComparer : IEqualityComparer<IOwningMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IOwningMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IOwningMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IOwningMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IOwningMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IOwningMembership x, IOwningMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IOwningMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IOwningMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IOwningMembership obj)
+        {
+            return HashCode.Combine(typeof(IOwningMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PackageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PackageComparer.cs
new file mode 100644
index 000000000..44e4d9e56
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PackageComparer.cs
@@ -0,0 +1,124 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PackageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Kernel.Packages;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IPackage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IPackage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class PackageComparer : IEqualityComparer<IPackage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IPackage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IPackage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IPackage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IPackage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IPackage x, IPackage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IPackage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IPackage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IPackage obj)
+        {
+            return HashCode.Combine(typeof(IPackage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ParameterMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ParameterMembershipComparer.cs
new file mode 100644
index 000000000..52c7e523c
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ParameterMembershipComparer.cs
@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ParameterMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Kernel.Behaviors;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IParameterMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IParameterMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ParameterMembershipComparer : IEqualityComparer<IParameterMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IParameterMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IParameterMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IParameterMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IParameterMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IParameterMembership x, IParameterMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IParameterMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IParameterMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IParameterMembership obj)
+        {
+            return HashCode.Combine(typeof(IParameterMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PartDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PartDefinitionComparer.cs
new file mode 100644
index 000000000..8bc63b2c0
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PartDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PartDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Parts;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IPartDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IPartDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class PartDefinitionComparer : IEqualityComparer<IPartDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IPartDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IPartDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IPartDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IPartDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IPartDefinition x, IPartDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IPartDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IPartDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IPartDefinition obj)
+        {
+            return HashCode.Combine(typeof(IPartDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PartUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PartUsageComparer.cs
new file mode 100644
index 000000000..66b68953c
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PartUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PartUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Parts;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IPartUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IPartUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class PartUsageComparer : IEqualityComparer<IPartUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IPartUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IPartUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IPartUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IPartUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IPartUsage x, IPartUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IPartUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IPartUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IPartUsage obj)
+        {
+            return HashCode.Combine(typeof(IPartUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PayloadFeatureComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PayloadFeatureComparer.cs
new file mode 100644
index 000000000..13d777c2b
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PayloadFeatureComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PayloadFeatureComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Interactions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IPayloadFeature"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IPayloadFeature"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class PayloadFeatureComparer : IEqualityComparer<IPayloadFeature>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IPayloadFeature"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IPayloadFeature"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IPayloadFeature"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IPayloadFeature"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IPayloadFeature x, IPayloadFeature y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IPayloadFeature"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IPayloadFeature"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IPayloadFeature obj)
+        {
+            return HashCode.Combine(typeof(IPayloadFeature), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PerformActionUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PerformActionUsageComparer.cs
new file mode 100644
index 000000000..da0e9ac8b
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PerformActionUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PerformActionUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IPerformActionUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IPerformActionUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class PerformActionUsageComparer : IEqualityComparer<IPerformActionUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IPerformActionUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IPerformActionUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IPerformActionUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IPerformActionUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IPerformActionUsage x, IPerformActionUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IPerformActionUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IPerformActionUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IPerformActionUsage obj)
+        {
+            return HashCode.Combine(typeof(IPerformActionUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PortConjugationComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PortConjugationComparer.cs
new file mode 100644
index 000000000..570a0d4fa
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PortConjugationComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PortConjugationComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Ports;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IPortConjugation"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IPortConjugation"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class PortConjugationComparer : IEqualityComparer<IPortConjugation>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IPortConjugation"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IPortConjugation"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IPortConjugation"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IPortConjugation"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IPortConjugation x, IPortConjugation y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (x.ConjugatedType != y.ConjugatedType) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.OriginalPortDefinition != y.OriginalPortDefinition) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IPortConjugation"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IPortConjugation"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IPortConjugation obj)
+        {
+            return HashCode.Combine(typeof(IPortConjugation), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PortDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PortDefinitionComparer.cs
new file mode 100644
index 000000000..856078019
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PortDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PortDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Ports;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IPortDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IPortDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class PortDefinitionComparer : IEqualityComparer<IPortDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IPortDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IPortDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IPortDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IPortDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IPortDefinition x, IPortDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IPortDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IPortDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IPortDefinition obj)
+        {
+            return HashCode.Combine(typeof(IPortDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PortUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PortUsageComparer.cs
new file mode 100644
index 000000000..5b51b3a8b
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PortUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PortUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Ports;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IPortUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IPortUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class PortUsageComparer : IEqualityComparer<IPortUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IPortUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IPortUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IPortUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IPortUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IPortUsage x, IPortUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IPortUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IPortUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IPortUsage obj)
+        {
+            return HashCode.Combine(typeof(IPortUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PredicateComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PredicateComparer.cs
new file mode 100644
index 000000000..407356c2e
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/PredicateComparer.cs
@@ -0,0 +1,128 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PredicateComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Kernel.Functions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IPredicate"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IPredicate"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class PredicateComparer : IEqualityComparer<IPredicate>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IPredicate"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IPredicate"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IPredicate"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IPredicate"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IPredicate x, IPredicate y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IPredicate"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IPredicate"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IPredicate obj)
+        {
+            return HashCode.Combine(typeof(IPredicate), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RedefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RedefinitionComparer.cs
new file mode 100644
index 000000000..c9e140375
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RedefinitionComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RedefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Features;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IRedefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IRedefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class RedefinitionComparer : IEqualityComparer<IRedefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IRedefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IRedefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IRedefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IRedefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IRedefinition x, IRedefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.RedefinedFeature != y.RedefinedFeature) return false;
+
+            if (x.RedefiningFeature != y.RedefiningFeature) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IRedefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IRedefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IRedefinition obj)
+        {
+            return HashCode.Combine(typeof(IRedefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ReferenceSubsettingComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ReferenceSubsettingComparer.cs
new file mode 100644
index 000000000..f7249b328
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ReferenceSubsettingComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ReferenceSubsettingComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Features;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IReferenceSubsetting"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IReferenceSubsetting"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ReferenceSubsettingComparer : IEqualityComparer<IReferenceSubsetting>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IReferenceSubsetting"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IReferenceSubsetting"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IReferenceSubsetting"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IReferenceSubsetting"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IReferenceSubsetting x, IReferenceSubsetting y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.ReferencedFeature != y.ReferencedFeature) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IReferenceSubsetting"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IReferenceSubsetting"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IReferenceSubsetting obj)
+        {
+            return HashCode.Combine(typeof(IReferenceSubsetting), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ReferenceUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ReferenceUsageComparer.cs
new file mode 100644
index 000000000..9092c3974
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ReferenceUsageComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ReferenceUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IReferenceUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IReferenceUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ReferenceUsageComparer : IEqualityComparer<IReferenceUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IReferenceUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IReferenceUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IReferenceUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IReferenceUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IReferenceUsage x, IReferenceUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IReferenceUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IReferenceUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IReferenceUsage obj)
+        {
+            return HashCode.Combine(typeof(IReferenceUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RenderingDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RenderingDefinitionComparer.cs
new file mode 100644
index 000000000..228c1b031
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RenderingDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RenderingDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Views;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IRenderingDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IRenderingDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class RenderingDefinitionComparer : IEqualityComparer<IRenderingDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IRenderingDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IRenderingDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IRenderingDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IRenderingDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IRenderingDefinition x, IRenderingDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IRenderingDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IRenderingDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IRenderingDefinition obj)
+        {
+            return HashCode.Combine(typeof(IRenderingDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RenderingUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RenderingUsageComparer.cs
new file mode 100644
index 000000000..a8f4ee37b
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RenderingUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RenderingUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Views;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IRenderingUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IRenderingUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class RenderingUsageComparer : IEqualityComparer<IRenderingUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IRenderingUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IRenderingUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IRenderingUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IRenderingUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IRenderingUsage x, IRenderingUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IRenderingUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IRenderingUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IRenderingUsage obj)
+        {
+            return HashCode.Combine(typeof(IRenderingUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RequirementConstraintMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RequirementConstraintMembershipComparer.cs
new file mode 100644
index 000000000..e63d1170e
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RequirementConstraintMembershipComparer.cs
@@ -0,0 +1,136 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RequirementConstraintMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.Systems.Requirements;
+    using SysML2.NET.Core.DTO.Systems.Requirements;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IRequirementConstraintMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IRequirementConstraintMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class RequirementConstraintMembershipComparer : IEqualityComparer<IRequirementConstraintMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IRequirementConstraintMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IRequirementConstraintMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IRequirementConstraintMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IRequirementConstraintMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IRequirementConstraintMembership x, IRequirementConstraintMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.Kind != y.Kind) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IRequirementConstraintMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IRequirementConstraintMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IRequirementConstraintMembership obj)
+        {
+            return HashCode.Combine(typeof(IRequirementConstraintMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RequirementDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RequirementDefinitionComparer.cs
new file mode 100644
index 000000000..b914c1f72
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RequirementDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RequirementDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Requirements;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IRequirementDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IRequirementDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class RequirementDefinitionComparer : IEqualityComparer<IRequirementDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IRequirementDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IRequirementDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IRequirementDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IRequirementDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IRequirementDefinition x, IRequirementDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ReqId, y.ReqId)) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IRequirementDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IRequirementDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IRequirementDefinition obj)
+        {
+            return HashCode.Combine(typeof(IRequirementDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RequirementUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RequirementUsageComparer.cs
new file mode 100644
index 000000000..a62c7cc1f
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RequirementUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RequirementUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Requirements;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IRequirementUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IRequirementUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class RequirementUsageComparer : IEqualityComparer<IRequirementUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IRequirementUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IRequirementUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IRequirementUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IRequirementUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IRequirementUsage x, IRequirementUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ReqId, y.ReqId)) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IRequirementUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IRequirementUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IRequirementUsage obj)
+        {
+            return HashCode.Combine(typeof(IRequirementUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RequirementVerificationMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RequirementVerificationMembershipComparer.cs
new file mode 100644
index 000000000..638957122
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/RequirementVerificationMembershipComparer.cs
@@ -0,0 +1,136 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RequirementVerificationMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.Systems.Requirements;
+    using SysML2.NET.Core.DTO.Systems.VerificationCases;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IRequirementVerificationMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IRequirementVerificationMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class RequirementVerificationMembershipComparer : IEqualityComparer<IRequirementVerificationMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IRequirementVerificationMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IRequirementVerificationMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IRequirementVerificationMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IRequirementVerificationMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IRequirementVerificationMembership x, IRequirementVerificationMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.Kind != y.Kind) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IRequirementVerificationMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IRequirementVerificationMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IRequirementVerificationMembership obj)
+        {
+            return HashCode.Combine(typeof(IRequirementVerificationMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ResultExpressionMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ResultExpressionMembershipComparer.cs
new file mode 100644
index 000000000..f931ef907
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ResultExpressionMembershipComparer.cs
@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ResultExpressionMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Kernel.Functions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IResultExpressionMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IResultExpressionMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ResultExpressionMembershipComparer : IEqualityComparer<IResultExpressionMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IResultExpressionMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IResultExpressionMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IResultExpressionMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IResultExpressionMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IResultExpressionMembership x, IResultExpressionMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IResultExpressionMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IResultExpressionMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IResultExpressionMembership obj)
+        {
+            return HashCode.Combine(typeof(IResultExpressionMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ReturnParameterMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ReturnParameterMembershipComparer.cs
new file mode 100644
index 000000000..0d10bca44
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ReturnParameterMembershipComparer.cs
@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ReturnParameterMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Kernel.Functions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IReturnParameterMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IReturnParameterMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ReturnParameterMembershipComparer : IEqualityComparer<IReturnParameterMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IReturnParameterMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IReturnParameterMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IReturnParameterMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IReturnParameterMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IReturnParameterMembership x, IReturnParameterMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IReturnParameterMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IReturnParameterMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IReturnParameterMembership obj)
+        {
+            return HashCode.Combine(typeof(IReturnParameterMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SatisfyRequirementUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SatisfyRequirementUsageComparer.cs
new file mode 100644
index 000000000..5ce0a2095
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SatisfyRequirementUsageComparer.cs
@@ -0,0 +1,154 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SatisfyRequirementUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Requirements;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ISatisfyRequirementUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ISatisfyRequirementUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class SatisfyRequirementUsageComparer : IEqualityComparer<ISatisfyRequirementUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ISatisfyRequirementUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ISatisfyRequirementUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ISatisfyRequirementUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ISatisfyRequirementUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ISatisfyRequirementUsage x, ISatisfyRequirementUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsNegated != y.IsNegated) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ReqId, y.ReqId)) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ISatisfyRequirementUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ISatisfyRequirementUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ISatisfyRequirementUsage obj)
+        {
+            return HashCode.Combine(typeof(ISatisfyRequirementUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SelectExpressionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SelectExpressionComparer.cs
new file mode 100644
index 000000000..06113c5d2
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SelectExpressionComparer.cs
@@ -0,0 +1,149 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SelectExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Expressions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ISelectExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ISelectExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class SelectExpressionComparer : IEqualityComparer<ISelectExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ISelectExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ISelectExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ISelectExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ISelectExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ISelectExpression x, ISelectExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Operator, y.Operator)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ISelectExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ISelectExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ISelectExpression obj)
+        {
+            return HashCode.Combine(typeof(ISelectExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SendActionUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SendActionUsageComparer.cs
new file mode 100644
index 000000000..34e837745
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SendActionUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SendActionUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ISendActionUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ISendActionUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class SendActionUsageComparer : IEqualityComparer<ISendActionUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ISendActionUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ISendActionUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ISendActionUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ISendActionUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ISendActionUsage x, ISendActionUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ISendActionUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ISendActionUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ISendActionUsage obj)
+        {
+            return HashCode.Combine(typeof(ISendActionUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SpecializationComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SpecializationComparer.cs
new file mode 100644
index 000000000..b4bdb1a44
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SpecializationComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SpecializationComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Types;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ISpecialization"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ISpecialization"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class SpecializationComparer : IEqualityComparer<ISpecialization>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ISpecialization"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ISpecialization"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ISpecialization"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ISpecialization"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ISpecialization x, ISpecialization y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.General != y.General) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Specific != y.Specific) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ISpecialization"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ISpecialization"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ISpecialization obj)
+        {
+            return HashCode.Combine(typeof(ISpecialization), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StakeholderMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StakeholderMembershipComparer.cs
new file mode 100644
index 000000000..7c0ac1341
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StakeholderMembershipComparer.cs
@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StakeholderMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Systems.Requirements;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IStakeholderMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IStakeholderMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class StakeholderMembershipComparer : IEqualityComparer<IStakeholderMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IStakeholderMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IStakeholderMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IStakeholderMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IStakeholderMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IStakeholderMembership x, IStakeholderMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IStakeholderMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IStakeholderMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IStakeholderMembership obj)
+        {
+            return HashCode.Combine(typeof(IStakeholderMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StateDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StateDefinitionComparer.cs
new file mode 100644
index 000000000..ed71a3090
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StateDefinitionComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StateDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.States;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IStateDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IStateDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class StateDefinitionComparer : IEqualityComparer<IStateDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IStateDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IStateDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IStateDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IStateDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IStateDefinition x, IStateDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsParallel != y.IsParallel) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IStateDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IStateDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IStateDefinition obj)
+        {
+            return HashCode.Combine(typeof(IStateDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StateSubactionMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StateSubactionMembershipComparer.cs
new file mode 100644
index 000000000..6d9489c9a
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StateSubactionMembershipComparer.cs
@@ -0,0 +1,136 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StateSubactionMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.Systems.States;
+    using SysML2.NET.Core.DTO.Systems.States;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IStateSubactionMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IStateSubactionMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class StateSubactionMembershipComparer : IEqualityComparer<IStateSubactionMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IStateSubactionMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IStateSubactionMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IStateSubactionMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IStateSubactionMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IStateSubactionMembership x, IStateSubactionMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.Kind != y.Kind) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IStateSubactionMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IStateSubactionMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IStateSubactionMembership obj)
+        {
+            return HashCode.Combine(typeof(IStateSubactionMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StateUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StateUsageComparer.cs
new file mode 100644
index 000000000..c5b14ce88
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StateUsageComparer.cs
@@ -0,0 +1,154 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StateUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.States;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IStateUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IStateUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class StateUsageComparer : IEqualityComparer<IStateUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IStateUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IStateUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IStateUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IStateUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IStateUsage x, IStateUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsParallel != y.IsParallel) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IStateUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IStateUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IStateUsage obj)
+        {
+            return HashCode.Combine(typeof(IStateUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StepComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StepComparer.cs
new file mode 100644
index 000000000..1eb734f49
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StepComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StepComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Behaviors;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IStep"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IStep"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class StepComparer : IEqualityComparer<IStep>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IStep"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IStep"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IStep"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IStep"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IStep x, IStep y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IStep"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IStep"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IStep obj)
+        {
+            return HashCode.Combine(typeof(IStep), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StructureComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StructureComparer.cs
new file mode 100644
index 000000000..4327d99f9
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/StructureComparer.cs
@@ -0,0 +1,128 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StructureComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Kernel.Structures;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IStructure"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IStructure"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class StructureComparer : IEqualityComparer<IStructure>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IStructure"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IStructure"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IStructure"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IStructure"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IStructure x, IStructure y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IStructure"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IStructure"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IStructure obj)
+        {
+            return HashCode.Combine(typeof(IStructure), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SubclassificationComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SubclassificationComparer.cs
new file mode 100644
index 000000000..f4e341b15
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SubclassificationComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SubclassificationComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Classifiers;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ISubclassification"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ISubclassification"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class SubclassificationComparer : IEqualityComparer<ISubclassification>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ISubclassification"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ISubclassification"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ISubclassification"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ISubclassification"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ISubclassification x, ISubclassification y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Subclassifier != y.Subclassifier) return false;
+
+            if (x.Superclassifier != y.Superclassifier) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ISubclassification"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ISubclassification"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ISubclassification obj)
+        {
+            return HashCode.Combine(typeof(ISubclassification), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SubjectMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SubjectMembershipComparer.cs
new file mode 100644
index 000000000..0b76e6f28
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SubjectMembershipComparer.cs
@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SubjectMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Systems.Requirements;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ISubjectMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ISubjectMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class SubjectMembershipComparer : IEqualityComparer<ISubjectMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ISubjectMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ISubjectMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ISubjectMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ISubjectMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ISubjectMembership x, ISubjectMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ISubjectMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ISubjectMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ISubjectMembership obj)
+        {
+            return HashCode.Combine(typeof(ISubjectMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SubsettingComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SubsettingComparer.cs
new file mode 100644
index 000000000..a7ac080fa
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SubsettingComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SubsettingComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Features;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ISubsetting"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ISubsetting"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class SubsettingComparer : IEqualityComparer<ISubsetting>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ISubsetting"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ISubsetting"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ISubsetting"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ISubsetting"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ISubsetting x, ISubsetting y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.SubsettedFeature != y.SubsettedFeature) return false;
+
+            if (x.SubsettingFeature != y.SubsettingFeature) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ISubsetting"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ISubsetting"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ISubsetting obj)
+        {
+            return HashCode.Combine(typeof(ISubsetting), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SuccessionAsUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SuccessionAsUsageComparer.cs
new file mode 100644
index 000000000..f631d8ce0
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SuccessionAsUsageComparer.cs
@@ -0,0 +1,153 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SuccessionAsUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Systems.Connections;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ISuccessionAsUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ISuccessionAsUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class SuccessionAsUsageComparer : IEqualityComparer<ISuccessionAsUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ISuccessionAsUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ISuccessionAsUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ISuccessionAsUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ISuccessionAsUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ISuccessionAsUsage x, ISuccessionAsUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ISuccessionAsUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ISuccessionAsUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ISuccessionAsUsage obj)
+        {
+            return HashCode.Combine(typeof(ISuccessionAsUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SuccessionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SuccessionComparer.cs
new file mode 100644
index 000000000..76cfd9408
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SuccessionComparer.cs
@@ -0,0 +1,153 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SuccessionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Connectors;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ISuccession"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ISuccession"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class SuccessionComparer : IEqualityComparer<ISuccession>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ISuccession"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ISuccession"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ISuccession"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ISuccession"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ISuccession x, ISuccession y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ISuccession"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ISuccession"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ISuccession obj)
+        {
+            return HashCode.Combine(typeof(ISuccession), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SuccessionFlowComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SuccessionFlowComparer.cs
new file mode 100644
index 000000000..786659393
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SuccessionFlowComparer.cs
@@ -0,0 +1,153 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SuccessionFlowComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Kernel.Interactions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ISuccessionFlow"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ISuccessionFlow"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class SuccessionFlowComparer : IEqualityComparer<ISuccessionFlow>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ISuccessionFlow"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ISuccessionFlow"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ISuccessionFlow"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ISuccessionFlow"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ISuccessionFlow x, ISuccessionFlow y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ISuccessionFlow"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ISuccessionFlow"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ISuccessionFlow obj)
+        {
+            return HashCode.Combine(typeof(ISuccessionFlow), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SuccessionFlowUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SuccessionFlowUsageComparer.cs
new file mode 100644
index 000000000..a51ad7225
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/SuccessionFlowUsageComparer.cs
@@ -0,0 +1,158 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SuccessionFlowUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Flows;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ISuccessionFlowUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ISuccessionFlowUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class SuccessionFlowUsageComparer : IEqualityComparer<ISuccessionFlowUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ISuccessionFlowUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ISuccessionFlowUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ISuccessionFlowUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ISuccessionFlowUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ISuccessionFlowUsage x, ISuccessionFlowUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ISuccessionFlowUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ISuccessionFlowUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ISuccessionFlowUsage obj)
+        {
+            return HashCode.Combine(typeof(ISuccessionFlowUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TerminateActionUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TerminateActionUsageComparer.cs
new file mode 100644
index 000000000..5efda216e
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TerminateActionUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TerminateActionUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ITerminateActionUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ITerminateActionUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class TerminateActionUsageComparer : IEqualityComparer<ITerminateActionUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ITerminateActionUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ITerminateActionUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ITerminateActionUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ITerminateActionUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ITerminateActionUsage x, ITerminateActionUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ITerminateActionUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ITerminateActionUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ITerminateActionUsage obj)
+        {
+            return HashCode.Combine(typeof(ITerminateActionUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TextualRepresentationComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TextualRepresentationComparer.cs
new file mode 100644
index 000000000..1f256011b
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TextualRepresentationComparer.cs
@@ -0,0 +1,128 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TextualRepresentationComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Root.Annotations;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ITextualRepresentation"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ITextualRepresentation"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class TextualRepresentationComparer : IEqualityComparer<ITextualRepresentation>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ITextualRepresentation"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ITextualRepresentation"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ITextualRepresentation"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ITextualRepresentation"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ITextualRepresentation x, ITextualRepresentation y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Body, y.Body)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!OrdinalStringComparer.Equals(x.Language, y.Language)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ITextualRepresentation"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ITextualRepresentation"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ITextualRepresentation obj)
+        {
+            return HashCode.Combine(typeof(ITextualRepresentation), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TransitionFeatureMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TransitionFeatureMembershipComparer.cs
new file mode 100644
index 000000000..941289f08
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TransitionFeatureMembershipComparer.cs
@@ -0,0 +1,136 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TransitionFeatureMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.Systems.States;
+    using SysML2.NET.Core.DTO.Systems.States;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ITransitionFeatureMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ITransitionFeatureMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class TransitionFeatureMembershipComparer : IEqualityComparer<ITransitionFeatureMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ITransitionFeatureMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ITransitionFeatureMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ITransitionFeatureMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ITransitionFeatureMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ITransitionFeatureMembership x, ITransitionFeatureMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.Kind != y.Kind) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ITransitionFeatureMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ITransitionFeatureMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ITransitionFeatureMembership obj)
+        {
+            return HashCode.Combine(typeof(ITransitionFeatureMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TransitionUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TransitionUsageComparer.cs
new file mode 100644
index 000000000..20a3e1cad
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TransitionUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TransitionUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.States;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ITransitionUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ITransitionUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class TransitionUsageComparer : IEqualityComparer<ITransitionUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ITransitionUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ITransitionUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ITransitionUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ITransitionUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ITransitionUsage x, ITransitionUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ITransitionUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ITransitionUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ITransitionUsage obj)
+        {
+            return HashCode.Combine(typeof(ITransitionUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TriggerInvocationExpressionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TriggerInvocationExpressionComparer.cs
new file mode 100644
index 000000000..3d0bd57c3
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TriggerInvocationExpressionComparer.cs
@@ -0,0 +1,150 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TriggerInvocationExpressionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Actions;
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ITriggerInvocationExpression"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ITriggerInvocationExpression"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class TriggerInvocationExpressionComparer : IEqualityComparer<ITriggerInvocationExpression>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ITriggerInvocationExpression"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ITriggerInvocationExpression"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ITriggerInvocationExpression"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ITriggerInvocationExpression"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ITriggerInvocationExpression x, ITriggerInvocationExpression y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariable != y.IsVariable) return false;
+
+            if (x.Kind != y.Kind) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ITriggerInvocationExpression"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ITriggerInvocationExpression"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ITriggerInvocationExpression obj)
+        {
+            return HashCode.Combine(typeof(ITriggerInvocationExpression), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TypeComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TypeComparer.cs
new file mode 100644
index 000000000..34a83496e
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TypeComparer.cs
@@ -0,0 +1,128 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TypeComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Types;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IType"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IType"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class TypeComparer : IEqualityComparer<IType>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IType"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IType"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IType"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IType"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IType x, IType y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IType"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IType"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IType obj)
+        {
+            return HashCode.Combine(typeof(IType), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TypeFeaturingComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TypeFeaturingComparer.cs
new file mode 100644
index 000000000..e56520a90
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/TypeFeaturingComparer.cs
@@ -0,0 +1,134 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TypeFeaturingComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Features;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="ITypeFeaturing"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="ITypeFeaturing"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class TypeFeaturingComparer : IEqualityComparer<ITypeFeaturing>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="ITypeFeaturing"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="ITypeFeaturing"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="ITypeFeaturing"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="ITypeFeaturing"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(ITypeFeaturing x, ITypeFeaturing y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.FeatureOfType != y.FeatureOfType) return false;
+
+            if (x.FeaturingType != y.FeaturingType) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="ITypeFeaturing"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="ITypeFeaturing"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(ITypeFeaturing obj)
+        {
+            return HashCode.Combine(typeof(ITypeFeaturing), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/UnioningComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/UnioningComparer.cs
new file mode 100644
index 000000000..5cf799386
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/UnioningComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="UnioningComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Core.Types;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IUnioning"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IUnioning"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class UnioningComparer : IEqualityComparer<IUnioning>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IUnioning"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IUnioning"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IUnioning"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IUnioning"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IUnioning x, IUnioning y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.UnioningType != y.UnioningType) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IUnioning"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IUnioning"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IUnioning obj)
+        {
+            return HashCode.Combine(typeof(IUnioning), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/UsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/UsageComparer.cs
new file mode 100644
index 000000000..925f3ccfc
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/UsageComparer.cs
@@ -0,0 +1,147 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="UsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.DTO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class UsageComparer : IEqualityComparer<IUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IUsage x, IUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IUsage obj)
+        {
+            return HashCode.Combine(typeof(IUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/UseCaseDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/UseCaseDefinitionComparer.cs
new file mode 100644
index 000000000..d512aebf8
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/UseCaseDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="UseCaseDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.UseCases;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IUseCaseDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IUseCaseDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class UseCaseDefinitionComparer : IEqualityComparer<IUseCaseDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IUseCaseDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IUseCaseDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IUseCaseDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IUseCaseDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IUseCaseDefinition x, IUseCaseDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IUseCaseDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IUseCaseDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IUseCaseDefinition obj)
+        {
+            return HashCode.Combine(typeof(IUseCaseDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/UseCaseUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/UseCaseUsageComparer.cs
new file mode 100644
index 000000000..de7d9f7e6
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/UseCaseUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="UseCaseUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.UseCases;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IUseCaseUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IUseCaseUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class UseCaseUsageComparer : IEqualityComparer<IUseCaseUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IUseCaseUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IUseCaseUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IUseCaseUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IUseCaseUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IUseCaseUsage x, IUseCaseUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IUseCaseUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IUseCaseUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IUseCaseUsage obj)
+        {
+            return HashCode.Combine(typeof(IUseCaseUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/VariantMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/VariantMembershipComparer.cs
new file mode 100644
index 000000000..10e8d6ef6
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/VariantMembershipComparer.cs
@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="VariantMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IVariantMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IVariantMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class VariantMembershipComparer : IEqualityComparer<IVariantMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IVariantMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IVariantMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IVariantMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IVariantMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IVariantMembership x, IVariantMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IVariantMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IVariantMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IVariantMembership obj)
+        {
+            return HashCode.Combine(typeof(IVariantMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/VerificationCaseDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/VerificationCaseDefinitionComparer.cs
new file mode 100644
index 000000000..f4d4ffea5
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/VerificationCaseDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="VerificationCaseDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.VerificationCases;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IVerificationCaseDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IVerificationCaseDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class VerificationCaseDefinitionComparer : IEqualityComparer<IVerificationCaseDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IVerificationCaseDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IVerificationCaseDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IVerificationCaseDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IVerificationCaseDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IVerificationCaseDefinition x, IVerificationCaseDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IVerificationCaseDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IVerificationCaseDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IVerificationCaseDefinition obj)
+        {
+            return HashCode.Combine(typeof(IVerificationCaseDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/VerificationCaseUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/VerificationCaseUsageComparer.cs
new file mode 100644
index 000000000..66fd6a10a
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/VerificationCaseUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="VerificationCaseUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.VerificationCases;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IVerificationCaseUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IVerificationCaseUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class VerificationCaseUsageComparer : IEqualityComparer<IVerificationCaseUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IVerificationCaseUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IVerificationCaseUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IVerificationCaseUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IVerificationCaseUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IVerificationCaseUsage x, IVerificationCaseUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IVerificationCaseUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IVerificationCaseUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IVerificationCaseUsage obj)
+        {
+            return HashCode.Combine(typeof(IVerificationCaseUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewDefinitionComparer.cs
new file mode 100644
index 000000000..c98552983
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ViewDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Views;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IViewDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IViewDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ViewDefinitionComparer : IEqualityComparer<IViewDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IViewDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IViewDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IViewDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IViewDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IViewDefinition x, IViewDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IViewDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IViewDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IViewDefinition obj)
+        {
+            return HashCode.Combine(typeof(IViewDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewRenderingMembershipComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewRenderingMembershipComparer.cs
new file mode 100644
index 000000000..c94c8e860
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewRenderingMembershipComparer.cs
@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ViewRenderingMembershipComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.DTO.Systems.Views;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IViewRenderingMembership"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IViewRenderingMembership"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ViewRenderingMembershipComparer : IEqualityComparer<IViewRenderingMembership>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IViewRenderingMembership"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IViewRenderingMembership"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IViewRenderingMembership"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IViewRenderingMembership"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IViewRenderingMembership x, IViewRenderingMembership y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsImplied != y.IsImplied) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelatedElement, y.OwnedRelatedElement)) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelatedElement != y.OwningRelatedElement) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.Visibility != y.Visibility) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IViewRenderingMembership"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IViewRenderingMembership"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IViewRenderingMembership obj)
+        {
+            return HashCode.Combine(typeof(IViewRenderingMembership), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewUsageComparer.cs
new file mode 100644
index 000000000..29e61e99e
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ViewUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Views;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IViewUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IViewUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ViewUsageComparer : IEqualityComparer<IViewUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IViewUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IViewUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IViewUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IViewUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IViewUsage x, IViewUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IViewUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IViewUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IViewUsage obj)
+        {
+            return HashCode.Combine(typeof(IViewUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewpointDefinitionComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewpointDefinitionComparer.cs
new file mode 100644
index 000000000..0434ba4be
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewpointDefinitionComparer.cs
@@ -0,0 +1,132 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ViewpointDefinitionComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.DTO.Systems.Views;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IViewpointDefinition"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IViewpointDefinition"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ViewpointDefinitionComparer : IEqualityComparer<IViewpointDefinition>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IViewpointDefinition"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IViewpointDefinition"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IViewpointDefinition"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IViewpointDefinition"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IViewpointDefinition x, IViewpointDefinition y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ReqId, y.ReqId)) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IViewpointDefinition"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IViewpointDefinition"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IViewpointDefinition obj)
+        {
+            return HashCode.Combine(typeof(IViewpointDefinition), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewpointUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewpointUsageComparer.cs
new file mode 100644
index 000000000..05b18851e
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/ViewpointUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ViewpointUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Views;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IViewpointUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IViewpointUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class ViewpointUsageComparer : IEqualityComparer<IViewpointUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IViewpointUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IViewpointUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IViewpointUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IViewpointUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IViewpointUsage x, IViewpointUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ReqId, y.ReqId)) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IViewpointUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IViewpointUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IViewpointUsage obj)
+        {
+            return HashCode.Combine(typeof(IViewpointUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Extensions/Core/AutoGenDtoComparers/WhileLoopActionUsageComparer.cs b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/WhileLoopActionUsageComparer.cs
new file mode 100644
index 000000000..9d4d7dc71
--- /dev/null
+++ b/SysML2.NET.Extensions/Core/AutoGenDtoComparers/WhileLoopActionUsageComparer.cs
@@ -0,0 +1,152 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="WhileLoopActionUsageComparer.cs" company="Starion Group S.A.">
+//
+//    Copyright (C) 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.Extensions.Core.DTO.Comparers
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.DTO.Systems.Actions;
+    using SysML2.NET.Extensions.Comparers;
+
+    /// <summary>
+    /// Provides an equality comparison for <see cref="IWhileLoopActionUsage"/> instances
+    /// based on their semantic content rather than object reference identity.
+    /// </summary>
+    /// <remarks>
+    /// This comparer is intended for use in deserialization, testing, and model
+    /// validation scenarios where two <see cref="IWhileLoopActionUsage"/> instances
+    /// originating from different sources (e.g. JSON and MessagePack) must be
+    /// considered equal if they represent the same SysML v2 model element.
+    /// </remarks>
+    [GeneratedCode("SysML2.NET", "latest")]
+    public sealed class WhileLoopActionUsageComparer : IEqualityComparer<IWhileLoopActionUsage>
+    {
+        /// <summary>
+        /// The <see cref="StringComparer"/> used for all string comparisons performed
+        /// by this comparer.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StringComparer.Ordinal"/> is used to ensure culture-independent,
+        /// deterministic comparison semantics suitable for identifiers and
+        /// model-level string values.
+        /// </remarks>
+        private static readonly StringComparer OrdinalStringComparer = StringComparer.Ordinal;
+
+        /// <summary>
+        /// Determines whether two <see cref="IWhileLoopActionUsage"/> instances are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first <see cref="IWhileLoopActionUsage"/> to compare.
+        /// </param>
+        /// <param name="y">
+        /// The second <see cref="IWhileLoopActionUsage"/> to compare.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if both instances represent the same <see cref="IWhileLoopActionUsage"/>
+        /// according to their semantic content; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method performs a deep, deterministic comparison of all relevant
+        /// properties, ignoring object reference identity and any transient or
+        /// derived state.
+        /// </remarks>
+        public bool Equals(IWhileLoopActionUsage x, IWhileLoopActionUsage y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+
+            if (x is null || y is null) return false;
+
+            if (x.Id != y.Id) return false;
+
+            if (!StringSequenceEquality.OrderedEqual(x.AliasIds, y.AliasIds)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredName, y.DeclaredName)) return false;
+
+            if (!OrdinalStringComparer.Equals(x.DeclaredShortName, y.DeclaredShortName)) return false;
+
+            if (x.Direction != y.Direction) return false;
+
+            if (!OrdinalStringComparer.Equals(x.ElementId, y.ElementId)) return false;
+
+            if (x.IsAbstract != y.IsAbstract) return false;
+
+            if (x.IsComposite != y.IsComposite) return false;
+
+            if (x.IsConstant != y.IsConstant) return false;
+
+            if (x.IsDerived != y.IsDerived) return false;
+
+            if (x.IsEnd != y.IsEnd) return false;
+
+            if (x.IsImpliedIncluded != y.IsImpliedIncluded) return false;
+
+            if (x.IsIndividual != y.IsIndividual) return false;
+
+            if (x.IsOrdered != y.IsOrdered) return false;
+
+            if (x.IsPortion != y.IsPortion) return false;
+
+            if (x.IsSufficient != y.IsSufficient) return false;
+
+            if (x.IsUnique != y.IsUnique) return false;
+
+            if (x.IsVariation != y.IsVariation) return false;
+
+            if (!GuidSequenceEquality.OrderedEqual(x.OwnedRelationship, y.OwnedRelationship)) return false;
+
+            if (x.OwningRelationship != y.OwningRelationship) return false;
+
+            if (x.PortionKind != y.PortionKind) return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified <see cref="IWhileLoopActionUsage"/>.
+        /// </summary>
+        /// <param name="obj">
+        /// The <see cref="IWhileLoopActionUsage"/> for which a hash code is to be returned.
+        /// </param>
+        /// <returns>
+        /// A hash code based on the stable identity of the element.
+        /// </returns>
+        /// <remarks>
+        /// The hash code is intentionally derived from the element identity only,
+        /// ensuring stability and compatibility with collection-based equality
+        /// checks
+        /// </remarks>
+        public int GetHashCode(IWhileLoopActionUsage obj)
+        {
+            return HashCode.Combine(typeof(IWhileLoopActionUsage), obj.Id);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Json.Tests/DeSerializerTestFixture.cs b/SysML2.NET.Serializer.Json.Tests/DeSerializerTestFixture.cs
index 09d1df102..8c3a946b7 100644
--- a/SysML2.NET.Serializer.Json.Tests/DeSerializerTestFixture.cs
+++ b/SysML2.NET.Serializer.Json.Tests/DeSerializerTestFixture.cs
@@ -28,12 +28,10 @@ namespace SysML2.NET.Serializer.Json.Tests
 
     using NUnit.Framework;
 
-    using SysML2.NET.PIM.DTO;
-    using SysML2.NET.Core.DTO;
-    using SysML2.NET.Serializer.Json;
-    using SysML2.NET.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.DTO.Core.Features;
+    using SysML2.NET.PIM.DTO;
+    using SysML2.NET.Serializer.Json;
 
     /// <summary>
     /// Suite of tests for the <see cref="DeSerializer"/>
@@ -41,7 +39,7 @@ namespace SysML2.NET.Serializer.Json.Tests
     [TestFixture]
     public class DeSerializerTestFixture
     {
-        private IDeSerializer deSerializer;
+        private DeSerializer deSerializer;
 
         [SetUp]
         public void SetUp()
@@ -52,7 +50,7 @@ public void SetUp()
         [Test]
         [TestCase(false)]
         [TestCase(true)]
-        public void Verify_that_idada_from_sysmlcore_json_can_be_deserialized(bool shouldDeserializeDerivedProperties)
+        public void Verify_that_iData_from_sysmlcore_json_can_be_deserialized(bool shouldDeserializeDerivedProperties)
         {
             var fileName = Path.Combine(TestContext.CurrentContext.WorkDirectory, "Data", "projects.000e9890-6935-43e6-a5d7-5d7cac601f4c.commits.6d7ad9fd-6520-4ff2-885b-8c5c129e6c27.elements.json");
             using var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read);
@@ -87,7 +85,7 @@ public void Verify_that_idada_from_sysmlcore_json_can_be_deserialized(bool shoul
         [Test]
         [TestCase(false)]
         [TestCase(true)]
-        public async Task Verify_that_idada_from_sysmlcore_json_can_be_deserialized_async(bool shouldDeserializeDerivedProperties)
+        public async Task Verify_that_iData_from_sysmlcore_json_can_be_deserialized_async(bool shouldDeserializeDerivedProperties)
         {
             var fileName = Path.Combine(TestContext.CurrentContext.WorkDirectory, "Data", "projects.000e9890-6935-43e6-a5d7-5d7cac601f4c.commits.6d7ad9fd-6520-4ff2-885b-8c5c129e6c27.elements.json");
 
diff --git a/SysML2.NET.Serializer.Json.Tests/JsonSerializeAndDeserializeTestFixture.cs b/SysML2.NET.Serializer.Json.Tests/JsonSerializeAndDeserializeTestFixture.cs
new file mode 100644
index 000000000..d1a3040b9
--- /dev/null
+++ b/SysML2.NET.Serializer.Json.Tests/JsonSerializeAndDeserializeTestFixture.cs
@@ -0,0 +1,96 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="JsonSerializeAndDeserializeTestFixture.cs" company="Starion Group S.A.">
+// 
+//   Copyright 2022-2025 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.Json.Tests
+{
+    using System.IO;
+    using System.Linq;
+    using System.Text.Json;
+
+    using NUnit.Framework;
+
+    using SysML2.NET.Extensions.Core.DTO.Comparers;
+
+    using SysML2.NET.Serializer.Json;
+
+    /// <summary>
+    /// Suite of tests for the <see cref="DeSerializer"/>
+    /// </summary>
+    [TestFixture]
+    public class JsonSerializeAndDeserializeTestFixture
+    {
+        private DeSerializer deSerializer;
+        private Serializer serializer;
+
+        [SetUp]
+        public void SetUp()
+        {
+            this.deSerializer = new DeSerializer();
+            this.serializer = new Serializer();
+        }
+
+        [Test]
+        public void Verify_that_Deserialize_Serialize_and_Deserialize_yields_equal_objects()
+        {
+            var fileName = Path.Combine(TestContext.CurrentContext.WorkDirectory, "Data", "projects.000e9890-6935-43e6-a5d7-5d7cac601f4c.commits.6d7ad9fd-6520-4ff2-885b-8c5c129e6c27.elements.json");
+            using var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read);
+
+            var jsonFileData = this.deSerializer.DeSerialize(stream, SerializationModeKind.JSON, SerializationTargetKind.CORE, false).ToList();
+
+            var jsonWriterOptions = new JsonWriterOptions { Indented = true };
+
+            var targetStream = new MemoryStream();
+
+            this.serializer.Serialize(jsonFileData, SerializationModeKind.JSON, false, targetStream, jsonWriterOptions);
+
+            targetStream.Position = 0;
+
+            var memoryStreamData = this.deSerializer.DeSerialize(targetStream, SerializationModeKind.JSON, SerializationTargetKind.CORE, false).ToList();
+
+            Assert.That(jsonFileData, Has.Count.EqualTo(memoryStreamData.Count));
+
+            var jsonFileById = jsonFileData.ToDictionary(x => x.Id);
+            var memoryStreamById = memoryStreamData.ToDictionary(x => x.Id);
+
+            Assert.That(jsonFileById.Keys, Is.EquivalentTo(memoryStreamById.Keys));
+
+            using (Assert.EnterMultipleScope())
+            {
+                foreach (var id in jsonFileById.Keys)
+                {
+                    var left = jsonFileById[id];
+                    var right = memoryStreamById[id];
+
+                    Assert.That(
+                        right.GetType(),
+                        Is.EqualTo(left.GetType()),
+                        $"Type mismatch for id {id}. Left={left.GetType().FullName}, Right={right.GetType().FullName}");
+
+                    var comparer = ComparerProvider.Resolve(left);
+
+                    Assert.That(
+                        comparer.Equals(left, right),
+                        Is.True,
+                        $"Round-trip semantic mismatch for id {id} ({left.GetType().Name}).");
+                }
+            }
+        }
+    }
+}
diff --git a/SysML2.NET.Serializer.Json.Tests/SysML2.NET.Serializer.Json.Tests.csproj b/SysML2.NET.Serializer.Json.Tests/SysML2.NET.Serializer.Json.Tests.csproj
index 7d062193d..141fc1756 100644
--- a/SysML2.NET.Serializer.Json.Tests/SysML2.NET.Serializer.Json.Tests.csproj
+++ b/SysML2.NET.Serializer.Json.Tests/SysML2.NET.Serializer.Json.Tests.csproj
@@ -35,6 +35,7 @@
     </ItemGroup>
 
     <ItemGroup>
+      <ProjectReference Include="..\SysML2.NET.Extensions\SysML2.NET.Extensions.csproj" />
       <ProjectReference Include="..\SysML2.NET.Serializer.Json\SysML2.NET.Serializer.Json.csproj" />
     </ItemGroup>
 
diff --git a/SysML2.NET.Serializer.MessagePack.Tests/Comparers/GuidComparerTestFixture.cs b/SysML2.NET.Serializer.MessagePack.Tests/Comparers/GuidComparerTestFixture.cs
deleted file mode 100644
index 5e7f3b3b9..000000000
--- a/SysML2.NET.Serializer.MessagePack.Tests/Comparers/GuidComparerTestFixture.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-// -------------------------------------------------------------------------------------------------
-// <copyright file="GuidComparerTestFixture.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.Extensions.Tests.Comparers
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-
-    using NUnit.Framework;
-
-    using SysML2.NET.Extensions.Comparers;
-
-    [TestFixture]
-    public class GuidComparerTestFixture
-    {
-        [Test]
-        public void Verify_that_List_of_Guid_is_ordered()
-        {
-            var id_1 = Guid.Parse("622d8e0f-ed5e-4dde-92b8-97ff06e69110");
-            var id_2 = Guid.Parse("90e43d0c-edf8-4630-963b-90e6530ac9db");
-            var id_3 = Guid.Parse("47b3abc1-ce06-40ef-8ea6-466e7eaccccd");
-
-            Assert.That(-1, Is.EqualTo(id_1.CompareTo(id_2)));
-
-            var ids = new List<Guid> { id_1, id_2, id_3 };
-            var ordered = new List<Guid> { id_3, id_1, id_2 };
-
-            var result = ids.OrderBy(x => x, new GuidComparer());
-
-            Assert.That(ordered, Is.EqualTo(result));
-        }
-    }
-}
diff --git a/SysML2.NET.Serializer.MessagePack.Tests/SerializerTestFixture.cs b/SysML2.NET.Serializer.MessagePack.Tests/SerializerTestFixture.cs
index 9fcd1643e..4c8644011 100644
--- a/SysML2.NET.Serializer.MessagePack.Tests/SerializerTestFixture.cs
+++ b/SysML2.NET.Serializer.MessagePack.Tests/SerializerTestFixture.cs
@@ -20,24 +20,15 @@
 
 namespace SysML2.NET.Serializer.MessagePack.Tests
 {
-    using System;
     using System.IO;
     using System.Linq;
-    using System.Threading;
-    using System.Threading.Tasks;
 
     using NUnit.Framework;
 
-    using SysML2.NET.PIM.DTO;
-
-    using SysML2.NET.Core;
-    using SysML2.NET.Core.DTO;
     using SysML2.NET.Serializer.Json;
-    using SysML2.NET.Serializer.MessagePack;
-    using SysML2.NET.Core.Core.Types;
-    using SysML2.NET.Core.DTO.Core.Features;
-    using SerializationTargetKind = MessagePack.SerializationTargetKind;
+    using SysML2.NET.Extensions.Core.DTO.Comparers;
 
+    using SerializationTargetKind = MessagePack.SerializationTargetKind;
 
     [TestFixture]
     public class SerializerTestFixture
@@ -60,14 +51,11 @@ public void SetUp()
         public void Verify_that_iData_from_sysml2_core_json_can_be_deserialized()
         {
             var fileName = Path.Combine(TestContext.CurrentContext.WorkDirectory, "Data", "projects.000e9890-6935-43e6-a5d7-5d7cac601f4c.commits.6d7ad9fd-6520-4ff2-885b-8c5c129e6c27.elements.json");
-            using var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read);
+            using var jsonStream = new FileStream(fileName, FileMode.Open, FileAccess.Read);
 
-            var jsonData = this.jsonDeSerializer.DeSerialize(stream, SerializationModeKind.JSON, Json.SerializationTargetKind.CORE,false);
+            var jsonData = this.jsonDeSerializer.DeSerialize(jsonStream, SerializationModeKind.JSON, Json.SerializationTargetKind.CORE,false).ToList();
 
-            using (Assert.EnterMultipleScope())
-            {
-                Assert.That(jsonData.Count(), Is.EqualTo(100));
-            }
+            Assert.That(jsonData.Count, Is.EqualTo(100));
 
             var messagePackStream = new MemoryStream();
 
@@ -75,12 +63,35 @@ public void Verify_that_iData_from_sysml2_core_json_can_be_deserialized()
 
             messagePackStream.Position = 0;
 
-            var messagePackData= this.messagePackDeSerializer.DeSerialize(messagePackStream, SerializationTargetKind.CORE);
+            var messagePackData= this.messagePackDeSerializer.DeSerialize(messagePackStream, SerializationTargetKind.CORE).ToList();
 
-            var jsonBasedDictionary = jsonData.ToDictionary(x => x.Id);
-            var messagePackBasedDictionary = messagePackData.ToDictionary(x => x.Id);
+            Assert.That(messagePackData, Has.Count.EqualTo(jsonData.Count));
 
-            Assert.That(jsonBasedDictionary.Keys, Is.EquivalentTo(messagePackBasedDictionary.Keys));
+            var jsonById = jsonData.ToDictionary(x => x.Id);
+            var msgById = messagePackData.ToDictionary(x => x.Id);
+
+            Assert.That(jsonById.Keys, Is.EquivalentTo(msgById.Keys));
+
+            using (Assert.EnterMultipleScope())
+            {
+                foreach (var id in jsonById.Keys)
+                {
+                    var left = jsonById[id];
+                    var right = msgById[id];
+
+                    Assert.That(
+                        right.GetType(),
+                        Is.EqualTo(left.GetType()),
+                        $"Type mismatch for id {id}. Left={left.GetType().FullName}, Right={right.GetType().FullName}");
+
+                    var comparer = ComparerProvider.Resolve(left);
+
+                    Assert.That(
+                        comparer.Equals(left, right),
+                        Is.True,
+                        $"Round-trip semantic mismatch for id {id} ({left.GetType().Name}).");
+                }
+            }
         }
     }
 }
diff --git a/SysML2.NET.Serializer.MessagePack.Tests/SysML2.NET.Serializer.MessagePack.Tests.csproj b/SysML2.NET.Serializer.MessagePack.Tests/SysML2.NET.Serializer.MessagePack.Tests.csproj
index dfb4adb4f..3c24f2c88 100644
--- a/SysML2.NET.Serializer.MessagePack.Tests/SysML2.NET.Serializer.MessagePack.Tests.csproj
+++ b/SysML2.NET.Serializer.MessagePack.Tests/SysML2.NET.Serializer.MessagePack.Tests.csproj
@@ -39,10 +39,6 @@
         <ProjectReference Include="..\SysML2.NET.Serializer.MessagePack\SysML2.NET.Serializer.MessagePack.csproj" />
     </ItemGroup>
 
-    <ItemGroup>
-      <Folder Include="Comparers\" />
-    </ItemGroup>
-
     <ItemGroup>
       <None Update="Data\projects.000e9890-6935-43e6-a5d7-5d7cac601f4c.commits.6d7ad9fd-6520-4ff2-885b-8c5c129e6c27.elements.json">
         <CopyToOutputDirectory>Always</CopyToOutputDirectory>
diff --git a/SysML2.NET.Serializer.MessagePack/Helpers/DataFormatterResolver.cs b/SysML2.NET.Serializer.MessagePack/Helpers/DataFormatterResolver.cs
index 7f9289558..7e6be2d0b 100644
--- a/SysML2.NET.Serializer.MessagePack/Helpers/DataFormatterResolver.cs
+++ b/SysML2.NET.Serializer.MessagePack/Helpers/DataFormatterResolver.cs
@@ -31,7 +31,21 @@ namespace SysML2.NET.Serializer.MessagePack.Helpers
     /// </summary>
     public class DataFormatterResolver : IFormatterResolver
     {
-        // Resolver should be singleton.
+        /// <summary>
+        /// Gets the singleton instance of the <see cref="DataFormatterResolver"/>.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// This resolver is implemented as a singleton to ensure that formatter
+        /// resolution is centralized, stateless, and allocation-free at runtime.
+        /// </para>
+        /// <para>
+        /// MessagePack resolvers are expected to be reusable and thread-safe.
+        /// Using a single shared instance avoids unnecessary allocations and
+        /// ensures consistent formatter behavior across all serialization and
+        /// deserialization operations.
+        /// </para>
+        /// </remarks>
         public static readonly IFormatterResolver Instance = new DataFormatterResolver();
 
         /// <summary>