sepa_rator 0.15.0

data/lib/sepa_rator/transaction/credit_transfer_transaction.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module SEPA
+  class CreditTransferTransaction < Transaction
+    include RegulatoryReportingValidator
+
+    attr_accessor :service_level,
+                  :category_purpose,
+                  :charge_bearer,
+                  # PmtInf-level instruction for debtor agent (v09/v13, Max140Text)
+                  :debtor_agent_instruction,
+                  # Transaction-level instruction for debtor agent (Max140Text in v03/v09, InstrInf in v13)
+                  :instruction_for_debtor_agent,
+                  # ExternalDebtorAgentInstruction1Code (v13 only, 1-4 chars)
+                  :instruction_for_debtor_agent_code,
+                  # Array<Hash> of {code:, instruction_info:} for creditor agent instructions
+                  :instructions_for_creditor_agent,
+                  # Array<Hash> of {indicator:, authority:, details: [{type:, date:, country:, code:, amount:, information: []}]}
+                  :regulatory_reportings,
+                  # CreditTransferMandateData1 fields (v13 only)
+                  :credit_transfer_mandate_id,
+                  :credit_transfer_mandate_date_of_signature,
+                  :credit_transfer_mandate_frequency,
+                  :creditor_contact_details
+
+    CHARGE_BEARERS = %w[DEBT CRED SHAR SLEV].freeze
+    EPC_ONLY_SCHEMAS = %w[pain.001.002.03 pain.001.003.03].freeze
+    UETR_SCHEMAS = %w[pain.001.001.09 pain.001.001.13].freeze
+    PMTINF_INSTR_SCHEMAS = %w[pain.001.001.09 pain.001.001.13].freeze
+    MNDT_RLTD_INF_SCHEMAS = %w[pain.001.001.13].freeze
+    INSTRUCTION3_CODES = %w[CHQB HOLD PHOB TELB].freeze
+    FREQUENCY_CODES = %w[YEAR MNTH QURT MIAN WEEK DAIL ADHO INDA FRTN].freeze
+    REGULATORY_INDICATORS = RegulatoryReportingValidator::REGULATORY_INDICATORS
+    # EPC schemas (pain.001.002.03, pain.001.003.03) do not define these elements
+    INSTR_FOR_CDTR_AGT_SCHEMAS = %w[pain.001.001.03 pain.001.001.09 pain.001.001.13 pain.001.001.03.ch.02].freeze
+    TXN_INSTR_FOR_DBTR_AGT_SCHEMAS = %w[pain.001.001.03 pain.001.001.09 pain.001.001.13 pain.001.001.03.ch.02].freeze
+    REGULATORY_REPORTING_SCHEMAS = %w[pain.001.001.03 pain.001.001.09 pain.001.001.13 pain.001.001.03.ch.02].freeze
+
+    validates_inclusion_of :service_level, in: %w[SEPA URGP], allow_nil: true
+    validates_length_of :category_purpose, within: 1..4, allow_nil: true
+    validates_inclusion_of :charge_bearer, in: CHARGE_BEARERS, allow_nil: true
+    validates_address :creditor_address
+
+    convert :debtor_agent_instruction, :instruction_for_debtor_agent,
+            :credit_transfer_mandate_id, to: :text
+
+    validates_length_of :debtor_agent_instruction, within: 1..140, allow_nil: true
+    validates_length_of :instruction_for_debtor_agent, within: 1..140, allow_nil: true
+    validates_length_of :instruction_for_debtor_agent_code, within: 1..4, allow_nil: true
+    validates_length_of :credit_transfer_mandate_id, within: 1..35, allow_nil: true
+    validates_inclusion_of :credit_transfer_mandate_frequency, in: FREQUENCY_CODES, allow_nil: true
+
+    validate do |t|
+      next unless t.creditor_contact_details && !t.creditor_contact_details.valid?
+
+      t.creditor_contact_details.errors.each { |error| t.errors.add(:creditor_contact_details, error.full_message) }
+    end
+    validate { |t| t.validate_requested_date_after(Date.today) }
+    validate :validate_instructions_for_creditor_agent
+    validate :validate_regulatory_reportings
+    validate :validate_credit_transfer_mandate_date_of_signature
+
+    def initialize(attributes = {})
+      super
+      self.service_level ||= 'SEPA' if currency == 'EUR'
+    end
+
+    def credit_transfer_mandate?
+      credit_transfer_mandate_id || credit_transfer_mandate_date_of_signature || credit_transfer_mandate_frequency
+    end
+
+    # Fields (uetr, bic) are already validated as nil-or-non-empty
+    # at add_transaction time, so a nil check is sufficient here.
+    def schema_compatible?(schema_name)
+      return false unless optional_fields_compatible?(schema_name)
+      return false unless instructions_for_creditor_agent_compatible?(schema_name)
+      return false unless regulatory_reportings_compatible?(schema_name)
+
+      case schema_name
+      when PAIN_001_001_03, PAIN_001_001_09, PAIN_001_001_13
+        iso_service_level_compatible?
+      when PAIN_001_002_03
+        bic && !bic.empty? && self.service_level == 'SEPA' && currency == 'EUR'
+      when PAIN_001_003_03
+        currency == 'EUR'
+      when PAIN_001_001_03_CH_02
+        currency == 'CHF'
+      end
+    end
+
+    private
+
+    def optional_fields_compatible?(schema_name)
+      return false if charge_bearer && charge_bearer != 'SLEV' && EPC_ONLY_SCHEMAS.include?(schema_name)
+
+      schema_allows_field?(uetr, UETR_SCHEMAS, schema_name) &&
+        schema_allows_field?(agent_lei, LEI_SCHEMAS, schema_name) &&
+        schema_allows_field?(debtor_agent_instruction, PMTINF_INSTR_SCHEMAS, schema_name) &&
+        schema_allows_field?(credit_transfer_mandate?, MNDT_RLTD_INF_SCHEMAS, schema_name) &&
+        schema_allows_field?(instruction_for_debtor_agent_code, [PAIN_001_001_13], schema_name) &&
+        schema_allows_field?(instruction_for_debtor_agent, TXN_INSTR_FOR_DBTR_AGT_SCHEMAS, schema_name) &&
+        schema_allows_field?(regulatory_reportings&.any?, REGULATORY_REPORTING_SCHEMAS, schema_name)
+    end
+
+    # v13 RegulatoryReporting10 requires DbtCdtRptgInd (indicator) and supports type_proprietary.
+    # v03/v09 StructuredRegulatoryReporting3 uses plain-text Tp, so type_proprietary is incompatible.
+    def regulatory_reportings_compatible?(schema_name)
+      return true unless regulatory_reportings&.any?
+
+      regulatory_reportings.all? { |r| regulatory_reporting_schema_ok?(r, schema_name) }
+    end
+
+    def regulatory_reporting_schema_ok?(reporting, schema_name)
+      return false unless reporting.is_a?(Hash)
+      return false if schema_name == PAIN_001_001_13 && !reporting[:indicator]
+      return false if schema_name != PAIN_001_001_13 && type_proprietary?(reporting)
+
+      true
+    end
+
+    def type_proprietary?(reporting)
+      reporting[:details]&.any? { |d| d.is_a?(Hash) && d[:type_proprietary] }
+    end
+
+    def schema_allows_field?(value, allowed_schemas, schema_name)
+      !value || allowed_schemas.include?(schema_name)
+    end
+
+    def iso_service_level_compatible?
+      !self.service_level || self.service_level == 'URGP' || (self.service_level == 'SEPA' && currency == 'EUR')
+    end
+
+    def validate_instructions_for_creditor_agent
+      return unless instructions_for_creditor_agent
+
+      unless instructions_for_creditor_agent.is_a?(Array)
+        errors.add(:instructions_for_creditor_agent, 'must be an Array')
+        return
+      end
+
+      instructions_for_creditor_agent.each_with_index do |instr, i|
+        unless instr.is_a?(Hash) && (instr[:code] || instr[:instruction_info])
+          errors.add(:instructions_for_creditor_agent, "entry #{i} must have :code and/or :instruction_info")
+          next
+        end
+        if instr[:instruction_info]
+          len = instr[:instruction_info].to_s.length
+          errors.add(:instructions_for_creditor_agent, "entry #{i} instruction_info must be 1-140 characters") unless len.between?(1, 140)
+        end
+      end
+    end
+
+    def validate_credit_transfer_mandate_date_of_signature
+      return unless credit_transfer_mandate_date_of_signature
+      return if credit_transfer_mandate_date_of_signature.is_a?(Date)
+
+      errors.add(:credit_transfer_mandate_date_of_signature, 'is not a Date')
+    end
+
+    def instructions_for_creditor_agent_compatible?(schema_name)
+      return true unless instructions_for_creditor_agent&.any?
+      return false unless INSTR_FOR_CDTR_AGT_SCHEMAS.include?(schema_name)
+
+      instructions_for_creditor_agent.each do |instr|
+        code = instr[:code]
+        next unless code
+
+        case schema_name
+        when PAIN_001_001_03, PAIN_001_001_09, PAIN_001_001_03_CH_02
+          return false unless INSTRUCTION3_CODES.include?(code)
+        when PAIN_001_001_13
+          return false unless code.to_s.length.between?(1, 4)
+        end
+      end
+      true
+    end
+  end
+end

data/lib/sepa_rator/transaction/direct_debit_transaction.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module SEPA
+  class DirectDebitTransaction < Transaction
+    SEQUENCE_TYPES = %w[FRST OOFF RCUR FNAL RPRE].freeze
+    SEQUENCE_TYPES_V1 = %w[FRST OOFF RCUR FNAL].freeze
+    LOCAL_INSTRUMENTS = %w[CORE COR1 B2B].freeze
+
+    attr_accessor :mandate_id,
+                  :mandate_date_of_signature,
+                  :local_instrument,
+                  :sequence_type,
+                  :creditor_account,
+                  :charge_bearer,
+                  :original_mandate_id,
+                  :original_debtor_account,
+                  :same_mandate_new_debtor_agent,
+                  :original_creditor_account,
+                  :debtor_contact_details
+
+    CHARGE_BEARERS = %w[DEBT CRED SHAR SLEV].freeze
+
+    validates_with MandateIdentifierValidator, field_name: :mandate_id, message: 'is invalid'
+    validates_presence_of :mandate_date_of_signature
+    validates_inclusion_of :local_instrument, in: LOCAL_INSTRUMENTS
+    validates_inclusion_of :sequence_type, in: SEQUENCE_TYPES
+    validates_inclusion_of :charge_bearer, in: CHARGE_BEARERS, allow_nil: true
+    validates_address :debtor_address
+    validate do |t|
+      next unless t.debtor_contact_details && !t.debtor_contact_details.valid?
+
+      t.debtor_contact_details.errors.each { |error| t.errors.add(:debtor_contact_details, error.full_message) }
+    end
+    validate { |t| t.validate_requested_date_after(Date.today.next) }
+
+    validate do |t|
+      errors.add(:original_mandate_id, 'is invalid') if original_mandate_id && !original_mandate_id.to_s.match?(MandateIdentifierValidator::REGEX)
+
+      errors.add(:creditor_account, 'is not correct') if creditor_account && !creditor_account.valid?
+
+      if original_debtor_account && !original_debtor_account.to_s.empty?
+        iban_str = original_debtor_account.to_s
+        errors.add(:original_debtor_account, 'is not a valid IBAN') unless
+          IBANTools::IBAN.valid?(iban_str) && iban_str.match?(IBANValidator::REGEX)
+      end
+
+      if t.mandate_date_of_signature.is_a?(Date)
+        errors.add(:mandate_date_of_signature, 'is in the future') if t.mandate_date_of_signature > Date.today
+      else
+        errors.add(:mandate_date_of_signature, 'is not a Date')
+      end
+    end
+
+    def initialize(attributes = {})
+      super
+      self.local_instrument ||= 'CORE'
+      self.sequence_type ||= 'OOFF'
+
+      return unless local_instrument == 'COR1'
+
+      warn '[SEPA] COR1 local instrument is deprecated since November 2017. Use CORE instead.'
+    end
+
+    def amendment_informations?
+      original_mandate_id || original_debtor_account || same_mandate_new_debtor_agent || original_creditor_account
+    end
+
+    UETR_SCHEMAS = %w[pain.008.001.08 pain.008.001.12].freeze
+
+    # Fields (uetr, instruction_priority, bic) are already validated as nil-or-non-empty
+    # at add_transaction time, so a nil check is sufficient here.
+    def schema_compatible?(schema_name)
+      return false unless optional_fields_schema_compatible?(schema_name)
+
+      case schema_name
+      when PAIN_008_001_02
+        SEQUENCE_TYPES_V1.include?(sequence_type)
+      when PAIN_008_002_02
+        epc_v2_compatible?
+      when PAIN_008_003_02
+        epc_compatible? && currency == 'EUR' && SEQUENCE_TYPES_V1.include?(sequence_type)
+      when PAIN_008_001_08, PAIN_008_001_12
+        true
+      end
+    end
+
+    private
+
+    def optional_fields_schema_compatible?(schema_name)
+      !(uetr && !UETR_SCHEMAS.include?(schema_name)) &&
+        !(agent_lei && !LEI_SCHEMAS.include?(schema_name)) &&
+        !(creditor_account&.agent_lei && !LEI_SCHEMAS.include?(schema_name))
+    end
+
+    def epc_v2_compatible?
+      epc_compatible? && bic && !bic.empty? && %w[CORE B2B].include?(local_instrument) &&
+        currency == 'EUR' && SEQUENCE_TYPES_V1.include?(sequence_type)
+    end
+
+    def epc_compatible?
+      !instruction_priority && (!charge_bearer || charge_bearer == 'SLEV')
+    end
+  end
+end

data/lib/sepa_rator/transaction.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module SEPA
+  class Transaction
+    include ActiveModel::Validations
+    include AttributeInitializer
+    extend Converter
+
+    # DSL to declare and validate address fields on subclasses (ISP-compliant).
+    # Each subclass declares only the address it actually uses.
+    def self.validates_address(*fields)
+      fields.each do |field|
+        attr_accessor field
+
+        validate do |t|
+          address = t.public_send(field)
+          next unless address && !address.valid?
+
+          address.errors.each { |error| t.errors.add(field, error.full_message) }
+        end
+      end
+    end
+
+    # Convention SEPA: 1999-01-01 signifies "execute as soon as possible" (ASAP).
+    # When no specific date is requested, this sentinel value tells the bank
+    # to process the payment at the earliest opportunity.
+    DEFAULT_REQUESTED_DATE = Date.new(1999, 1, 1).freeze
+
+    attr_accessor :name,
+                  :iban,
+                  :bic,
+                  :agent_lei,
+                  :amount,
+                  :instruction,
+                  :reference,
+                  :remittance_information,
+                  :requested_date,
+                  :batch_booking,
+                  :currency,
+                  :structured_remittance_information,
+                  :structured_remittance_reference_type,
+                  :structured_remittance_issuer,
+                  :additional_remittance_information,
+                  :uetr,
+                  :instruction_priority,
+                  :purpose_code,
+                  :ultimate_debtor_name,
+                  :ultimate_creditor_name
+
+    convert :name, :instruction, :reference, :remittance_information, :structured_remittance_information,
+            :structured_remittance_reference_type, :structured_remittance_issuer,
+            :purpose_code, :ultimate_debtor_name, :ultimate_creditor_name, to: :text
+    convert :amount, to: :decimal
+
+    validates_length_of :name, within: 1..70
+    validates_format_of :currency, with: /\A[A-Z]{3}\z/
+    validates_inclusion_of :instruction_priority, in: %w[HIGH NORM], allow_nil: true
+    validates_length_of :instruction, within: 1..35, allow_nil: true
+    validates_length_of :reference, within: 1..35, allow_nil: true
+    validates_length_of :remittance_information, within: 1..140, allow_nil: true
+    validates_length_of :structured_remittance_information, within: 1..35, allow_nil: true
+    validates_length_of :structured_remittance_reference_type, within: 1..4, allow_nil: true
+    validates_length_of :structured_remittance_issuer, within: 1..35, allow_nil: true
+    validates_length_of :purpose_code, within: 1..4, allow_nil: true
+    validates_length_of :ultimate_debtor_name, within: 1..70, allow_nil: true
+    validates_length_of :ultimate_creditor_name, within: 1..70, allow_nil: true
+    validates_numericality_of :amount, greater_than: 0, less_than_or_equal_to: 999_999_999.99
+    validates_presence_of :requested_date
+
+    UETR_REGEX = /\A[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}\z/
+    validates_format_of :uetr, with: UETR_REGEX, allow_nil: true
+    validates_inclusion_of :batch_booking, in: [true, false]
+    validates_with BICValidator, IBANValidator, message: 'is invalid'
+    validates_with LEIValidator, field_name: :agent_lei, message: 'is invalid'
+
+    validate do |t|
+      if t.remittance_information && (t.structured_remittance_information || t.additional_remittance_information)
+        t.errors.add(:base, 'remittance_information and structured remittance fields are mutually exclusive')
+      end
+
+      next unless t.additional_remittance_information
+
+      unless t.additional_remittance_information.is_a?(Array) && t.additional_remittance_information.length <= 3
+        t.errors.add(:additional_remittance_information, 'must be an Array with at most 3 items')
+        next
+      end
+
+      t.additional_remittance_information.each_with_index do |info, i|
+        t.errors.add(:additional_remittance_information, "entry #{i} exceeds 140 characters") if info.to_s.length > 140
+      end
+    end
+
+    def initialize(attributes = {})
+      super
+      self.requested_date ||= DEFAULT_REQUESTED_DATE
+      self.reference ||= 'NOTPROVIDED'
+      self.batch_booking = true if batch_booking.nil?
+      self.currency ||= 'EUR'
+    end
+
+    protected
+
+    # NOTE: This validation only checks that the date is not in the past.
+    # It does NOT validate against the TARGET2 business calendar (weekends, holidays).
+    # Callers should ensure the requested date falls on a TARGET2 business day.
+    def validate_requested_date_after(min_requested_date)
+      return unless requested_date.is_a?(Date)
+
+      return unless requested_date != DEFAULT_REQUESTED_DATE && requested_date < min_requested_date
+
+      errors.add(:requested_date, "must be greater or equal to #{min_requested_date}, or nil")
+    end
+  end
+end

data/lib/sepa_rator/validator.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module SEPA
+  class IBANValidator < ActiveModel::Validator
+    # IBAN2007Identifier (taken from schema)
+    REGEX = /\A[A-Z]{2,2}[0-9]{2,2}[a-zA-Z0-9]{1,30}\z/
+
+    def validate(record)
+      field_name = options[:field_name] || :iban
+      value = record.public_send(field_name).to_s
+
+      return if IBANTools::IBAN.valid?(value) && value.match?(REGEX)
+
+      record.errors.add(field_name, :invalid, message: options[:message])
+    end
+  end
+
+  class BICValidator < ActiveModel::Validator
+    # AnyBICIdentifier (pain.001.001.03 and earlier schemas)
+    V03_REGEX = /\A[A-Z]{6,6}[A-Z2-9][A-NP-Z0-9]([A-Z0-9]{3,3}){0,1}\z/
+    # BICFIDec2014Identifier (pain.001.001.09 / .13 and pain.008.001.08 / .12)
+    V09_REGEX = /\A[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}\z/
+
+    REGEX = V03_REGEX
+
+    def validate(record)
+      field_name = options[:field_name] || :bic
+      value = record.public_send(field_name)
+
+      return unless value
+      return if value.to_s.match?(V03_REGEX) || value.to_s.match?(V09_REGEX)
+
+      record.errors.add(field_name, :invalid, message: options[:message])
+    end
+  end
+
+  class CreditorIdentifierValidator < ActiveModel::Validator
+    REGEX = %r{\A
+      [a-zA-Z]{2}                 # ISO country code
+      [0-9]{2}                    # Check digits
+      [A-Za-z0-9]{3}              # Creditor business code
+      [A-Za-z0-9+?/:().,'-]{1,28} # National identifier
+    \z}x
+
+    def validate(record)
+      field_name = options[:field_name] || :creditor_identifier
+      value = record.public_send(field_name)
+
+      return if valid?(value)
+
+      record.errors.add(field_name, :invalid, message: options[:message])
+    end
+
+    def valid?(creditor_identifier)
+      return false unless creditor_identifier.to_s.match?(REGEX)
+
+      # In Germany, the identifier has to be exactly 18 chars long
+      return false if creditor_identifier[0..1].match?(/DE/i) && creditor_identifier.length != 18
+
+      # Verify mod-97 check digit (ISO 7064)
+      # Structure: CC DD BBB NNNN...
+      # CC = country code, DD = check digits, BBB = business code (skipped), N = national id
+      # Strip non-alphanumeric chars from national id before check (the spec allows +?/:().,'-
+      # but they are ignored for mod-97 computation)
+      check_base = creditor_identifier[0..3] + creditor_identifier[7..].gsub(/[^A-Za-z0-9]/, '')
+      rearranged = check_base[4..] + check_base[0..3]
+      numeric = rearranged.gsub(/[A-Z]/i) { |c| c.upcase.ord - 55 }
+      numeric.to_i % 97 == 1
+    end
+  end
+
+  class MandateIdentifierValidator < ActiveModel::Validator
+    REGEX = %r{\A[A-Za-z0-9 +?/:().,'-]{1,35}\z}
+
+    def validate(record)
+      field_name = options[:field_name] || :mandate_id
+      value = record.public_send(field_name)
+
+      return if value.to_s.match?(REGEX)
+
+      record.errors.add(field_name, :invalid, message: options[:message])
+    end
+  end
+
+  class LEIValidator < ActiveModel::Validator
+    # LEIIdentifier (ISO 17442): 18 alphanumeric + 2 check digits
+    REGEX = /\A[A-Z0-9]{18}[0-9]{2}\z/
+
+    def validate(record)
+      field_name = options[:field_name] || :lei
+      value = record.public_send(field_name)
+
+      return unless value
+      return if value.to_s.match?(REGEX)
+
+      record.errors.add(field_name, :invalid, message: options[:message])
+    end
+  end
+end

data/lib/sepa_rator/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SEPA
+  VERSION = '0.15.0'
+end

data/lib/sepa_rator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'bigdecimal'
+require 'nokogiri'
+require 'iban-tools'
+
+require 'sepa_rator/error'
+require 'sepa_rator/converter'
+require 'sepa_rator/validator'
+require 'sepa_rator/concerns/attribute_initializer'
+require 'sepa_rator/concerns/schema_validation'
+require 'sepa_rator/concerns/xml_builder'
+require 'sepa_rator/concerns/regulatory_reporting_validator'
+require 'sepa_rator/account'
+require 'sepa_rator/account/debtor_account'
+require 'sepa_rator/account/address'
+require 'sepa_rator/account/contact_details'
+require 'sepa_rator/account/debtor_address'
+require 'sepa_rator/account/creditor_account'
+require 'sepa_rator/account/creditor_address'
+require 'sepa_rator/transaction'
+require 'sepa_rator/transaction/direct_debit_transaction'
+require 'sepa_rator/transaction/credit_transfer_transaction'
+require 'sepa_rator/message'
+require 'sepa_rator/message/direct_debit'
+require 'sepa_rator/message/credit_transfer'

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: sepa_rator
+version: !ruby/object:Gem::Version
+  version: 0.15.0
+platform: ruby
+authors:
+- Georg Leciejewski
+- Georg Ledermann
+- AdVitam
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: iban-tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.13'
+description: Ruby gem for creating SEPA XML files (ISO 20022). Supports pain.001.001.03/.09/.13
+  and pain.008.001.02/.08/.12.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/schema/pain.001.001.03.ch.02.xsd
+- lib/schema/pain.001.001.03.xsd
+- lib/schema/pain.001.001.09.xsd
+- lib/schema/pain.001.001.13.xsd
+- lib/schema/pain.001.002.03.xsd
+- lib/schema/pain.001.003.03.xsd
+- lib/schema/pain.008.001.02.xsd
+- lib/schema/pain.008.001.08.xsd
+- lib/schema/pain.008.001.12.xsd
+- lib/schema/pain.008.002.02.xsd
+- lib/schema/pain.008.003.02.xsd
+- lib/sepa_rator.rb
+- lib/sepa_rator/account.rb
+- lib/sepa_rator/account/address.rb
+- lib/sepa_rator/account/contact_details.rb
+- lib/sepa_rator/account/creditor_account.rb
+- lib/sepa_rator/account/creditor_address.rb
+- lib/sepa_rator/account/debtor_account.rb
+- lib/sepa_rator/account/debtor_address.rb
+- lib/sepa_rator/concerns/attribute_initializer.rb
+- lib/sepa_rator/concerns/regulatory_reporting_validator.rb
+- lib/sepa_rator/concerns/schema_validation.rb
+- lib/sepa_rator/concerns/xml_builder.rb
+- lib/sepa_rator/converter.rb
+- lib/sepa_rator/error.rb
+- lib/sepa_rator/message.rb
+- lib/sepa_rator/message/credit_transfer.rb
+- lib/sepa_rator/message/direct_debit.rb
+- lib/sepa_rator/transaction.rb
+- lib/sepa_rator/transaction/credit_transfer_transaction.rb
+- lib/sepa_rator/transaction/direct_debit_transaction.rb
+- lib/sepa_rator/validator.rb
+- lib/sepa_rator/version.rb
+homepage: https://github.com/AdVitam/sepa_rator
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/AdVitam/sepa_rator
+  changelog_uri: https://github.com/AdVitam/sepa_rator/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/AdVitam/sepa_rator/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Ruby gem for creating SEPA XML files
+test_files: []