openehr 2.1.0 → 2.3.0

data/lib/openehr/parser/xml_primitive_parsing.rb

@@ -0,0 +1,145 @@
+module OpenEHR
+  module Parser
+    # The 8 C_PRIMITIVE readers (boolean/string/integer/real/date/
+    # date_time/time/duration), shared between OPTParser and
+    # XMLArchetypeParser - both read a <item xsi:type="C_*">-wrapped
+    # element with the same internal shape. Extracted from opt_parser.rb
+    # without behavior changes, except C_REAL's range now reads Float
+    # bounds instead of silently truncating them to Integer via
+    # numeric_interval(real: true) (see xml_constraint_parsing.rb).
+    module XMLPrimitiveParsing
+      private
+
+      def c_date(xml)
+        pattern = xml.at('pattern')
+        range = xml.at('range')
+        if pattern
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDate.new(pattern: pattern.text)
+        elsif range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDate.new(range: occurrences(range))
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDate.new
+        end
+      end
+
+      def c_date_time(xml)
+        pattern = xml.at('pattern')
+        range = xml.at('range')
+        if pattern
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDateTime.new(pattern: pattern.text)
+        elsif range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDateTime.new(range: occurrences(range))
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDateTime.new
+        end
+      end
+
+      def c_integer(xml)
+        range = xml.at('range')
+        list = xml.xpath('list')
+        if range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CInteger.new(range: occurrences(range))
+        elsif !list.empty?
+          list_values = list.map { |item| item.text.to_i }
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CInteger.new(list: list_values)
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CInteger.new
+        end
+      end
+
+      def c_real(xml)
+        range = xml.at('range')
+        list = xml.xpath('list')
+        if range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CReal.new(range: numeric_interval(range, real: true))
+        elsif !list.empty?
+          list_values = list.map { |item| item.text.to_f }
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CReal.new(list: list_values)
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CReal.new
+        end
+      end
+
+      def c_duration(xml)
+        pattern = xml.at('pattern')
+        range_xml = xml.at('range')
+        list = xml.xpath('list')
+        if pattern
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new(pattern: pattern.text)
+        elsif range_xml
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new(range: duration_range(range_xml))
+        elsif !list.empty?
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new(list: list.map(&:text))
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new
+        end
+      end
+
+      # A C_DURATION range's bounds are ISO8601 duration strings (e.g.
+      # PT24H), not plain numbers, so occurrences() (built for numeric
+      # Interval bounds) doesn't apply here; wrap each bound as a
+      # DV_DURATION instead, matching what CDuration#valid_value?
+      # already expects its range bounds to be.
+      def duration_range(range_xml)
+        lower = duration_bound(range_xml.at('lower'), range_xml.at('lower_unbounded'))
+        upper = duration_bound(range_xml.at('upper'), range_xml.at('upper_unbounded'))
+        return nil if lower.nil? && upper.nil?
+
+        OpenEHR::AssumedLibraryTypes::Interval.new(
+          lower: lower, upper: upper,
+          lower_included: lower.nil? ? nil : bool_node(range_xml.at('lower_included'), true),
+          upper_included: upper.nil? ? nil : bool_node(range_xml.at('upper_included'), true))
+      end
+
+      def duration_bound(value_node, unbounded_node)
+        return nil if bool_node(unbounded_node, false)
+        return nil if value_node.nil? || value_node.text.empty?
+
+        OpenEHR::RM::DataTypes::Quantity::DateTime::DvDuration.new(value: value_node.text)
+      end
+
+      def bool_node(node, default)
+        node ? to_bool(node.text) : default
+      end
+
+      def c_time(xml)
+        pattern = xml.at('pattern')
+        range = xml.at('range')
+        if pattern
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CTime.new(pattern: pattern.text)
+        elsif range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CTime.new(range: occurrences(range))
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CTime.new
+        end
+      end
+
+      def c_boolean(xml)
+        true_valid = xml.at('true_valid')
+        false_valid = xml.at('false_valid')
+        assumed_value = xml.at('assumed_value')
+
+        true_valid_value = true_valid ? to_bool(true_valid.text) : nil
+        false_valid_value = false_valid ? to_bool(false_valid.text) : nil
+        assumed_value_value = assumed_value ? to_bool(assumed_value.text) : nil
+
+        OpenEHR::AM::Archetype::ConstraintModel::Primitive::CBoolean.new(
+          true_valid: true_valid_value,
+          false_valid: false_valid_value,
+          assumed_value: assumed_value_value
+        )
+      end
+
+      def c_string(attr_xml)
+        if attr_xml.at('pattern')
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CString.new(pattern: attr_xml.at('pattern').text)
+        else
+          list = attr_xml.xpath('.//list').map do |str|
+            str.text
+          end
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CString.new(list: list)
+        end
+      end
+    end
+  end
+end

data/lib/openehr/parser.rb

@@ -19,6 +19,7 @@ module OpenEHR
     require_relative 'parser/exception'
     require_relative 'parser/adl_parser'
     require_relative 'parser/opt_parser'
+    require_relative 'parser/xml_archetype_parser'
     require_relative 'parser/archetype_validator'
   end
 end

data/lib/openehr/rm/common/generic.rb

@@ -167,8 +167,8 @@ module OpenEHR
         end
 
         class Participation
-          attr_reader :performer, :function, :mode
-          attr_accessor :time
+          attr_reader :performer, :function
+          attr_accessor :time, :mode
 
           def initialize(args ={ })
             self.performer = args[:performer]
@@ -186,11 +186,8 @@ module OpenEHR
             raise ArgumentError, 'function is mandatory' if function.nil?
             @function = function
           end
-
-          def mode=(mode)
-            raise ArgumentError, 'mode is mandatory' if mode.nil?
-            @mode = mode
-          end
+          # mode is optional (0..1) since RM 1.0.4 - attr_accessor above
+          # covers it, no validation needed.
         end
 
         class Attestation < AuditDetails

data/lib/openehr/rm/composition/content/entry.rb

@@ -258,9 +258,12 @@ module OpenEHR
               @current_state = current_state
             end
 
+            # transition is optional (0..1) since RM 1.1.0; when present
+            # its code is still validated against the terminology.
             def transition=(transition)
               if transition.nil?
-                raise ArgumentError, 'transition is mandatory'
+                @transition = nil
+                return
               end
               unless OpenEHR::TerminologyService.has_code_for_group?('ism transition careflow transition', transition.defining_code.code_string)
                 raise ArgumentError, 'transition code is invalid'

data/lib/openehr/rm/data_structures/item_structure/representation.rb

@@ -21,12 +21,13 @@ module OpenEHR
             NULL_FLAVOUR_CODES = %w[271 272 273 253].freeze
 
             attr_accessor :value
-            attr_reader :null_flavor
-            path_attribute :value, :null_flavour
+            attr_reader :null_flavor, :null_reason
+            path_attribute :value, :null_flavour, :null_reason
             def initialize(args = {})
               super(args)
               self.value = args[:value]
               self.null_flavor= args[:null_flavor]
+              self.null_reason = args[:null_reason]
             end
 
             def null_flavor=(null_flavor)
@@ -40,6 +41,15 @@ module OpenEHR
             alias null_flavour null_flavor
             alias null_flavour= null_flavor=
 
+            # null_reason is DV_TEXT [0..1] since RM 1.1.0. Invariant: if
+            # set, null_flavor must also be set.
+            def null_reason=(null_reason)
+              if !null_reason.nil? && @null_flavor.nil?
+                raise ArgumentError, 'null_reason requires null_flavor to be set'
+              end
+              @null_reason = null_reason
+            end
+
             def is_null?
               return @value.nil?
             end

data/lib/openehr/rm/data_types/basic.rb

@@ -75,17 +75,17 @@ module OpenEHR
             self.type = args[:type]
           end
 
+          # issuer/assigner/type are optional (0..1) since RM 1.0.4 - only
+          # id is mandatory. A non-nil value must still not be empty.
           def issuer=(issuer)
-            if issuer.nil? or issuer.empty?
-              raise ArgumentError, 'issuer is mandatory'
-            end
+            raise ArgumentError, 'issuer must not be empty' if !issuer.nil? && issuer.empty?
+
             @issuer = issuer
           end
 
           def assigner=(assigner)
-            if assigner.nil? or assigner.empty?
-              raise ArgumentError, 'assigner is mandatory'
-            end
+            raise ArgumentError, 'assigner must not be empty' if !assigner.nil? && assigner.empty?
+
             @assigner = assigner
           end
 
@@ -97,9 +97,8 @@ module OpenEHR
           end
 
           def type=(type)
-            if type.nil? or type.empty?
-              raise ArgumentError, 'type is mandatory'
-            end
+            raise ArgumentError, 'type must not be empty' if !type.nil? && type.empty?
+
             @type = type
           end
         end #end of DvIdentifier

data/lib/openehr/rm/data_types/encapsulated.rb

@@ -65,6 +65,7 @@ module OpenEHR
           def initialize(args = {})
             super(args)
             self.media_type = args[:media_type]
+            self.size = args[:size]
             self.uri = args[:uri]
             self.data = args[:data]
             self.compression_algorithm = args[:compression_algorithm]
@@ -81,6 +82,21 @@ module OpenEHR
             @media_type = media_type
           end
 
+          # size is Integer [1..1] since RM 1.1.0 (size in bytes of the raw
+          # data content). Left unset (nil), it falls back to the inherited
+          # DvEncapsulated#size (@value.size) for backward compatibility.
+          def size
+            @size.nil? ? super : @size
+          end
+
+          def size=(size)
+            unless size.nil?
+              raise ArgumentError, 'size must be an Integer' unless size.is_a?(Integer)
+              raise ArgumentError, 'size must not be negative' if size.negative?
+            end
+            @size = size
+          end
+
           def is_external?
             !@uri.nil?
           end

data/lib/openehr/rm/data_types/quantity/date_time.rb

@@ -30,6 +30,17 @@ module OpenEHR
             end
 
             undef magnitude=
+
+            private
+
+            # Shared guard for add/subtract on DvDate/DvTime/DvDateTime:
+            # DvAbsoluteQuantity#add/subtract assume magnitude=-based
+            # reconstruction, which DvTemporal subclasses can't support
+            # (see the undef above), so each subclass implements its own
+            # add/subtract against a DvDuration directly instead.
+            def validate_duration_operand(a_diff)
+              raise ArgumentError, 'a_diff must be a DvDuration' unless a_diff.is_a?(DvDuration)
+            end
           end
 
           class DvDate < DvTemporal
@@ -74,8 +85,30 @@ module OpenEHR
                          week.to_s + 'W' + day.to_s + 'D')
             end
 
+            def add(a_diff)
+              validate_duration_operand(a_diff)
+              raise ArgumentError, 'a_diff must not have a time component' if time_component?(a_diff)
+
+              DvDate.new(:value => shift_by(a_diff).iso8601)
+            end
+
+            def subtract(a_diff)
+              add(-a_diff)
+            end
+
             private
 
+            def time_component?(a_diff)
+              [a_diff.hours, a_diff.minutes, a_diff.seconds].any? { |v| v && !v.zero? }
+            end
+
+            def shift_by(a_diff)
+              sign = a_diff.negative? ? -1 : 1
+              months = (((a_diff.years || 0) * MONTH_IN_YEAR) + (a_diff.months || 0)) * sign
+              days = (((a_diff.weeks || 0) * DAYS_IN_WEEK) + (a_diff.days || 0)) * sign
+              (Date.new(@year, @month, @day) >> months) + days
+            end
+
             # Returns [month_adjustment, day] for diff: when future's
             # day-of-month is behind past's, a month is borrowed from
             # future's calendar to make day non-negative.
@@ -130,6 +163,48 @@ module OpenEHR
               end
               return DvDuration.new(:value => str)
             end
+
+            def add(a_diff)
+              validate_duration_operand(a_diff)
+              raise ArgumentError, 'a_diff must not have a date component' if date_component?(a_diff)
+
+              DvTime.new(:value => shifted_time_string(a_diff))
+            end
+
+            def subtract(a_diff)
+              add(-a_diff)
+            end
+
+            private
+
+            def date_component?(a_diff)
+              [a_diff.years, a_diff.months, a_diff.weeks, a_diff.days].any? { |v| v && !v.zero? }
+            end
+
+            def duration_seconds(a_diff)
+              ((a_diff.hours || 0) * MINUTES_IN_HOUR * SECONDS_IN_MINUTE) +
+                ((a_diff.minutes || 0) * SECONDS_IN_MINUTE) +
+                (a_diff.seconds || 0) +
+                (a_diff.fractional_second || 0)
+            end
+
+            def shifted_time_string(a_diff)
+              sign = a_diff.negative? ? -1 : 1
+              day_seconds = HOURS_IN_DAY * MINUTES_IN_HOUR * SECONDS_IN_MINUTE
+              total = (magnitude + (sign * duration_seconds(a_diff))) % day_seconds
+              formatted_time(total) + timezone
+            end
+
+            def formatted_time(total_seconds)
+              hour = (total_seconds / (MINUTES_IN_HOUR * SECONDS_IN_MINUTE)).to_i
+              remainder = total_seconds - (hour * MINUTES_IN_HOUR * SECONDS_IN_MINUTE)
+              minute = (remainder / SECONDS_IN_MINUTE).to_i
+              second_with_fraction = remainder - (minute * SECONDS_IN_MINUTE)
+              second = second_with_fraction.to_i
+              fractional = (second_with_fraction - second).round(6)
+              str = format('%02d:%02d:%02d', hour, minute, second)
+              fractional.zero? ? str : str + fractional.to_s[1..]
+            end
           end
 
           class DvDateTime < DvTemporal
@@ -204,11 +279,55 @@ module OpenEHR
             end
             # rubocop:enable Metrics/AbcSize
 
+            def add(a_diff)
+              validate_duration_operand(a_diff)
+
+              shifted_date = date_part_shifted_by(a_diff)
+              day_carry, wrapped_seconds = time_of_day_seconds_shifted_by(a_diff).divmod(day_seconds)
+              DvDateTime.new(:value => combine(shifted_date + day_carry, wrapped_seconds) + timezone)
+            end
+
+            def subtract(a_diff)
+              add(-a_diff)
+            end
+
             private
+
             def split_date_time(date_time)
               /^(.*)T(.*)$/ =~ date_time.as_string
               return DvDate.new(:value => $1), DvTime.new(:value => $2)
             end
+
+            def day_seconds
+              HOURS_IN_DAY * MINUTES_IN_HOUR * SECONDS_IN_MINUTE
+            end
+
+            def date_part_shifted_by(a_diff)
+              sign = a_diff.negative? ? -1 : 1
+              months = (((a_diff.years || 0) * MONTH_IN_YEAR) + (a_diff.months || 0)) * sign
+              days = (((a_diff.weeks || 0) * DAYS_IN_WEEK) + (a_diff.days || 0)) * sign
+              (Date.new(@year, @month, @day) >> months) + days
+            end
+
+            def time_of_day_seconds_shifted_by(a_diff)
+              sign = a_diff.negative? ? -1 : 1
+              own_seconds = (@hour * MINUTES_IN_HOUR * SECONDS_IN_MINUTE) + (@minute * SECONDS_IN_MINUTE) +
+                @second + (@fractional_second || 0)
+              diff_seconds = ((a_diff.hours || 0) * MINUTES_IN_HOUR * SECONDS_IN_MINUTE) +
+                ((a_diff.minutes || 0) * SECONDS_IN_MINUTE) + (a_diff.seconds || 0) + (a_diff.fractional_second || 0)
+              own_seconds + (sign * diff_seconds)
+            end
+
+            def combine(date, total_seconds)
+              hour = (total_seconds / (MINUTES_IN_HOUR * SECONDS_IN_MINUTE)).to_i
+              remainder = total_seconds - (hour * MINUTES_IN_HOUR * SECONDS_IN_MINUTE)
+              minute = (remainder / SECONDS_IN_MINUTE).to_i
+              second_with_fraction = remainder - (minute * SECONDS_IN_MINUTE)
+              second = second_with_fraction.to_i
+              fractional = (second_with_fraction - second).round(6)
+              str = date.iso8601 + format('T%02d:%02d:%02d', hour, minute, second)
+              fractional.zero? ? str : str + fractional.to_s[1..]
+            end
           end
 
           class DvDuration < DvTemporal
@@ -261,6 +380,55 @@ module OpenEHR
               text = value.start_with?('-') ? value[1..-1] : "-#{value}"
               DvDuration.new(:value => text)
             end
+
+            # DV_DURATION is a DV_AMOUNT in the openEHR RM even though it
+            # inherits DvAbsoluteQuantity's add/subtract/diff method names
+            # here (see DvTemporal); those assume magnitude=-based
+            # reconstruction, which DvTemporal subclasses can't support,
+            # so +/-/multiply are implemented directly instead, going
+            # through magnitude (already sign-aware and nominal-month
+            # aware) and reconstructing via an ISO8601 string.
+            def +(other)
+              raise ArgumentError, 'type mismatch' unless is_strictly_comparable_to?(other)
+
+              self.class.from_seconds(magnitude + other.magnitude)
+            end
+
+            def -(other)
+              raise ArgumentError, 'type mismatch' unless is_strictly_comparable_to?(other)
+
+              self.class.from_seconds(magnitude - other.magnitude)
+            end
+
+            def multiply(factor)
+              raise ArgumentError, 'factor must be Numeric' unless factor.is_a?(Numeric)
+
+              self.class.from_seconds(magnitude * factor)
+            end
+            alias * multiply
+
+            def self.from_seconds(total_seconds)
+              sign = total_seconds.negative? ? '-' : ''
+              days, hours, minutes, seconds_part = duration_components(total_seconds.abs)
+              new(:value => "#{sign}P0Y0M0W#{days}DT#{hours}H#{minutes}M#{seconds_part}S")
+            end
+
+            def self.duration_components(total_seconds)
+              days, remainder = total_seconds.divmod(HOURS_IN_DAY * MINUTES_IN_HOUR * SECONDS_IN_MINUTE)
+              hours, remainder = remainder.divmod(MINUTES_IN_HOUR * SECONDS_IN_MINUTE)
+              minutes, remainder = remainder.divmod(SECONDS_IN_MINUTE)
+              [days, hours, minutes, seconds_with_fraction(remainder)]
+            end
+            private_class_method :duration_components
+
+            def self.seconds_with_fraction(remainder)
+              seconds = remainder.to_i
+              fractional = (remainder - seconds).round(6)
+              seconds += 1 if fractional >= 1.0
+              fractional = 0.0 if fractional >= 1.0
+              fractional.zero? ? seconds.to_s : "#{seconds}#{fractional.to_s[1..]}"
+            end
+            private_class_method :seconds_with_fraction
           end
         end # of DateTime
       end # of Quantity

data/lib/openehr/rm/data_types/quantity.rb

@@ -237,23 +237,27 @@ module OpenEHR
             unless self.is_strictly_comparable_to? other
               raise ArgumentError, 'type mismatch'
             end
-            result = self.dup
-            result.magnitude = @magnitude + other.magnitude
-            return result
+            build_arithmetic_result(magnitude + other.magnitude)
           end
 
           def -(other)
-            negated = other.dup
-            negated.magnitude = -other.magnitude
-            self + negated
+            unless self.is_strictly_comparable_to? other
+              raise ArgumentError, 'type mismatch'
+            end
+            build_arithmetic_result(magnitude - other.magnitude)
           end
 
           def -@
-            negated = self.dup
-            negated.magnitude = -magnitude
-            negated
+            build_arithmetic_result(-magnitude)
           end
 
+          def multiply(factor)
+            raise ArgumentError, 'factor must be Numeric' unless factor.is_a?(Numeric)
+
+            build_arithmetic_result(magnitude * factor)
+          end
+          alias * multiply
+
           def set_accuracy(accuracy, accuracy_percent)
             if accuracy_percent
               raise ArgumentError, 'accuracy invalid' unless self.class.valid_percentage(accuracy)
@@ -270,6 +274,20 @@ module OpenEHR
           def self.valid_percentage(number)
             number >= 0.0 && number <= 100.0
           end
+
+          private
+
+          # Overridable hook used by +/-/-@/multiply: reconstructs the
+          # result from a new magnitude via dup + magnitude=. Works for
+          # any subclass whose magnitude is ivar-backed (DvQuantity,
+          # DvCount). DvProportion's magnitude is derived from
+          # numerator/denominator instead, so it overrides +/-@/multiply
+          # directly rather than relying on this hook.
+          def build_arithmetic_result(new_magnitude)
+            result = dup
+            result.magnitude = new_magnitude
+            result
+          end
         end
 
         class DvQuantity < DvAmount
@@ -446,6 +464,43 @@ module OpenEHR
               return false
             end
           end
+
+          # DvProportion's magnitude is derived from numerator/denominator
+          # rather than ivar-backed, so it cannot use DvAmount's default
+          # build_arithmetic_result (magnitude=-based reconstruction) -
+          # +/-@/multiply are overridden here at the numerator/denominator
+          # level instead. Only same-denominator addition/subtraction is
+          # well-defined without inventing a fraction-normalization
+          # policy beyond what the RM specifies.
+          def +(other)
+            unless is_strictly_comparable_to?(other) && denominator == other.denominator
+              raise ArgumentError, 'type mismatch: proportions must share type and denominator'
+            end
+            build_arithmetic_result(numerator + other.numerator)
+          end
+
+          def -(other)
+            self + (-other)
+          end
+
+          def -@
+            build_arithmetic_result(-numerator)
+          end
+
+          def multiply(factor)
+            raise ArgumentError, 'factor must be Numeric' unless factor.is_a?(Numeric)
+
+            build_arithmetic_result(numerator * factor)
+          end
+          alias * multiply
+
+          private
+
+          def build_arithmetic_result(new_numerator)
+            result = dup
+            result.numerator = new_numerator
+            result
+          end
         end # end of DvProportion
       end # of Quantity
     end # of Data_Types

data/lib/openehr/rm/ehr.rb

@@ -45,6 +45,8 @@ module OpenEHR
           @time_created = time_created
         end
 
+        # contributions is optional (0..1) since RM 1.1.0 (was mandatory
+        # pre-1.1.0).
         def contributions=(contributions)
           unless contributions.nil?
             contributions.each do |contrib|
@@ -52,10 +54,8 @@ module OpenEHR
                 raise ArgumentError, 'contribution type should be CONTRIBUTION'
               end
             end
-            @contributions = contributions
-          else
-            raise ArgumentError, 'contributions are mandatory'
           end
+          @contributions = contributions
         end
 
         def ehr_access=(ehr_access)
@@ -72,6 +72,8 @@ module OpenEHR
           @ehr_status = ehr_status
         end
 
+        # compositions is optional (0..1) since RM 1.1.0 (was mandatory
+        # pre-1.1.0).
         def compositions=(compositions)
           unless compositions.nil?
             compositions.each do |compo|
@@ -79,10 +81,8 @@ module OpenEHR
                 raise ArgumentError, 'composition type should be VERSIONED_COMPOSITION'
               end
             end
-            @compositions = compositions
-          else
-            raise ArgumentError, 'compositions are mandatory'
           end
+          @compositions = compositions
         end
 
         def directory=(directory)

data/lib/openehr/rm/factory.rb

@@ -597,6 +597,10 @@ module OpenEHR
 
     class CompositionFactory < Factory
       class << self
+        def create(param)
+          OpenEHR::RM::Composition::Composition.new(param)
+        end
+
         def create_from_json(json)
           hash = JSON.parse(json, max_nesting: false, symbolize_names: true)
           OpenEHR::RM::Composition::Composition.new(params(hash))