facturx 0.1.0

data/lib/facturx/error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Error < StandardError
+    attr_reader :details
+
+    def initialize(message = nil, **details)
+      @details = details.freeze
+      super(message)
+    end
+  end
+
+  class InvalidXmlError < Error; end
+  class UnknownProfileError < InvalidXmlError; end
+  class XsdValidationError < InvalidXmlError; end
+  class InvalidPdfError < Error; end
+  class ProtectedPdfError < InvalidPdfError; end
+  class ComposerUnavailableError < Error; end
+  class CompositionError < Error; end
+  class ExtractionError < Error; end
+  class VerificationError < Error; end
+end

data/lib/facturx/pdf/document.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'pdf/reader'
+require 'stringio'
+
+require_relative '../error'
+
+module Facturx
+  module Pdf
+    class Document
+      attr_reader :catalog, :reader
+
+      class << self
+        def open(pdf, reject_signed: false)
+          parse(pdf, reject_signed:)
+        rescue InvalidPdfError
+          raise
+        rescue PDF::Reader::MalformedPDFError, PDF::Reader::UnsupportedFeatureError,
+               ArgumentError, IOError => e
+          raise invalid_error(e)
+        end
+
+        private
+
+        def parse(pdf, reject_signed:)
+          raise InvalidPdfError.new('PDF must be a byte string', reason: :invalid_input) unless pdf.is_a?(String)
+
+          reader = build_reader(pdf)
+          raise encrypted_error if reader.objects.encrypted?
+
+          document = new(reader)
+          document.validate!
+          raise signed_error if reject_signed && document.signed?
+
+          document
+        end
+
+        def build_reader(pdf)
+          PDF::Reader.new(StringIO.new(pdf.b))
+        rescue PDF::Reader::EncryptedPDFError
+          raise encrypted_error
+        end
+
+        def encrypted_error
+          ProtectedPdfError.new('Encrypted PDFs are not supported', protection: :encryption)
+        end
+
+        def signed_error
+          ProtectedPdfError.new('Signed PDFs are not supported', protection: :signature)
+        end
+
+        def invalid_error(error)
+          InvalidPdfError.new('Invalid PDF', reason: :malformed, cause: error.class.name)
+        end
+      end
+
+      def initialize(reader)
+        @reader = reader
+        @catalog = reader.objects.deref_hash(reader.objects.trailer[:Root])
+      end
+
+      def objects
+        reader.objects
+      end
+
+      def page_count
+        reader.page_count
+      end
+
+      def metadata
+        stream = objects.deref_stream(catalog[:Metadata])
+        return unless stream
+
+        stream.unfiltered_data.dup.force_encoding(Encoding::BINARY)
+      rescue PDF::Reader::MalformedPDFError, PDF::Reader::UnsupportedFeatureError
+        nil
+      end
+
+      def validate!
+        raise PDF::Reader::MalformedPDFError, 'PDF catalog is missing' unless catalog
+
+        reader.page_count
+      end
+
+      def signed?
+        return true if catalog.key?(:Perms)
+
+        objects.any? do |_reference, object|
+          dictionary = object.is_a?(PDF::Reader::Stream) ? object.hash : object
+          signature_dictionary?(dictionary)
+        end
+      end
+
+      private
+
+      def signature_dictionary?(dictionary)
+        return false unless dictionary.is_a?(Hash)
+
+        dictionary[:Type] == :Sig || (dictionary.key?(:ByteRange) && dictionary.key?(:Contents))
+      end
+    end
+  end
+end

data/lib/facturx/pdf/extractor.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative 'document'
+require_relative 'name_tree'
+require_relative '../embedding'
+
+module Facturx
+  module Pdf
+    class Extractor
+      Result = Data.define(:xml, :filename, :relationship, :metadata, :page_count)
+      Candidate = Data.define(:file_specification, :names)
+
+      def call(pdf)
+        document = Document.open(pdf)
+        build_result(document, select_candidate(document))
+      rescue InvalidPdfError, ExtractionError
+        raise
+      rescue PDF::Reader::MalformedPDFError => e
+        raise InvalidPdfError.new('Invalid PDF', reason: :malformed, cause: e.class.name)
+      rescue PDF::Reader::UnsupportedFeatureError => e
+        raise ExtractionError.new('Unable to decode the Factur-X attachment', reason: :unsupported_stream,
+                                                                              cause: e.class.name)
+      end
+
+      private
+
+      def build_result(document, candidate)
+        file_specification = candidate.file_specification
+        validate_names!(candidate.names)
+        validate_relationship!(file_specification)
+
+        Result.new(xml: embedded_xml(document, file_specification),
+                   filename: FACTURX_EMBEDDING.filename,
+                   relationship: FACTURX_EMBEDDING.relationship,
+                   metadata: document.metadata,
+                   page_count: document.page_count)
+      end
+
+      def select_candidate(document)
+        matches = matching_candidates(associated_file_candidates(document))
+        matches = matching_candidates(name_tree_candidates(document)) if matches.empty?
+
+        raise ExtractionError.new('Factur-X XML attachment is missing', reason: :missing_attachment) if matches.empty?
+        if matches.length > 1
+          raise ExtractionError.new('Factur-X XML attachment is ambiguous', reason: :ambiguous_attachment,
+                                                                            count: matches.length)
+        end
+
+        matches.first
+      end
+
+      def matching_candidates(candidates)
+        candidates.select { |candidate| candidate.names.include?(FACTURX_EMBEDDING.filename) }
+      end
+
+      def associated_file_candidates(document)
+        references = document.objects.deref_array(document.catalog[:AF]) || []
+        references.filter_map { |reference| candidate_from(document, reference) }
+      end
+
+      def name_tree_candidates(document)
+        NameTree.new(document).call.filter_map do |tree_name, file_specification|
+          candidate_from(document, file_specification, tree_name)
+        end
+      end
+
+      def candidate_from(document, reference, tree_name = nil)
+        file_specification = document.objects.deref_hash(reference)
+        return unless file_specification
+
+        names = [tree_name, file_specification[:F], file_specification[:UF]]
+                .compact
+                .map { |name| normalize_name(document, name) }
+        Candidate.new(file_specification:, names:)
+      end
+
+      def normalize_name(document, name)
+        value = document.objects.deref(name)
+        return value unless value.is_a?(String)
+        return value unless value.byteslice(0, 2) == "\xFE\xFF".b
+
+        value.byteslice(2..).force_encoding(Encoding::UTF_16BE).encode(Encoding::UTF_8)
+      rescue EncodingError
+        raise ExtractionError.new('Factur-X attachment has an invalid filename encoding',
+                                  reason: :invalid_filename_encoding)
+      end
+
+      def validate_names!(names)
+        return if names.all?(FACTURX_EMBEDDING.filename)
+
+        raise ExtractionError.new('Factur-X attachment has an invalid filename', reason: :invalid_filename,
+                                                                                 filenames: names)
+      end
+
+      def validate_relationship!(file_specification)
+        return if file_specification[:AFRelationship] == FACTURX_EMBEDDING.relationship
+
+        raise ExtractionError.new('Factur-X attachment must use the Alternative relationship',
+                                  reason: :invalid_relationship,
+                                  relationship: file_specification[:AFRelationship])
+      end
+
+      def embedded_xml(document, file_specification)
+        embedded_files = document.objects.deref_hash(file_specification[:EF])
+        stream_reference = embedded_files && (embedded_files[:UF] || embedded_files[:F])
+        stream = document.objects.deref(stream_reference)
+        unless stream.is_a?(PDF::Reader::Stream)
+          raise ExtractionError.new('Factur-X attachment stream is missing', reason: :missing_stream)
+        end
+
+        stream.unfiltered_data.dup.force_encoding(Encoding::BINARY)
+      end
+    end
+  end
+end

data/lib/facturx/pdf/inspector.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'document'
+
+module Facturx
+  module Pdf
+    class Inspector
+      Result = Data.define(:page_count)
+
+      def call(pdf)
+        document = Document.open(pdf, reject_signed: true)
+
+        Result.new(page_count: document.page_count)
+      end
+    end
+  end
+end

data/lib/facturx/pdf/name_tree.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Facturx
+  module Pdf
+    class NameTree
+      def initialize(document)
+        @document = document
+      end
+
+      def call
+        names = objects.deref_hash(document.catalog[:Names])
+        root = names && names[:EmbeddedFiles]
+        root ? collect(root, {}) : []
+      end
+
+      private
+
+      attr_reader :document
+
+      def objects
+        document.objects
+      end
+
+      def collect(reference, visited)
+        key = reference_key(reference)
+        visit!(visited, key)
+        node = objects.deref_hash(reference) || invalid_tree!
+
+        entries(node[:Names]) + children(node).flat_map { |child| collect(child, visited) }
+      ensure
+        visited.delete(key)
+      end
+
+      def entries(reference)
+        return [] unless reference
+
+        names = objects.deref_array(reference)
+        invalid_tree! unless names&.length&.even?
+        names.each_slice(2).map { |tree_name, file_specification| [tree_name, file_specification] }
+      end
+
+      def children(node)
+        objects.deref_array(node[:Kids]) || []
+      end
+
+      def visit!(visited, key)
+        invalid_tree!('Embedded files name tree contains a cycle') if visited.key?(key)
+        visited[key] = true
+      end
+
+      def reference_key(reference)
+        reference.is_a?(PDF::Reader::Reference) ? [reference.id, reference.gen] : reference.object_id
+      end
+
+      def invalid_tree!(message = 'Embedded files name tree is invalid')
+        raise ExtractionError.new(message, reason: :invalid_name_tree)
+      end
+    end
+  end
+end

data/lib/facturx/pdf/verifier.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'digest'
+
+require_relative '../embedding'
+require_relative '../error'
+
+module Facturx
+  module Pdf
+    class Verifier
+      PDFA_NAMESPACE = 'http://www.aiim.org/pdfa/ns/id/'
+      RDF_NAMESPACE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
+      XMP_META_NAMESPACE = 'adobe:ns:meta/'
+      XMP_NAMESPACES = {
+        'fx' => FACTURX_EMBEDDING.xmp_namespace,
+        'pdfaid' => PDFA_NAMESPACE,
+        'rdf' => RDF_NAMESPACE,
+        'x' => XMP_META_NAMESPACE
+      }.freeze
+      DESCRIPTION_XPATH = '/x:xmpmeta/rdf:RDF/rdf:Description'
+      XMPField = Data.define(:xpath, :expected)
+      XMP_FIELDS = {
+        pdfa_part: XMPField.new(
+          xpath: "#{DESCRIPTION_XPATH}/pdfaid:part | " \
+                 "#{DESCRIPTION_XPATH}/@pdfaid:part",
+          expected: '3'
+        ),
+        pdfa_conformance: XMPField.new(
+          xpath: "#{DESCRIPTION_XPATH}/pdfaid:conformance | " \
+                 "#{DESCRIPTION_XPATH}/@pdfaid:conformance",
+          expected: 'B'
+        ),
+        document_filename: XMPField.new(
+          xpath: "#{DESCRIPTION_XPATH}/fx:DocumentFileName", expected: FACTURX_EMBEDDING.filename
+        ),
+        document_type: XMPField.new(
+          xpath: "#{DESCRIPTION_XPATH}/fx:DocumentType", expected: FACTURX_EMBEDDING.document_type
+        ),
+        facturx_version: XMPField.new(
+          xpath: "#{DESCRIPTION_XPATH}/fx:Version", expected: FACTURX_EMBEDDING.version
+        )
+      }.freeze
+      CONFORMANCE_LEVEL_XPATH = "#{DESCRIPTION_XPATH}/fx:ConformanceLevel".freeze
+      private_constant :XMPField
+
+      def call(result:, expected_xml:, expected_page_count:, profile:)
+        verify_result!(result, expected_xml, expected_page_count)
+        xmp = parse_xmp(result.metadata)
+        verify_xmp!(xmp, profile)
+      end
+
+      private
+
+      def verify_xmp!(xmp, profile)
+        XMP_FIELDS.each do |field, definition|
+          verify_xmp_value!(xmp, field, definition.xpath, definition.expected)
+        end
+        verify_xmp_value!(xmp, :facturx_conformance_level, CONFORMANCE_LEVEL_XPATH, profile.conformance_level)
+      end
+
+      def verify_result!(result, expected_xml, expected_page_count)
+        verify_xml!(result.xml, expected_xml)
+        verify_value!(:filename, result.filename, FACTURX_EMBEDDING.filename)
+        verify_value!(:relationship, result.relationship, FACTURX_EMBEDDING.relationship)
+        verify_value!(:page_count, result.page_count, expected_page_count)
+      end
+
+      def verify_xml!(actual, expected)
+        unless actual.is_a?(String) && expected.is_a?(String)
+          raise VerificationError.new('PDF verification input is invalid', reason: :invalid_input, field: :xml)
+        end
+        return if actual.b == expected.b
+
+        raise VerificationError.new('Composed PDF does not contain the requested XML bytes',
+                                    reason: :result_mismatch, field: :xml, **xml_details(actual, expected))
+      end
+
+      def xml_details(actual, expected)
+        {
+          expected_sha256: Digest::SHA256.hexdigest(expected),
+          actual_sha256: Digest::SHA256.hexdigest(actual),
+          expected_size: expected.bytesize,
+          actual_size: actual.bytesize
+        }
+      end
+
+      def parse_xmp(metadata)
+        raise VerificationError.new('PDF XMP metadata is missing', reason: :missing_xmp) unless metadata.is_a?(String)
+
+        Nokogiri::XML(metadata) { |config| config.strict.nonet }
+      rescue Nokogiri::XML::SyntaxError => e
+        raise VerificationError.new('PDF XMP metadata is invalid', reason: :invalid_xmp, cause: e.class.name)
+      end
+
+      def verify_xmp_value!(xmp, field, xpath, expected)
+        values = xmp.xpath(xpath, XMP_NAMESPACES).map(&:text)
+        return if values.one? && values.first == expected
+
+        raise VerificationError.new('PDF XMP metadata does not match Factur-X requirements',
+                                    reason: :xmp_mismatch, field:, expected:, actual: xmp_value(values))
+      end
+
+      def xmp_value(values)
+        values.one? ? values.first : values
+      end
+
+      def verify_value!(field, actual, expected)
+        return if actual == expected
+
+        raise VerificationError.new('Composed PDF does not match the requested Factur-X document',
+                                    reason: :result_mismatch, field:, expected:, actual:)
+      end
+    end
+  end
+end

data/lib/facturx/profile.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Facturx
+  Profile = Data.define(:id, :guideline_urn, :xsd_path, :conformance_level)
+end

data/lib/facturx/profiles.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'profile'
+
+module Facturx
+  module Profiles
+    SPECIFICATION_VERSION = '1.09.2'
+    SCHEMA_ROOT = File.expand_path("schema/#{SPECIFICATION_VERSION}", __dir__).freeze
+
+    ALL = [
+      Profile.new(
+        id: :minimum,
+        guideline_urn: 'urn:factur-x.eu:1p0:minimum',
+        xsd_path: File.join(SCHEMA_ROOT, 'minimum/Factur-X_1.09.2_MINIMUM.xsd').freeze,
+        conformance_level: 'MINIMUM'
+      ),
+      Profile.new(
+        id: :basic_wl,
+        guideline_urn: 'urn:factur-x.eu:1p0:basicwl',
+        xsd_path: File.join(SCHEMA_ROOT, 'basic-wl/Factur-X_1.09.2_BASICWL.xsd').freeze,
+        conformance_level: 'BASIC WL'
+      ),
+      Profile.new(
+        id: :basic,
+        guideline_urn: 'urn:cen.eu:en16931:2017#compliant#urn:factur-x.eu:1p0:basic',
+        xsd_path: File.join(SCHEMA_ROOT, 'basic/Factur-X_1.09.2_BASIC.xsd').freeze,
+        conformance_level: 'BASIC'
+      ),
+      Profile.new(
+        id: :en16931,
+        guideline_urn: 'urn:cen.eu:en16931:2017',
+        xsd_path: File.join(SCHEMA_ROOT, 'en16931/Factur-X_1.09.2_EN16931.xsd').freeze,
+        conformance_level: 'EN 16931'
+      ),
+      Profile.new(
+        id: :extended,
+        guideline_urn: 'urn:cen.eu:en16931:2017#conformant#urn:factur-x.eu:1p0:extended',
+        xsd_path: File.join(SCHEMA_ROOT, 'extended/Factur-X_1.09.2_EXTENDED.xsd').freeze,
+        conformance_level: 'EXTENDED'
+      )
+    ].freeze
+
+    BY_ID = ALL.to_h { |profile| [profile.id, profile] }.freeze
+    BY_GUIDELINE_URN = ALL.to_h { |profile| [profile.guideline_urn, profile] }.freeze
+
+    module_function
+
+    def all
+      ALL
+    end
+
+    def fetch(id)
+      BY_ID.fetch(id.to_sym)
+    end
+
+    def for_guideline_urn(guideline_urn)
+      BY_GUIDELINE_URN[guideline_urn]
+    end
+  end
+end

data/lib/facturx/schema/1.09.2/basic/Factur-X_1.09.2_BASIC.xsd

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:rsm="urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    xmlns:qdt="urn:un:unece:uncefact:data:standard:QualifiedDataType:100"
+    xmlns:ram="urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100"
+    xmlns:udt="urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100"
+    targetNamespace="urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100"
+    elementFormDefault="qualified">
+  <xs:import namespace="urn:un:unece:uncefact:data:standard:QualifiedDataType:100" schemaLocation="Factur-X_1.09.2_BASIC_urn_un_unece_uncefact_data_standard_QualifiedDataType_100.xsd"/>
+  <xs:import namespace="urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100" schemaLocation="ReusableAggregateBusinessInformationEntity_100.xsd"/>
+  <xs:import namespace="urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100" schemaLocation="Factur-X_1.09.2_BASIC_urn_un_unece_uncefact_data_standard_UnqualifiedDataType_100.xsd"/>
+  <xs:element name="CrossIndustryInvoice" type="rsm:CrossIndustryInvoiceType"/>
+  <xs:complexType name="CrossIndustryInvoiceType">
+    <xs:sequence>
+      <xs:element name="ExchangedDocumentContext" type="ram:ExchangedDocumentContextType"/>
+      <xs:element name="ExchangedDocument" type="ram:ExchangedDocumentType"/>
+      <xs:element name="SupplyChainTradeTransaction" type="ram:SupplyChainTradeTransactionType"/>
+    </xs:sequence>
+  </xs:complexType>
+</xs:schema>

data/lib/facturx/schema/1.09.2/basic/Factur-X_1.09.2_BASIC_urn_un_unece_uncefact_data_standard_QualifiedDataType_100.xsd

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:qdt="urn:un:unece:uncefact:data:standard:QualifiedDataType:100"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    targetNamespace="urn:un:unece:uncefact:data:standard:QualifiedDataType:100"
+    elementFormDefault="qualified">
+  <xs:simpleType name="AllowanceChargeReasonCodeContentType">
+    <xs:restriction base="xs:token"/>
+  </xs:simpleType>
+  <xs:complexType name="AllowanceChargeReasonCodeType">
+    <xs:simpleContent>
+      <xs:extension base="qdt:AllowanceChargeReasonCodeContentType"/>
+    </xs:simpleContent>
+  </xs:complexType>
+  <xs:simpleType name="CountryIDContentType">
+    <xs:restriction base="xs:token"/>
+  </xs:simpleType>
+  <xs:complexType name="CountryIDType">
+    <xs:simpleContent>
+      <xs:extension base="qdt:CountryIDContentType"/>
+    </xs:simpleContent>
+  </xs:complexType>
+  <xs:simpleType name="CurrencyCodeContentType">
+    <xs:restriction base="xs:token"/>
+  </xs:simpleType>
+  <xs:complexType name="CurrencyCodeType">
+    <xs:simpleContent>
+      <xs:extension base="qdt:CurrencyCodeContentType"/>
+    </xs:simpleContent>
+  </xs:complexType>
+  <xs:simpleType name="DocumentCodeContentType">
+    <xs:restriction base="xs:token"/>
+  </xs:simpleType>
+  <xs:complexType name="DocumentCodeType">
+    <xs:simpleContent>
+      <xs:extension base="qdt:DocumentCodeContentType"/>
+    </xs:simpleContent>
+  </xs:complexType>
+  <xs:simpleType name="FormattedDateTimeFormatContentType">
+    <xs:restriction base="xs:string"/>
+  </xs:simpleType>
+  <xs:complexType name="FormattedDateTimeType">
+    <xs:sequence>
+      <xs:element name="DateTimeString">
+        <xs:complexType>
+          <xs:simpleContent>
+            <xs:extension base="xs:string">
+              <xs:attribute name="format" type="qdt:FormattedDateTimeFormatContentType" use="required"/>
+            </xs:extension>
+          </xs:simpleContent>
+        </xs:complexType>
+      </xs:element>
+    </xs:sequence>
+  </xs:complexType>
+  <xs:simpleType name="PaymentMeansCodeContentType">
+    <xs:restriction base="xs:token"/>
+  </xs:simpleType>
+  <xs:complexType name="PaymentMeansCodeType">
+    <xs:simpleContent>
+      <xs:extension base="qdt:PaymentMeansCodeContentType"/>
+    </xs:simpleContent>
+  </xs:complexType>
+  <xs:simpleType name="TaxCategoryCodeContentType">
+    <xs:restriction base="xs:token"/>
+  </xs:simpleType>
+  <xs:complexType name="TaxCategoryCodeType">
+    <xs:simpleContent>
+      <xs:extension base="qdt:TaxCategoryCodeContentType"/>
+    </xs:simpleContent>
+  </xs:complexType>
+  <xs:simpleType name="TaxTypeCodeContentType">
+    <xs:restriction base="xs:token"/>
+  </xs:simpleType>
+  <xs:complexType name="TaxTypeCodeType">
+    <xs:simpleContent>
+      <xs:extension base="qdt:TaxTypeCodeContentType"/>
+    </xs:simpleContent>
+  </xs:complexType>
+  <xs:simpleType name="TimeReferenceCodeContentType">
+    <xs:restriction base="xs:token"/>
+  </xs:simpleType>
+  <xs:complexType name="TimeReferenceCodeType">
+    <xs:simpleContent>
+      <xs:extension base="qdt:TimeReferenceCodeContentType"/>
+    </xs:simpleContent>
+  </xs:complexType>
+</xs:schema>

data/lib/facturx/schema/1.09.2/basic/Factur-X_1.09.2_BASIC_urn_un_unece_uncefact_data_standard_UnqualifiedDataType_100.xsd

@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:udt="urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    targetNamespace="urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100"
+    elementFormDefault="qualified">
+  <xs:complexType name="AmountType">
+    <xs:simpleContent>
+      <xs:extension base="xs:decimal">
+        <xs:attribute name="currencyID" type="xs:token"/>
+      </xs:extension>
+    </xs:simpleContent>
+  </xs:complexType>
+  <xs:complexType name="CodeType">
+    <xs:simpleContent>
+      <xs:extension base="xs:token"/>
+    </xs:simpleContent>
+  </xs:complexType>
+  <xs:complexType name="DateTimeType">
+    <xs:choice>
+      <xs:element name="DateTimeString">
+        <xs:complexType>
+          <xs:simpleContent>
+            <xs:extension base="xs:string">
+              <xs:attribute name="format" type="xs:string" use="required"/>
+            </xs:extension>
+          </xs:simpleContent>
+        </xs:complexType>
+      </xs:element>
+    </xs:choice>
+  </xs:complexType>
+  <xs:complexType name="IDType">
+    <xs:simpleContent>
+      <xs:extension base="xs:token">
+        <xs:attribute name="schemeID" type="xs:token"/>
+      </xs:extension>
+    </xs:simpleContent>
+  </xs:complexType>
+  <xs:complexType name="IndicatorType">
+    <xs:choice>
+      <xs:element name="Indicator" type="xs:boolean"/>
+    </xs:choice>
+  </xs:complexType>
+  <xs:complexType name="PercentType">
+    <xs:simpleContent>
+      <xs:extension base="xs:decimal"/>
+    </xs:simpleContent>
+  </xs:complexType>
+  <xs:complexType name="QuantityType">
+    <xs:simpleContent>
+      <xs:extension base="xs:decimal">
+        <xs:attribute name="unitCode" type="xs:token"/>
+      </xs:extension>
+    </xs:simpleContent>
+  </xs:complexType>
+  <xs:complexType name="TextType">
+    <xs:simpleContent>
+      <xs:extension base="xs:string"/>
+    </xs:simpleContent>
+  </xs:complexType>
+</xs:schema>