@fin.cx/einvoice 5.0.2

package/dist_ts/formats/utils/format.detector.js

@@ -0,0 +1,249 @@
+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
+     */
+    static detectFormat(xml) {
+        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
+     */
+    static quickFormatCheck(xml) {
+        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
+     */
+    static isUBLFormat(root) {
+        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
+     */
+    static isXRechnungFormat(doc) {
+        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
+     */
+    static isCIIFormat(root) {
+        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
+     */
+    static isZUGFeRDV1Format(root) {
+        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
+     */
+    static isFatturaPAFormat(root) {
+        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
+     */
+    static detectCIIFormat(doc, xml) {
+        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
+     */
+    static detectCIIFormatFromString(xml) {
+        // 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"format.detector.js","sourceRoot":"","sources":["../../../ts/formats/utils/format.detector.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,23 @@
+/**
+ * EN16931 mandatory field validator
+ * Validates that invoices contain the minimum required fields per the EN16931 standard
+ */
+export declare class EN16931Validator {
+    /**
+     * Valid ISO 4217 currency codes (common subset)
+     */
+    private static readonly VALID_CURRENCIES;
+    /**
+     * Validates that an invoice object contains all mandatory EN16931 fields
+     * @param invoice The invoice object to validate
+     * @throws Error if mandatory fields are missing
+     */
+    static validateMandatoryFields(invoice: any): void;
+    /**
+     * 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
+     */
+    static validateXmlMandatoryFields(doc: Document, format: string): void;
+}

package/dist_ts/formats/validation/en16931.validator.js

@@ -0,0 +1,119 @@
+/**
+ * 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)
+     */
+    static { this.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
+     */
+    static validateMandatoryFields(invoice) {
+        const errors = [];
+        // 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
+     */
+    static validateXmlMandatoryFields(doc, format) {
+        const errors = [];
+        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')}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW4xNjkzMS52YWxpZGF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9mb3JtYXRzL3ZhbGlkYXRpb24vZW4xNjkzMS52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBQ0gsTUFBTSxPQUFPLGdCQUFnQjtJQUMzQjs7T0FFRzthQUNxQixxQkFBZ0IsR0FBRztRQUN6QyxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLO1FBQ3BFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUs7UUFDcEUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSztRQUNwRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLO1FBQ3BFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUs7UUFDcEUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSztRQUNwRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLO1FBQ3BFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUs7UUFDcEUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSztRQUNwRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLO1FBQ3BFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUs7UUFDcEUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSztRQUNwRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLO1FBQ3BFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUs7UUFDcEUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSztRQUNwRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLO1FBQ3BFLEtBQUs7S0FDTixDQUFDO0lBRUY7Ozs7T0FJRztJQUNJLE1BQU0sQ0FBQyx1QkFBdUIsQ0FBQyxPQUFZO1FBQ2hELE1BQU0sTUFBTSxHQUFhLEVBQUUsQ0FBQztRQUU1QixxQ0FBcUM7UUFDckMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsZUFBZSxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ2xFLE1BQU0sQ0FBQyxJQUFJLENBQUMsb0NBQW9DLENBQUMsQ0FBQztRQUNwRCxDQUFDO1FBRUQseUNBQXlDO1FBQ3pDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ3hDLE1BQU0sQ0FBQyxJQUFJLENBQUMsd0NBQXdDLENBQUMsQ0FBQztRQUN4RCxDQUFDO1FBRUQsa0NBQWtDO1FBQ2xDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLElBQUksRUFBRSxDQUFDO1lBQ3hCLE1BQU0sQ0FBQyxJQUFJLENBQUMsaUNBQWlDLENBQUMsQ0FBQztRQUNqRCxDQUFDO1FBRUQsbUNBQW1DO1FBQ25DLElBQUksQ0FBQyxPQUFPLENBQUMsRUFBRSxFQUFFLElBQUksRUFBRSxDQUFDO1lBQ3RCLE1BQU0sQ0FBQyxJQUFJLENBQUMsZ0NBQWdDLENBQUMsQ0FBQztRQUNoRCxDQUFDO1FBRUQsa0RBQWtEO1FBQ2xELElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxJQUFJLE9BQU8sQ0FBQyxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQ2pELE1BQU0sQ0FBQyxJQUFJLENBQUMsK0NBQStDLENBQUMsQ0FBQztRQUMvRCxDQUFDO1FBRUQsd0NBQXdDO1FBQ3hDLElBQUksQ0FBQyxPQUFPLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztZQUMvQixNQUFNLENBQUMsSUFBSSxDQUFDLHVDQUF1QyxDQUFDLENBQUM7UUFDdkQsQ0FBQztRQUVELDRDQUE0QztRQUM1QyxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ3RCLE1BQU0sQ0FBQyxJQUFJLENBQUMsMkNBQTJDLENBQUMsQ0FBQztRQUMzRCxDQUFDO2FBQU0sQ0FBQztZQUNOLDJCQUEyQjtZQUMzQixJQUFJLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLFdBQVcsRUFBRSxDQUFDLEVBQUUsQ0FBQztnQkFDcEUsTUFBTSxDQUFDLElBQUksQ0FBQywwQkFBMEIsT0FBTyxDQUFDLFFBQVEsMENBQTBDLENBQUMsQ0FBQztZQUNwRyxDQUFDO1FBQ0gsQ0FBQztRQUVELDRDQUE0QztRQUM1QyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxPQUFPLEVBQUUsSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxPQUFPLEVBQUUsVUFBVSxJQUFJLENBQUMsQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLE9BQU8sRUFBRSxXQUFXLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLE9BQU8sRUFBRSxPQUFPLENBQUMsRUFBRSxDQUFDO1lBQ25KLE1BQU0sQ0FBQyxJQUFJLENBQUMsd0VBQXdFLENBQUMsQ0FBQztRQUN4RixDQUFDO1FBRUQsMkNBQTJDO1FBQzNDLElBQUksQ0FBQyxPQUFPLENBQUMsRUFBRSxFQUFFLE9BQU8sRUFBRSxJQUFJLElBQUksQ0FBQyxPQUFPLENBQUMsRUFBRSxFQUFFLE9BQU8sRUFBRSxVQUFVLElBQUksQ0FBQyxDQUFDLE9BQU8sQ0FBQyxFQUFFLEVBQUUsT0FBTyxFQUFFLFdBQVcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFLEVBQUUsT0FBTyxFQUFFLE9BQU8sQ0FBQyxFQUFFLENBQUM7WUFDM0ksTUFBTSxDQUFDLElBQUksQ0FBQyx1RUFBdUUsQ0FBQyxDQUFDO1FBQ3ZGLENBQUM7UUFFRCxJQUFJLE1BQU0sQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDdEIsTUFBTSxJQUFJLEtBQUssQ0FBQywrQkFBK0IsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDdEUsQ0FBQztJQUNILENBQUM7SUFFRDs7Ozs7T0FLRztJQUNJLE1BQU0sQ0FBQywwQkFBMEIsQ0FBQyxHQUFhLEVBQUUsTUFBYztRQUNwRSxNQUFNLE1BQU0sR0FBYSxFQUFFLENBQUM7UUFFNUIsSUFBSSxNQUFNLEtBQUssS0FBSyxJQUFJLE1BQU0sS0FBSyxXQUFXLEVBQUUsQ0FBQztZQUMvQyxpQ0FBaUM7WUFDakMsTUFBTSxFQUFFLEdBQUcsR0FBRyxDQUFDLG9CQUFvQixDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLFdBQVcsQ0FBQztZQUM5RCxJQUFJLENBQUMsRUFBRSxFQUFFLENBQUM7Z0JBQ1IsTUFBTSxDQUFDLElBQUksQ0FBQyxxQ0FBcUMsQ0FBQyxDQUFDO1lBQ3JELENBQUM7WUFFRCxNQUFNLFNBQVMsR0FBRyxHQUFHLENBQUMsb0JBQW9CLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsV0FBVyxDQUFDO1lBQzVFLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQztnQkFDZixNQUFNLENBQUMsSUFBSSxDQUFDLDZDQUE2QyxDQUFDLENBQUM7WUFDN0QsQ0FBQztZQUVELE1BQU0sVUFBVSxHQUFHLEdBQUcsQ0FBQyxhQUFhLENBQUMsd0NBQXdDLENBQUMsRUFBRSxXQUFXO2dCQUN4RSxHQUFHLENBQUMsYUFBYSxDQUFDLDJEQUEyRCxDQUFDLEVBQUUsV0FBVyxDQUFDO1lBQy9HLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztnQkFDaEIsTUFBTSxDQUFDLElBQUksQ0FBQyxzQ0FBc0MsQ0FBQyxDQUFDO1lBQ3RELENBQUM7WUFFRCxNQUFNLFNBQVMsR0FBRyxHQUFHLENBQUMsYUFBYSxDQUFDLHdDQUF3QyxDQUFDLEVBQUUsV0FBVztnQkFDeEUsR0FBRyxDQUFDLGFBQWEsQ0FBQywyREFBMkQsQ0FBQyxFQUFFLFdBQVcsQ0FBQztZQUM5RyxJQUFJLENBQUMsU0FBUyxFQUFFLENBQUM7Z0JBQ2YsTUFBTSxDQUFDLElBQUksQ0FBQyxxQ0FBcUMsQ0FBQyxDQUFDO1lBQ3JELENBQUM7WUFFRCxNQUFNLFlBQVksR0FBRyxHQUFHLENBQUMsb0JBQW9CLENBQUMsYUFBYSxDQUFDLENBQUM7WUFDN0QsSUFBSSxZQUFZLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO2dCQUM5QixNQUFNLENBQUMsSUFBSSxDQUFDLHNDQUFzQyxDQUFDLENBQUM7WUFDdEQsQ0FBQztRQUNILENBQUM7UUFFRCxJQUFJLE1BQU0sQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDdEIsTUFBTSxJQUFJLEtBQUssQ0FBQyxtQ0FBbUMsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDMUUsQ0FBQztJQUNILENBQUMifQ==

package/dist_ts/formats/validator.factory.d.ts

@@ -0,0 +1,18 @@
+import { BaseValidator } from './base.validator.js';
+/**
+ * Factory to create the appropriate validator based on the XML format
+ */
+export declare class ValidatorFactory {
+    /**
+     * Creates a validator for the specified XML content
+     * @param xml XML content to validate
+     * @returns Appropriate validator instance
+     */
+    static createValidator(xml: string): BaseValidator;
+    /**
+     * Detects the invoice format from XML content
+     * @param xml XML content to analyze
+     * @returns Detected invoice format
+     */
+    private static detectFormat;
+}

package/dist_ts/formats/validator.factory.js

@@ -0,0 +1,78 @@
+import { InvoiceFormat } from '../interfaces.js';
+import { BaseValidator } from './base.validator.js';
+import { FacturXValidator } from './facturx.validator.js';
+import { UBLValidator } from './ubl.validator.js';
+import { DOMParser } from 'xmldom';
+/**
+ * Factory to create the appropriate validator based on the XML format
+ */
+export class ValidatorFactory {
+    /**
+     * Creates a validator for the specified XML content
+     * @param xml XML content to validate
+     * @returns Appropriate validator instance
+     */
+    static createValidator(xml) {
+        const format = ValidatorFactory.detectFormat(xml);
+        switch (format) {
+            case InvoiceFormat.UBL:
+            case InvoiceFormat.XRECHNUNG:
+                return new UBLValidator(xml);
+            case InvoiceFormat.CII:
+            case InvoiceFormat.ZUGFERD:
+            case InvoiceFormat.FACTURX:
+                return new FacturXValidator(xml);
+            // FatturaPA and other formats would be implemented here
+            default:
+                throw new Error(`Unsupported invoice format: ${format}`);
+        }
+    }
+    /**
+     * Detects the invoice format from XML content
+     * @param xml XML content to analyze
+     * @returns Detected invoice format
+     */
+    static detectFormat(xml) {
+        try {
+            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 (root.nodeName === 'Invoice' || root.nodeName === 'CreditNote') {
+                // Check if it's XRechnung by looking at CustomizationID
+                const customizationNodes = root.getElementsByTagName('cbc:CustomizationID');
+                if (customizationNodes.length > 0) {
+                    const customizationId = customizationNodes[0].textContent || '';
+                    if (customizationId.includes('xrechnung') || customizationId.includes('XRechnung')) {
+                        return InvoiceFormat.XRECHNUNG;
+                    }
+                }
+                return InvoiceFormat.UBL;
+            }
+            // Factur-X/ZUGFeRD detection (CrossIndustryInvoice root element)
+            if (root.nodeName === 'rsm:CrossIndustryInvoice' || root.nodeName === 'CrossIndustryInvoice') {
+                // Check for profile to determine if it's Factur-X or ZUGFeRD
+                const profileNodes = root.getElementsByTagName('ram:ID');
+                for (let i = 0; i < profileNodes.length; i++) {
+                    const profileText = profileNodes[i].textContent || '';
+                    if (profileText.includes('factur-x') || profileText.includes('Factur-X')) {
+                        return InvoiceFormat.FACTURX;
+                    }
+                    if (profileText.includes('zugferd') || profileText.includes('ZUGFeRD')) {
+                        return InvoiceFormat.ZUGFERD;
+                    }
+                }
+                // If no specific profile found, default to CII
+                return InvoiceFormat.CII;
+            }
+            // FatturaPA detection would be implemented here
+            return InvoiceFormat.UNKNOWN;
+        }
+        catch (error) {
+            return InvoiceFormat.UNKNOWN;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/formats/xinvoice.decoder.d.ts

@@ -0,0 +1,28 @@
+import * as plugins from '../plugins.js';
+import { BaseDecoder } from './base.decoder.js';
+/**
+ * A decoder specifically for XInvoice/XRechnung format.
+ * XRechnung is the German implementation of the European standard EN16931
+ * for electronic invoices to the German public sector.
+ */
+export declare class XInvoiceDecoder extends BaseDecoder {
+    private xmlDoc;
+    private namespaces;
+    constructor(xmlString: string);
+    /**
+     * Set up namespaces from the document
+     */
+    private setupNamespaces;
+    /**
+     * Extract element text by tag name with namespace awareness
+     */
+    private getElementText;
+    /**
+     * Converts XInvoice/XRechnung XML to a structured letter object
+     */
+    getLetterData(): Promise<plugins.tsclass.business.ILetter>;
+    /**
+     * Extracts invoice items from XInvoice document
+     */
+    private extractInvoiceItems;
+}