lutaml-model 0.8.17 → 0.8.19

data/lib/lutaml/model/union.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Type
+      # Functional xsd:union: an attribute value conforms to one of several
+      # declared member types. A single shared class recognized by identity
+      # (mirrors Type::Reference); the per-attribute member list lives in the
+      # attribute's @options[:union_member_types]. Stateless: serialization is
+      # driven by value.class, never by per-instance tracking.
+      #
+      # This class owns ALL union knowledge: the conformance engine, the
+      # definition-time validation, and the per-format mapped-field source.
+      # Every serializer touchpoint is a thin identity check that delegates here.
+      class Union < Value
+        # Options that cannot be combined with a union member list.
+        INCOMPATIBLE_OPTIONS = %i[polymorphic raw with child_mappings].freeze
+
+        # Native Ruby class a parsed/plain-Ruby value already has when it
+        # conforms to a scalar member without needing a lexical-space parse.
+        NATIVE_CLASSES = {
+          Lutaml::Model::Type::Integer => ::Integer,
+          Lutaml::Model::Type::Float => ::Float,
+          Lutaml::Model::Type::Boolean => [::TrueClass, ::FalseClass],
+          Lutaml::Model::Type::String => ::String,
+        }.freeze
+
+        # Native classes for value types whose dependency loads lazily
+        # (require "bigdecimal" / "date"). Looked up by constant name so the
+        # union never force-loads an optional dependency; if such a value
+        # exists at runtime, its constant is necessarily already defined.
+        # Decimal's native class (BigDecimal) loads lazily (require
+        # "bigdecimal"); looked up by constant name so the union never
+        # force-loads it. (Decimal is the only supported value type with a
+        # lazily-loaded native class.)
+        LAZY_NATIVE_CLASS_NAMES = {
+          Lutaml::Model::Type::Decimal => :BigDecimal,
+        }.freeze
+
+        INTEGER_LEXICAL = /\A\s*[+-]?\d+\s*\z/
+        # Matches Type::Boolean.cast (XSD true/false/1/0 plus the library's
+        # t/f/yes/no/y/n forms), so a union :boolean accepts the same inputs as
+        # a plain :boolean attribute.
+        BOOLEAN_LEXICAL = /\A(true|false|t|f|yes|no|y|n|1|0)\z/i
+
+        FLOAT_LEXICAL = lambda do |string|
+          Float(string).finite?
+        rescue ArgumentError, TypeError
+          false
+        end
+
+        # Whether a String input belongs to a scalar member's lexical space.
+        # Keyed by member class (identity), parallel to NATIVE_CLASSES.
+        LEXICAL_PREDICATES = {
+          Lutaml::Model::Type::Integer => ->(s) { s.match?(INTEGER_LEXICAL) },
+          Lutaml::Model::Type::Float => FLOAT_LEXICAL,
+          Lutaml::Model::Type::Decimal => FLOAT_LEXICAL,
+          Lutaml::Model::Type::Boolean => ->(s) { s.match?(BOOLEAN_LEXICAL) },
+          Lutaml::Model::Type::String => ->(_s) { true },
+        }.freeze
+
+        # Sound scalar union members are exactly the value types with a lexical
+        # predicate above: each maps to a distinct, stable Ruby runtime class
+        # (Integer, Float, BigDecimal, TrueClass/FalseClass, String), so the
+        # stateless value.class-driven serialization can always recover the
+        # member. Other value types are excluded because they cannot round-trip
+        # soundly in a union — e.g. Type::Date.cast can yield a DateTime, and
+        # Time / TimeWithoutDate share a Ruby Time class. Models are always OK.
+        SUPPORTED_VALUE_TYPES = LEXICAL_PREDICATES.keys.freeze
+
+        # Lossless numeric widening: a source value type may conform to a
+        # broader member. Narrowing (Float -> integer) and unrelated types are
+        # absent and therefore rejected. Exact-class matches are handled
+        # earlier by the instance_of? check in conform_scalar.
+        WIDENS_INTO = {
+          Integer => [Float, Decimal],
+          Float => [Decimal],
+        }.freeze
+
+        class << self
+          # Resolve the first member (in declared order) whose lexical/structural
+          # space the value belongs to, and the value cast to that member.
+          #
+          # @param value [Object] raw value (scalar, Hash sub-tree, or XmlElement)
+          # @param members [Array<Class>] resolved members, declared order
+          # @param format [Symbol, nil] serialization format being deserialized
+          # @param register [Symbol, nil] register for nested-model resolution
+          # @return [Array(Class, Object), nil] [member, casted] or nil (no match)
+          def conforming_member(value, members, format:, register:)
+            return nil if value.nil? || Utils.uninitialized?(value)
+
+            members.each do |member|
+              casted = if model_member?(member)
+                         conform_model(member, value, format, register)
+                       else
+                         conform_scalar(member, value)
+                       end
+              return [member, casted] unless casted == :no_match
+            end
+            nil
+          end
+
+          # Whether a compiled mapping rule's attribute is a union — the single
+          # identity check every serializer touchpoint shares.
+          def rule?(rule)
+            rule.attribute_type == self
+          end
+
+          # An XML child is routed to member resolution (vs the plain-text
+          # scalar path) when it has child elements or attributes. Resolution
+          # tries model members by key coverage, then falls back to the scalar
+          # members on the element's text — so a text-only element with an
+          # unrelated attribute (e.g. xml:lang) still resolves to a scalar.
+          def xml_structured?(element)
+            return false unless element.respond_to?(:children)
+
+            element.children.any?(&:element?) || element.attributes.any?
+          end
+
+          # Serialize a scalar union value through the value type matching its
+          # own class, so output is canonical/portable (a BigDecimal emits
+          # "1.5", not a raw Ruby object). value.class drives the type —
+          # stateless, identical to how a plain scalar attribute serializes.
+          # Falls back to the value as-is when it maps to no known value type.
+          def serialize_scalar(value, format)
+            type = scalar_type_for(value)
+            return value unless type
+
+            type.new(value).public_send(:"to_#{format}")
+          end
+
+          def validate_members!(members)
+            unless members.is_a?(::Array) && !members.empty?
+              raise ArgumentError, "union type must be a non-empty array of types"
+            end
+
+            resolved = members.map { |member| resolve_member!(member) }
+            validate_catch_all_position!(resolved)
+            resolved
+          end
+
+          def validate_combo!(options)
+            present = INCOMPATIBLE_OPTIONS.select { |key| options[key] }
+            return if present.empty?
+
+            raise ArgumentError,
+                  "union type cannot be combined with: #{present.join(', ')}"
+          end
+
+          private
+
+          def model_member?(member)
+            member.is_a?(::Class) && member.include?(Serialize)
+          end
+
+          # Structural (key-coverage) selection: every input key maps to one of
+          # the member's mapped fields, with no input key left unmapped. Once
+          # selected, field values cast leniently via the member's normal path.
+          # An existing member instance conforms as-is, keeping conformance
+          # idempotent — values can re-enter casting (e.g. a value transformer
+          # builds the member before the cast runs).
+          def conform_model(member, value, format, register)
+            return value if value.is_a?(member)
+
+            keys = input_keys(value, format)
+            return :no_match if keys.nil? || keys.empty?
+
+            field_names = member_field_names(member, format, register)
+            return :no_match unless keys.all? { |key| field_names.include?(key) }
+
+            # Plain-Ruby assignment (format nil) builds straight from the
+            # attribute hash, mirroring how non-union model attributes accept
+            # `Model.new(child: { ... })`; a format builds via the mappings.
+            return member.new(value) if format.nil?
+
+            member.apply_mappings(value, format, register: register)
+          end
+
+          # A scalar conforms if the value already is the member's native Ruby
+          # class (covers parsed and plain-Ruby values), or if a String input
+          # belongs to the member's space. Lenient built-ins (Integer/Float/
+          # Decimal/Boolean/String) are gated by an explicit lexical predicate
+          # so their forgiving casts can't false-match; every other value type
+          # owns its space via its own (strict) cast — nil/raise means no match.
+          def conform_scalar(member, value)
+            # Scalar payload: an XML element contributes its text (so a scalar
+            # member matches when no model member covers it); Hash and primitive
+            # inputs pass through unchanged.
+            value = value.text if xml_element?(value)
+
+            # Exact native class (instance_of?): the value is precisely the
+            # member's native Ruby class (covers parsed and plain-Ruby values).
+            native = Array(NATIVE_CLASSES[member] || lazy_native_class(member))
+            return value if native.any? { |klass| value.instance_of?(klass) }
+
+            predicate = LEXICAL_PREDICATES[member]
+            return :no_match unless predicate
+
+            # String input: accept only within the member's lexical space.
+            if value.is_a?(::String)
+              return predicate.call(value) ? member.cast(value) : :no_match
+            end
+
+            # Native non-string value (e.g. a parsed Integer for a :float
+            # member): accept only as a lossless widening into a broader member,
+            # so a lenient built-in can't narrow or distort it — :float accepts
+            # 42, but :integer won't swallow 3.7 or 3.0. lossless_cast then
+            # guards precision (e.g. 2**60+1 is not exactly representable as
+            # Float).
+            source = scalar_type_for(value)
+            return :no_match unless WIDENS_INTO[source]&.include?(member)
+
+            lossless_cast(member, value)
+          end
+
+          # A native non-string value conforms to a lenient built-in only if the
+          # member's cast preserves it (value-equal round-trip), so cross-numeric
+          # widening is accepted but narrowing/distortion is not.
+          def lossless_cast(member, value)
+            casted = member.cast(value)
+            casted == value ? casted : :no_match
+          rescue StandardError
+            :no_match
+          end
+
+          def lazy_native_class(member)
+            const_name = LAZY_NATIVE_CLASS_NAMES[member]
+            return nil unless const_name && Object.const_defined?(const_name)
+
+            Object.const_get(const_name)
+          end
+
+          # The value type whose native Ruby class the value is an instance of
+          # (reverse of NATIVE_CLASSES plus the lazily-loaded native classes).
+          def scalar_type_for(value)
+            NATIVE_CLASSES.each do |type, klasses|
+              return type if Array(klasses).any? { |k| value.instance_of?(k) }
+            end
+            LAZY_NATIVE_CLASS_NAMES.each_key do |type|
+              klass = lazy_native_class(type)
+              return type if klass && value.instance_of?(klass)
+            end
+            nil
+          end
+
+          # Input keys by format: Hash keys for key-value; child element local
+          # names + attribute names for XML; nil otherwise.
+          def input_keys(value, format)
+            return value.keys.map(&:to_s) if value.is_a?(::Hash)
+
+            if format == :xml && xml_element?(value)
+              names = value.children.select(&:element?).map(&:unprefixed_name) +
+                value.attributes.values.map(&:unprefixed_name)
+              return names.map(&:to_s)
+            end
+
+            nil
+          end
+
+          def xml_element?(value)
+            value.respond_to?(:children) && value.respond_to?(:attributes)
+          end
+
+          # The set of mapped field names for a member in the given format.
+          # One source, parameterized by format. A nil format is plain-Ruby
+          # assignment, which has no mapping context — match on attribute names.
+          def member_field_names(member, format, register)
+            return member.attributes.keys.map(&:to_s) if format.nil?
+
+            mapping = member.mappings_for(format, register)
+            rules = if format == :xml
+                      mapping.elements(register) + mapping.attributes(register)
+                    else
+                      mapping.mappings(register)
+                    end
+            rules.flat_map do |rule|
+              (rule.multiple_mappings? ? rule.name : [rule.name]).map(&:to_s)
+            end
+          end
+
+          def resolve_member!(member)
+            if member.is_a?(::Hash)
+              raise ArgumentError,
+                    "union members must be types or symbols; option hashes " \
+                    "(e.g. { ref: ... }) are not supported as union members"
+            end
+
+            klass =
+              begin
+                Lutaml::Model::Attribute.cast_type!(member)
+              rescue ArgumentError
+                nil
+              end
+            unless klass
+              raise ArgumentError, "invalid union member: #{member.inspect}"
+            end
+            return klass if klass.is_a?(::Class) && klass.include?(Serialize)
+            return klass if SUPPORTED_VALUE_TYPES.include?(klass)
+
+            raise ArgumentError,
+                  "unsupported union member type: #{member.inspect}. Supported " \
+                  "scalar members are :string, :integer, :float, :decimal, " \
+                  ":boolean, or a Serializable model"
+          end
+
+          # The catch-all must be the last member overall (not merely the last
+          # value type): XML scalar matching reads element.text, so a :string
+          # placed before a model member would swallow structured elements too.
+          def validate_catch_all_position!(resolved)
+            return unless resolved.include?(Lutaml::Model::Type::String)
+            return if resolved.last == Lutaml::Model::Type::String
+
+            raise ArgumentError,
+                  "a universal catch-all type must be the last union member"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/utils.rb

@@ -102,6 +102,12 @@ module Lutaml
           snake_case(base_class_name(klass))
         end
 
+        # Return the final segment of a `prefix:local` style qualified name,
+        # e.g. `"xs:string" -> "string"`. Returns nil for nil input.
+        def last_of_split(field)
+          field&.split(":")&.last
+        end
+
         def initialized?(value)
           !value.equal?(UNINITIALIZED)
         end

data/lib/lutaml/model/validation.rb

@@ -14,10 +14,7 @@ module Lutaml
               sub_errors = value.validate
               errors.concat(sub_errors) if sub_errors.is_a?(Array)
             else
-              resolver = Lutaml::Model::Services::DefaultValueResolver.new(
-                attr, register, self
-              )
-              attr.validate_value!(value, register, resolver)
+              attr.validate_value!(value, register, instance_object: self)
             end
           rescue Lutaml::Model::CollectionCountOutOfRangeError => e
             errors << e unless attr.choice

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.17"
+    VERSION = "0.8.19"
   end
 end

data/lib/lutaml/model.rb

@@ -142,6 +142,8 @@ module Lutaml
     autoload :UnknownTypeError, "#{__dir__}/model/error/unknown_type_error"
     autoload :RequiredAttributeMissingError,
              "#{__dir__}/model/error/required_attribute_missing_error"
+    autoload :UnionSchemaUnsupportedError,
+             "#{__dir__}/model/error/union_schema_unsupported_error"
     autoload :MultipleMappingsError,
              "#{__dir__}/model/error/multiple_mappings_error"
     autoload :CollectionTrueMissingError,
@@ -235,6 +237,22 @@ module Lutaml
     def self.reset_configuration!
       @configuration = nil
     end
+
+    # Convenience accessors for runtime/platform detection.
+    # Delegates to RuntimeCompatibility so call sites can write
+    # `Lutaml::Model.opal?` (or `Model.opal?` inside the namespace)
+    # instead of the long `Lutaml::Model::RuntimeCompatibility.opal?`.
+    def self.opal?
+      RuntimeCompatibility.opal?
+    end
+
+    def self.native?
+      RuntimeCompatibility.native?
+    end
+
+    def self.windows?
+      RuntimeCompatibility.windows?
+    end
   end
 end
 

data/lib/lutaml/toml.rb

@@ -30,7 +30,7 @@ Lutaml::Model::FormatRegistry.register(
   adapter_class: nil,
   transformer: Lutaml::Toml::Adapter::Transform,
   key_value: true,
-  adapter_options: if Lutaml::Model::RuntimeCompatibility.opal?
+  adapter_options: if Lutaml::Model.opal?
                      nil
                    else
                      {

data/lib/lutaml/xml/adapter.rb

@@ -13,11 +13,11 @@ module Lutaml
       autoload :NamespaceUriCollector,
                "#{__dir__}/adapter/namespace_uri_collector"
       autoload :OgaAdapter, "#{__dir__}/adapter/oga_adapter"
+      autoload :RexmlAdapter, "#{__dir__}/adapter/rexml_adapter"
       Lutaml::Model::RuntimeCompatibility.autoload_native(
         self,
         NokogiriAdapter: "#{__dir__}/adapter/nokogiri_adapter",
         OxAdapter: "#{__dir__}/adapter/ox_adapter",
-        RexmlAdapter: "#{__dir__}/adapter/rexml_adapter",
       )
     end
   end

data/lib/lutaml/xml/adapter_loader.rb

@@ -13,7 +13,7 @@ module Lutaml
       # @param _adapter [String] The adapter format name ("xml")
       # @param type [String] The normalized type name (e.g., "nokogiri_adapter")
       def self.load_adapter_file(_adapter, type)
-        adapter_path = if Lutaml::Model::RuntimeCompatibility.opal?
+        adapter_path = if Lutaml::Model.opal?
                          "lutaml/xml/adapter/#{type}"
                        else
                          File.join(File.dirname(__FILE__), "adapter", type)

data/lib/lutaml/xml/builder/base.rb

@@ -14,7 +14,7 @@ module Lutaml
       class Base
         def self.build(options = {})
           context = Moxml.new(moxml_backend)
-          if Lutaml::Model::RuntimeCompatibility.opal?
+          if Lutaml::Model.opal?
             context.config.namespace_validation_mode = :lenient
           end
 

data/lib/lutaml/xml/builder.rb

@@ -6,11 +6,11 @@ module Lutaml
     module Builder
       autoload :Base, "#{__dir__}/builder/base"
       autoload :Oga, "#{__dir__}/builder/oga"
+      autoload :Rexml, "#{__dir__}/builder/rexml"
       Lutaml::Model::RuntimeCompatibility.autoload_native(
         self,
         Nokogiri: "#{__dir__}/builder/nokogiri",
         Ox: "#{__dir__}/builder/ox",
-        Rexml: "#{__dir__}/builder/rexml",
       )
     end
   end

data/lib/lutaml/xml/error/schema_validation_error.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    module Error
+      # Collected when a model's generated XML does not conform to the
+      # XSD schema configured via the `validate_xml_with` macro.
+      #
+      # One instance represents one schema violation reported by the
+      # validating parser, so Lutaml::Model::ValidationError#error_messages
+      # lists each violation individually.
+      #
+      # Not to be confused with Schema::Xsd::SchemaValidationError, which
+      # reports problems in an XSD document itself.
+      class SchemaValidationError < XmlError
+        attr_reader :schema_path
+
+        def initialize(message, schema_path)
+          @schema_path = schema_path
+          super("XML does not conform to schema #{schema_path}: #{message}")
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/xml/model_transform.rb

@@ -708,7 +708,9 @@ _effective_register)
         base_cast_options[:resolved_type] = attr_type
 
         children.each do |child|
-          if !rule_has_custom_method && attr_type_is_serializable
+          if !rule_has_custom_method &&
+              (attr_type_is_serializable ||
+                (attr&.union? && ::Lutaml::Model::Type::Union.xml_structured?(child)))
             # Performance: Build cast_options efficiently (dup + []= cheaper than merge)
             cast_options = if (child_namespace_uri = child.namespace_uri)
                              ns_type = attr.type_with_namespace(effective_register,
@@ -984,6 +986,8 @@ effective_register = lutaml_register)
       # @return [Boolean] true if a matching child likely exists
       def child_matches_rule?(rule, child_names_set, default_namespace)
         rule_names = rule.namespaced_names(default_namespace)
+        # Array#intersect? requires an Array argument; child_names_set may
+        # be a Set, so use the block form which works for any includable.
         rule_names.any? { |rn| child_names_set.include?(rn) } ||
           child_names_set.include?(rule.name.to_s)
       end

data/lib/lutaml/xml/schema/relaxng_schema.rb

@@ -31,6 +31,11 @@ module Lutaml
 
         def self.generate_attributes(xml, klass, register)
           klass.attributes.each do |name, attr|
+            if attr.union?
+              raise Lutaml::Model::UnionSchemaUnsupportedError.new(name,
+                                                                   "RelaxNG")
+            end
+
             attr_type = attr.type(register)
             if attr_type <= Lutaml::Model::Serialize
               xml.ref(name: attr_type.name)

data/lib/lutaml/xml/schema/xsd_schema.rb

@@ -409,6 +409,10 @@ attr_name)
 
         def self.get_attribute_xsd_type(attr, attr_type, register,
 _mapping_rule = nil)
+          if attr.union?
+            raise Lutaml::Model::UnionSchemaUnsupportedError.new(attr.name, "XSD")
+          end
+
           # 1. Check for deprecated attribute-level xsd_type override
           return attr.options[:xsd_type] if attr.options[:xsd_type]
 

data/lib/lutaml/xml/serialization/format_conversion.rb

@@ -44,6 +44,50 @@ module Lutaml
           @namespace_class&.prefix_default
         end
 
+        # Configure one or more XSD schemas that the model's generated
+        # XML must conform to. Checked during validate/validate!
+        # (issue #264). Repeated calls (including in subclasses) append.
+        #
+        # Relative paths resolve against the file that declares the macro,
+        # so a model works regardless of the process working directory.
+        #
+        # @param paths [Array<String, Pathname>] paths to XSD schema files
+        def validate_xml_with(*paths)
+          base = File.dirname(caller_locations(1, 1).first.path)
+          @own_xml_schema_paths = own_xml_schema_paths +
+            paths.flatten.map { |path| File.expand_path(path.to_s, base) }
+        end
+
+        # All configured XSD schema paths, parent-first: inherited paths
+        # come before paths declared on this class.
+        #
+        # @return [Array<String>]
+        def xml_schema_paths
+          inherited = if superclass.respond_to?(:xml_schema_paths)
+                        superclass.xml_schema_paths
+                      else
+                        []
+                      end
+          inherited + own_xml_schema_paths
+        end
+
+        # Validate a raw XML string against the configured schemas without
+        # instantiating a model — the explicit input-side counterpart to
+        # the validate/validate! output-side check.
+        #
+        # @param xml [String] an XML document
+        # @return [Array<Lutaml::Xml::Error::SchemaValidationError>]
+        def validate_xml(xml)
+          XsdValidator.validate(xml, xml_schema_paths)
+        end
+
+        # @raise [Lutaml::Model::ValidationError] when the XML does not
+        #   conform to every configured schema
+        def validate_xml!(xml)
+          errors = validate_xml(xml)
+          raise Lutaml::Model::ValidationError.new(errors) if errors.any?
+        end
+
         # Override choice to set format: :xml so Choice knows which format it belongs to.
         def choice(min: 1, max: 1, format: :xml, &)
           super
@@ -204,6 +248,10 @@ module Lutaml
 
         private
 
+        def own_xml_schema_paths
+          @own_xml_schema_paths ||= []
+        end
+
         # Handle XML mapping class inheritance pattern (e.g., `xml SomeMapping`)
         #
         # When a mapping class is passed, inherit mappings from it directly.

data/lib/lutaml/xml/serialization/instance_methods.rb

@@ -263,6 +263,19 @@ module Lutaml
           self.class.mappings_for(:xml, register)&.element_sequence
         end
 
+        # Append XSD schema errors (validate_xml_with macro) to the
+        # standard validation errors. No-op unless schemas are configured.
+        #
+        # @see Lutaml::Model::Validation#validate
+        def validate(register: Lutaml::Model::Config.default_register)
+          errors = super
+          return errors if self.class.xml_schema_paths.empty?
+
+          errors.concat(
+            self.class.validate_xml(to_xml(register: register)),
+          )
+        end
+
         private
 
         # Build declaration plan from stored element reference (lazy mode).

data/lib/lutaml/xml/transformation/element_builder.rb

@@ -28,13 +28,22 @@ register_id, register)
           # class AND the value is not a nil/empty marker from collection handlers.
           # Nil and empty string markers should create simple elements, not attempt
           # nested model transformation.
-          is_nested_model = rule.attribute_type.is_a?(Class) &&
-            rule.attribute_type < Lutaml::Model::Serialize &&
-            !value.nil? &&
-            !(value.is_a?(String) && value.empty?)
+          # Union: dispatch on the value's own class (stateless). A model member
+          # becomes a nested element; a scalar member a simple value element.
+          union = Lutaml::Model::Type::Union.rule?(rule)
+
+          is_nested_model = !value.nil? &&
+            !(value.is_a?(String) && value.empty?) &&
+            if union
+              value.is_a?(Lutaml::Model::Serialize)
+            else
+              rule.attribute_type.is_a?(Class) &&
+                rule.attribute_type < Lutaml::Model::Serialize
+            end
 
           if is_nested_model
-            create_nested_model_element(rule, value, options, register)
+            create_nested_model_element(rule, value, options, register,
+                                        union: union)
           else
             create_simple_value_element(rule, value, options, model_class,
                                         register_id)
@@ -119,7 +128,8 @@ parent_element_form_default)
         # @param options [Hash] Options
         # @param register [Register, nil] The register
         # @return [::Lutaml::Xml::DataModel::XmlElement] The created element
-        def create_nested_model_element(rule, value, options, register)
+        def create_nested_model_element(rule, value, options, register,
+                                        union: false)
           # Resolve polymorphic configuration
           polymorphic_config = rule.options[:polymorphic]
           is_polymorphic = polymorphic_config.is_a?(::Hash) ? !polymorphic_config.empty? : !!polymorphic_config
@@ -130,8 +140,11 @@ parent_element_form_default)
           actual_class = resolve_polymorphic_class(rule, value, is_polymorphic,
                                                    is_polymorphic_subtype)
 
-          # Get transformation for the actual class
-          child_transformation = if is_polymorphic || is_polymorphic_subtype
+          # Get transformation for the actual class. Unions resolve the member
+          # from the value's own class, like polymorphism.
+          child_transformation = if union
+                                   value.class.transformation_for(:xml, register)
+                                 elsif is_polymorphic || is_polymorphic_subtype
                                    actual_class.transformation_for(:xml,
                                                                    register)
                                  else