edoxen 0.7.2 → 2.1.1

data/lib/edoxen/agenda.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module Edoxen
-  # The business-order document of a Meeting. Distinct from the
-  # timetable (Schedule) — the Agenda orders topics; the Schedule
-  # orders time slots.
+  # The business-order document of a Meeting. Distinct from the timetable
+  # (MeetingComponent) — the Agenda orders topics; components order time
+  # slots. Opening/closing sessions are components, not agenda entries.
   #
   # An Agenda may be versioned independently of the Meeting: a draft
   # agenda circulates weeks before; a final agenda at meeting time;
@@ -14,11 +14,8 @@ module Edoxen
     attribute :status, :string, values: Enums::AGENDA_STATUS
     attribute :source_doc, :string
     attribute :items, AgendaItem, collection: true
-    attribute :opening_session, ScheduleItem
-    attribute :closing_session, ScheduleItem
+    attribute :extensions, MeetingExtension, collection: true
 
-    # Find an agenda item by its label (e.g., "5.2"). Returns nil
-    # when no item matches.
     def find_item(label)
       items&.find { |item| item.label == label.to_s }
     end

data/lib/edoxen/agenda_item.rb

@@ -3,8 +3,12 @@
 module Edoxen
   # One entry on an Agenda. `label` is the visible identifier (e.g.,
   # "5.2"); `kind` discriminates numbered/unnumbered/header/opening/
-  # closing; `outcome` records what happened; `resolution_ref`
-  # optionally links to the URN of the resolution this item produced.
+  # closing/aob; `outcome` records what happened; `decision_ref`
+  # optionally links to the URN of the decision this item produced.
+  #
+  # Topics (0..*) are the subject(s) of discussion at this agenda item.
+  # AOB (Any Other Business) items have 0 topics until raised during
+  # the meeting.
   class AgendaItem < Lutaml::Model::Serializable
     attribute :label, :string
     attribute :kind, :string, values: Enums::AGENDA_ITEM_KIND
@@ -12,6 +16,9 @@ module Edoxen
     attribute :description, :string
     attribute :references, Reference, collection: true
     attribute :outcome, :string, values: Enums::AGENDA_ITEM_OUTCOME
-    attribute :resolution_ref, :string
+    attribute :decision_ref, :string
+    attribute :topics, Topic, collection: true
+    attribute :components, :string, collection: true
+    attribute :extensions, MeetingExtension, collection: true
   end
 end

data/lib/edoxen/approval.rb

@@ -6,7 +6,7 @@ module Edoxen
   class Approval < Lutaml::Model::Serializable
     attribute :type, :string, values: Enums::APPROVAL_TYPE
     attribute :degree, :string, values: Enums::APPROVAL_DEGREE
-    attribute :date, ResolutionDate
+    attribute :date, DecisionDate
     attribute :message, :string
   end
 end

data/lib/edoxen/attendance.rb

@@ -1,23 +1,29 @@
 # frozen_string_literal: true
 
 module Edoxen
-  # One attendance record per person. Mirrors the ParticipationStatus
-  # enum from edoxen-model/models/participation_status.lutaml.
-  # Optional `affiliation` and `notes` fields let callers annotate
-  # proxy representatives and any meeting-specific details.
+  # One attendance record per person. Combines:
+  #   - status: ParticipationStatus (in-meeting observation: present/absent/
+  #             apologies/observer/excused)
+  #   - role: AttendanceRole (structural importance: chair/required/optional/
+  #           non_participant — from iCalendar ROLE, plain English)
+  #   - response: AttendanceResponse (RSVP state: pending/confirmed/declined/
+  #               tentative/delegated — from iCalendar PARTSTAT, plain English)
   class Attendance < Lutaml::Model::Serializable
     attribute :person, Person
     attribute :status, :string, values: Enums::PARTICIPATION_STATUS
+    attribute :role, :string, values: Enums::ATTENDANCE_ROLE
+    attribute :response, :string, values: Enums::ATTENDANCE_RESPONSE
     attribute :affiliation, :string
     attribute :proxy_for, Person
     attribute :notes, :string
+    attribute :extensions, MeetingExtension, collection: true
 
-    key_value do
-      map "person", to: :person
-      map "status", to: :status
-      map "affiliation", to: :affiliation
-      map "proxy_for", to: :proxy_for
-      map "notes", to: :notes
+    def present?
+      status == "present"
+    end
+
+    def declined?
+      response == "declined"
     end
   end
 end

data/lib/edoxen/body_vocabulary_entry.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # BodyVocabularyEntry — one entry in a per-dataset body_vocabulary
+  # list (v2.1, TODO.refactor/46).
+  #
+  # Maps a free-form `body_type` (e.g. "CIML Meeting", "Plenary") to a
+  # short canonical value (e.g. "plenary"). Bodies declare their
+  # vocabulary on the collection metadata; consumers look up the
+  # canonical_type via the parent collection's vocabulary.
+  #
+  # SSOT: the body_vocabulary list on collection metadata is the single
+  # source of truth for body_type → canonical_type resolution within
+  # that dataset.
+  #
+  # Permissive: when no vocabulary entry matches a body_type, the gem
+  # returns the body_type string itself (with a warning at debug
+  # level). Strict mode is a v3.x concern.
+  class BodyVocabularyEntry < Lutaml::Model::Serializable
+    attribute :body_type, :string
+    attribute :canonical_type, :string
+    attribute :definition, :string
+  end
+end

data/lib/edoxen/body_vocabulary_host.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # Mixed into metadata classes that carry a per-dataset
+  # `body_vocabulary[]` collection (v2.1, TODO.refactor/46). Provides
+  # the attribute declaration and the `canonical_type_for` lookup in
+  # one place so DecisionMetadata and MeetingCollectionMetadata share
+  # a single implementation.
+  #
+  # Permissive by design: when no vocabulary entry matches a
+  # body_type, the body_type string itself is returned (with no
+  # warning). Strict mode is a v3.x concern.
+  module BodyVocabularyHost
+    def self.included(base)
+      base.attribute :body_vocabulary, BodyVocabularyEntry, collection: true
+    end
+
+    # Resolve a body_type to its canonical_type via this collection's
+    # vocabulary. Returns the body_type unchanged when nil/empty or
+    # when no matching entry exists.
+    def canonical_type_for(body_type)
+      return body_type if body_type.nil? || body_type.to_s.empty?
+      return body_type unless body_vocabulary
+
+      entry = body_vocabulary.find { |e| e.body_type == body_type }
+      entry ? entry.canonical_type : body_type
+    end
+  end
+end

data/lib/edoxen/cli.rb

@@ -5,17 +5,50 @@ require "fileutils"
 
 module Edoxen
   class Cli < Thor
+    # Each top-level YAML document is either a Decision collection or a
+    # Meeting (single or collection). The two share the same batch
+    # scaffold (expand → header → loop → tally → exit) but differ in
+    # which schema validates them and which model class loads them.
+    #
+    # A Profile bundles those two facts so the Thor command methods are
+    # one-line delegations. Adding a third document kind (e.g. an
+    # attendance-only file) is one Profile constant + one desc block —
+    # no new scaffolding.
+    Profile = Struct.new(:name, :schema_file, :loader) do
+      def schema_path
+        File.expand_path("../../schema/#{schema_file}", __dir__)
+      end
+
+      # Returns the loaded model object, raising StandardError on failure.
+      # Single-vs-collection detection is up to the loader (Meeting side
+      # sniffs the top-level key; Decision side always returns a
+      # DecisionCollection).
+      def load(content)
+        loader.call(content)
+      end
+    end
+
+    PROFILES = {
+      decisions: Profile.new(
+        "decisions", "edoxen.yaml",
+        ->(content) { DecisionCollection.from_yaml(content) }
+      ),
+      meetings: Profile.new(
+        "meetings", "meeting.yaml",
+        lambda do |content|
+          data = YAML.safe_load(content, permitted_classes: [Date, Time])
+          if data.is_a?(Hash) && data.key?("meetings")
+            MeetingCollection.from_yaml(content)
+          else
+            Meeting.from_yaml(content)
+          end
+        end
+      )
+    }.freeze
+
     # Deep module behind the per-command interface. Owns the
     # expand/sort/empty/header/loop/tally/summary/exit scaffold so
-    # `validate` and `normalize` collapse to per-file blocks.
-    #
-    # Commands call `Batch.run(self, pattern, header:)` and yield a block
-    # that returns `Result.ok(message)` or `Result.bad(errors)`. The
-    # batch runner prints progress, tallies, prints the summary, and
-    # exits with the right code.
-    #
-    # In-process; no adapter. The seam is the call site in each
-    # command method — internal to the CLI.
+    # `validate` and `normalize` collapse to one-line delegations.
     module Batch
       # Per-file outcome. `ok` carries an optional message appended to
       # the success indicator (e.g. "NORMALIZED → /out/path"). `bad`
@@ -32,11 +65,6 @@ module Edoxen
 
       module_function
 
-      # Run a batch over every YAML file matching `pattern`.
-      #
-      # Yields each file path to the caller's block. Block must return
-      # a Batch::Result. The batch runner handles progress output,
-      # tallies, summary, and the exit code.
       def run(cli, pattern, header:, summary_extra: [])
         files = expand(pattern)
         if files.empty?
@@ -84,62 +112,32 @@ module Edoxen
 
     package_name "edoxen"
 
+    # --- Decision-side commands -----------------------------------------
+
     desc "validate YAML_FILE_PATTERN",
-         "Validate one or more Edoxen YAML files against the schema and the model."
+         "Validate Decision YAML file(s) against schema/edoxen.yaml and the model."
 
     def validate(pattern)
-      validator = SchemaValidator.new
-      Batch.run(self, pattern, header: "🔍 Validating") do |file|
-        schema_errors = validator.validate_file(file)
-        model_errors = collect_model_errors(file)
-        if schema_errors.empty? && model_errors.empty?
-          Batch::Result.ok("VALID")
-        else
-          errors = (schema_errors + model_errors).map(&:to_clickable_format)
-          Batch::Result.bad(errors)
-        end
-      end
+      run_validate(PROFILES.fetch(:decisions), pattern)
     end
 
     desc "normalize YAML_FILE_PATTERN",
-         "Round-trip YAML file(s) through the Edoxen model (--output DIR or --inplace)."
+         "Round-trip Decision YAML file(s) through the model (--output DIR or --inplace)."
 
     option :output, type: :string, desc: "Output directory for normalized files"
     option :inplace, type: :boolean, desc: "Modify files in place (no backup)"
 
     def normalize(pattern)
-      unless valid_normalize_options?
-        say normalize_options_error, :red
-        exit 1
-      end
-
-      summary_extra = [
-        ["  Output directory", options[:output]],
-        ["  Mode", options[:inplace] ? "in place" : "--output"]
-      ].compact
-
-      Batch.run(self, pattern, header: "🔄 Normalizing", summary_extra: summary_extra) do |file|
-        Batch::Result.ok(normalize_file(file))
-      rescue StandardError => e
-        Batch::Result.bad(["#{file}:1:1: #{e.message}"])
-      end
+      run_normalize(PROFILES.fetch(:decisions), pattern)
     end
 
+    # --- Meeting-side commands ------------------------------------------
+
     desc "validate-meetings YAML_FILE_PATTERN",
          "Validate Meeting/Agenda YAML file(s) against schema/meeting.yaml."
 
     def validate_meetings(pattern)
-      validator = SchemaValidator.new(meeting_schema_path)
-      Batch.run(self, pattern, header: "🔍 Validating meetings") do |file|
-        schema_errors = validator.validate_file(file)
-        model_errors = collect_meeting_model_errors(file)
-        if schema_errors.empty? && model_errors.empty?
-          Batch::Result.ok("VALID")
-        else
-          errors = (schema_errors + model_errors).map(&:to_clickable_format)
-          Batch::Result.bad(errors)
-        end
-      end
+      run_validate(PROFILES.fetch(:meetings), pattern)
     end
 
     desc "normalize-meetings YAML_FILE_PATTERN",
@@ -149,24 +147,13 @@ module Edoxen
     option :inplace, type: :boolean, desc: "Modify files in place (no backup)"
 
     def normalize_meetings(pattern)
-      unless valid_normalize_options?
-        say normalize_options_error, :red
-        exit 1
-      end
-
-      summary_extra = [
-        ["  Output directory", options[:output]],
-        ["  Mode", options[:inplace] ? "in place" : "--output"]
-      ].compact
-
-      Batch.run(self, pattern, header: "🔄 Normalizing meetings", summary_extra: summary_extra) do |file|
-        Batch::Result.ok(normalize_meeting_file(file))
-      rescue StandardError => e
-        Batch::Result.bad(["#{file}:1:1: #{e.message}"])
-      end
+      run_normalize(PROFILES.fetch(:meetings), pattern)
     end
 
+    # --- Reference-data lookups -----------------------------------------
+
     desc "unlocode CODE", "Resolve a UN/LOCODE via the canonical registry."
+
     def unlocode(code)
       entry = Edoxen::ReferenceData.find_unlocode(code)
       if entry.nil?
@@ -180,18 +167,59 @@ module Edoxen
       say "  Subdiv:    #{entry.subdivision}" if entry.subdivision
       coords = entry.coordinates
       say "  Coords:    #{coords}" if coords
-      funcs = entry.functions.compact.map(&:to_s)
+      funcs = entry.function_codes.compact
       say "  Functions: #{funcs.join(", ")}" unless funcs.empty?
     end
 
+    desc "iata CODE", "Resolve an IATA airport/city code via the canonical registry."
+
+    def iata(code)
+      entry = Edoxen::ReferenceData.find_iata(code)
+      if entry.nil?
+        say "No entry for #{code.upcase} in the IATA registry.", :red
+        exit 1
+      end
+
+      say "IATA:       #{entry.code}", :blue
+      say "  Name:      #{entry.name}"
+      say "  Country:   #{entry.country_iso2}"
+    end
+
     private
 
-    def meeting_schema_path
-      File.expand_path("../../schema/meeting.yaml", __dir__)
+    def run_validate(profile, pattern)
+      validator = SchemaValidator.new(profile.schema_path)
+      Batch.run(self, pattern, header: "🔍 Validating #{profile.name}") do |file|
+        schema_errors = validator.validate_file(file)
+        model_errors = collect_model_errors(profile, file)
+        if schema_errors.empty? && model_errors.empty?
+          Batch::Result.ok("VALID")
+        else
+          Batch::Result.bad((schema_errors + model_errors).map(&:to_clickable_format))
+        end
+      end
     end
 
-    def collect_model_errors(file)
-      ResolutionCollection.from_yaml(File.read(file))
+    def run_normalize(profile, pattern)
+      unless valid_normalize_options?
+        say normalize_options_error, :red
+        exit 1
+      end
+
+      summary_extra = [
+        ["  Output directory", options[:output]],
+        ["  Mode", options[:inplace] ? "in place" : "--output"]
+      ].compact
+
+      Batch.run(self, pattern, header: "🔄 Normalizing #{profile.name}", summary_extra: summary_extra) do |file|
+        Batch::Result.ok(normalize_file(profile, file))
+      rescue StandardError => e
+        Batch::Result.bad(["#{file}:1:1: #{e.message}"])
+      end
+    end
+
+    def collect_model_errors(profile, file)
+      profile.load(File.read(file))
       []
     rescue StandardError => e
       [Edoxen::ValidationError.new(
@@ -201,27 +229,26 @@ module Edoxen
       )]
     end
 
-    def collect_meeting_model_errors(file)
-      load_meeting_document(file)
-      []
+    def normalize_file(profile, file)
+      original = File.read(file)
+      schema_comment = extract_yaml_language_server_comment(original)
+      normalized = profile.load(original).to_yaml
+      write_normalized(file, normalized, schema_comment)
     rescue StandardError => e
-      [Edoxen::ValidationError.new(
-        file: file, line: 1, column: 1,
-        message_text: "Meeting model parsing failed: #{e.message}",
-        source: Edoxen::ValidationError::SOURCE_MODEL
-      )]
+      raise "#{file}: #{e.message}"
     end
 
-    # A meeting YAML may be either a single Meeting or a
-    # MeetingCollection. Detect by the presence of a top-level
-    # `meetings:` key and parse accordingly. Returns whichever
-    # model object was successfully constructed.
-    def load_meeting_document(file)
-      data = YAML.safe_load(File.read(file), permitted_classes: [Date, Time])
-      if data.is_a?(Hash) && data.key?("meetings")
-        MeetingCollection.from_yaml(File.read(file))
+    def write_normalized(file, normalized, schema_comment)
+      normalized = "#{schema_comment}\n#{normalized}" if schema_comment
+
+      if options[:inplace]
+        File.write(file, normalized)
+        "NORMALIZED"
       else
-        Meeting.from_yaml(File.read(file))
+        out = File.join(options[:output], File.basename(file))
+        FileUtils.mkdir_p(File.dirname(out))
+        File.write(out, normalized)
+        "NORMALIZED → #{out}"
       end
     end
 
@@ -244,35 +271,5 @@ module Edoxen
         "Error: Must specify either --output or --inplace option"
       end
     end
-
-    # Writes the normalized YAML either to the original file (--inplace)
-    # or under the --output directory. Returns a one-line status message
-    # for the batch runner to print after the ✅.
-    def normalize_file(file)
-      original = File.read(file)
-      yaml_language_server_comment = extract_yaml_language_server_comment(original)
-      normalized = ResolutionCollection.from_yaml(original).to_yaml
-      write_normalized(file, normalized, yaml_language_server_comment)
-    end
-
-    def normalize_meeting_file(file)
-      yaml_language_server_comment = extract_yaml_language_server_comment(File.read(file))
-      normalized = load_meeting_document(file).to_yaml
-      write_normalized(file, normalized, yaml_language_server_comment)
-    end
-
-    def write_normalized(file, normalized, yaml_language_server_comment)
-      normalized = "#{yaml_language_server_comment}\n#{normalized}" if yaml_language_server_comment
-
-      if options[:inplace]
-        File.write(file, normalized)
-        "NORMALIZED"
-      else
-        out = File.join(options[:output], File.basename(file))
-        FileUtils.mkdir_p(File.dirname(out))
-        File.write(out, normalized)
-        "NORMALIZED → #{out}"
-      end
-    end
   end
 end

data/lib/edoxen/component_localization.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # ComponentLocalization — per-language content for a MeetingComponent.
+  class ComponentLocalization < Lutaml::Model::Serializable
+    attribute :language_code, :string
+    attribute :script, :string
+    attribute :title, :string
+    attribute :description, :string
+  end
+end

data/lib/edoxen/consideration.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module Edoxen
-  # Basis for a resolution: a verb (having, noting, considering, ...) plus
+  # Basis for a Decision: a verb (having, noting, considering, ...) plus
   # one effective date and the elaborated reasoning.
   class Consideration < Lutaml::Model::Serializable
     attribute :type, :string, values: Enums::CONSIDERATION_TYPE
-    attribute :date_effective, ResolutionDate
+    attribute :date_effective, DecisionDate
     attribute :message, :string
   end
 end

data/lib/edoxen/contact.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # VCARD-like abstract contact. Generalises Person for cases where the
+  # contact may be a person, an organisation, a department, a role
+  # ("Secretariat"), or any other entity with a name and one or more
+  # communication channels.
+  #
+  # Use Contact where the kind of contact is open or mixed (meeting
+  # local-contact, meeting-series organiser, host-ref contact). Use
+  # Person (which inherits from Contact) where the contact is
+  # specifically an individual with identity (officer, attendee, voter).
+  class Contact < Lutaml::Model::Serializable
+    attribute :name, Name
+    attribute :kind, :string
+    attribute :role, :string
+    attribute :title, :string
+    attribute :affiliation, :string
+    attribute :contact_methods, ContactMethod, collection: true
+    attribute :identifiers, ContactIdentifier, collection: true
+    attribute :address, :string
+    attribute :extensions, MeetingExtension, collection: true
+  end
+end

data/lib/edoxen/contact_identifier.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # One polymorphic external identifier for a Contact — ORCID, ISNI,
+  # Wikidata QID, ROR, Ringgold, GitHub handle, etc. Replaces the hard-
+  # coded `orcid` field. OCP: new identifier schemes are added via the
+  # ContactIdentifierKind enum (or `other` + extensions).
+  class ContactIdentifier < Lutaml::Model::Serializable
+    attribute :kind, :string, values: Enums::CONTACT_IDENTIFIER_KIND
+    attribute :value, :string
+    attribute :extensions, MeetingExtension, collection: true
+  end
+end

data/lib/edoxen/contact_method.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # One polymorphic communication channel — phone, email, fax, url, mail,
+  # etc. Replaces the hard-coded `email` / `phone` fields that used to
+  # live on Person and Venue. New channel kinds are added via the
+  # ContactMethodKind enum (or `other` + extensions for adopter-specific
+  # channels); the model itself never needs to change (OCP).
+  class ContactMethod < Lutaml::Model::Serializable
+    attribute :kind, :string, values: Enums::CONTACT_METHOD_KIND
+    attribute :value, :string
+    attribute :label, :string
+    attribute :primary, :boolean
+    attribute :extensions, MeetingExtension, collection: true
+  end
+end

data/lib/edoxen/decision.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # A formal Decision — the base type for any outcome adopted by a Meeting.
+  # Was `Resolution` in v0.x; renamed in v2.0 because the same formal concept
+  # has many names across bodies (resolution, order, ruling, determination,
+  # finding, opinion). `Resolution` is one `kind` value, not a class name.
+  #
+  # Language-agnostic admin fields live here; every translatable field is
+  # wrapped inside `localizations[]` (one entry per available language; at
+  # least one is required by the schema).
+  class Decision < Lutaml::Model::Serializable
+    include LocalizationHost
+
+    attribute :identifier, StructuredIdentifier, collection: true
+    attribute :kind, :string, values: Enums::DECISION_KIND
+    attribute :status, :string, values: Enums::DECISION_STATUS
+    attribute :doi, :string
+    attribute :urn, :string
+    attribute :agenda_item, :string
+    attribute :dates, DecisionDate, collection: true
+    attribute :categories, :string, collection: true
+    attribute :meeting, MeetingIdentifier
+    attribute :relations, DecisionRelation, collection: true
+    attribute :urls, Url, collection: true
+    attribute :brought_by_motions, :string, collection: true
+    attribute :about_topics, :string, collection: true
+    attribute :made_in_component, :string
+    attribute :localizations, Localization, collection: true
+    # v2.1 (TODO.refactor/46): free-form body-specific label (e.g.
+    # "Resolution", "Order", "Ruling"). Resolves to a short canonical
+    # value via the parent collection's `body_vocabulary[]`.
+    attribute :body_type, :string
+    attribute :extensions, MeetingExtension, collection: true
+
+    # --- v2.1 derivation accessors (TODO.refactor/45) -------------------
+    # These methods compute the reverse direction of relationships whose
+    # canonical storage lives elsewhere. They are additive — the stored
+    # `brought_by_motions[]`, `about_topics[]`, and `made_in_component`
+    # fields remain on the wire for back-compat through v2.x; v3.0
+    # removes them and these methods become the only path.
+
+    # Returns the Motions in `meeting` whose `resulting_decision` (or
+    # `resulting_decision_ref`) points at this Decision's URN.
+    #
+    # Storage side: Motion.resultingDecision (SSOT for the relationship).
+    def brought_by_motions_in(meeting:)
+      return [] unless meeting && urn
+
+      meeting.motions.select do |motion|
+        motion.resulting_decision == urn ||
+          motion.resulting_decision_ref&.urn == urn
+      end
+    end
+
+    # Returns the MeetingComponent in `meeting` whose key matches
+    # `made_in_component`.
+    #
+    # Storage side: Decision.madeInComponent (SSOT for the relationship).
+    def component_in(meeting:)
+      return nil unless meeting && made_in_component
+
+      meeting.components&.find do |component|
+        component.identifier == made_in_component ||
+          component.urn == made_in_component
+      end
+    end
+  end
+end

data/lib/edoxen/decision_collection.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # Top-level container for a published decision collection: metadata
+  # plus the list of decisions. Was ResolutionCollection in v0.x.
+  class DecisionCollection < Lutaml::Model::Serializable
+    attribute :metadata, DecisionMetadata
+    attribute :decisions, Decision, collection: true
+  end
+end

data/lib/edoxen/decision_date.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # Date with semantic kind. Was ResolutionDate in v0.x.
+  class DecisionDate < Lutaml::Model::Serializable
+    attribute :date, :date
+    attribute :type, :string, values: Enums::DECISION_DATE_TYPE
+  end
+end