pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/iso/identifiers/international_workshop_agreement.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class InternationalWorkshopAgreement < SingleIdentifier
+
+        # IWA identifiers have no publisher prefix (rendered "IWA 1", not
+        # "ISO IWA 1"), so there is no implied publisher to default on load.
+        def self.default_publisher
+          nil
+        end
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pwiiwa,
+            stage_code: :pwi,
+            type_code: :iwa,
+            abbr: ["PWI IWA"],
+            name: "Proposed Work Item for International Workshop Agreement",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :npiwa,
+            stage_code: :np,
+            type_code: :iwa,
+            abbr: ["NP IWA"],
+            name: "New Work Item Proposal for International Workshop Agreement",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :awiiwa,
+            stage_code: :awi,
+            type_code: :iwa,
+            abbr: ["AWI IWA"],
+            name: "Approved Work Item for International Workshop Agreement",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wdiwa,
+            stage_code: :wd,
+            type_code: :iwa,
+            abbr: ["WD IWA"],
+            name: "Working Draft for International Workshop Agreement",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :cdiwa,
+            stage_code: :cd,
+            type_code: :iwa,
+            abbr: ["CD IWA"],
+            name: "Committee Draft for International Workshop Agreement",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :diwa,
+            stage_code: :diwa,
+            type_code: :iwa,
+            abbr: ["DIWA"],
+            name: "Draft International Workshop Agreement",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :prfiwa,
+            stage_code: :prf,
+            type_code: :iwa,
+            abbr: ["PRF IWA"],
+            name: "Proof International Workshop Agreement",
+            harmonized_stages: %w[50.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :iwa,
+            stage_code: :published,
+            type_code: :iwa,
+            abbr: ["IWA"],
+            name: "International Workshop Agreement",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :iwa,
+            web: :international_workshop_agreement, title: "International Workshop Agreement", short: "IWA" }
+        end
+
+        def to_s(**opts)
+          context = build_rendering_context(nil, format: :human, **opts)
+          Pubid::Renderers::IwaRenderer.new(self).render(context:,
+                                                         **opts.slice(:with_edition))
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iso/identifiers/pas.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      # Publicly Available Specification", Identifier
+      class Pas < SingleIdentifier
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pwipas,
+            stage_code: :pwi,
+            type_code: :pas,
+            abbr: ["PWI PAS"],
+            name: "Proposed Work Item for Publicly Available Specification",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :nppas,
+            stage_code: :np,
+            type_code: :pas,
+            abbr: ["NP PAS"],
+            name: "New Work Item Proposal for Publicly Available Specification",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :awipas,
+            stage_code: :awi,
+            type_code: :pas,
+            abbr: ["AWI PAS"],
+            name: "Approved Work Item for Publicly Available Specification",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wdpas,
+            stage_code: :wd,
+            type_code: :pas,
+            abbr: ["WD PAS"],
+            name: "Working Draft for Publicly Available Specification",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :cdpas,
+            stage_code: :cd,
+            type_code: :pas,
+            abbr: ["CD PAS"],
+            name: "Committee Draft for Publicly Available Specification",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :dpas,
+            stage_code: :dpas,
+            type_code: :pas,
+            abbr: ["DPAS"],
+            name: "Draft Publicly Available Specification",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :fdpas,
+            stage_code: :final_draft,
+            type_code: :pas,
+            abbr: ["FDPAS"],
+            name: "Final Draft Publicly Available Specification",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :prfpas,
+            stage_code: :prf,
+            type_code: :pas,
+            abbr: ["PRF PAS"],
+            name: "Proof Publicly Available Specification",
+            harmonized_stages: %w[60.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :pas,
+            stage_code: :published,
+            type_code: :pas,
+            abbr: ["PAS"],
+            name: "Publicly Available Specification",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :pas,
+            web: :publicly_available_specification, title: "Publicly Available Specification", short: "PAS" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iso/identifiers/recommendation.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class Recommendation < SingleIdentifier
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :dp,
+            stage_code: :np,
+            type_code: :rec,
+            abbr: ["DP"],
+            name: "Draft Proposal",
+            harmonized_stages: %w[
+              00.00 00.20 00.60 00.92 00.93 00.98 00.99
+              10.00 10.20 10.60 10.92 10.93 10.98 10.99
+              20.00 20.20 20.60 20.92 20.93 20.98 20.99
+              30.00 30.20 30.60 30.92 30.93 30.98 30.99
+              40.00 40.20 40.60 40.92 40.93 40.98 40.99
+            ],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :rec,
+            stage_code: :published,
+            type_code: :rec,
+            abbr: ["R"],
+            name: "Recommendation",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :rec,
+            web: :recommendation, title: "Recommendation", short: "R" }
+        end
+
+        # Override URN type code - Recommendation uses 'r' in URN (RFC 5141)
+        def urn_type_code
+          "r"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iso/identifiers/supplement.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class Supplement < SupplementIdentifier
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pwisuppl,
+            stage_code: :pwi,
+            type_code: :suppl,
+            abbr: ["PWI Suppl"],
+            name: "Proposed Work Item for Supplement",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :npsuppl,
+            stage_code: :np,
+            type_code: :suppl,
+            abbr: ["NP Suppl"],
+            name: "New Work Item Proposal for Supplement",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :awisuppl,
+            stage_code: :awi,
+            type_code: :suppl,
+            abbr: ["AWI Suppl"],
+            name: "Approved Work Item for Supplement",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wdsuppl,
+            stage_code: :wd,
+            type_code: :suppl,
+            abbr: ["WD Suppl"],
+            name: "Working Draft for Supplement",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :cdsuppl,
+            stage_code: :cd,
+            type_code: :suppl,
+            abbr: ["CD Suppl"],
+            name: "Committee Draft for Supplement",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :dsuppl,
+            stage_code: :dsuppl,
+            type_code: :suppl,
+            abbr: ["DSuppl", "DIS Suppl"],
+            name: "Draft Supplement",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fdsuppl,
+            stage_code: :fdsuppl,
+            type_code: :suppl,
+            abbr: ["FDSuppl", "FDIS Suppl"],
+            name: "Final Draft Supplement",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :prfsuppl,
+            stage_code: :prf,
+            type_code: :suppl,
+            abbr: ["PRF Suppl"],
+            name: "Proof Supplement",
+            harmonized_stages: %w[50.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :pubsuppl,
+            stage_code: :published,
+            type_code: :suppl,
+            abbr: ["Suppl", "Suppl."],
+            name: "Supplement",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        # Override URN type code - Supplement uses 'sup' in URN (RFC 5141)
+        def urn_supplement_type
+          "sup"
+        end
+
+        def self.type
+          { key: :suppl,
+            web: :supplement, title: "Supplement", short: "suppl" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iso/identifiers/tc_document.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      # Technical Committee Document
+      # Format: TC 184/SC 4/WG 3 N 123, JTC 1 N 456, TC 184 N 100
+      class TcDocument < Identifier
+        # TC type (TC, JTC, PC, IT, etc.)
+        attribute :tc_type, ::Pubid::Components::Code
+        # TC number
+        attribute :tc_number, ::Pubid::Components::Code
+        # SC type
+        attribute :sc_type, ::Pubid::Components::Code
+        # SC number
+        attribute :sc_number, ::Pubid::Components::Code
+        # WG type
+        attribute :wg_type, ::Pubid::Components::Code
+        # WG number
+        attribute :wg_number, ::Pubid::Components::Code
+
+        # TC types from ISO system
+        TC_TYPES = %w[TC JTC PC IT CAB CASCO COPOLCO COUNCIL CPSG CS DEVCO GA
+                      GAAB INFCO ITN ISOlutions REMCO TMB TMBG WMO DMT JCG SGPM
+                      ATMG CCCC CCCC-TG JDMT JSAG JSCTF-TF JTCG JTCG-TF SAG_Acc
+                      SAG_CRMI SAG_CRMI_CG SAG_ESG SAG_ESG_CG SAG_MRS SAG_SF SAG_SF_CG
+                      SMCC STMG MENA_STAR].freeze
+
+        # WG types from ISO system
+        WG_TYPES = %w[AG AhG WG JWG QC TF PPC CAG CSC ITSAG CSC/FIN CSC/NOM CSC/OVE
+                      CSC/SP CSC SF ITSG JAG JCTF JSG JTAG JTG].freeze
+
+        # TC documents don't use typed stages like other identifiers
+        TYPED_STAGES = [].freeze
+
+        # Serialize the committee structure (all plain-string Codes) on top of
+        # the inherited ISO mapping; TC documents have no stage.
+        key_value do
+          map "tc_type", with: { to: :tc_type_to_kv, from: :tc_type_from_kv }
+          map "tc_number", with: { to: :tc_number_to_kv, from: :tc_number_from_kv }
+          map "sc_type", with: { to: :sc_type_to_kv, from: :sc_type_from_kv }
+          map "sc_number", with: { to: :sc_number_to_kv, from: :sc_number_from_kv }
+          map "wg_type", with: { to: :wg_type_to_kv, from: :wg_type_from_kv }
+          map "wg_number", with: { to: :wg_number_to_kv, from: :wg_number_from_kv }
+        end
+
+        # TC documents have no stage; suppress the inherited stage emission.
+        def stage_to_kv(_model, _doc); end
+
+        def tc_type_to_kv(m, doc) = emit_code(doc, "tc_type", m.tc_type)
+        def tc_type_from_kv(m, v) = m.tc_type = build_code(v)
+        def tc_number_to_kv(m, doc) = emit_code(doc, "tc_number", m.tc_number)
+        def tc_number_from_kv(m, v) = m.tc_number = build_code(v)
+        def sc_type_to_kv(m, doc) = emit_code(doc, "sc_type", m.sc_type)
+        def sc_type_from_kv(m, v) = m.sc_type = build_code(v)
+        def sc_number_to_kv(m, doc) = emit_code(doc, "sc_number", m.sc_number)
+        def sc_number_from_kv(m, v) = m.sc_number = build_code(v)
+        def wg_type_to_kv(m, doc) = emit_code(doc, "wg_type", m.wg_type)
+        def wg_type_from_kv(m, v) = m.wg_type = build_code(v)
+        def wg_number_to_kv(m, doc) = emit_code(doc, "wg_number", m.wg_number)
+        def wg_number_from_kv(m, v) = m.wg_number = build_code(v)
+
+        def self.type
+          { key: :tc,
+            web: :tc_document, title: "Technical Committee Document", short: "TC" }
+        end
+
+        def self.typed_stages
+          TYPED_STAGES
+        end
+
+        def to_s(...)
+          result = publisher.to_s if publisher
+
+          # Add TC type and number
+          result += "/#{tc_type.render} " if tc_type&.value
+          result += tc_number.render.to_s if tc_number&.value
+
+          # Add SC type and number
+          if sc_type&.value && sc_number&.value
+            result += "/#{sc_type.render} "
+            result += sc_number.render.to_s
+          end
+
+          # Add WG type and number
+          if wg_type&.value && wg_number&.value
+            result += "/#{wg_type.render} "
+            result += wg_number.render.to_s
+          end
+
+          # Add document number
+          result += " N #{number.render}" if number&.value
+
+          # Add year if present
+          result += ":#{date.render}" if date&.year
+
+          result
+        end
+
+        # Generate URN for TC document
+        # Format: urn:iso:doc:iso:tc:184:sc-4:wg-3:123
+        def to_urn
+          urn_ctx = Rendering::RenderingContext.urn
+          parts = ["urn:iso:doc"]
+          parts << publisher.render(context: urn_ctx) if publisher
+
+          # Add TC
+          parts << "tc:#{tc_number.render(context: urn_ctx)}" if tc_number&.value
+
+          # Add SC
+          parts << "sc-#{sc_number.render(context: urn_ctx)}" if sc_number&.value
+
+          # Add WG
+          parts << "wg-#{wg_number.render(context: urn_ctx)}" if wg_number&.value
+
+          # Add document number
+          parts << number.render(context: urn_ctx) if number&.value
+
+          parts.join(":")
+        end
+
+        def ==(other)
+          return false unless other.is_a?(TcDocument)
+
+          publisher == other.publisher &&
+            tc_type == other.tc_type &&
+            tc_number == other.tc_number &&
+            sc_type == other.sc_type &&
+            sc_number == other.sc_number &&
+            wg_type == other.wg_type &&
+            wg_number == other.wg_number &&
+            number == other.number
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class TechnicalReport < SingleIdentifier
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pwitr,
+            stage_code: :pwi,
+            type_code: :tr,
+            abbr: ["PWI TR"],
+            name: "Proposed Work Item for Technical Report",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :nptr,
+            stage_code: :np,
+            type_code: :tr,
+            abbr: ["NP TR"],
+            name: "New Work Item Proposal for Technical Report",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :awitr,
+            stage_code: :awi,
+            type_code: :tr,
+            abbr: ["AWI TR"],
+            name: "Approved Work Item for Technical Report",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :wdtr,
+            stage_code: :wd,
+            type_code: :tr,
+            abbr: ["WD TR"],
+            name: "Working Draft Technical Report",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :cdtr,
+            stage_code: :cd,
+            type_code: :tr,
+            abbr: ["CD TR"],
+            name: "Committee Draft Technical Report",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :pdtr,
+            stage_code: :cd,
+            type_code: :tr,
+            abbr: ["PDTR"],
+            name: "Proposed Draft Technical Report",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :dtr,
+            stage_code: :draft,
+            type_code: :tr,
+            abbr: ["DTR", "DIS TR"],
+            name: "Draft Technical Report",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fdtr,
+            stage_code: :final_draft,
+            type_code: :tr,
+            abbr: ["FDTR", "FDIS TR"],
+            name: "Final Draft Technical Report",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :prftr,
+            stage_code: :prf,
+            type_code: :tr,
+            abbr: ["PRF TR"],
+            name: "Proof Technical Report",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :pubtr,
+            stage_code: :published,
+            type_code: :tr,
+            abbr: ["TR"],
+            name: "Published Technical Report",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :tr,
+            web: :technical_report, title: "Technical Report", short: "TR" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class TechnicalSpecification < SingleIdentifier
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pwits,
+            stage_code: :pwi,
+            type_code: :ts,
+            abbr: ["PWI TS"],
+            name: "Proposed Work Item for Technical Specification",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :npts,
+            stage_code: :np,
+            type_code: :ts,
+            abbr: ["NP TS"],
+            name: "New Work Item Proposal for Technical Specification",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :awits,
+            stage_code: :awi,
+            type_code: :ts,
+            abbr: ["AWI TS"],
+            name: "Approved Work Item for Technical Specification",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :wdts,
+            stage_code: :wd,
+            type_code: :ts,
+            abbr: ["WD TS"],
+            name: "Working Draft Technical Specification",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :cdts,
+            stage_code: :cd,
+            type_code: :ts,
+            abbr: ["CDTS", "CD TS"],
+            name: "Committee Draft Technical Specification",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :pdts,
+            stage_code: :cd,
+            type_code: :ts,
+            abbr: ["PDTS"],
+            name: "Proposed Draft Technical Specification",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :dts,
+            stage_code: :dts,
+            type_code: :ts,
+            abbr: ["DTS"],
+            name: "Draft Technical Specification",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fdts,
+            stage_code: :fdts,
+            type_code: :ts,
+            abbr: ["FDTS"],
+            name: "Final Draft Technical Specification",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :prfts,
+            stage_code: :prf,
+            type_code: :ts,
+            abbr: ["PRF TS"],
+            name: "Proof Technical Specification",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :pubts,
+            stage_code: :published,
+            type_code: :ts,
+            abbr: ["TS"],
+            name: "Published Technical Specification",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :ts,
+            web: :technical_specification, title: "Technical Specification", short: "TS" }
+        end
+      end
+    end
+  end
+end