sepa_rator 0.15.0

data/lib/sepa_rator/message/credit_transfer.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module SEPA
+  CreditTransferGroup = Data.define(:requested_date, :batch_booking, :service_level, :category_purpose,
+                                    :instruction_priority, :charge_bearer, :debtor_agent_instruction)
+
+  class CreditTransfer < Message
+    self.account_class = DebtorAccount
+    self.transaction_class = CreditTransferTransaction
+    self.xml_main_tag = 'CstmrCdtTrfInitn'
+    self.known_schemas = [PAIN_001_001_03, PAIN_001_001_03_CH_02, PAIN_001_001_09, PAIN_001_001_13, PAIN_001_003_03, PAIN_001_002_03]
+
+    private
+
+    # Find groups of transactions which share the same values of some attributes
+    def transaction_group(transaction)
+      CreditTransferGroup.new(
+        requested_date: transaction.requested_date,
+        batch_booking: transaction.batch_booking,
+        service_level: transaction.service_level,
+        category_purpose: transaction.category_purpose,
+        instruction_priority: transaction.instruction_priority,
+        charge_bearer: transaction.charge_bearer || (transaction.service_level ? 'SLEV' : nil),
+        debtor_agent_instruction: transaction.debtor_agent_instruction
+      )
+    end
+
+    def build_payment_informations(builder, schema_name)
+      grouped_transactions.each do |group, transactions|
+        builder.PmtInf do
+          builder.PmtInfId(payment_information_identification(group))
+          builder.PmtMtd('TRF')
+          builder.BtchBookg(group.batch_booking)
+          builder.NbOfTxs(transactions.length)
+          builder.CtrlSum(format_amount(amount_total(transactions)))
+          build_payment_type_information(builder, group)
+          build_requested_execution_date(builder, group, schema_name)
+          build_debtor_info(builder, schema_name)
+          build_pmtinf_debtor_agent_instruction(builder, group, schema_name)
+          builder.ChrgBr(group.charge_bearer) if group.charge_bearer
+
+          transactions.each { |transaction| build_transaction(builder, transaction, schema_name) }
+        end
+      end
+    end
+
+    def build_payment_type_information(builder, group)
+      return unless group.service_level || group.category_purpose || group.instruction_priority
+
+      builder.PmtTpInf do
+        builder.InstrPrty(group.instruction_priority) if group.instruction_priority
+        if group.service_level
+          builder.SvcLvl do
+            builder.Cd(group.service_level)
+          end
+        end
+        if group.category_purpose
+          builder.CtgyPurp do
+            builder.Cd(group.category_purpose)
+          end
+        end
+      end
+    end
+
+    def build_requested_execution_date(builder, group, schema_name)
+      if schema_features(schema_name)[:wrap_date]
+        builder.ReqdExctnDt do
+          builder.Dt(group.requested_date.iso8601)
+        end
+      else
+        builder.ReqdExctnDt(group.requested_date.iso8601)
+      end
+    end
+
+    def build_debtor_info(builder, schema_name)
+      builder.Dbtr do
+        builder.Nm(account.name)
+        build_postal_address(builder, account.address) if account.address
+        build_contact_details(builder, account.contact_details)
+      end
+      build_iban_account(builder, :DbtrAcct, account.iban)
+      builder.DbtrAgt do
+        build_agent_bic(builder, account.bic, schema_name,
+                        fallback: !schema_features(schema_name)[:swiss],
+                        lei: account.agent_lei)
+      end
+    end
+
+    # InstrForDbtrAgt at PmtInf level (v09/v13 only, Max140Text)
+    def build_pmtinf_debtor_agent_instruction(builder, group, schema_name)
+      return unless CreditTransferTransaction::PMTINF_INSTR_SCHEMAS.include?(schema_name) && group.debtor_agent_instruction
+
+      builder.InstrForDbtrAgt(group.debtor_agent_instruction)
+    end
+
+    # XSD element order: PmtId > Amt > [MndtRltdInf v13] > [UltmtDbtr] > [CdtrAgt] > [Cdtr] >
+    #   [CdtrAcct] > [UltmtCdtr] > [InstrForCdtrAgt] > [InstrForDbtrAgt] > [Purp] > [RgltryRptg] > [RmtInf]
+    def build_transaction(builder, transaction, schema_name)
+      builder.CdtTrfTxInf do
+        build_payment_identification(builder, transaction)
+        builder.Amt do
+          builder.InstdAmt(format_amount(transaction.amount), Ccy: transaction.currency)
+        end
+        build_credit_transfer_mandate(builder, transaction, schema_name)
+        build_ultimate_party(builder, :UltmtDbtr, transaction.ultimate_debtor_name)
+        if transaction.bic || transaction.agent_lei
+          builder.CdtrAgt do
+            build_agent_bic(builder, transaction.bic, schema_name, fallback: false, lei: transaction.agent_lei)
+          end
+        end
+        builder.Cdtr do
+          builder.Nm(transaction.name)
+          build_postal_address(builder, transaction.creditor_address) if transaction.creditor_address
+          build_contact_details(builder, transaction.creditor_contact_details)
+        end
+        build_iban_account(builder, :CdtrAcct, transaction.iban)
+        build_ultimate_party(builder, :UltmtCdtr, transaction.ultimate_creditor_name)
+        build_instructions_for_creditor_agent(builder, transaction)
+        build_txn_instruction_for_debtor_agent(builder, transaction, schema_name)
+        build_purpose(builder, transaction.purpose_code)
+        build_regulatory_reportings(builder, transaction, schema_name)
+        build_remittance_information(builder, transaction)
+      end
+    end
+
+    # MndtRltdInf — CreditTransferMandateData1 (v13 only)
+    def build_credit_transfer_mandate(builder, transaction, schema_name)
+      return unless CreditTransferTransaction::MNDT_RLTD_INF_SCHEMAS.include?(schema_name) && transaction.credit_transfer_mandate?
+
+      builder.MndtRltdInf do
+        builder.MndtId(transaction.credit_transfer_mandate_id) if transaction.credit_transfer_mandate_id
+        builder.DtOfSgntr(transaction.credit_transfer_mandate_date_of_signature.iso8601) if transaction.credit_transfer_mandate_date_of_signature
+        builder.Frqcy { builder.Tp(transaction.credit_transfer_mandate_frequency) } if transaction.credit_transfer_mandate_frequency
+      end
+    end
+
+    # InstrForCdtrAgt — unbounded, same XML structure for all versions
+    def build_instructions_for_creditor_agent(builder, transaction)
+      return unless transaction.instructions_for_creditor_agent
+
+      transaction.instructions_for_creditor_agent.each do |instr|
+        builder.InstrForCdtrAgt do
+          builder.Cd(instr[:code]) if instr[:code]
+          builder.InstrInf(instr[:instruction_info]) if instr[:instruction_info]
+        end
+      end
+    end
+
+    # InstrForDbtrAgt at transaction level — text (v03/v09) or structured (v13)
+    def build_txn_instruction_for_debtor_agent(builder, transaction, schema_name)
+      return unless transaction.instruction_for_debtor_agent || transaction.instruction_for_debtor_agent_code
+
+      if schema_features(schema_name)[:instr_for_dbtr_agt_format] == :structured
+        builder.InstrForDbtrAgt do
+          builder.Cd(transaction.instruction_for_debtor_agent_code) if transaction.instruction_for_debtor_agent_code
+          builder.InstrInf(transaction.instruction_for_debtor_agent) if transaction.instruction_for_debtor_agent
+        end
+      elsif transaction.instruction_for_debtor_agent
+        builder.InstrForDbtrAgt(transaction.instruction_for_debtor_agent)
+      end
+    end
+
+    # RgltryRptg — RegulatoryReporting3 (v03/v09) or RegulatoryReporting10 (v13)
+    def build_regulatory_reportings(builder, transaction, schema_name)
+      return unless transaction.regulatory_reportings
+
+      version = schema_features(schema_name)[:regulatory_reporting_version]
+
+      transaction.regulatory_reportings.each do |reporting|
+        builder.RgltryRptg do
+          builder.DbtCdtRptgInd(reporting[:indicator]) if reporting[:indicator]
+          build_regulatory_authority(builder, reporting[:authority])
+          reporting[:details]&.each do |detail|
+            builder.Dtls do
+              # XSD sequence: Tp → Dt → Ctry → Cd/RptgCd → Amt → Inf
+              build_regulatory_detail_type(builder, detail, version)
+              builder.Dt(detail[:date].iso8601) if detail[:date]
+              builder.Ctry(detail[:country]) if detail[:country]
+              code_tag = version == :v10 ? :RptgCd : :Cd
+              builder.__send__(code_tag, detail[:code]) if detail[:code]
+              build_regulatory_detail_amount(builder, detail[:amount])
+              Array(detail[:information]).each { |inf| builder.Inf(inf) }
+            end
+          end
+        end
+      end
+    end
+
+    def build_regulatory_authority(builder, authority)
+      return unless authority
+
+      builder.Authrty do
+        builder.Nm(authority[:name]) if authority[:name]
+        builder.Ctry(authority[:country]) if authority[:country]
+      end
+    end
+
+    def build_regulatory_detail_type(builder, detail, version)
+      return unless detail[:type] || detail[:type_proprietary]
+
+      if version == :v10
+        builder.Tp do
+          detail[:type_proprietary] ? builder.Prtry(detail[:type_proprietary]) : builder.Cd(detail[:type])
+        end
+      elsif detail[:type]
+        builder.Tp(detail[:type])
+      end
+    end
+
+    # ActiveOrHistoricCurrencyAndAmount allows up to 5 fractional digits (unlike payment amounts at 2).
+    def build_regulatory_detail_amount(builder, amount)
+      return unless amount
+
+      decimal = BigDecimal(amount[:value].to_s).truncate(5)
+      # Ensure at least 2 fractional digits, up to 5 (ActiveOrHistoricCurrencyAndAmount)
+      frac_digits = [decimal.to_s('F').split('.').last&.length.to_i, 2].max
+      value = format("%.#{frac_digits}f", decimal)
+      builder.Amt(value, Ccy: amount[:currency])
+    end
+  end
+end

data/lib/sepa_rator/message/direct_debit.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module SEPA
+  DirectDebitGroup = Data.define(:requested_date, :local_instrument, :sequence_type, :batch_booking, :account, :instruction_priority, :charge_bearer)
+
+  class DirectDebit < Message
+    self.account_class = CreditorAccount
+    self.transaction_class = DirectDebitTransaction
+    self.xml_main_tag = 'CstmrDrctDbtInitn'
+    self.known_schemas = [PAIN_008_001_02, PAIN_008_001_08, PAIN_008_001_12, PAIN_008_003_02, PAIN_008_002_02]
+
+    validate do |record|
+      errors.add(:base, 'CORE, COR1 AND B2B must not be mixed in one message!') if record.transactions.map(&:local_instrument).uniq.size > 1
+    end
+
+    private
+
+    # Find groups of transactions which share the same values of some attributes
+    def transaction_group(transaction)
+      DirectDebitGroup.new(
+        requested_date: transaction.requested_date,
+        local_instrument: transaction.local_instrument,
+        sequence_type: transaction.sequence_type,
+        batch_booking: transaction.batch_booking,
+        account: transaction.creditor_account || account,
+        instruction_priority: transaction.instruction_priority,
+        charge_bearer: transaction.charge_bearer || 'SLEV'
+      )
+    end
+
+    def build_payment_informations(builder, schema_name)
+      grouped_transactions.each do |group, transactions|
+        builder.PmtInf do
+          builder.PmtInfId(payment_information_identification(group))
+          builder.PmtMtd('DD')
+          builder.BtchBookg(group.batch_booking)
+          builder.NbOfTxs(transactions.length)
+          builder.CtrlSum(format_amount(amount_total(transactions)))
+          build_payment_type_information(builder, group)
+          build_creditor_info(builder, group, schema_name)
+          build_creditor_scheme_identification(builder, group)
+
+          transactions.each { |transaction| build_transaction(builder, transaction, schema_name) }
+        end
+      end
+    end
+
+    def build_payment_type_information(builder, group)
+      builder.PmtTpInf do
+        builder.InstrPrty(group.instruction_priority) if group.instruction_priority
+        builder.SvcLvl do
+          builder.Cd('SEPA')
+        end
+        builder.LclInstrm do
+          builder.Cd(group.local_instrument)
+        end
+        builder.SeqTp(group.sequence_type)
+      end
+    end
+
+    def build_creditor_info(builder, group, schema_name)
+      builder.ReqdColltnDt(group.requested_date.iso8601)
+      builder.Cdtr do
+        builder.Nm(group.account.name)
+        build_postal_address(builder, group.account.address) if group.account.address
+        build_contact_details(builder, group.account.contact_details)
+      end
+      build_iban_account(builder, :CdtrAcct, group.account.iban)
+      builder.CdtrAgt do
+        build_agent_bic(builder, group.account.bic, schema_name, lei: group.account.agent_lei)
+      end
+      builder.ChrgBr(group.charge_bearer)
+    end
+
+    def build_creditor_scheme_identification(builder, group)
+      builder.CdtrSchmeId do
+        builder.Id do
+          builder.PrvtId do
+            builder.Othr do
+              builder.Id(group.account.creditor_identifier)
+              builder.SchmeNm do
+                builder.Prtry('SEPA')
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def build_amendment_informations(builder, transaction)
+      builder.AmdmntInd(true)
+      builder.AmdmntInfDtls do
+        builder.OrgnlMndtId(transaction.original_mandate_id) if transaction.original_mandate_id
+
+        if transaction.original_debtor_account
+          build_iban_account(builder, :OrgnlDbtrAcct, transaction.original_debtor_account)
+        elsif transaction.same_mandate_new_debtor_agent
+          builder.OrgnlDbtrAgt do
+            builder.FinInstnId do
+              builder.Othr do
+                builder.Id('SMNDA')
+              end
+            end
+          end
+        end
+        if transaction.original_creditor_account
+          builder.OrgnlCdtrSchmeId do
+            builder.Nm(transaction.original_creditor_account.name) if transaction.original_creditor_account.name
+            if transaction.original_creditor_account.creditor_identifier
+              builder.Id do
+                builder.PrvtId do
+                  builder.Othr do
+                    builder.Id(transaction.original_creditor_account.creditor_identifier)
+                    builder.SchmeNm do
+                      builder.Prtry('SEPA')
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def build_transaction(builder, transaction, schema_name)
+      builder.DrctDbtTxInf do
+        build_payment_identification(builder, transaction)
+        builder.InstdAmt(format_amount(transaction.amount), Ccy: transaction.currency)
+        builder.DrctDbtTx do
+          builder.MndtRltdInf do
+            builder.MndtId(transaction.mandate_id)
+            builder.DtOfSgntr(transaction.mandate_date_of_signature.iso8601)
+            build_amendment_informations(builder, transaction) if transaction.amendment_informations?
+          end
+        end
+        build_ultimate_party(builder, :UltmtCdtr, transaction.ultimate_creditor_name)
+        builder.DbtrAgt do
+          build_agent_bic(builder, transaction.bic, schema_name, lei: transaction.agent_lei)
+        end
+        builder.Dbtr do
+          builder.Nm(transaction.name)
+          build_postal_address(builder, transaction.debtor_address) if transaction.debtor_address
+          build_contact_details(builder, transaction.debtor_contact_details)
+        end
+        build_iban_account(builder, :DbtrAcct, transaction.iban)
+        build_ultimate_party(builder, :UltmtDbtr, transaction.ultimate_debtor_name)
+        build_purpose(builder, transaction.purpose_code)
+        build_remittance_information(builder, transaction)
+      end
+    end
+  end
+end

data/lib/sepa_rator/message.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module SEPA
+  PAIN_008_001_02 = 'pain.008.001.02'
+  PAIN_008_001_08 = 'pain.008.001.08'
+  PAIN_008_001_12 = 'pain.008.001.12'
+  PAIN_008_002_02 = 'pain.008.002.02'
+  PAIN_008_003_02 = 'pain.008.003.02'
+  PAIN_001_001_03 = 'pain.001.001.03'
+  PAIN_001_001_09 = 'pain.001.001.09'
+  PAIN_001_001_13 = 'pain.001.001.13'
+  PAIN_001_002_03 = 'pain.001.002.03'
+  PAIN_001_003_03 = 'pain.001.003.03'
+  PAIN_001_001_03_CH_02 = 'pain.001.001.03.ch.02'
+
+  SCHEMA_FEATURES = {
+    PAIN_001_001_03 => { bic_tag: :BIC,   wrap_date: false, swiss: false, requires_bic: false,
+                         org_bic_tag: :BICOrBEI, instr_for_dbtr_agt_format: :text, regulatory_reporting_version: :v3 },
+    PAIN_001_001_09 => { bic_tag: :BICFI, wrap_date: true,  swiss: false, requires_bic: false,
+                         org_bic_tag: :AnyBIC, instr_for_dbtr_agt_format: :text, regulatory_reporting_version: :v3 },
+    PAIN_001_001_13 => { bic_tag: :BICFI, wrap_date: true,  swiss: false, requires_bic: false,
+                         org_bic_tag: :AnyBIC, instr_for_dbtr_agt_format: :structured, regulatory_reporting_version: :v10 },
+    PAIN_001_002_03 => { bic_tag: :BIC,   wrap_date: false, swiss: false, requires_bic: true,
+                         org_bic_tag: :BICOrBEI, instr_for_dbtr_agt_format: :text, regulatory_reporting_version: :v3 },
+    PAIN_001_003_03 => { bic_tag: :BIC,   wrap_date: false, swiss: false, requires_bic: false,
+                         org_bic_tag: :BICOrBEI, instr_for_dbtr_agt_format: :text, regulatory_reporting_version: :v3 },
+    PAIN_001_001_03_CH_02 => { bic_tag: :BIC, wrap_date: false, swiss: true, requires_bic: false,
+                               org_bic_tag: :BICOrBEI, instr_for_dbtr_agt_format: :text, regulatory_reporting_version: :v3 },
+    PAIN_008_001_02 => { bic_tag: :BIC,   wrap_date: false, swiss: false, requires_bic: false,
+                         org_bic_tag: :BICOrBEI, instr_for_dbtr_agt_format: :text, regulatory_reporting_version: :v3 },
+    PAIN_008_001_08 => { bic_tag: :BICFI, wrap_date: false, swiss: false, requires_bic: false,
+                         org_bic_tag: :AnyBIC, instr_for_dbtr_agt_format: :text, regulatory_reporting_version: :v3 },
+    PAIN_008_001_12 => { bic_tag: :BICFI, wrap_date: false, swiss: false, requires_bic: false,
+                         org_bic_tag: :AnyBIC, instr_for_dbtr_agt_format: :text, regulatory_reporting_version: :v3 },
+    PAIN_008_002_02 => { bic_tag: :BIC,   wrap_date: false, swiss: false, requires_bic: true,
+                         org_bic_tag: :BICOrBEI, instr_for_dbtr_agt_format: :text, regulatory_reporting_version: :v3 },
+    PAIN_008_003_02 => { bic_tag: :BIC,   wrap_date: false, swiss: false, requires_bic: false,
+                         org_bic_tag: :BICOrBEI, instr_for_dbtr_agt_format: :text, regulatory_reporting_version: :v3 }
+  }.each_value(&:freeze).freeze
+
+  # Schemas that support LEI (Legal Entity Identifier) in FinInstnId and OrgId
+  LEI_SCHEMAS = [PAIN_001_001_09, PAIN_001_001_13, PAIN_008_001_08, PAIN_008_001_12].freeze
+
+  # Element order follows PostalAddress27 XSD sequence (the superset).
+  # Fields absent in older schemas are rejected by XSD validation.
+  POSTAL_ADDRESS_FIELDS = [
+    %i[CareOf care_of],
+    %i[Dept department],
+    %i[SubDept sub_department],
+    %i[StrtNm street_name],
+    %i[BldgNb building_number],
+    %i[BldgNm building_name],
+    %i[Flr floor],
+    %i[UnitNb unit_number],
+    %i[PstBx post_box],
+    %i[Room room],
+    %i[PstCd post_code],
+    %i[TwnNm town_name],
+    %i[TwnLctnNm town_location_name],
+    %i[DstrctNm district_name],
+    %i[CtrySubDvsn country_sub_division],
+    %i[Ctry country_code],
+    %i[AdrLine address_line1],
+    %i[AdrLine address_line2]
+  ].freeze
+
+  # Element order follows Contact13 XSD sequence (the superset).
+  # Fields absent in older schemas are rejected by XSD validation.
+  # Othr (OtherContact1) and PrefrdMtd are handled separately (complex/enum structures).
+  CONTACT_DETAILS_FIELDS = [
+    %i[NmPrfx name_prefix],
+    %i[Nm name],
+    %i[PhneNb phone_number],
+    %i[MobNb mobile_number],
+    %i[FaxNb fax_number],
+    %i[URLAdr url_address],
+    %i[EmailAdr email_address],
+    %i[EmailPurp email_purpose],
+    %i[JobTitl job_title],
+    %i[Rspnsblty responsibility],
+    %i[Dept department]
+  ].freeze
+
+  class Message
+    include ActiveModel::Validations
+    include SchemaValidation
+    include XmlBuilder
+
+    attr_reader :account, :grouped_transactions
+    attr_accessor :initiation_source_name, :initiation_source_provider
+
+    INITN_SRC_SCHEMAS = [PAIN_001_001_13].freeze
+
+    validates_presence_of :transactions
+    validates_length_of :initiation_source_name, within: 1..140, allow_nil: true
+    validates_length_of :initiation_source_provider, within: 1..35, allow_nil: true
+    validate do |record|
+      record.errors.add(:account, record.account.errors.full_messages) unless record.account.valid?
+    end
+
+    class_attribute :account_class, :transaction_class, :xml_main_tag, :known_schemas, instance_writer: false
+
+    # @param account_options [Hash] attributes for the debtor/creditor account (:name, :iban, :bic)
+    def initialize(account_options = {})
+      @grouped_transactions = {}
+      @account = account_class.new(account_options)
+    end
+
+    # Add a transaction to the message. The transaction is validated immediately.
+    # @param options [Hash] transaction attributes (see {Transaction} subclasses for valid keys)
+    # @raise [SEPA::ValidationError] if the transaction is invalid
+    def add_transaction(options)
+      transaction = transaction_class.new(options)
+      raise SEPA::ValidationError, transaction.errors.full_messages.join("\n") unless transaction.valid?
+
+      group = transaction_group(transaction)
+      @grouped_transactions[group] ||= []
+      @grouped_transactions[group] << transaction
+      @transactions = nil
+    end
+
+    # @return [Array<Transaction>] all transactions across all groups
+    def transactions
+      @transactions ||= grouped_transactions.values.flatten
+    end
+
+    # Generate the SEPA XML document for the given schema.
+    # @param schema_name [String] one of {known_schemas} (defaults to the first)
+    # @return [String] UTF-8 encoded XML
+    # @raise [SEPA::ValidationError] if the message or account is invalid
+    # @raise [SEPA::SchemaValidationError] if transactions are incompatible or XML fails XSD validation
+    def to_xml(schema_name = known_schemas.first)
+      raise SEPA::ValidationError, errors.full_messages.join("\n") unless valid?
+      raise SEPA::SchemaValidationError, "Incompatible with schema #{schema_name}!" unless schema_compatible?(schema_name)
+
+      xml_builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |builder|
+        builder.Document(xml_schema(schema_name)) do
+          builder.__send__(xml_main_tag) do
+            build_group_header(builder, schema_name)
+            build_payment_informations(builder, schema_name)
+          end
+        end
+      end
+
+      validate_final_document!(xml_builder.doc, schema_name)
+      xml_builder.to_xml
+    end
+
+    # @param selected_transactions [Array<Transaction>] subset to sum (defaults to all)
+    # @return [BigDecimal] total amount
+    def amount_total(selected_transactions = transactions)
+      selected_transactions.sum(&:amount)
+    end
+
+    # Check if all transactions are compatible with the given schema.
+    # @param schema_name [String] one of {known_schemas}
+    # @return [Boolean]
+    # @raise [ArgumentError] if the schema is unknown
+    def schema_compatible?(schema_name)
+      raise ArgumentError, "Schema #{schema_name} is unknown!" unless known_schemas.include?(schema_name)
+
+      features = schema_features(schema_name)
+      return false if features[:requires_bic] && (account.bic.nil? || account.bic.empty?)
+      return false if @initiation_source_name && !INITN_SRC_SCHEMAS.include?(schema_name)
+      return false if account.agent_lei && !LEI_SCHEMAS.include?(schema_name)
+      return false if account.respond_to?(:initiating_party_lei) && account.initiating_party_lei && !LEI_SCHEMAS.include?(schema_name)
+
+      transactions.all? { |t| t.schema_compatible?(schema_name) }
+    end
+
+    # Set unique identifier for the message (max 35 chars, alphanumeric + punctuation).
+    # Validates and assigns immediately (fail-fast) rather than deferring to ActiveModel,
+    # because this field has a lazy default and must always be in a valid state once assigned.
+    # @param value [String] unique message ID (1-35 chars)
+    # @raise [ArgumentError] if value is not a valid string
+    def message_identification=(value)
+      raise ArgumentError, 'message_identification must be a string!' unless value.is_a?(String)
+
+      regex = %r{\A([A-Za-z0-9]|[+|?/\-:().,'\ ]){1,35}\z}
+      raise ArgumentError, "message_identification does not match #{regex}!" unless value.match?(regex)
+
+      @message_identification = value
+    end
+
+    # @return [String] unique message identifier (auto-generated if not set)
+    def message_identification
+      @message_identification ||= "MSG/#{SecureRandom.hex(14)}"
+    end
+
+    # Set creation date time for the message (ISO 8601 format).
+    # Validates and assigns immediately (fail-fast) rather than deferring to ActiveModel,
+    # because this field has a lazy default and must always be in a valid state once assigned.
+    # @note Rabobank (NL) only accepts the strict format YYYY-MM-DDTHH:MM:SS
+    # @param value [String] ISO 8601 datetime
+    # @raise [ArgumentError] if value does not match the expected format
+    def creation_date_time=(value)
+      raise ArgumentError, 'creation_date_time must be a string!' unless value.is_a?(String)
+
+      regex = /[0-9]{4}-[0-9]{2,2}-[0-9]{2,2}(?:\s|T)[0-9]{2,2}:[0-9]{2,2}:[0-9]{2,2}/
+      raise ArgumentError, "creation_date_time does not match #{regex}!" unless value.match?(regex)
+
+      @creation_date_time = value
+    end
+
+    # @return [String] ISO 8601 creation datetime (auto-generated if not set)
+    def creation_date_time
+      @creation_date_time ||= Time.now.iso8601
+    end
+
+    # Find the PmtInf ID for the batch containing a transaction with the given reference.
+    # @param transaction_reference [String] the transaction's EndToEndId reference
+    # @return [String, nil] the payment information identification, or nil if not found
+    def batch_id(transaction_reference)
+      grouped_transactions.each do |group, transactions|
+        return payment_information_identification(group) if transactions.any? { |transaction| transaction.reference == transaction_reference }
+      end
+      nil
+    end
+
+    # @return [Array<String>] list of all PmtInf IDs in the message
+    def batches
+      grouped_transactions.keys.map { |group| payment_information_identification(group) }
+    end
+
+    private
+
+    def schema_features(schema_name)
+      SCHEMA_FEATURES.fetch(schema_name) { raise ArgumentError, "Schema #{schema_name} is unknown!" }
+    end
+
+    # @return {Hash<Symbol=>String>} xml schema information used in output xml
+    def xml_schema(schema_name)
+      if schema_features(schema_name)[:swiss]
+        {
+          xmlns: 'http://www.six-interbank-clearing.com/de/pain.001.001.03.ch.02.xsd',
+          'xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:schemaLocation': 'http://www.six-interbank-clearing.com/de/pain.001.001.03.ch.02.xsd  pain.001.001.03.ch.02.xsd'
+        }
+      else
+        {
+          xmlns: "urn:iso:std:iso:20022:tech:xsd:#{schema_name}",
+          'xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:schemaLocation': "urn:iso:std:iso:20022:tech:xsd:#{schema_name} #{schema_name}.xsd"
+        }
+      end
+    end
+
+    def build_group_header(builder, schema_name)
+      builder.GrpHdr do
+        builder.MsgId(message_identification)
+        builder.CreDtTm(creation_date_time)
+        builder.NbOfTxs(transactions.length)
+        builder.CtrlSum(format_amount(amount_total))
+        builder.InitgPty do
+          builder.Nm(account.name)
+          account.initiating_party_id(builder, schema_name)
+          build_contact_details(builder, account.contact_details)
+        end
+        build_initiation_source(builder, schema_name)
+      end
+    end
+
+    # Unique and consecutive identifier (used for the <PmntInf> blocks)
+    def payment_information_identification(group)
+      suffix = "/#{grouped_transactions.keys.index(group) + 1}"
+      max_prefix_length = 35 - suffix.length
+      "#{message_identification[0, max_prefix_length]}#{suffix}"
+    end
+
+    # Returns a key to determine the group to which the transaction belongs
+    def transaction_group(transaction)
+      transaction
+    end
+
+    def build_initiation_source(builder, schema_name)
+      return unless INITN_SRC_SCHEMAS.include?(schema_name) && @initiation_source_name
+
+      builder.InitnSrc do
+        builder.Nm(@initiation_source_name)
+        builder.Prvdr(@initiation_source_provider) if @initiation_source_provider
+      end
+    end
+  end
+end