lutaml-model 0.8.33 → 0.8.34

data/lib/lutaml/model/serialize/format_conversion.rb

@@ -50,26 +50,30 @@ module Lutaml
             return fast if fast
           end
 
-          Instrumentation.instrument(:from, model: name, format: format) do
-            adapter = resolve_adapter(format, options.delete(:adapter))
+          # The rescue sits on the parse block, not the method, so cache
+          # store failures propagate instead of becoming InvalidFormatError.
+          with_conversion_cache(:from, format, data, options) do
+            Instrumentation.instrument(:from, model: name, format: format) do
+              adapter = resolve_adapter(format, options.delete(:adapter))
 
-            raise Lutaml::Model::FormatAdapterNotSpecifiedError.new(format) if adapter.nil?
+              raise Lutaml::Model::FormatAdapterNotSpecifiedError.new(format) if adapter.nil?
 
-            # Resolve imports at the entry point of deserialization
-            register = options[:register] || Lutaml::Model::Config.default_register
+              # Resolve imports at the entry point of deserialization
+              register = options[:register] || Lutaml::Model::Config.default_register
 
-            # Hook for format-specific pre-deserialization (e.g., XML mapping import resolution)
-            pre_deserialize_hook(format, register)
+              # Hook for format-specific pre-deserialization (e.g., XML mapping import resolution)
+              pre_deserialize_hook(format, register)
 
-            # Recursively resolve child model imports
-            # This ensures the entire model tree is finalized before parsing
-            ensure_child_imports_resolved!(register)
+              # Recursively resolve child model imports
+              # This ensures the entire model tree is finalized before parsing
+              ensure_child_imports_resolved!(register)
 
-            doc = adapter.parse(data, options)
-            send("of_#{format}", doc, options)
+              doc = adapter.parse(data, options)
+              send("of_#{format}", doc, options)
+            end
+          rescue *format_error_types => e
+            raise Lutaml::Model::InvalidFormatError.new(format, e.message)
           end
-        rescue *format_error_types => e
-          raise Lutaml::Model::InvalidFormatError.new(format, e.message)
         end
 
         # Hook for format-specific pre-deserialization logic.
@@ -253,33 +257,37 @@ module Lutaml
         #   is always preserved when available, regardless of this option.
         # @return [String] The serialized output
         def to(format, instance, options = {})
-          # Ruby's JSON generator hands #to_json its own JSON::State rather
-          # than an options hash. It carries no LutaML options, but it does
-          # carry the surrounding indent context, so it is forwarded to the
-          # adapter unchanged instead of being read like a Hash -- json 3.0
-          # removed JSON::State#[].
-          options = Serialize.wrap_generator_state(options)
-          generator_state = options.delete(Serialize::GENERATOR_STATE_KEY)
-
-          Instrumentation.instrument(:to, model: name, format: format) do
-            adapter_override = options.delete(:adapter)
-            options[:_adapter_override] = true if adapter_override
-            if format == :xml && Lutaml::Model::Config.instance.xml_plan_fast_path
-              fast = xml_plan_fast_serialize(instance, options)
-              return fast if fast
-            end
-            value = public_send(:"as_#{format}", instance, options)
-            adapter = resolve_adapter(format, adapter_override)
+          # The rescue sits on the parse block, not the method, so cache
+          # store failures propagate instead of becoming InvalidFormatError.
+          with_conversion_cache(:to, format, instance, options) do
+            # Ruby's JSON generator hands #to_json its own JSON::State rather
+            # than an options hash. It carries no LutaML options, but it does
+            # carry the surrounding indent context, so it is forwarded to the
+            # adapter unchanged instead of being read like a Hash -- json 3.0
+            # removed JSON::State#[].
+            options = Serialize.wrap_generator_state(options)
+            generator_state = options.delete(Serialize::GENERATOR_STATE_KEY)
+
+            Instrumentation.instrument(:to, model: name, format: format) do
+              adapter_override = options.delete(:adapter)
+              options[:_adapter_override] = true if adapter_override
+              if format == :xml && Lutaml::Model::Config.instance.xml_plan_fast_path
+                fast = xml_plan_fast_serialize(instance, options)
+                return fast if fast
+              end
+              value = public_send(:"as_#{format}", instance, options)
+              adapter = resolve_adapter(format, adapter_override)
 
-            # Hook for format-specific options preparation (e.g., XML prefix/namespace/declaration)
-            options = prepare_to_options(format, instance, options)
+              # Hook for format-specific options preparation (e.g., XML prefix/namespace/declaration)
+              options = prepare_to_options(format, instance, options)
 
-            document = adapter.new(value, register: options[:register])
+              document = adapter.new(value, register: options[:register])
 
-            document.public_send(
-              :"to_#{format}",
-              forward_options(document, generator_state, options),
-            )
+              document.public_send(
+                :"to_#{format}",
+                forward_options(document, generator_state, options),
+              )
+            end
           end
         end
 

data/lib/lutaml/model/serialize/initialization.rb

@@ -395,8 +395,10 @@ module Lutaml
         def define_collection_register_methods(name)
           define_method(name) do |*args|
             if args.empty?
-              current = instance_variable_get(:"@#{name}")
-              current.equal?(LAZY_EMPTY_COLLECTION) ? [] : current
+              # Store the materialized Array instead of discarding it, so
+              # `model.items << x` on a register-scoped model reaches the model
+              # rather than a throwaway copy.
+              materialize_lazy_collection(name)
             else
               value = args.first
               current = instance_variable_get(:"@#{name}")

data/lib/lutaml/model/serialize.rb

@@ -11,6 +11,7 @@ module Lutaml
       autoload :EnumHandling, "#{__dir__}/serialize/enum_handling"
       autoload :ModelImport, "#{__dir__}/serialize/model_import"
       autoload :FormatConversion, "#{__dir__}/serialize/format_conversion"
+      autoload :ConversionCaching, "#{__dir__}/serialize/conversion_caching"
       autoload :ValueMapping, "#{__dir__}/serialize/value_mapping"
       autoload :TransformationBuilder,
                "#{__dir__}/serialize/transformation_builder"
@@ -47,6 +48,7 @@ module Lutaml
         include Serialize::EnumHandling
         include Serialize::ModelImport
         include Serialize::FormatConversion
+        include Serialize::ConversionCaching
         include Serialize::ValueMapping
         include Serialize::TransformationBuilder
 
@@ -340,6 +342,65 @@ module Lutaml
 
         ref.is_a?(Type::Reference) ? ref.object : ref
       end
+
+      # Hand back a collection the caller can push onto.
+      #
+      # An unused collection points at LAZY_EMPTY_COLLECTION, one frozen Array
+      # shared by every instance of every class, so an untouched collection
+      # costs nothing. A reader cannot hand that array out: `model.items << x`
+      # raises FrozenError, and unfreezing it would leak one instance's items
+      # into all the others. So the first read swaps in this instance's own
+      # empty Array and stores it — which is what the sentinel's own comment
+      # has promised all along. A frozen model keeps the sentinel; there is
+      # nothing to store into.
+      #
+      # nil is left alone on purpose. A nil collection is a state of its own
+      # here, distinct from an empty one — `initialize_empty: false` is what
+      # produces it and `render_nil` renders it — so a reader that turned nil
+      # into [] would erase a documented distinction.
+      #
+      # @param attribute_name [Symbol] the collection attribute
+      # @return [Object] the stored collection
+      def materialize_lazy_collection(attribute_name)
+        current = instance_variable_get(:"@#{attribute_name}")
+        return current unless current.equal?(LAZY_EMPTY_COLLECTION)
+        return current if frozen?
+
+        instance_variable_set(:"@#{attribute_name}", [])
+      end
+
+      # Hand back a reference collection the caller can push onto.
+      #
+      # A reference attribute stores Type::Reference objects, and resolving
+      # them built a fresh Array per read — so `book.co_authors << author`
+      # landed on a throwaway and never reached the document. A Reference
+      # stays lazy until its target registers itself, so the reader can only
+      # store the resolved Array once every reference has actually resolved;
+      # until then it has to keep re-resolving and keeps handing back a copy.
+      # Once stored there is nothing left to resolve: resolve_reference_value
+      # passes a model instance straight through, and the generated key reader
+      # runs Attribute#reference_key over it to get the key back.
+      #
+      # Storing means `#{name}_ref` reports resolved objects from then on. It
+      # is the backing store, and after this the objects are what it holds.
+      #
+      # @param attribute_name [Symbol] the reference collection attribute
+      # @return [Object] the stored collection
+      def materialize_reference_collection(attribute_name)
+        refs = instance_variable_get(:"@#{attribute_name}_ref")
+        return resolve_reference_value(refs) unless refs.is_a?(::Array)
+        return refs if refs.none?(Type::Reference)
+
+        resolved = resolve_reference_value(refs)
+        # Only a Reference that resolved to nothing keeps this lazy. A raw nil
+        # the caller put there is data, and waiting on it would never end.
+        dangling = refs.zip(resolved).any? do |ref, value|
+          ref.is_a?(Type::Reference) && value.nil?
+        end
+        return resolved if frozen? || dangling
+
+        instance_variable_set(:"@#{attribute_name}_ref", resolved)
+      end
     end
   end
 end

data/lib/lutaml/model/services/type/validator.rb

@@ -35,6 +35,29 @@ module Lutaml
 
               raise Lutaml::Model::Type::MaxBoundError.new(value, max)
             end
+
+            # Reads the canonical facet keys (:min_exclusive/:max_exclusive);
+            # the inclusive `validate_min_max_bounds!` above reads the legacy
+            # :min/:max keys it shares with the eager cast path.
+            def validate_exclusive_bounds!(value, options)
+              min, max = options&.values_at(:min_exclusive, :max_exclusive)
+              return if min.nil? && max.nil?
+
+              validate_min_exclusive_bound!(value, min) if min
+              validate_max_exclusive_bound!(value, max) if max
+            end
+
+            def validate_min_exclusive_bound!(value, min)
+              return if value > min
+
+              raise Lutaml::Model::Type::MinExclusiveError.new(value, min)
+            end
+
+            def validate_max_exclusive_bound!(value, max)
+              return if value < max
+
+              raise Lutaml::Model::Type::MaxExclusiveError.new(value, max)
+            end
           end
 
           extend ClassMethods

data/lib/lutaml/model/type/string.rb

@@ -8,13 +8,20 @@ module Lutaml
         def self.cast(value, options = {})
           return nil if value.nil?
           return value if Utils.uninitialized?(value)
-          # Short-circuit: return immediately if already a String with no options
-          # Use identity check for EMPTY_OPTIONS (faster than .empty?)
-          if value.is_a?(::String) && options.equal?(EMPTY_OPTIONS)
+
+          # Short-circuit an already-::String value with no options only when
+          # no xs:whiteSpace normalization is requested (the common :string
+          # case); a non-preserve mode must fall through to transform the text.
+          mode = white_space_mode
+          if value.is_a?(::String) && options.equal?(EMPTY_OPTIONS) &&
+              mode == :preserve
             return value
           end
 
           value = value.to_s
+          value = value.gsub(/[\t\n\r]/, " ") unless mode == :preserve
+          value = value.squeeze(" ").strip if mode == :collapse
+
           unless options.equal?(EMPTY_OPTIONS)
             Model::Services::Type::Validator::String.validate!(value,
                                                                options)
@@ -22,6 +29,24 @@ module Lutaml
           value
         end
 
+        # Effective xs:whiteSpace mode for this type, defaulting to :preserve.
+        # Memoized per class so the hot cast path avoids re-walking the facet
+        # chain; class-instance variables are not inherited, so each subclass
+        # computes (and freezes) its own effective mode.
+        def self.white_space_mode
+          @white_space_mode ||= facets[:white_space] || :preserve
+        end
+
+        # Drop the memoized mode when a facet is declared after it was first
+        # computed (e.g. a cast before the `white_space` declaration), so the
+        # next cast recomputes it from the updated facets.
+        def self.reset_facet_cache
+          return unless instance_variable_defined?(:@white_space_mode)
+
+          remove_instance_variable(:@white_space_mode)
+        end
+        private_class_method :reset_facet_cache
+
         # Default XSD type for String
         #
         # @return [String] xs:string

data/lib/lutaml/model/type/value.rb

@@ -21,6 +21,28 @@ module Lutaml
         # Use options.equal?(EMPTY_OPTIONS) for fast-path checks
         EMPTY_OPTIONS = {}.freeze
 
+        # Canonical facet keys grouped by how a tighter constraint compares: a
+        # min-like facet tightens upward (greater wins), a max-like facet
+        # tightens downward (lesser wins). `:length` (exact) only matches equal.
+        MIN_FACETS = %i[min_inclusive min_exclusive min_length].freeze
+        MAX_FACETS = %i[
+          max_inclusive
+          max_exclusive
+          max_length
+          total_digits
+          fraction_digits
+        ].freeze
+
+        # Facets whose combined value is the concatenation of every declaration
+        # in the chain: accumulating them is always a tightening (all patterns
+        # must match), so they bypass the widen check on inheritance.
+        LIST_FACETS = %i[pattern].freeze
+
+        # xs:whiteSpace normalization modes in ascending strictness: a stricter
+        # mode transforms at least as much as a looser one, so `tighter_facet`
+        # picks the stricter and a subclass may tighten but not loosen it.
+        WHITE_SPACE_MODES = %i[preserve replace collapse].freeze
+
         # Format type serializer registry
         # Keys: [format, TypeClass] => { to: Proc, from: Proc }
         @format_type_serializers = {}
@@ -66,6 +88,215 @@ from: nil)
             cache[key] = found
             found
           end
+
+          # Freeze a type's facets to further declarations once it is
+          # subclassed, so a parent cannot widen facets after children exist.
+          def inherited(subclass)
+            super
+            @facets_closed = true
+          end
+
+          # Effective canonical facets for this type, merged parent-first. A
+          # subclass may only tighten an inherited facet; widening raises.
+          def facets
+            facet_layers.each_with_object({}) do |layer, merged|
+              layer.each do |key, value|
+                merged[key] = inherit_facet(key, merged[key], value)
+              end
+            end
+          end
+
+          # Conjunctive-merge primitive for two facet values of the same key:
+          # the tighter one wins (greater for min-like, lesser for max-like),
+          # an exact `:length` must agree. The canonical home for facet
+          # combination, reused by the Layer-1/Layer-2 merge.
+          def tighter_facet(key, existing, incoming)
+            return incoming if existing.nil?
+            return existing if incoming.nil?
+            return incoming & existing if key == :enumeration
+            return existing + incoming if LIST_FACETS.include?(key)
+            return [existing, incoming].max if MIN_FACETS.include?(key)
+            return [existing, incoming].min if MAX_FACETS.include?(key)
+            return stricter_white_space(existing, incoming) if key == :white_space
+            return existing if existing == incoming
+
+            raise ArgumentError,
+                  "conflicting `#{key}` facets: #{existing} and #{incoming}"
+          end
+
+          # Constrain ordered values via min/maxInclusive.
+          def inclusive(min: nil, max: nil)
+            min = cast_facet_value(min)
+            max = cast_facet_value(max)
+            raise_unordered!("inclusive", min, max)
+            declare_facets(min_inclusive: min, max_inclusive: max)
+          end
+
+          # Constrain ordered values via min/maxExclusive.
+          def exclusive(min: nil, max: nil)
+            min = cast_facet_value(min)
+            max = cast_facet_value(max)
+            raise_unordered!("exclusive", min, max)
+            declare_facets(min_exclusive: min, max_exclusive: max)
+          end
+
+          # Constrain length: exact `length N`, or `length min:, max:`.
+          def length(exact = nil, min: nil, max: nil)
+            return declare_exact_length(exact, min, max) unless exact.nil?
+
+            raise_unordered!("length", min, max)
+            raise_negative_length!(min)
+            raise_negative_length!(max)
+            declare_facets(min_length: min, max_length: max)
+          end
+
+          # Restrict to an enumerated set of allowed values (any type). A
+          # subclass narrows the parent's set; the effective set is the
+          # intersection across the chain (see `tighter_facet`).
+          def enumeration(*values)
+            declare_facets(enumeration: values.map { |v| cast_facet_value(v) })
+          end
+
+          # Restrict a string-derived value to match a regular expression. A
+          # String argument is compiled to a Regexp. Patterns accumulate across
+          # the chain; a value must match all of them.
+          def pattern(regex_or_string)
+            regexp = regex_or_string.is_a?(Regexp) ? regex_or_string : Regexp.new(regex_or_string)
+            declare_facets(pattern: [regexp])
+          end
+
+          # Normalize a string-derived value's whitespace at cast time
+          # (xs:whiteSpace). Unlike every other facet this transforms the
+          # stored value rather than validating it, so it is applied in
+          # `String.cast`, not the lazy validator. Only string-derived types
+          # carry lexical text, so declaring it elsewhere fails fast.
+          def white_space(mode)
+            unless self <= Type::String
+              raise ArgumentError,
+                    "`white_space` is only allowed for string-derived types"
+            end
+            unless WHITE_SPACE_MODES.include?(mode)
+              raise ArgumentError,
+                    "`white_space` must be one of " \
+                    "#{WHITE_SPACE_MODES.map(&:inspect).join(', ')}"
+            end
+
+            declare_facets(white_space: mode)
+          end
+
+          # Cap the total number of significant digits (xs:totalDigits) an
+          # integer- or decimal-derived value may carry. A maximum; the value
+          # must have at most `count` significant digits. Applicability to the
+          # resolved type is enforced lazily at validation time.
+          def total_digits(count)
+            declare_digit_facet(:total_digits, count, minimum: 1)
+          end
+
+          # Cap the number of significant fraction digits (xs:fractionDigits) an
+          # integer- or decimal-derived value may carry (a maximum).
+          def fraction_digits(count)
+            declare_digit_facet(:fraction_digits, count, minimum: 0)
+          end
+
+          private
+
+          # Cast a bound/enumeration literal to this type at declaration, so
+          # facets accumulate and compare as typed values (not raw strings whose
+          # lexical order or `eql?` would differ from the cast value). A non-nil
+          # literal that will not cast is a misdeclared facet.
+          def cast_facet_value(value)
+            return nil if value.nil?
+
+            cast = cast(value)
+            return cast unless cast.nil?
+
+            raise ArgumentError,
+                  "`#{self}` facet value #{value.inspect} is not castable"
+          end
+
+          def declare_digit_facet(key, count, minimum:)
+            unless count.is_a?(::Integer) && count >= minimum
+              raise ArgumentError,
+                    "`#{key}` must be an Integer >= #{minimum}, " \
+                    "got #{count.inspect}"
+            end
+
+            declare_facets(key => count)
+          end
+
+          def stricter_white_space(existing, incoming)
+            [existing, incoming].max_by { |mode| WHITE_SPACE_MODES.index(mode) }
+          end
+
+          def facet_layers
+            layers = []
+            klass = self
+            while klass && klass <= Value
+              own = klass.instance_variable_get(:@facets)
+              layers.unshift(own) if own
+              klass = klass.superclass
+            end
+            layers
+          end
+
+          def inherit_facet(key, inherited, declared)
+            return declared if inherited.nil?
+            if LIST_FACETS.include?(key)
+              return tighter_facet(key, inherited, declared)
+            end
+            return declared if tighter_facet(key, inherited, declared) == declared
+
+            raise ArgumentError,
+                  "#{self} cannot widen inherited facet `#{key}` " \
+                  "from #{inherited} to #{declared}"
+          end
+
+          def declare_exact_length(exact, min, max)
+            unless min.nil? && max.nil?
+              raise ArgumentError,
+                    "`length #{exact}` cannot be combined with min:/max:"
+            end
+
+            raise_negative_length!(exact)
+            declare_facets(length: exact)
+          end
+
+          def declare_facets(values)
+            ensure_facets_open!
+            facets = values.compact
+            raise ArgumentError, "at least one facet value is required" if facets.empty?
+
+            store = (@facets ||= {})
+            facets.each do |key, value|
+              store[key] = tighter_facet(key, store[key], value)
+            end
+            reset_facet_cache
+          end
+
+          # Hook: drop any per-class value derived from the facet set when a
+          # facet is (re)declared, so a stale memo cannot outlive the facets it
+          # was computed from. A no-op here; subclasses that memoize override it.
+          def reset_facet_cache; end
+
+          def ensure_facets_open!
+            return unless @facets_closed
+
+            raise ArgumentError,
+                  "Cannot declare facets on #{self}: it already has subclasses"
+          end
+
+          def raise_unordered!(macro, min, max)
+            return if min.nil? || max.nil? || min <= max
+
+            raise ArgumentError,
+                  "`#{macro}` min (#{min}) must not exceed max (#{max})"
+          end
+
+          def raise_negative_length!(value)
+            return if value.nil? || value >= 0
+
+            raise ArgumentError, "length facet must not be negative: #{value}"
+          end
         end
 
         attr_reader :value

data/lib/lutaml/model/type.rb

@@ -29,6 +29,8 @@ module Lutaml
       autoload :InvalidValueError, "#{__dir__}/error/type/invalid_value_error"
       autoload :MinBoundError, "#{__dir__}/error/type/min_bound_error"
       autoload :MaxBoundError, "#{__dir__}/error/type/max_bound_error"
+      autoload :MinExclusiveError, "#{__dir__}/error/type/min_exclusive_error"
+      autoload :MaxExclusiveError, "#{__dir__}/error/type/max_exclusive_error"
       autoload :PatternNotMatchedError,
                "#{__dir__}/error/type/pattern_not_matched_error"
       autoload :MinLengthError, "#{__dir__}/error/type/min_length_error"

data/lib/lutaml/model/validation.rb

@@ -68,7 +68,8 @@ module Lutaml
                  Lutaml::Model::PolymorphicError,
                  Lutaml::Model::ValidationFailedError,
                  Lutaml::Model::RequiredAttributeMissingError,
-                 Lutaml::Model::PatternNotMatchedError => e
+                 Lutaml::Model::PatternNotMatchedError,
+                 Lutaml::Model::RestrictionError => e
             errors << e
           end
         end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.33"
+    VERSION = "0.8.34"
   end
 end

data/lib/lutaml/model.rb

@@ -70,6 +70,7 @@ module Lutaml
     autoload :ComparableNil, "#{__dir__}/model/comparable_nil"
     autoload :ComparableModel, "#{__dir__}/model/comparable_model"
     autoload :CollectionHandler, "#{__dir__}/model/collection_handler"
+    autoload :RestrictionValidation, "#{__dir__}/model/restriction_validation"
     autoload :AttributeValidator, "#{__dir__}/model/attribute_validator"
     autoload :Attribute, "#{__dir__}/model/attribute"
     autoload :ValuePolicy, "#{__dir__}/model/value_policy"
@@ -199,6 +200,21 @@ module Lutaml
              "#{__dir__}/model/error/mixed_content_collection_error"
     autoload :OrderedContentMappingError,
              "#{__dir__}/model/error/ordered_content_mapping_error"
+    autoload :RestrictionError, "#{__dir__}/model/error/restriction_error"
+    autoload :MinInclusiveError,
+             "#{__dir__}/model/error/min_inclusive_error"
+    autoload :MaxInclusiveError,
+             "#{__dir__}/model/error/max_inclusive_error"
+    autoload :MinExclusiveError,
+             "#{__dir__}/model/error/min_exclusive_error"
+    autoload :MaxExclusiveError,
+             "#{__dir__}/model/error/max_exclusive_error"
+    autoload :MinLengthError, "#{__dir__}/model/error/min_length_error"
+    autoload :MaxLengthError, "#{__dir__}/model/error/max_length_error"
+    autoload :LengthError, "#{__dir__}/model/error/length_error"
+    autoload :TotalDigitsError, "#{__dir__}/model/error/total_digits_error"
+    autoload :FractionDigitsError,
+             "#{__dir__}/model/error/fraction_digits_error"
 
     # Error for passing incorrect model type
     #

data/lib/lutaml/xml/model_transform.rb

@@ -399,7 +399,10 @@ module Lutaml
       def set_instance_ordering(instance, doc, ordered_option,
 mixed_content_option, xml_mapping = nil,
 instance_is_serialize = nil)
-        instance.element_order = doc.root.order
+        # dup: XmlElement#order hands back a frozen cache shared with the
+        # DOM. The model's copy has to stay mutable so callers can maintain
+        # element_order themselves.
+        instance.element_order = doc.root.order.dup
         if instance_is_serialize && doc.root.is_a?(::Lutaml::Xml::XmlElement)
           instance.attribute_order = doc.root.attribute_order
         end

data/lib/lutaml/xml/schema/xsd/max_exclusive.rb

@@ -6,7 +6,7 @@ module Lutaml
       module Xsd
         class MaxExclusive < Base
           attribute :fixed, :string
-          attribute :value, :integer
+          attribute :value, :string
 
           xml do
             element "maxExclusive"

data/lib/lutaml/xml/schema/xsd/min_exclusive.rb

@@ -6,7 +6,7 @@ module Lutaml
       module Xsd
         class MinExclusive < Base
           attribute :fixed, :string
-          attribute :value, :integer
+          attribute :value, :string
 
           xml do
             element "minExclusive"