pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e650437c35c0d8e6ba019b07ae835ca224bd620415bd9c9d27c20a36a1b82589
-  data.tar.gz: 3d8d15f420d6cff7dbba69007218d670cde06511fc00df7b7dcfd957493600cb
+  metadata.gz: 16698d2e32777261efbf6842754351b03a2a0d272992ca1525ebd3fbedaf648d
+  data.tar.gz: 46d2aa4fb40d9f9ab3fcf7f42bdc3c9b2662637653a9e5c98f26baebecaea0cd
 SHA512:
-  metadata.gz: f231838d92fd52c9d8fb298899a6f62018c29872d0d67104ea064ea70ea5cd4e115490876e2e83ba9601da87aeb9060d9f28e34535d0495ca680bc93ad6801ec
-  data.tar.gz: de691a34d6783e9df75f4304315d6791eb30e68b7788177f8e04285aa8f88372e38ce9754527eb8479db0926ef9276ddef7c6fae1ede170380541459c150a823
+  metadata.gz: 638b16ccaed8a371fecee3ec8372a9790ae4649d689d0aeafa306b4b1681e0df42365d5ede2da46da743f8b42e7a70ddcc882774a6c6c333a1a2fec8d30255e4
+  data.tar.gz: 2d55ed5b29d6121665c808d697832307bcea629345b7782308c5c0fe76ffc9baae849f752a8f75b5d77c7b3aaed782be9e15dcc9e1dc85e7c229ae77cf4431b8

data/data/nist/update_codes.yaml

@@ -26,7 +26,9 @@ NIST.CSWP.01162020pt: NIST.CSWP.01162020(por)
 FIPS PUB: FIPS
 NBS CRPL c4-4: NBS CRPL 4-4
 NIST AMS 300-8r1 (February 2021 update): NIST AMS 300-8r1/Upd1-202102
+NIST AMS 300-8r1/upd: NIST AMS 300-8r1/Upd1-202102
 NIST IR 8115r1-upd: NIST IR 8115r1/Upd1-202103
+NIST IR 8170-upd: NIST IR 8170/Upd1-202003
 NIST TN 2150-upd: NIST TN 2150/Upd1-202102
 NBS IR 73-197r: NBS IR 73-197r1
 NBS.HB.105-1r1990: NIST.HB.105-1r1990

data/lib/pubid/amca/identifier.rb

@@ -13,6 +13,45 @@ module Pubid
       rescue Parslet::ParseFailed => e
         raise "Failed to parse ACMA identifier '#{identifier}': #{e.message}"
       end
+
+      # Factory that builds an AMCA identifier from a hash of primitives.
+      #
+      # Dispatch on `:type`:
+      #   * `:standard` (default) → Identifiers::Standard
+      #   * `:publication`        → Identifiers::Publication
+      #   * `:interpretation`     → Identifiers::Interpretation
+      #
+      # AMCA stores the "AMCA" prefix in the `copublisher` string
+      # attribute (matching parsed output); `.create` defaults it to
+      # "AMCA" unless the caller supplies one.
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts))
+      end
+
+      def self.resolve_create_class(type)
+        case type&.to_sym
+        when nil, :standard       then Identifiers::Standard
+        when :publication         then Identifiers::Publication
+        when :interpretation      then Identifiers::Interpretation
+        else
+          raise ArgumentError, "Unknown AMCA type: #{type.inspect}"
+        end
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = { copublisher: (opts[:copublisher] || "AMCA").to_s }
+        if (v = opts[:code] || opts[:number])
+          attrs[:code] = Pubid::Components::Code.new(value: v.to_s)
+        end
+        if (v = opts[:year])
+          attrs[:year] = Pubid::Components::Date.new(year: v.to_s)
+        end
+        attrs[:suffix] = opts[:suffix].to_s if opts[:suffix]
+        attrs[:reaffirmed] = opts[:reaffirmed].to_s if opts[:reaffirmed]
+        attrs
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs
     end
   end
 end

data/lib/pubid/ansi/identifier.rb

@@ -8,6 +8,48 @@ module Pubid
         parsed = Pubid::Ansi::Parser.new.parse(string)
         Pubid::Ansi::Builder.new(Pubid::Ansi::Scheme).build(parsed)
       end
+
+      # Factory that builds an ANSI identifier from a hash of primitives.
+      #
+      # Defaults to {Identifiers::Standard} (ANSI has Standard and
+      # AmericanNationalStandard, both sharing the same type key `:ans`).
+      #
+      # ANSI quirk: the parser stores the publication year in the `part`
+      # attribute, not `date`. `.create` mirrors that — `:year` is coerced
+      # into `part` so the rendered output matches a parsed identifier.
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts))
+      end
+
+      def self.resolve_create_class(type)
+        case type&.to_sym
+        when nil, :ans, :standard
+          Identifiers::Standard
+        when :american_national_standard
+          Identifiers::AmericanNationalStandard
+        else
+          raise ArgumentError, "Unknown ANSI type: #{type.inspect}"
+        end
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = {
+          publisher: Pubid::Components::Publisher.new(
+            body: (opts[:publisher] || "ANSI").to_s,
+          ),
+        }
+        if (v = opts[:number])
+          attrs[:number] = Pubid::Components::Code.new(value: v.to_s)
+        end
+        # ANSI parser stores year in part; mirror that here.
+        year_or_part = opts[:year] || opts[:part]
+        if year_or_part
+          attrs[:part] = Pubid::Components::Code.new(value: year_or_part.to_s)
+        end
+        attrs
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs
     end
   end
 end

data/lib/pubid/api/identifier.rb

@@ -3,6 +3,7 @@
 require_relative "parser"
 require_relative "builder"
 require_relative "single_identifier"
+require_relative "scheme"
 
 module Pubid
   module Api
@@ -16,6 +17,52 @@ module Pubid
       rescue Parslet::ParseFailed => e
         raise e
       end
+
+      # Factory that builds an API identifier from a hash of primitives.
+      # Dispatch on `:type` to the matching subclass; default is
+      # {Identifiers::Standard}.
+      #
+      # API identifiers have a hardcoded "API" publisher (via
+      # SingleIdentifier#publisher method) so the `:publisher` kwarg is
+      # silently dropped.
+      TYPE_KEY_TO_KLASS = {
+        std:      "Standard",
+        rp:       "RecommendedPractice",
+        spec:     "Specification",
+        tr:       "TechnicalReport",
+        bull:     "Bulletin",
+        mpms:     "Mpms",
+        cos:      "ContinuousOperationsStandard",
+        publ:     "Publication",
+        typeless: "TypelessStandard",
+      }.freeze
+
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts))
+      end
+
+      def self.resolve_create_class(type)
+        return Identifiers::Standard if type.nil?
+
+        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
+        raise ArgumentError, "Unknown API type: #{type.inspect}" unless klass_name
+
+        Identifiers.const_get(klass_name)
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = {}
+        if (v = opts[:code] || opts[:number])
+          attrs[:code] = Pubid::Api::Components::Code.new(value: v.to_s)
+        end
+        %i[part year reaffirmation].each do |k|
+          attrs[k] = opts[k].to_s unless opts[k].nil?
+        end
+        # TODO(create-shim): :publisher silently dropped (API hardcoded).
+        attrs
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs
     end
   end
 end

data/lib/pubid/ashrae/identifier.rb

@@ -13,6 +13,45 @@ module Pubid
       rescue Parslet::ParseFailed => e
         raise "Failed to parse ASHRAE identifier '#{identifier}': #{e.message}"
       end
+
+      # Factory that builds an ASHRAE identifier from a hash of primitives.
+      # Dispatch on `:type` to the matching subclass; default is
+      # {Identifiers::Standard}.
+      TYPE_KEY_TO_KLASS = {
+        standard:         "Standard",
+        guideline:        "Guideline",
+        addendum:         "Addendum",
+        addenda_package:  "AddendaPackage",
+        combined_addenda: "CombinedAddenda",
+        errata:           "Errata",
+        interpretation:   "Interpretation",
+      }.freeze
+
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts))
+      end
+
+      def self.resolve_create_class(type)
+        return Identifiers::Standard if type.nil?
+
+        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
+        raise ArgumentError, "Unknown ASHRAE type: #{type.inspect}" unless klass_name
+
+        Identifiers.const_get(klass_name)
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = { publisher: (opts[:publisher] || "ASHRAE").to_s }
+        if (v = opts[:code] || opts[:number])
+          attrs[:code] = v.to_s
+        end
+        %i[year suffix amendment reaffirmed copublisher].each do |k|
+          attrs[k] = opts[k].to_s unless opts[k].nil?
+        end
+        attrs
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs
     end
   end
 end

data/lib/pubid/asme/identifier.rb

@@ -10,6 +10,52 @@ module Pubid
         parsed = parser.parse(str)
         builder.build(parsed)
       end
+
+      # Factory that builds an ASME identifier from a hash of primitives.
+      # Default is {Identifiers::Standard}. ASME's Code Component has
+      # `:designator` (leading letters, e.g. "B") and `:number` (rest,
+      # e.g. "16.34"); `.create` accepts either an already-split pair or
+      # a combined `:code` string which it splits at the first digit.
+      def self.create(**opts)
+        Identifiers::Standard.new(**coerce_create_attrs(opts))
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = { publisher: (opts[:publisher] || "ASME").to_s }
+
+        if opts[:designator] || opts[:number]
+          attrs[:code] = Pubid::Asme::Components::Code.new(
+            designator: opts[:designator]&.to_s,
+            number:     opts[:number]&.to_s,
+          )
+        elsif (combined = opts[:code])
+          designator, number = split_asme_code(combined.to_s)
+          attrs[:code] = Pubid::Asme::Components::Code.new(
+            designator: designator,
+            number:     number,
+          )
+        end
+
+        %i[year reaffirmation language csa_number draft_year
+           revision_note parenthetical_revision ptc_suffix
+           joint_publisher first_publisher first_code].each do |k|
+          attrs[k] = opts[k].to_s unless opts[k].nil?
+        end
+        attrs[:handbook] = opts[:handbook] if opts.key?(:handbook)
+        attrs
+      end
+
+      # ASME codes pair a letter designator with a numeric/dotted number.
+      # Split at the first digit. "B16.34" → ["B", "16.34"]; "Y14.5" →
+      # ["Y", "14.5"]; "BPVC.III.1.NB" → ["BPVC.III.1.NB", nil] (no
+      # leading all-letters before the first digit — pass through).
+      def self.split_asme_code(str)
+        match = str.match(/\A([A-Za-z]+)(\d.*)\z/)
+        return match.captures if match
+
+        [str, nil]
+      end
+      private_class_method :coerce_create_attrs, :split_asme_code
     end
   end
 end

data/lib/pubid/astm/identifier.rb

@@ -10,6 +10,83 @@ module Pubid
         parsed = parser.parse(str)
         builder.build(parsed)
       end
+
+      # Factory that builds an ASTM identifier from a hash of primitives.
+      # Default is {Identifiers::Standard}.
+      #
+      # ASTM's Code Component has :letter (single letter A–Z) + :number
+      # (rest); `.create` accepts either an already-split pair or a
+      # combined `:code` string which it splits at the first digit.
+      TYPE_KEY_TO_KLASS = {
+        standard:           "Standard",
+        adjunct:            "Adjunct",
+        manual:             "Manual",
+        monograph:          "Monograph",
+        research_report:    "ResearchReport",
+        technical_report:   "TechnicalReport",
+        data_series:        "DataSeries",
+        iso_dual_published: "IsoDualPublished",
+        work_in_progress:   "WorkInProgress",
+      }.freeze
+
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts, klass: klass))
+      end
+
+      def self.resolve_create_class(type)
+        return Identifiers::Standard if type.nil?
+
+        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
+        raise ArgumentError, "Unknown ASTM type: #{type.inspect}" unless klass_name
+
+        Identifiers.const_get(klass_name)
+      end
+
+      def self.coerce_create_attrs(opts, klass:)
+        attrs = { publisher: (opts[:publisher] || "ASTM").to_s }
+
+        if opts[:letter] || opts[:number]
+          attrs[:code] = Pubid::Astm::Components::Code.new(
+            letter:    opts[:letter]&.to_s,
+            number:    opts[:number]&.to_s,
+            suffix:    opts[:suffix]&.to_s,
+            subseries: opts[:subseries]&.to_s,
+            dual_m:    opts[:dual_m],
+          )
+        elsif (combined = opts[:code])
+          letter, number = split_astm_code(combined.to_s)
+          attrs[:code] = Pubid::Astm::Components::Code.new(
+            letter: letter, number: number,
+          )
+        end
+
+        attrs[:year] = opts[:year].to_s if opts[:year]
+        attrs[:format_suffix] = opts[:format_suffix].to_s if opts[:format_suffix]
+
+        # Pass through subclass-specific kwargs (designation, edition,
+        # committee, …) when the class declares them.
+        opts.each do |k, v|
+          next if attrs.key?(k)
+          next if %i[publisher code letter number suffix subseries
+                     dual_m year format_suffix].include?(k)
+          attrs[k] = v if klass.attributes.key?(k)
+        end
+        attrs
+      end
+
+      # ASTM codes use a single letter prefix (A–Z) followed by digits.
+      # "A36" → ["A", "36"]; "E1444" → ["E", "1444"]. Codes without a
+      # leading letter (data series numbers, etc.) pass through with
+      # letter: nil.
+      def self.split_astm_code(str)
+        match = str.match(/\A([A-Za-z])(\d.*)\z/)
+        return match.captures if match
+
+        [nil, str]
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs,
+                           :split_astm_code
     end
   end
 end

data/lib/pubid/bsi/identifier.rb

@@ -22,6 +22,66 @@ module Pubid
       rescue Parslet::ParseFailed => e
         raise StandardError, "Failed to parse '#{string}': #{e.message}"
       end
+
+      # Factory mirroring pubid 1.x's `Pubid::Bsi::Identifier.create` API.
+      # Dispatches via {Pubid::Bsi::Scheme}'s IDENTIFIER_CLASS_MAP and
+      # TYPED_STAGES_REGISTRY; default subclass is BritishStandard.
+      #
+      # BSI's renderer requires BSI-namespaced Component subclasses
+      # (`Bsi::Components::*`), so coercion is inlined rather than reusing
+      # {Pubid::Components::Factory}.
+      def self.create(type: nil, stage: nil, **opts)
+        klass = resolve_create_class(type: type, stage: stage)
+        attrs = coerce_create_attrs(opts)
+        ts = resolve_create_typed_stage(klass, stage)
+        attrs[:typed_stage] = ts if ts
+        klass.new(**attrs)
+      end
+
+      def self.resolve_create_class(type:, stage:)
+        scheme = Scheme.new
+        klass = nil
+        if type
+          klass = scheme.locate_identifier_klass_by_type_code(type)
+        elsif stage
+          ts = scheme.locate_typed_stage_by_abbr(stage.to_s)
+          klass = scheme.locate_identifier_klass_by_type_code(ts.type_code) if ts
+        end
+        klass || Identifiers::BritishStandard
+      end
+
+      def self.resolve_create_typed_stage(klass, stage)
+        if stage
+          Scheme.new.locate_typed_stage_by_abbr(stage.to_s)
+        elsif klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES).find do |ts|
+            ts.stage_code.to_sym == :published
+          end
+        end
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = {}
+        if (v = opts[:publisher])
+          attrs[:publisher] = Components::Publisher.new(body: v.to_s)
+        end
+        %i[number part subpart].each do |k|
+          v = opts[k]
+          attrs[k] = Components::Code.new(value: v.to_s) unless v.nil?
+        end
+        if (v = opts[:year])
+          attrs[:date] = Components::Date.new(year: v.to_s)
+        end
+        # BSI :edition is a plain string attribute (not a Component).
+        attrs[:edition] = opts[:edition].to_s if opts[:edition]
+        # TODO(create-shim): BSI also has prefix, flex_prefix, iteration,
+        # second_number, month, translation_lang/upper attributes that
+        # aren't yet wired through. Add as call sites require them.
+        attrs
+      end
+      private_class_method :resolve_create_class,
+                           :resolve_create_typed_stage,
+                           :coerce_create_attrs
     end
   end
 end

data/lib/pubid/ccsds/identifier.rb

@@ -11,6 +11,74 @@ module Pubid
       rescue Parslet::ParseFailed => e
         raise "Failed to parse CCSDS identifier '#{identifier}': #{e.message}"
       end
+
+      # Factory that builds a CCSDS identifier from a hash of primitives.
+      #
+      # Accepts the field shape used by relaton-data-ccsds index entries:
+      # `:publisher`, `:number`, `:series`, `:part`, `:book_color`,
+      # `:retired`, `:edition`, plus the parsed-shape fields `:type`,
+      # `:suffix`, `:language`. CCSDS 2.x maps these as:
+      #
+      #   * `:series` + `:number`  → combined number ("A" + "20" → "A20")
+      #   * `:book_color`          → `:type`            (B/G/M/R/Y/O)
+      #   * `:publisher`           → ignored (hardcoded "CCSDS")
+      #   * `:retired`             → ignored (no 2.x field)
+      #
+      # Supplement subclasses (currently just Corrigendum, via `type: :cor`)
+      # raise ArgumentError until `base:` kwarg is wired through.
+      def self.create(type: nil, **opts)
+        if type
+          type_sym = type.to_sym
+          base_type_key = Identifiers::Base.type[:key].to_sym
+
+          if type_sym != base_type_key
+            supplement = supplement_klass_for(type_sym)
+            if supplement
+              # TODO(create-shim): supplement subclasses (Corrigendum)
+              # require a base_identifier. Wire `base:` kwarg through once
+              # a caller needs it.
+              raise ArgumentError, "#{supplement} requires a " \
+                                   "base_identifier; Identifier.create " \
+                                   "cannot build supplements yet"
+            end
+
+            # Not a class-dispatch key — treat as book_color data
+            # (e.g. `type: "G"` for Green Book) and merge back into opts.
+            opts = opts.merge(type: type)
+          end
+        end
+
+        Identifiers::Base.new(**coerce_create_attrs(opts))
+      end
+
+      def self.supplement_klass_for(type_sym)
+        Scheme.supplement_identifiers.find do |k|
+          k.type[:key].to_sym == type_sym
+        end
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = {}
+
+        if opts[:number]
+          num = opts[:number].to_s
+          attrs[:number] =
+            opts[:series] ? "#{opts[:series]}#{num}" : num
+        end
+
+        attrs[:type] = opts[:book_color].to_s if opts[:book_color]
+        # Allow caller to pass :type as data when no :book_color given
+        # (parsed identifiers expose it via Base#type attribute).
+        attrs[:type] = opts[:type].to_s if opts[:type] && !attrs[:type]
+
+        %i[part edition suffix language].each do |k|
+          v = opts[k]
+          attrs[k] = v.to_s unless v.nil?
+        end
+
+        attrs
+      end
+      private_class_method :supplement_klass_for, :coerce_create_attrs
     end
   end
 end

data/lib/pubid/ccsds/identifiers/base.rb

@@ -24,6 +24,17 @@ module Pubid
           { key: :base, title: "Base Standard", short: nil }
         end
 
+        # Return a copy of this identifier with the named attributes
+        # nil'd. Mirrors the {Pubid::Identifier#exclude} convenience.
+        # CCSDS Base extends Lutaml::Model::Serializable directly (not
+        # Pubid::Identifier), so the method is defined here too.
+        def exclude(*args)
+          attrs = self.class.attributes.each_with_object({}) do |(name, _), h|
+            h[name] = args.include?(name) ? nil : send(name)
+          end
+          self.class.new(attrs)
+        end
+
         # Generate URN for this identifier
         #
         # @return [String] URN representation

data/lib/pubid/ccsds/single_identifier.rb

@@ -2,7 +2,10 @@
 
 module Pubid
   module Ccsds
-    class SingleIdentifier < Identifier
+    # Qualified as ::Pubid::Identifier to avoid resolving to the local
+    # Pubid::Ccsds::Identifier module, which is a parser entry point
+    # (`self.parse`) — not the base class.
+    class SingleIdentifier < ::Pubid::Identifier
       attribute :publisher, Components::Publisher, default: -> {
         Components::Publisher.new(body: "CCSDS")
       }

data/lib/pubid/cen_cenelec/identifier.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../components/factory"
+
 module Pubid
   module CenCenelec
     module Identifier
@@ -10,6 +12,41 @@ module Pubid
       rescue Parslet::ParseFailed => e
         raise "Failed to parse CEN identifier '#{identifier}': #{e.message}"
       end
+
+      # Factory mirroring pubid 1.x's `Pubid::Cen::Identifier.create` API.
+      # Dispatches via {Pubid::CenCenelec::Scheme}'s IDENTIFIER_CLASS_MAP
+      # and TYPED_STAGES_REGISTRY. Default is EuropeanNorm.
+      def self.create(type: nil, stage: nil, **opts)
+        klass = resolve_create_class(type: type, stage: stage)
+        attrs = ::Pubid::Components::Factory.from_hash(opts)
+        ts = resolve_create_typed_stage(klass, stage)
+        attrs[:typed_stage] = ts if ts
+        klass.new(**attrs)
+      end
+
+      def self.resolve_create_class(type:, stage:)
+        scheme = Scheme.new
+        klass = nil
+        if type
+          klass = scheme.locate_identifier_klass_by_type_code(type)
+        elsif stage
+          ts = scheme.locate_typed_stage_by_abbr(stage.to_s)
+          klass = scheme.locate_identifier_klass_by_type_code(ts.type_code) if ts
+        end
+        klass || Identifiers::EuropeanNorm
+      end
+
+      def self.resolve_create_typed_stage(klass, stage)
+        if stage
+          Scheme.new.locate_typed_stage_by_abbr(stage.to_s)
+        elsif klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES).find do |ts|
+            ts.stage_code.to_sym == :published
+          end
+        end
+      end
+      private_class_method :resolve_create_class,
+                           :resolve_create_typed_stage
     end
   end
 end

data/lib/pubid/cie/identifier.rb

@@ -13,6 +13,59 @@ module Pubid
         builder = Builder.new
         builder.build(parsed, original_string: input)
       end
+
+      # Factory that builds a CIE identifier from a hash of primitives.
+      # Dispatch on `:type` to a SingleIdentifier subclass; default is
+      # {Identifiers::Standard}.
+      TYPE_KEY_TO_KLASS = {
+        standard:        "Standard",
+        conference:      "Conference",
+        bundle:          "Bundle",
+        joint_published: "JointPublished",
+        dual_published:  "DualPublished",
+        identical:       "Identical",
+        tutorial_bundle: "TutorialBundle",
+      }.freeze
+
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts, klass: klass))
+      end
+
+      def self.resolve_create_class(type)
+        return Identifiers::Standard if type.nil?
+
+        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
+        raise ArgumentError, "Unknown CIE type: #{type.inspect}" unless klass_name
+
+        Identifiers.const_get(klass_name)
+      end
+
+      def self.coerce_create_attrs(opts, klass:)
+        attrs = {}
+        attrs[:year] = opts[:year].to_s if opts[:year]
+        attrs[:date_separator] = opts[:date_separator].to_s if opts[:date_separator]
+
+        if (v = opts[:code] || opts[:number])
+          attrs[:code] = Pubid::Cie::Components::Code.new(
+            number:         v.to_s,
+            part:           opts[:part]&.to_s,
+            iteration:      opts[:iteration]&.to_s,
+            style:          opts[:style]&.to_s,
+            part_separator: opts[:part_separator]&.to_s,
+          )
+        end
+
+        # Standard-only attributes
+        if klass.attributes.key?(:s_prefix) && opts.key?(:s_prefix)
+          attrs[:s_prefix] = opts[:s_prefix]
+        end
+        if klass.attributes.key?(:stage) && opts[:stage]
+          attrs[:stage] = opts[:stage].to_s
+        end
+        attrs
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs
     end
   end
 end