pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

data/lib/pubid/tgpp/identifier.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    # Base class for every 3GPP identifier AND the flavor's parse entry point —
+    # mirrors Pubid::Jis::Identifier. Concrete identifiers under
+    # Pubid::Tgpp::Identifiers descend from this class, so a parsed 3GPP id is
+    # an instance of Pubid::Tgpp::Identifier.
+    class Identifier < ::Pubid::Identifier
+      # The dotted core (e.g. "23.207") kept as a string to preserve leading
+      # zeros. `number` overrides the base Components::Code attribute.
+      attribute :number, :string
+      # Optional letter suffix directly after the number: "U", "dcs", "ext"…
+      attribute :suffix, :string
+      # 1–2 hyphen parts (e.g. "26.171-1", "29.198-04-1"); strings preserve any
+      # zero-padding.
+      # `initialize_empty` makes a part-less identifier hold `[]` on BOTH
+      # construction paths: Builder always passes an array, but the serialized
+      # hash carries no `parts` key, so from_hash used to leave it nil and the
+      # two compared unequal — which silently broke `#matches?` (and so every
+      # part-less relaton index lookup). It does not change the serialized
+      # shape: lutaml omits an empty collection either way. See CLAUDE.md.
+      attribute :parts, :string, collection: true, initialize_empty: true
+      # Raw release token, stored verbatim: "REL-4", "Ph1", "UMTS",
+      # "Release 2000".
+      attribute :release, :string
+      # Three-part version string, e.g. "2.0.0".
+      attribute :version, :string
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization.
+      # Keys are the `pubid:3gpp:…` names produced by polymorphic_name (below).
+      TGPP_TYPE_MAP = {
+        "pubid:3gpp:technical-report" =>
+          "Pubid::Tgpp::Identifiers::TechnicalReport",
+        "pubid:3gpp:technical-specification" =>
+          "Pubid::Tgpp::Identifiers::TechnicalSpecification",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: TGPP_TYPE_MAP
+        map "number", to: :number
+        map "suffix", to: :suffix
+        map "parts", to: :parts
+        map "release", to: :release
+        map "version", to: :version
+      end
+
+      # Publisher token. A plain constant (not a `publisher` method) so it does
+      # not shadow the inherited lutaml `publisher` attribute.
+      PUBLISHER = "3GPP"
+
+      # The auto-derived polymorphic name would be "pubid:tgpp:…" (from the
+      # module constant). Force the "3gpp" segment so the `_type` tag matches
+      # the relaton flavor name and TGPP_TYPE_MAP.
+      def self.polymorphic_name
+        super&.sub(/\Apubid:tgpp:/, "pubid:3gpp:")
+      end
+
+      # Rendering flag: whether to prefix the string with "3GPP ". Transient
+      # (not serialized). #to_s sets it, renders, then resets it to false in an
+      # ensure block, so a subsequent bare #render defaults to no publisher and
+      # the flag never leaks past the to_s call that set it.
+      attr_reader :with_publisher
+
+      # The rendered document code, e.g. "29.198-04-1" (number+suffix+parts).
+      def code
+        result = "#{number}#{suffix}"
+        result += parts.map { |p| "-#{p}" }.join if parts&.any?
+        result
+      end
+
+      # Basic string representation. Delegates to the :human renderer. Default
+      # omits the "3GPP " publisher token (matches the relaton index id);
+      # `to_s(with_publisher: true)` emits the printed "3GPP TS …" form.
+      def to_s(with_publisher: false, **opts)
+        @with_publisher = with_publisher
+        render(format: :human, **opts)
+      ensure
+        @with_publisher = false
+      end
+
+      # Parse a 3GPP identifier string into an identifier object.
+      #
+      # Let Parslet::ParseFailed propagate on a bad reference (matching ISO and
+      # ETSI), so relaton-cli's `rescue Parslet::ParseFailed` fetch handler
+      # catches it instead of a bare RuntimeError. The length guard keeps its
+      # ArgumentError — that is a different failure (input too long, not
+      # unparseable) and it is the ReDoS barrier.
+      #
+      # @param identifier [String] The 3GPP identifier string to parse
+      # @return [Identifier] The appropriate identifier object
+      def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      end
+    end
+  end
+end

data/lib/pubid/tgpp/identifiers/technical_report.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    module Identifiers
+      # Technical Report identifier type.
+      # Format: [3GPP ]TR NN.NNN[suffix][-part…][:<release>][/<version>]
+      # Example: TR 00.01U:UMTS/3.0.0, or the partial "TR 00.01U".
+      class TechnicalReport < Pubid::Tgpp::Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :tr,
+            stage_code: :published,
+            type_code: :tr,
+            abbr: ["TR"],
+            name: "Technical Report",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :tr,
+            web: :technical_report, title: "Technical Report", short: "TR" }
+        end
+
+        def type_prefix
+          "TR"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/tgpp/identifiers/technical_specification.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    module Identifiers
+      # Technical Specification identifier type.
+      # Format: [3GPP ]TS NN.NNN[suffix][-part…][:<release>][/<version>]
+      # Example: TS 23.207:REL-4/2.0.0, or the partial "TS 23.207".
+      class TechnicalSpecification < Pubid::Tgpp::Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :ts,
+            stage_code: :published,
+            type_code: :ts,
+            abbr: ["TS"],
+            name: "Technical Specification",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :ts,
+            web: :technical_specification,
+            title: "Technical Specification", short: "TS" }
+        end
+
+        def type_prefix
+          "TS"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/tgpp/identifiers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    module Identifiers
+      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
+      autoload :TechnicalSpecification,
+               "#{__dir__}/identifiers/technical_specification"
+    end
+  end
+end

data/lib/pubid/tgpp/parser.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Tgpp
+    # Parslet grammar for 3GPP identifiers.
+    #
+    # Form: `[3GPP ]<TR|TS> <NN.NNN>[suffix][-part…][:<release>][/<version>]`
+    #   TS 23.207:REL-4/2.0.0
+    #   3GPP TR 00.01U:UMTS/3.0.0
+    #   TS 29.198-04-1:REL-5/5.0.0
+    #   TS 02.68:Release 2000/9.0.0
+    #   3GPP TS 23.207                (bare reference)
+    #
+    # The release and the version are both optional: a user reference names the
+    # document alone ("3GPP TS 23.207"), and relaton parses that bare form to
+    # search the index. Only the type and the dotted number core are required,
+    # so "TS" and "TS foo" are still rejected.
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+      rule(:space) { str(" ") }
+
+      # Optional leading publisher token.
+      rule(:publisher_prefix) { str("3GPP") >> space }
+
+      # Document type.
+      rule(:type) { (str("TR") | str("TS")).as(:type) }
+
+      # Dotted number core, kept as a string (preserves leading zeros).
+      rule(:number_core) { (digits >> str(".") >> digits).as(:number) }
+
+      # Letter suffix directly after the number ("U"/"dcs"/"ext"…). Generic so
+      # future controlled-vocabulary values keep round-tripping.
+      rule(:suffix) { match["A-Za-z"].repeat(1).as(:suffix) }
+
+      # Hyphen parts.
+      rule(:part) { str("-") >> digits.as(:part) }
+      rule(:parts) { part.repeat(0).as(:parts) }
+
+      # Release token, stored verbatim: everything up to the version separator.
+      # Excludes ":" (as well as "/") so the ":"-delimited URN scheme can always
+      # encode it — every real release ("REL-4", "Ph1", "UMTS", "Release 2000")
+      # is colon-free.
+      #
+      # A trailing segment shaped exactly like a version is a mistyped "/"
+      # separator ("TS 23.207:2.0.0"), not a release: no release in the 88,464
+      # published index rows contains a dot at all. Reject it rather than
+      # silently misfiling the version as the release — which only became
+      # reachable once the version segment was made optional.
+      rule(:release) do
+        (version_core >> any.absent?).absent? >>
+          match["^/:"].repeat(1).as(:release)
+      end
+
+      # Three-part version, kept as a string.
+      rule(:version_core) do
+        digits >> str(".") >> digits >> str(".") >> digits
+      end
+      rule(:version) { version_core.as(:version) }
+
+      rule(:identifier) do
+        publisher_prefix.maybe >>
+          type >> space >>
+          number_core >> suffix.maybe >> parts >>
+          (str(":") >> release).maybe >>
+          (str("/") >> version).maybe
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/tgpp/renderer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    # Human-readable renderer for 3GPP identifiers.
+    #
+    # Produces strings like:
+    #   "TS 23.207:REL-4/2.0.0"                (default, no publisher)
+    #   "3GPP TS 23.207:REL-4/2.0.0"           (with_publisher: true)
+    #   "TS 29.198-04-1:REL-5/5.0.0"           (parts)
+    #   "TR 00.01U:UMTS/3.0.0"                 (suffix)
+    #   "TS 23.207"                            (partial reference)
+    class Renderer < ::Pubid::Renderers::Base
+      PUBLISHER = "3GPP"
+
+      def render(context: nil, **_opts)
+        id = @id
+        head = []
+        head << PUBLISHER if with_publisher?(id)
+        head << id.type_prefix
+        "#{head.join(' ')} #{id.code}#{qualifiers(id)}"
+      end
+
+      private
+
+      # The trailing ":<release>" and "/<version>" qualifiers. Both are
+      # optional: a handful of legacy records omit the release entirely
+      # (e.g. "TS 29.215/2.0.0"), and a partial user reference omits both
+      # (e.g. "TS 23.207"). Render no separator for an absent one.
+      #
+      # Blank, not just nil: the grammar cannot produce "", but a hand-built
+      # hash can, and a dangling "TS 23.207:" would not re-parse. This mirrors
+      # the same guard in UrnGenerator#tail_segments.
+      def qualifiers(id)
+        result = +""
+        result << ":#{id.release}" unless blank?(id.release)
+        result << "/#{id.version}" unless blank?(id.version)
+        result
+      end
+
+      def blank?(value)
+        value.nil? || value.empty?
+      end
+
+      # Default is no publisher token (the relaton index id form); the caller
+      # opts in via `to_s(with_publisher: true)`.
+      def with_publisher?(id)
+        id.with_publisher == true
+      end
+    end
+  end
+end

data/lib/pubid/tgpp/urn_generator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    # Emits `urn:3gpp:<type>:<code>:<release>:<version>`, e.g.
+    # `urn:3gpp:ts:23.207:REL-4:2.0.0`. `<code>` is number+suffix+parts.
+    #
+    # A partial identifier has no release, no version, or neither. Only the
+    # TRAILING empty segments are dropped, so a bare reference gets the clean
+    # `urn:3gpp:ts:23.207` rather than a malformed `urn:3gpp:ts:23.207::`. An
+    # INTERIOR empty segment is kept, so the release-less form keeps the URN it
+    # has always emitted: `TS 29.215/2.0.0` -> `urn:3gpp:ts:29.215::2.0.0`.
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        (head_segments + tail_segments).join(":")
+      end
+
+      private
+
+      # The namespace, the document type and the code. Always present.
+      def head_segments
+        ["urn", "3gpp", identifier.type_prefix.downcase, identifier.code]
+      end
+
+      # The two optional qualifiers, with the trailing empty ones removed.
+      def tail_segments
+        segments = [identifier.release, identifier.version]
+        # NOTE: `empty?`, not `any?` — a bare `Array#any?` tests element
+        # truthiness, so `[nil, nil].any?` is false and would strip nothing.
+        segments.pop until segments.empty? || !blank?(segments.last)
+        segments.map(&:to_s)
+      end
+
+      def blank?(value)
+        value.nil? || value.empty?
+      end
+    end
+  end
+end

data/lib/pubid/tgpp/urn_parser.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    # Parses 3GPP URNs back into identifiers.
+    #
+    # UrnGenerator emits `urn:3gpp:<type>:<code>:<release>:<version>`; the code,
+    # release and version chunks never contain ":", so a plain split recovers
+    # them. Example: urn:3gpp:ts:23.207:REL-4:2.0.0 → TS 23.207:REL-4/2.0.0
+    class UrnParser < Pubid::UrnParser::Base
+      # The module is Tgpp but the URN namespace is "3gpp".
+      def flavor_name
+        "3gpp"
+      end
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        type, code, release, version = split_parts(body)
+        # A partial identifier drops its trailing segments, and the no-release
+        # form (e.g. TS 29.215/2.0.0) serialises with an empty release chunk
+        # ("urn:3gpp:ts:29.215::2.0.0"). Rebuild only the segments present, so
+        # neither the release colon nor the version slash dangles.
+        result = "#{type.upcase} #{code}"
+        result += ":#{release}" unless release.nil? || release.empty?
+        result += "/#{version}" unless version.nil? || version.empty?
+        flavor_parse(result)
+      end
+    end
+  end
+end

data/lib/pubid/tgpp.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "pubid"
+module Pubid
+  # 3GPP (3rd Generation Partnership Project) flavor.
+  #
+  # The Ruby constant is `Pubid::Tgpp` because a constant may not begin with a
+  # digit, but the external contract stays "3gpp": the registry key is "3gpp",
+  # the polymorphic `_type` is `pubid:3gpp:…`, and URNs use the `urn:3gpp:`
+  # namespace. Only the on-disk file names (lib/pubid/tgpp/…) follow the module.
+  module Tgpp
+    extend Pubid::PrefixesSupport
+
+    # Sole routing token. 3GPP references are printed as "3GPP TS 23.207:…";
+    # the bare document types (TR/TS) are ambiguous (JIS uses them too) and are
+    # excluded. The parser still accepts an optional leading "3GPP ".
+    PREFIXES = ["3GPP"].freeze
+
+    autoload :Builder, "#{__dir__}/tgpp/builder"
+    autoload :Identifier, "#{__dir__}/tgpp/identifier"
+    autoload :Identifiers, "#{__dir__}/tgpp/identifiers"
+    autoload :Parser, "#{__dir__}/tgpp/parser"
+    autoload :Renderer, "#{__dir__}/tgpp/renderer"
+    autoload :UrnGenerator, "#{__dir__}/tgpp/urn_generator"
+    autoload :UrnParser, "#{__dir__}/tgpp/urn_parser"
+
+    # Parse a 3GPP identifier string
+    def self.parse(identifier)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Tgpp::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+# Register 3GPP flavor with the registry (external key stays "3gpp").
+Pubid::Registry.register(:"3gpp", Pubid::Tgpp)

data/lib/pubid/type_resolver.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "pubid"
+module Pubid
+  # Resolves a polymorphic `_type` string (e.g. "pubid:iso:technical-report")
+  # to the concrete Ruby class that owns it.
+  #
+  # Each flavor's Identifier base owns a `polymorphic_type_map` for the types
+  # defined in its own namespace. A nested polymorphic attribute (e.g. a GOST
+  # Harmonized identifier's adopted ISO identifier) carries a `_type` from a
+  # different flavor, so the owning flavor's map misses. This service routes
+  # the lookup to the registered flavor whose name appears in the type's
+  # second segment ("pubid:<flavor>:…"), giving every from_hash caller a
+  # single cross-flavor dispatch path.
+  class TypeResolver
+    TYPE_PREFIX = "pubid:"
+    SEGMENT_SEPARATOR = ":"
+
+    class << self
+      # @param type [String, nil] Polymorphic _type, e.g. "pubid:iso:technical-report".
+      # @return [Class<Pubid::Identifier>, nil] The concrete class, or nil if
+      #   the type is blank, malformed, or unknown to its flavor.
+      def resolve(type)
+        return nil unless type.is_a?(String)
+
+        flavor_name = flavor_segment(type)
+        return nil unless flavor_name
+
+        # Ensure the flavor module is loaded so its self-register call has
+        # run; without this, Registry may know of flavors that haven't yet
+        # populated their Identifier base's polymorphic_type_map.
+        ::Pubid.eager_load_flavors!
+
+        flavor = ::Pubid::Registry.get(flavor_name) ||
+          flavor_by_module_segment(flavor_name)
+        return nil unless flavor
+
+        identifier_base = flavor::Identifier
+        identifier_base.polymorphic_type_map[type]
+      rescue NameError
+        # Flavor module is registered but its Identifier base cannot be
+        # loaded (autoload failure). Treat as unresolvable.
+        nil
+      end
+
+      private
+
+      # The registered flavor whose module constant gives +segment+.
+      # Identifier.polymorphic_name takes the segment from the module name
+      # ("Pubid::CenCenelec" -> "cencenelec"), and a flavor can be registered
+      # under other names ("cen_cenelec", "cen"). Without this fallback no
+      # CEN/CENELEC `_type` resolved, so the root class and a nested
+      # attribute of another flavor (BSI) read a CEN hash as the abstract
+      # root.
+      def flavor_by_module_segment(segment)
+        ::Pubid::Registry.flavors.each_value.find do |flavor_module|
+          flavor_module.name.to_s.split("::")[1]&.downcase == segment
+        end
+      end
+
+      # The flavor name is the segment between the leading "pubid:" and the
+      # type-name, e.g. "iso" in "pubid:iso:technical-report".
+      def flavor_segment(type)
+        return nil unless type.start_with?(TYPE_PREFIX)
+
+        remainder = type[TYPE_PREFIX.length..]
+        flavor_end = remainder.index(SEGMENT_SEPARATOR)
+        return nil unless flavor_end
+
+        remainder[0, flavor_end]
+      end
+    end
+  end
+end

data/lib/pubid/un/builder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Un
+    class Builder
+      YEAR_REGEX = /\A\d{4}\z/.freeze
+
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        tokens = extract_tokens(data)
+        raise "UN identifier has no tokens" if tokens.empty?
+
+        number = tokens.last
+        path = tokens[0...-1]
+        year_token = path.reverse.find { |t| t.match?(YEAR_REGEX) }
+
+        Identifiers::Document.new(
+          path: path,
+          number: number,
+          date: year_token ? ::Pubid::Components::Date.new(year: year_token) : nil,
+        )
+      end
+
+      private
+
+      def extract_tokens(data)
+        raw = data.is_a?(Hash) ? data[:token] : data
+        case raw
+        when Array
+          raw.map { |h| h.is_a?(Hash) ? h[:token].to_s : h.to_s }
+        when Hash
+          [raw[:token].to_s]
+        else
+          [raw.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/pubid/un/identifier.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Un
+    class Identifier < ::Pubid::Identifier
+      attribute :path, :string, collection: true, default: []
+      attribute :number, :string
+
+      UN_TYPE_MAP = {
+        "pubid:un:document" => "Pubid::Un::Identifiers::Document",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: UN_TYPE_MAP
+        map "path", to: :path
+        map "number", to: :number
+      end
+
+      PUBLISHER = "UN"
+
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      end
+    end
+  end
+end

data/lib/pubid/un/identifiers/document.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Un
+    module Identifiers
+      class Document < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubun,
+            stage_code: :published,
+            type_code: :un,
+            abbr: ["UN"],
+            name: "UN Document",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :un, web: :document, title: "UN Document", short: "UN" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/un/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Un
+    module Identifiers
+      autoload :Document, "#{__dir__}/identifiers/document"
+    end
+  end
+end