@fin.cx/einvoice 5.0.2

package/ts/formats/ubl/xrechnung.validator.ts

@@ -0,0 +1,185 @@
+import { EN16931UBLValidator } from './en16931.ubl.validator.js';
+
+/**
+ * XRechnung-specific validator that extends EN16931 validation
+ * Implements additional German CIUS (Core Invoice Usage Specification) rules
+ */
+export class XRechnungValidator extends EN16931UBLValidator {
+  /**
+   * Validates XRechnung-specific structure requirements
+   */
+  protected validateStructure(): boolean {
+    // First validate EN16931 structure
+    let valid = super.validateStructure();
+
+    // XRechnung-specific: Check for proper customization ID
+    const customizationID = this.getText('//cbc:CustomizationID');
+    if (!customizationID || !customizationID.includes('xrechnung')) {
+      this.addError(
+        'XRECH-STRUCT-1',
+        'XRechnung customization ID is missing or invalid',
+        '//cbc:CustomizationID'
+      );
+      valid = false;
+    }
+
+    return valid;
+  }
+
+  /**
+   * Validates XRechnung-specific business rules
+   */
+  protected validateBusinessRules(): boolean {
+    // First validate EN16931 business rules
+    let valid = super.validateBusinessRules();
+
+    // BR-DE-1: Payment terms (BT-20) or Payment due date (BT-9) shall be provided.
+    if (!this.exists('//cbc:PaymentDueDate') && !this.exists('//cac:PaymentTerms/cbc:Note')) {
+      this.addError(
+        'BR-DE-1',
+        'Payment terms or Payment due date shall be provided',
+        '//cac:PaymentTerms'
+      );
+      valid = false;
+    }
+
+    // BR-DE-2: The element "Buyer reference" (BT-10) shall be provided.
+    if (!this.exists('//cbc:BuyerReference')) {
+      this.addError(
+        'BR-DE-2',
+        'Buyer reference is required in XRechnung',
+        '//cbc:BuyerReference'
+      );
+      valid = false;
+    }
+
+    // BR-DE-5: In Germany, the element "Seller VAT identifier" (BT-31) shall be provided.
+    const sellerCountry = this.getText('//cac:AccountingSupplierParty//cac:PostalAddress//cac:Country/cbc:IdentificationCode');
+    if (sellerCountry === 'DE' && !this.exists('//cac:AccountingSupplierParty//cac:PartyTaxScheme[cac:TaxScheme/cbc:ID="VAT"]/cbc:CompanyID')) {
+      this.addError(
+        'BR-DE-5',
+        'Seller VAT identifier is required for German sellers',
+        '//cac:AccountingSupplierParty//cac:PartyTaxScheme'
+      );
+      valid = false;
+    }
+
+    // BR-DE-6: In Germany, the element "Buyer VAT identifier" (BT-48) shall be provided.
+    const buyerCountry = this.getText('//cac:AccountingCustomerParty//cac:PostalAddress//cac:Country/cbc:IdentificationCode');
+    if (buyerCountry === 'DE' && !this.exists('//cac:AccountingCustomerParty//cac:PartyTaxScheme[cac:TaxScheme/cbc:ID="VAT"]/cbc:CompanyID')) {
+      this.addError(
+        'BR-DE-6',
+        'Buyer VAT identifier is required for German buyers',
+        '//cac:AccountingCustomerParty//cac:PartyTaxScheme'
+      );
+      valid = false;
+    }
+
+    // BR-DE-7: The element "Seller city" (BT-37) shall be provided.
+    if (!this.exists('//cac:AccountingSupplierParty//cac:PostalAddress/cbc:CityName')) {
+      this.addError(
+        'BR-DE-7',
+        'Seller city is required',
+        '//cac:AccountingSupplierParty//cac:PostalAddress'
+      );
+      valid = false;
+    }
+
+    // BR-DE-8: The element "Seller post code" (BT-38) shall be provided.
+    if (!this.exists('//cac:AccountingSupplierParty//cac:PostalAddress/cbc:PostalZone')) {
+      this.addError(
+        'BR-DE-8',
+        'Seller post code is required',
+        '//cac:AccountingSupplierParty//cac:PostalAddress'
+      );
+      valid = false;
+    }
+
+    // BR-DE-9: The element "Buyer city" (BT-52) shall be provided.
+    if (!this.exists('//cac:AccountingCustomerParty//cac:PostalAddress/cbc:CityName')) {
+      this.addError(
+        'BR-DE-9',
+        'Buyer city is required',
+        '//cac:AccountingCustomerParty//cac:PostalAddress'
+      );
+      valid = false;
+    }
+
+    // BR-DE-10: The element "Buyer post code" (BT-53) shall be provided.
+    if (!this.exists('//cac:AccountingCustomerParty//cac:PostalAddress/cbc:PostalZone')) {
+      this.addError(
+        'BR-DE-10',
+        'Buyer post code is required',
+        '//cac:AccountingCustomerParty//cac:PostalAddress'
+      );
+      valid = false;
+    }
+
+    // BR-DE-11: The element "Seller contact telephone number" (BT-42) shall be provided.
+    if (!this.exists('//cac:AccountingSupplierParty//cac:Contact/cbc:Telephone')) {
+      this.addError(
+        'BR-DE-11',
+        'Seller contact telephone number is required',
+        '//cac:AccountingSupplierParty//cac:Contact'
+      );
+      valid = false;
+    }
+
+    // BR-DE-12: The element "Seller contact email address" (BT-43) shall be provided.
+    if (!this.exists('//cac:AccountingSupplierParty//cac:Contact/cbc:ElectronicMail')) {
+      this.addError(
+        'BR-DE-12',
+        'Seller contact email address is required',
+        '//cac:AccountingSupplierParty//cac:Contact'
+      );
+      valid = false;
+    }
+
+    // BR-DE-13: The element "Buyer electronic address" (BT-49) shall be provided.
+    if (!this.exists('//cac:AccountingCustomerParty//cac:Party/cbc:EndpointID')) {
+      this.addError(
+        'BR-DE-13',
+        'Buyer electronic address (EndpointID) is required',
+        '//cac:AccountingCustomerParty//cac:Party'
+      );
+      valid = false;
+    }
+
+    // BR-DE-14: The element "Payment means type code" (BT-81) shall be provided.
+    if (!this.exists('//cac:PaymentMeans/cbc:PaymentMeansCode')) {
+      this.addError(
+        'BR-DE-14',
+        'Payment means type code is required',
+        '//cac:PaymentMeans'
+      );
+      valid = false;
+    }
+
+    // BR-DE-15: The element "Invoice line identifier" (BT-126) shall be provided.
+    const invoiceLines = this.select('//cac:InvoiceLine | //cac:CreditNoteLine', this.doc) as Node[];
+    for (let i = 0; i < invoiceLines.length; i++) {
+      const line = invoiceLines[i];
+      if (!this.exists('./cbc:ID', line)) {
+        this.addError(
+          'BR-DE-15',
+          `Invoice line ${i + 1} is missing identifier`,
+          `//cac:InvoiceLine[${i + 1}]`
+        );
+        valid = false;
+      }
+    }
+
+    // German VAT ID format validation
+    const supplierVatId = this.getText('//cac:AccountingSupplierParty//cbc:CompanyID[../cac:TaxScheme/cbc:ID="VAT"]');
+    if (supplierVatId && supplierVatId.startsWith('DE') && !/^DE[0-9]{9}$/.test(supplierVatId)) {
+      this.addError(
+        'BR-DE-VAT',
+        'German VAT ID format is invalid (must be DE followed by 9 digits)',
+        '//cac:AccountingSupplierParty//cbc:CompanyID'
+      );
+      valid = false;
+    }
+
+    return valid;
+  }
+}

package/ts/formats/utils/format.detector.ts

@@ -0,0 +1,306 @@
+import { InvoiceFormat } from '../../interfaces/common.js';
+import { DOMParser, xpath } from '../../plugins.js';
+import { CII_PROFILE_IDS, ZUGFERD_V1_NAMESPACES } from '../cii/cii.types.js';
+
+/**
+ * Utility class for detecting invoice formats
+ */
+export class FormatDetector {
+  /**
+   * Detects the format of an XML document
+   * @param xml XML content to analyze
+   * @returns Detected invoice format
+   */
+  public static detectFormat(xml: string): InvoiceFormat {
+    try {
+      // Quick check for empty or invalid XML
+      if (!xml || typeof xml !== 'string' || xml.trim().length === 0) {
+        return InvoiceFormat.UNKNOWN;
+      }
+
+      // Quick string-based pre-checks for performance
+      const quickCheck = FormatDetector.quickFormatCheck(xml);
+      if (quickCheck !== InvoiceFormat.UNKNOWN) {
+        return quickCheck;
+      }
+
+      // More thorough parsing-based checks
+      const doc = new DOMParser().parseFromString(xml, 'application/xml');
+      const root = doc.documentElement;
+
+      if (!root) {
+        return InvoiceFormat.UNKNOWN;
+      }
+
+      // UBL detection (Invoice or CreditNote root element)
+      if (FormatDetector.isUBLFormat(root)) {
+        // Check for XRechnung customization
+        if (FormatDetector.isXRechnungFormat(doc)) {
+          return InvoiceFormat.XRECHNUNG;
+        }
+        return InvoiceFormat.UBL;
+      }
+
+      // Factur-X/ZUGFeRD detection (CrossIndustryInvoice root element)
+      if (FormatDetector.isCIIFormat(root)) {
+        return FormatDetector.detectCIIFormat(doc, xml);
+      }
+
+      // ZUGFeRD v1 detection (CrossIndustryDocument root element)
+      if (FormatDetector.isZUGFeRDV1Format(root)) {
+        return InvoiceFormat.ZUGFERD;
+      }
+
+      // FatturaPA detection
+      if (FormatDetector.isFatturaPAFormat(root)) {
+        return InvoiceFormat.FATTURAPA;
+      }
+
+      return InvoiceFormat.UNKNOWN;
+    } catch (error) {
+      console.error('Error detecting format:', error);
+      return InvoiceFormat.UNKNOWN;
+    }
+  }
+
+  /**
+   * Performs a quick format check based on string content
+   * This is faster than full XML parsing for obvious cases
+   * @param xml XML string
+   * @returns Detected format or UNKNOWN if more analysis is needed
+   */
+  private static quickFormatCheck(xml: string): InvoiceFormat {
+    const lowerXml = xml.toLowerCase();
+
+    // Check for obvious Factur-X indicators
+    if (
+      lowerXml.includes('factur-x.eu') ||
+      lowerXml.includes('factur-x.xml') ||
+      lowerXml.includes('factur-x:') ||
+      lowerXml.includes('urn:cen.eu:en16931:2017') && lowerXml.includes('factur-x')
+    ) {
+      return InvoiceFormat.FACTURX;
+    }
+
+    // Check for obvious ZUGFeRD indicators
+    if (
+      lowerXml.includes('zugferd:') ||
+      lowerXml.includes('zugferd-invoice.xml') ||
+      lowerXml.includes('urn:ferd:') ||
+      lowerXml.includes('urn:zugferd')
+    ) {
+      return InvoiceFormat.ZUGFERD;
+    }
+
+    // Check for obvious XRechnung indicators
+    if (
+      lowerXml.includes('xrechnung') ||
+      lowerXml.includes('urn:xoev-de:kosit:standard:xrechnung')
+    ) {
+      return InvoiceFormat.XRECHNUNG;
+    }
+
+    // Check for obvious FatturaPA indicators
+    if (
+      lowerXml.includes('fatturapa') ||
+      lowerXml.includes('fattura elettronica') ||
+      lowerXml.includes('fatturaelettronica')
+    ) {
+      return InvoiceFormat.FATTURAPA;
+    }
+
+    // Need more analysis
+    return InvoiceFormat.UNKNOWN;
+  }
+
+  /**
+   * Checks if the document is a UBL format
+   * @param root Root element
+   * @returns True if it's a UBL format
+   */
+  private static isUBLFormat(root: Element): boolean {
+    return (
+      root.nodeName === 'Invoice' ||
+      root.nodeName === 'CreditNote' ||
+      root.nodeName === 'ubl:Invoice' ||
+      root.nodeName === 'ubl:CreditNote' ||
+      root.nodeName.endsWith(':Invoice') ||
+      root.nodeName.endsWith(':CreditNote')
+    );
+  }
+
+  /**
+   * Checks if the document is an XRechnung format
+   * @param doc XML document
+   * @returns True if it's an XRechnung format
+   */
+  private static isXRechnungFormat(doc: Document): boolean {
+    try {
+      // Set up namespaces for XPath queries
+      const namespaces = {
+        'cbc': 'urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2',
+        'ubl': 'urn:oasis:names:specification:ubl:schema:xsd:Invoice-2'
+      };
+
+      // Create XPath selector with namespaces
+      const select = xpath.useNamespaces(namespaces);
+
+      // Use getElementsByTagName directly for more reliable results
+      const customizationNodes = doc.getElementsByTagName('cbc:CustomizationID');
+      
+      // Check if any CustomizationID node contains "xrechnung"
+      for (let i = 0; i < customizationNodes.length; i++) {
+        const node = customizationNodes[i];
+        if (node.textContent && node.textContent.includes('xrechnung')) {
+          return true;
+        }
+      }
+      
+      return false;
+    } catch (error) {
+      console.warn('Error checking for XRechnung format:', error);
+      // If direct DOM access fails, try a string-based approach
+      const xmlStr = new XMLSerializer().serializeToString(doc);
+      return xmlStr.includes('xrechnung') || xmlStr.includes('XRechnung');
+    }
+  }
+
+  /**
+   * Checks if the document is a CII format (Factur-X/ZUGFeRD v2+)
+   * @param root Root element
+   * @returns True if it's a CII format
+   */
+  private static isCIIFormat(root: Element): boolean {
+    return (
+      root.nodeName === 'rsm:CrossIndustryInvoice' ||
+      root.nodeName === 'CrossIndustryInvoice' ||
+      root.nodeName.endsWith(':CrossIndustryInvoice')
+    );
+  }
+
+  /**
+   * Checks if the document is a ZUGFeRD v1 format
+   * @param root Root element
+   * @returns True if it's a ZUGFeRD v1 format
+   */
+  private static isZUGFeRDV1Format(root: Element): boolean {
+    return (
+      root.nodeName === 'rsm:CrossIndustryDocument' ||
+      root.nodeName === 'CrossIndustryDocument' ||
+      root.nodeName === 'ram:CrossIndustryDocument' ||
+      root.nodeName.endsWith(':CrossIndustryDocument')
+    );
+  }
+
+  /**
+   * Checks if the document is a FatturaPA format
+   * @param root Root element
+   * @returns True if it's a FatturaPA format
+   */
+  private static isFatturaPAFormat(root: Element): boolean {
+    return (
+      root.nodeName === 'FatturaElettronica' ||
+      (root.getAttribute('xmlns') && root.getAttribute('xmlns')!.includes('fatturapa.gov.it'))
+    );
+  }
+
+  /**
+   * Detects the specific CII format (Factur-X vs ZUGFeRD)
+   * @param doc XML document
+   * @param xml Original XML string for fallback checks
+   * @returns Detected format
+   */
+  private static detectCIIFormat(doc: Document, xml: string): InvoiceFormat {
+    try {
+      // Use direct DOM traversal instead of XPath for more reliable behavior
+      const contextNodes = doc.getElementsByTagNameNS(
+        'urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100',
+        'ExchangedDocumentContext'
+      );
+      
+      if (contextNodes.length === 0) {
+        // Try without namespace
+        const noNsContextNodes = doc.getElementsByTagName('ExchangedDocumentContext');
+        if (noNsContextNodes.length === 0) {
+          // Fallback to string-based detection
+          return FormatDetector.detectCIIFormatFromString(xml);
+        }
+      }
+      
+      // Loop through all potential context nodes
+      const allContextNodes = [...Array.from(contextNodes), ...Array.from(doc.getElementsByTagName('ExchangedDocumentContext'))];
+      
+      for (const contextNode of allContextNodes) {
+        // Find guideline parameter
+        const guidelineNodes = contextNode.getElementsByTagName('ram:GuidelineSpecifiedDocumentContextParameter');
+        
+        if (guidelineNodes.length === 0) {
+          continue;
+        }
+        
+        for (const guidelineNode of Array.from(guidelineNodes)) {
+          // Find ID element
+          const idNodes = guidelineNode.getElementsByTagName('ram:ID');
+          
+          if (idNodes.length === 0) {
+            continue;
+          }
+          
+          for (const idNode of Array.from(idNodes)) {
+            const profileText = idNode.textContent || '';
+            
+            // Check for ZUGFeRD profiles (v1 and v2)
+            if (
+              profileText.includes('zugferd') ||
+              profileText.includes('urn:ferd:') ||
+              profileText === CII_PROFILE_IDS.ZUGFERD_BASIC ||
+              profileText === CII_PROFILE_IDS.ZUGFERD_COMFORT ||
+              profileText === CII_PROFILE_IDS.ZUGFERD_EXTENDED ||
+              profileText === CII_PROFILE_IDS.ZUGFERD_V1_BASIC ||
+              profileText === CII_PROFILE_IDS.ZUGFERD_V1_COMFORT ||
+              profileText === CII_PROFILE_IDS.ZUGFERD_V1_EXTENDED
+            ) {
+              return InvoiceFormat.ZUGFERD;
+            }
+
+            // Check for Factur-X profiles
+            if (
+              profileText.includes('factur-x') ||
+              profileText === CII_PROFILE_IDS.FACTURX_MINIMUM ||
+              profileText === CII_PROFILE_IDS.FACTURX_BASIC ||
+              profileText === CII_PROFILE_IDS.FACTURX_EN16931
+            ) {
+              return InvoiceFormat.FACTURX;
+            }
+          }
+        }
+      }
+      
+      // If we reach here, fall back to string checking
+      return FormatDetector.detectCIIFormatFromString(xml);
+    } catch (error) {
+      console.warn('Error detecting CII format, falling back to generic CII:', error);
+      return FormatDetector.detectCIIFormatFromString(xml);
+    }
+  }
+  
+  /**
+   * Fallback method to detect CII format from string content
+   * @param xml XML string
+   * @returns Detected format
+   */
+  private static detectCIIFormatFromString(xml: string): InvoiceFormat {
+    // Check for Factur-X indicators
+    if (xml.includes('factur-x') || xml.includes('Factur-X')) {
+      return InvoiceFormat.FACTURX;
+    }
+    
+    // Check for ZUGFeRD indicators
+    if (xml.includes('zugferd') || xml.includes('ZUGFeRD')) {
+      return InvoiceFormat.ZUGFERD;
+    }
+    
+    // Generic CII if we can't determine more specifically
+    return InvoiceFormat.CII;
+  }
+}

package/ts/formats/validation/en16931.validator.ts

@@ -0,0 +1,135 @@
+/**
+ * EN16931 mandatory field validator
+ * Validates that invoices contain the minimum required fields per the EN16931 standard
+ */
+export class EN16931Validator {
+  /**
+   * Valid ISO 4217 currency codes (common subset)
+   */
+  private static readonly VALID_CURRENCIES = [
+    'AED', 'AFN', 'ALL', 'AMD', 'ANG', 'AOA', 'ARS', 'AUD', 'AWG', 'AZN',
+    'BAM', 'BBD', 'BDT', 'BGN', 'BHD', 'BIF', 'BMD', 'BND', 'BOB', 'BRL',
+    'BSD', 'BTN', 'BWP', 'BYN', 'BZD', 'CAD', 'CDF', 'CHF', 'CLP', 'CNY',
+    'COP', 'CRC', 'CUC', 'CUP', 'CVE', 'CZK', 'DJF', 'DKK', 'DOP', 'DZD',
+    'EGP', 'ERN', 'ETB', 'EUR', 'FJD', 'FKP', 'GBP', 'GEL', 'GGP', 'GHS',
+    'GIP', 'GMD', 'GNF', 'GTQ', 'GYD', 'HKD', 'HNL', 'HRK', 'HTG', 'HUF',
+    'IDR', 'ILS', 'IMP', 'INR', 'IQD', 'IRR', 'ISK', 'JEP', 'JMD', 'JOD',
+    'JPY', 'KES', 'KGS', 'KHR', 'KMF', 'KPW', 'KRW', 'KWD', 'KYD', 'KZT',
+    'LAK', 'LBP', 'LKR', 'LRD', 'LSL', 'LYD', 'MAD', 'MDL', 'MGA', 'MKD',
+    'MMK', 'MNT', 'MOP', 'MRU', 'MUR', 'MVR', 'MWK', 'MXN', 'MYR', 'MZN',
+    'NAD', 'NGN', 'NIO', 'NOK', 'NPR', 'NZD', 'OMR', 'PAB', 'PEN', 'PGK',
+    'PHP', 'PKR', 'PLN', 'PYG', 'QAR', 'RON', 'RSD', 'RUB', 'RWF', 'SAR',
+    'SBD', 'SCR', 'SDG', 'SEK', 'SGD', 'SHP', 'SLL', 'SOS', 'SPL', 'SRD',
+    'STN', 'SYP', 'SZL', 'THB', 'TJS', 'TMT', 'TND', 'TOP', 'TRY', 'TTD',
+    'TVD', 'TWD', 'TZS', 'UAH', 'UGX', 'USD', 'UYU', 'UZS', 'VEF', 'VND',
+    'VUV', 'WST', 'XAF', 'XCD', 'XDR', 'XOF', 'XPF', 'YER', 'ZAR', 'ZMW',
+    'ZWD'
+  ];
+
+  /**
+   * Validates that an invoice object contains all mandatory EN16931 fields
+   * @param invoice The invoice object to validate
+   * @throws Error if mandatory fields are missing
+   */
+  public static validateMandatoryFields(invoice: any): void {
+    const errors: string[] = [];
+
+    // BR-01: Invoice number is mandatory
+    if (!invoice.id && !invoice.accountingDocId && !invoice.invoiceId) {
+      errors.push('BR-01: Invoice number is mandatory');
+    }
+
+    // BR-02: Invoice issue date is mandatory
+    if (!invoice.date && !invoice.issueDate) {
+      errors.push('BR-02: Invoice issue date is mandatory');
+    }
+
+    // BR-06: Seller name is mandatory
+    if (!invoice.from?.name) {
+      errors.push('BR-06: Seller name is mandatory');
+    }
+
+    // BR-07: Buyer name is mandatory  
+    if (!invoice.to?.name) {
+      errors.push('BR-07: Buyer name is mandatory');
+    }
+
+    // BR-16: Invoice line is mandatory (at least one)
+    if (!invoice.items || invoice.items.length === 0) {
+      errors.push('BR-16: At least one invoice line is mandatory');
+    }
+
+    // BR-03: Invoice type code is mandatory
+    if (!invoice.accountingDocType) {
+      errors.push('BR-03: Invoice type code is mandatory');
+    }
+
+    // BR-05: Invoice currency code is mandatory
+    if (!invoice.currency) {
+      errors.push('BR-05: Invoice currency code is mandatory');
+    } else {
+      // Validate currency format
+      if (!this.VALID_CURRENCIES.includes(invoice.currency.toUpperCase())) {
+        errors.push(`Invalid currency code: ${invoice.currency}. Must be a valid ISO 4217 currency code`);
+      }
+    }
+
+    // BR-08: Seller postal address is mandatory
+    if (!invoice.from?.address?.city || !invoice.from?.address?.postalCode || (!invoice.from?.address?.countryCode && !invoice.from?.address?.country)) {
+      errors.push('BR-08: Seller postal address (city, postal code, country) is mandatory');
+    }
+
+    // BR-10: Buyer postal address is mandatory
+    if (!invoice.to?.address?.city || !invoice.to?.address?.postalCode || (!invoice.to?.address?.countryCode && !invoice.to?.address?.country)) {
+      errors.push('BR-10: Buyer postal address (city, postal code, country) is mandatory');
+    }
+
+    if (errors.length > 0) {
+      throw new Error(`EN16931 validation failed:\n${errors.join('\n')}`);
+    }
+  }
+
+  /**
+   * Validates mandatory fields for a parsed XML structure
+   * @param doc The parsed XML document
+   * @param format The invoice format
+   * @throws Error if mandatory fields are missing in XML
+   */
+  public static validateXmlMandatoryFields(doc: Document, format: string): void {
+    const errors: string[] = [];
+
+    if (format === 'ubl' || format === 'xrechnung') {
+      // Check for UBL mandatory fields
+      const id = doc.getElementsByTagName('cbc:ID')[0]?.textContent;
+      if (!id) {
+        errors.push('BR-01: Invoice ID is missing in XML');
+      }
+
+      const issueDate = doc.getElementsByTagName('cbc:IssueDate')[0]?.textContent;
+      if (!issueDate) {
+        errors.push('BR-02: Invoice issue date is missing in XML');
+      }
+
+      const sellerName = doc.querySelector('AccountingSupplierParty PartyName Name')?.textContent ||
+                         doc.querySelector('AccountingSupplierParty PartyLegalEntity RegistrationName')?.textContent;
+      if (!sellerName) {
+        errors.push('BR-06: Seller name is missing in XML');
+      }
+
+      const buyerName = doc.querySelector('AccountingCustomerParty PartyName Name')?.textContent ||
+                        doc.querySelector('AccountingCustomerParty PartyLegalEntity RegistrationName')?.textContent;
+      if (!buyerName) {
+        errors.push('BR-07: Buyer name is missing in XML');
+      }
+
+      const invoiceLines = doc.getElementsByTagName('InvoiceLine');
+      if (invoiceLines.length === 0) {
+        errors.push('BR-16: No invoice lines found in XML');
+      }
+    }
+
+    if (errors.length > 0) {
+      throw new Error(`EN16931 XML validation failed:\n${errors.join('\n')}`);
+    }
+  }
+}