@fin.cx/einvoice 5.0.2 → 5.1.2

package/dist_ts/formats/validation/schematron.downloader.js

@@ -0,0 +1,254 @@
+import * as plugins from '../../plugins.js';
+import * as path from 'path';
+import { promises as fs } from 'fs';
+/**
+ * Official Schematron sources for e-invoicing standards
+ */
+export const SCHEMATRON_SOURCES = {
+    EN16931: [
+        {
+            name: 'EN16931-UBL',
+            version: '1.3.14',
+            url: 'https://github.com/ConnectingEurope/eInvoicing-EN16931/raw/master/ubl/schematron/EN16931-UBL-validation.sch',
+            description: 'Official EN16931 validation rules for UBL format',
+            format: 'UBL'
+        },
+        {
+            name: 'EN16931-CII',
+            version: '1.3.14',
+            url: 'https://github.com/ConnectingEurope/eInvoicing-EN16931/raw/master/cii/schematron/EN16931-CII-validation.sch',
+            description: 'Official EN16931 validation rules for CII format',
+            format: 'CII'
+        },
+        {
+            name: 'EN16931-EDIFACT',
+            version: '1.3.14',
+            url: 'https://github.com/ConnectingEurope/eInvoicing-EN16931/raw/master/edifact/schematron/EN16931-EDIFACT-validation.sch',
+            description: 'Official EN16931 validation rules for EDIFACT format',
+            format: 'CII'
+        }
+    ],
+    XRECHNUNG: [
+        {
+            name: 'XRechnung-UBL',
+            version: '3.0.2',
+            url: 'https://github.com/itplr-kosit/xrechnung-schematron/raw/master/src/validation/schematron/ubl/XRechnung-UBL-validation.sch',
+            description: 'XRechnung CIUS validation for UBL',
+            format: 'UBL'
+        },
+        {
+            name: 'XRechnung-CII',
+            version: '3.0.2',
+            url: 'https://github.com/itplr-kosit/xrechnung-schematron/raw/master/src/validation/schematron/cii/XRechnung-CII-validation.sch',
+            description: 'XRechnung CIUS validation for CII',
+            format: 'CII'
+        }
+    ],
+    PEPPOL: [
+        {
+            name: 'PEPPOL-EN16931-UBL',
+            version: '3.0.17',
+            url: 'https://github.com/OpenPEPPOL/peppol-bis-invoice-3/raw/master/rules/sch/PEPPOL-EN16931-UBL.sch',
+            description: 'PEPPOL BIS Billing 3.0 validation rules for UBL',
+            format: 'UBL'
+        },
+        {
+            name: 'PEPPOL-EN16931-CII',
+            version: '3.0.17',
+            url: 'https://github.com/OpenPEPPOL/peppol-bis-invoice-3/raw/master/rules/sch/PEPPOL-EN16931-CII.sch',
+            description: 'PEPPOL BIS Billing 3.0 validation rules for CII',
+            format: 'CII'
+        }
+    ]
+};
+/**
+ * Schematron downloader and cache manager
+ */
+export class SchematronDownloader {
+    constructor(cacheDir = 'assets_downloaded/schematron') {
+        this.cacheDir = cacheDir;
+    }
+    /**
+     * Initialize the downloader
+     */
+    async initialize() {
+        // Ensure cache directory exists
+        this.smartfile = await import('@push.rocks/smartfile');
+        await fs.mkdir(this.cacheDir, { recursive: true });
+    }
+    /**
+     * Download a Schematron file
+     */
+    async download(source) {
+        const fileName = `${source.name}-v${source.version}.sch`;
+        const filePath = path.join(this.cacheDir, fileName);
+        // Check if already cached
+        if (await this.isCached(filePath)) {
+            console.log(`Using cached Schematron: ${fileName}`);
+            return filePath;
+        }
+        console.log(`Downloading Schematron: ${source.name} v${source.version}`);
+        try {
+            // Download the file
+            const response = await fetch(source.url);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const content = await response.text();
+            // Validate it's actually Schematron
+            if (!content.includes('schematron') && !content.includes('sch:schema')) {
+                throw new Error('Downloaded file does not appear to be Schematron');
+            }
+            // Save to cache
+            await fs.writeFile(filePath, content, 'utf-8');
+            // Also save metadata
+            const metaPath = filePath.replace('.sch', '.meta.json');
+            await fs.writeFile(metaPath, JSON.stringify({
+                source: source.name,
+                version: source.version,
+                url: source.url,
+                format: source.format,
+                downloadDate: new Date().toISOString()
+            }, null, 2), 'utf-8');
+            console.log(`Successfully downloaded: ${fileName}`);
+            return filePath;
+        }
+        catch (error) {
+            throw new Error(`Failed to download ${source.name}: ${error.message}`);
+        }
+    }
+    /**
+     * Download all Schematron files for a standard
+     */
+    async downloadStandard(standard) {
+        const sources = SCHEMATRON_SOURCES[standard];
+        if (!sources) {
+            throw new Error(`Unknown standard: ${standard}`);
+        }
+        const paths = [];
+        for (const source of sources) {
+            try {
+                const path = await this.download(source);
+                paths.push(path);
+            }
+            catch (error) {
+                console.warn(`Failed to download ${source.name}: ${error.message}`);
+            }
+        }
+        return paths;
+    }
+    /**
+     * Check if a file is cached
+     */
+    async isCached(filePath) {
+        try {
+            await fs.access(filePath);
+            // Check if file is not empty
+            const stats = await fs.stat(filePath);
+            return stats.size > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get cached Schematron files
+     */
+    async getCachedFiles() {
+        const files = [];
+        try {
+            const entries = await fs.readdir(this.cacheDir);
+            for (const entry of entries) {
+                if (entry.endsWith('.sch')) {
+                    const filePath = path.join(this.cacheDir, entry);
+                    const metaPath = filePath.replace('.sch', '.meta.json');
+                    try {
+                        const metadata = JSON.parse(await fs.readFile(metaPath, 'utf-8'));
+                        files.push({ path: filePath, metadata });
+                    }
+                    catch {
+                        // No metadata file
+                        files.push({ path: filePath, metadata: null });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to list cached files: ${error.message}`);
+        }
+        return files;
+    }
+    /**
+     * Clear cache
+     */
+    async clearCache() {
+        try {
+            const entries = await fs.readdir(this.cacheDir);
+            for (const entry of entries) {
+                if (entry.endsWith('.sch') || entry.endsWith('.meta.json')) {
+                    await fs.unlink(path.join(this.cacheDir, entry));
+                }
+            }
+            console.log('Schematron cache cleared');
+        }
+        catch (error) {
+            console.warn(`Failed to clear cache: ${error.message}`);
+        }
+    }
+    /**
+     * Get the appropriate Schematron for a format
+     */
+    async getSchematronForFormat(standard, format) {
+        const sources = SCHEMATRON_SOURCES[standard];
+        if (!sources)
+            return null;
+        const source = sources.find(s => s.format === format || s.format === 'BOTH');
+        if (!source)
+            return null;
+        return await this.download(source);
+    }
+    /**
+     * Update all cached Schematron files
+     */
+    async updateAll() {
+        console.log('Updating all Schematron files...');
+        for (const standard of ['EN16931', 'XRECHNUNG', 'PEPPOL']) {
+            await this.downloadStandard(standard);
+        }
+        console.log('All Schematron files updated');
+    }
+}
+/**
+ * ISO Schematron skeleton URLs
+ * These are needed to compile Schematron to XSLT
+ */
+export const ISO_SCHEMATRON_SKELETONS = {
+    'iso_dsdl_include.xsl': 'https://github.com/Schematron/schematron/raw/master/trunk/schematron/code/iso_dsdl_include.xsl',
+    'iso_abstract_expand.xsl': 'https://github.com/Schematron/schematron/raw/master/trunk/schematron/code/iso_abstract_expand.xsl',
+    'iso_svrl_for_xslt2.xsl': 'https://github.com/Schematron/schematron/raw/master/trunk/schematron/code/iso_svrl_for_xslt2.xsl',
+    'iso_schematron_skeleton_for_saxon.xsl': 'https://github.com/Schematron/schematron/raw/master/trunk/schematron/code/iso_schematron_skeleton_for_saxon.xsl'
+};
+/**
+ * Download ISO Schematron skeleton files
+ */
+export async function downloadISOSkeletons(targetDir = 'assets_downloaded/schematron/iso') {
+    await fs.mkdir(targetDir, { recursive: true });
+    console.log('Downloading ISO Schematron skeleton files...');
+    for (const [name, url] of Object.entries(ISO_SCHEMATRON_SKELETONS)) {
+        try {
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            const content = await response.text();
+            const filePath = path.join(targetDir, name);
+            await fs.writeFile(filePath, content, 'utf-8');
+            console.log(`Downloaded: ${name}`);
+        }
+        catch (error) {
+            console.warn(`Failed to download ${name}: ${error.message}`);
+        }
+    }
+    console.log('ISO Schematron skeleton download complete');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schematron.downloader.js","sourceRoot":"","sources":["../../../ts/formats/validation/schematron.downloader.ts"],"names":[],"mappings":"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"}

package/dist_ts/formats/validation/schematron.integration.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Integration of official Schematron validation with the EInvoice module
+ */
+import type { ValidationOptions, ValidationReport } from './validation.types.js';
+import type { EInvoice } from '../../einvoice.js';
+/**
+ * Integrated validator combining TypeScript and Schematron validation
+ */
+export declare class IntegratedValidator {
+    private hybridValidator;
+    private schematronValidator;
+    private businessRulesValidator;
+    private codeListValidator;
+    private schematronLoaded;
+    constructor();
+    /**
+     * Setup TypeScript validators in the hybrid pipeline
+     */
+    private setupTypeScriptValidators;
+    /**
+     * Load Schematron for a specific format and standard
+     */
+    loadSchematron(standard: 'EN16931' | 'PEPPOL' | 'XRECHNUNG', format: 'UBL' | 'CII'): Promise<void>;
+    /**
+     * Get the path to the appropriate Schematron file
+     */
+    private getSchematronPath;
+    /**
+     * Validate an invoice using all available validators
+     */
+    validate(invoice: EInvoice, xmlContent?: string, options?: ValidationOptions): Promise<ValidationReport>;
+    /**
+     * Detect format from XML content
+     */
+    private detectFormat;
+    /**
+     * Estimate total number of rules for a profile
+     */
+    private estimateTotalRules;
+    /**
+     * Validate with automatic format detection
+     */
+    validateAuto(invoice: EInvoice, xmlContent?: string): Promise<ValidationReport>;
+    /**
+     * Check if Schematron validation is available
+     */
+    hasSchematron(): boolean;
+    /**
+     * Get available Schematron files
+     */
+    getAvailableSchematron(): Promise<Array<{
+        standard: string;
+        format: string;
+        path: string;
+    }>>;
+}
+/**
+ * Create a pre-configured validator for a specific standard
+ */
+export declare function createStandardValidator(standard: 'EN16931' | 'PEPPOL' | 'XRECHNUNG', format: 'UBL' | 'CII'): Promise<IntegratedValidator>;

package/dist_ts/formats/validation/schematron.integration.js

@@ -0,0 +1,230 @@
+/**
+ * Integration of official Schematron validation with the EInvoice module
+ */
+import { SchematronValidator, HybridValidator } from './schematron.validator.js';
+import { EN16931BusinessRulesValidator } from './en16931.business-rules.validator.js';
+import { CodeListValidator } from './codelist.validator.js';
+import * as path from 'path';
+import { promises as fs } from 'fs';
+/**
+ * Integrated validator combining TypeScript and Schematron validation
+ */
+export class IntegratedValidator {
+    constructor() {
+        this.schematronLoaded = false;
+        this.schematronValidator = new SchematronValidator();
+        this.hybridValidator = new HybridValidator(this.schematronValidator);
+        this.businessRulesValidator = new EN16931BusinessRulesValidator();
+        this.codeListValidator = new CodeListValidator();
+        // Add TypeScript validators to hybrid pipeline
+        this.setupTypeScriptValidators();
+    }
+    /**
+     * Setup TypeScript validators in the hybrid pipeline
+     */
+    setupTypeScriptValidators() {
+        // Wrap business rules validator
+        this.hybridValidator.addTSValidator({
+            validate: (xml) => {
+                // Note: This would need the invoice object, not XML
+                // In practice, we'd parse the XML to EInvoice first
+                return [];
+            }
+        });
+    }
+    /**
+     * Load Schematron for a specific format and standard
+     */
+    async loadSchematron(standard, format) {
+        const schematronPath = await this.getSchematronPath(standard, format);
+        if (!schematronPath) {
+            throw new Error(`No Schematron available for ${standard} ${format}`);
+        }
+        // Check if file exists
+        try {
+            await fs.access(schematronPath);
+        }
+        catch {
+            throw new Error(`Schematron file not found: ${schematronPath}. Run 'npm run download-schematron' first.`);
+        }
+        await this.schematronValidator.loadSchematron(schematronPath, true);
+        this.schematronLoaded = true;
+    }
+    /**
+     * Get the path to the appropriate Schematron file
+     */
+    async getSchematronPath(standard, format) {
+        const basePath = 'assets_downloaded/schematron';
+        // Map standard and format to file pattern
+        const patterns = {
+            EN16931: {
+                UBL: 'EN16931-UBL-*.sch',
+                CII: 'EN16931-CII-*.sch'
+            },
+            PEPPOL: {
+                UBL: 'PEPPOL-EN16931-UBL-*.sch',
+                CII: 'PEPPOL-EN16931-CII-*.sch'
+            },
+            XRECHNUNG: {
+                UBL: 'XRechnung-UBL-*.sch',
+                CII: 'XRechnung-CII-*.sch'
+            }
+        };
+        const pattern = patterns[standard]?.[format];
+        if (!pattern)
+            return null;
+        // Find matching files
+        try {
+            const files = await fs.readdir(basePath);
+            const regex = new RegExp(pattern.replace('*', '.*'));
+            const matches = files.filter(f => regex.test(f));
+            if (matches.length > 0) {
+                // Return the most recent version (lexicographically last)
+                matches.sort();
+                return path.join(basePath, matches[matches.length - 1]);
+            }
+        }
+        catch {
+            // Directory doesn't exist
+        }
+        return null;
+    }
+    /**
+     * Validate an invoice using all available validators
+     */
+    async validate(invoice, xmlContent, options = {}) {
+        const startTime = Date.now();
+        const results = [];
+        // Determine format hint
+        const formatHint = options.formatHint || this.detectFormat(xmlContent);
+        // Run TypeScript validators
+        if (options.checkCodeLists !== false) {
+            results.push(...this.codeListValidator.validate(invoice));
+        }
+        results.push(...this.businessRulesValidator.validate(invoice, options));
+        // Run Schematron validation if XML is provided and Schematron is loaded
+        if (xmlContent && this.schematronLoaded) {
+            try {
+                const schematronResults = await this.schematronValidator.validate(xmlContent, {
+                    includeWarnings: !options.strictMode,
+                    parameters: {
+                        profile: options.profile
+                    }
+                });
+                results.push(...schematronResults);
+            }
+            catch (error) {
+                console.warn(`Schematron validation failed: ${error.message}`);
+            }
+        }
+        // Calculate statistics
+        const errorCount = results.filter(r => r.severity === 'error').length;
+        const warningCount = results.filter(r => r.severity === 'warning').length;
+        const infoCount = results.filter(r => r.severity === 'info').length;
+        // Estimate rule coverage
+        const totalRules = this.estimateTotalRules(options.profile);
+        const rulesChecked = new Set(results.map(r => r.ruleId)).size;
+        return {
+            valid: errorCount === 0,
+            profile: options.profile || 'EN16931',
+            timestamp: new Date().toISOString(),
+            validatorVersion: '1.0.0',
+            rulesetVersion: '1.3.14',
+            results,
+            errorCount,
+            warningCount,
+            infoCount,
+            rulesChecked,
+            rulesTotal: totalRules,
+            coverage: (rulesChecked / totalRules) * 100,
+            validationTime: Date.now() - startTime,
+            documentId: invoice.accountingDocId,
+            documentType: invoice.accountingDocType,
+            format: formatHint
+        };
+    }
+    /**
+     * Detect format from XML content
+     */
+    detectFormat(xmlContent) {
+        if (!xmlContent)
+            return undefined;
+        if (xmlContent.includes('urn:oasis:names:specification:ubl:schema:xsd:Invoice-2')) {
+            return 'UBL';
+        }
+        else if (xmlContent.includes('urn:un:unece:uncefact:data:standard:CrossIndustryInvoice')) {
+            return 'CII';
+        }
+        return undefined;
+    }
+    /**
+     * Estimate total number of rules for a profile
+     */
+    estimateTotalRules(profile) {
+        const ruleCounts = {
+            EN16931: 150,
+            PEPPOL_BIS_3_0: 250,
+            XRECHNUNG_3_0: 280,
+            FACTURX_BASIC: 100,
+            FACTURX_EN16931: 150
+        };
+        return ruleCounts[profile || 'EN16931'] || 150;
+    }
+    /**
+     * Validate with automatic format detection
+     */
+    async validateAuto(invoice, xmlContent) {
+        // Auto-detect format
+        const format = this.detectFormat(xmlContent);
+        // Try to load appropriate Schematron
+        if (format && !this.schematronLoaded) {
+            try {
+                await this.loadSchematron('EN16931', format);
+            }
+            catch (error) {
+                console.warn(`Could not load Schematron: ${error.message}`);
+            }
+        }
+        return this.validate(invoice, xmlContent, {
+            formatHint: format,
+            checkCalculations: true,
+            checkVAT: true,
+            checkCodeLists: true
+        });
+    }
+    /**
+     * Check if Schematron validation is available
+     */
+    hasSchematron() {
+        return this.schematronLoaded;
+    }
+    /**
+     * Get available Schematron files
+     */
+    async getAvailableSchematron() {
+        const available = [];
+        for (const standard of ['EN16931', 'PEPPOL', 'XRECHNUNG']) {
+            for (const format of ['UBL', 'CII']) {
+                const schematronPath = await this.getSchematronPath(standard, format);
+                if (schematronPath) {
+                    available.push({ standard, format, path: schematronPath });
+                }
+            }
+        }
+        return available;
+    }
+}
+/**
+ * Create a pre-configured validator for a specific standard
+ */
+export async function createStandardValidator(standard, format) {
+    const validator = new IntegratedValidator();
+    try {
+        await validator.loadSchematron(standard, format);
+    }
+    catch (error) {
+        console.warn(`Schematron not available for ${standard} ${format}: ${error.message}`);
+    }
+    return validator;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schematron.integration.js","sourceRoot":"","sources":["../../../ts/formats/validation/schematron.integration.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjF,OAAO,EAAE,6BAA6B,EAAE,MAAM,uCAAuC,CAAC;AACtF,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAG5D,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,IAAI,CAAC;AAEpC;;GAEG;AACH,MAAM,OAAO,mBAAmB;IAO9B;QAFQ,qBAAgB,GAAY,KAAK,CAAC;QAGxC,IAAI,CAAC,mBAAmB,GAAG,IAAI,mBAAmB,EAAE,CAAC;QACrD,IAAI,CAAC,eAAe,GAAG,IAAI,eAAe,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACrE,IAAI,CAAC,sBAAsB,GAAG,IAAI,6BAA6B,EAAE,CAAC;QAClE,IAAI,CAAC,iBAAiB,GAAG,IAAI,iBAAiB,EAAE,CAAC;QAEjD,+CAA+C;QAC/C,IAAI,CAAC,yBAAyB,EAAE,CAAC;IACnC,CAAC;IAED;;OAEG;IACK,yBAAyB;QAC/B,gCAAgC;QAChC,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC;YAClC,QAAQ,EAAE,CAAC,GAAW,EAAE,EAAE;gBACxB,oDAAoD;gBACpD,oDAAoD;gBACpD,OAAO,EAAE,CAAC;YACZ,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,cAAc,CACzB,QAA4C,EAC5C,MAAqB;QAErB,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAEtE,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,+BAA+B,QAAQ,IAAI,MAAM,EAAE,CAAC,CAAC;QACvE,CAAC;QAED,uBAAuB;QACvB,IAAI,CAAC;YACH,MAAM,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;QAClC,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,IAAI,KAAK,CAAC,8BAA8B,cAAc,4CAA4C,CAAC,CAAC;QAC5G,CAAC;QAED,MAAM,IAAI,CAAC,mBAAmB,CAAC,cAAc,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;QACpE,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAC/B,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,iBAAiB,CAC7B,QAA4C,EAC5C,MAAqB;QAErB,MAAM,QAAQ,GAAG,8BAA8B,CAAC;QAEhD,0CAA0C;QAC1C,MAAM,QAAQ,GAA2C;YACvD,OAAO,EAAE;gBACP,GAAG,EAAE,mBAAmB;gBACxB,GAAG,EAAE,mBAAmB;aACzB;YACD,MAAM,EAAE;gBACN,GAAG,EAAE,0BAA0B;gBAC/B,GAAG,EAAE,0BAA0B;aAChC;YACD,SAAS,EAAE;gBACT,GAAG,EAAE,qBAAqB;gBAC1B,GAAG,EAAE,qBAAqB;aAC3B;SACF,CAAC;QAEF,MAAM,OAAO,GAAG,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;QAC7C,IAAI,CAAC,OAAO;YAAE,OAAO,IAAI,CAAC;QAE1B,sBAAsB;QACtB,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YACzC,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;YACrD,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YAEjD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvB,0DAA0D;gBAC1D,OAAO,CAAC,IAAI,EAAE,CAAC;gBACf,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;YAC1D,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,0BAA0B;QAC5B,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,QAAQ,CACnB,OAAiB,EACjB,UAAmB,EACnB,UAA6B,EAAE;QAE/B,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,MAAM,OAAO,GAAuB,EAAE,CAAC;QAEvC,wBAAwB;QACxB,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QAEvE,4BAA4B;QAC5B,IAAI,OAAO,CAAC,cAAc,KAAK,KAAK,EAAE,CAAC;YACrC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;QAC5D,CAAC;QAED,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;QAExE,wEAAwE;QACxE,IAAI,UAAU,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxC,IAAI,CAAC;gBACH,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,UAAU,EAAE;oBAC5E,eAAe,EAAE,CAAC,OAAO,CAAC,UAAU;oBACpC,UAAU,EAAE;wBACV,OAAO,EAAE,OAAO,CAAC,OAAO;qBACzB;iBACF,CAAC,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,GAAG,iBAAiB,CAAC,CAAC;YACrC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,OAAO,CAAC,IAAI,CAAC,iCAAiC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACjE,CAAC;QACH,CAAC;QAED,uBAAuB;QACvB,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,MAAM,CAAC;QACtE,MAAM,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,MAAM,CAAC;QAC1E,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,MAAM,CAAC,CAAC,MAAM,CAAC;QAEpE,yBAAyB;QACzB,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAC5D,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;QAE9D,OAAO;YACL,KAAK,EAAE,UAAU,KAAK,CAAC;YACvB,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,SAAS;YACrC,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACnC,gBAAgB,EAAE,OAAO;YACzB,cAAc,EAAE,QAAQ;YACxB,OAAO;YACP,UAAU;YACV,YAAY;YACZ,SAAS;YACT,YAAY;YACZ,UAAU,EAAE,UAAU;YACtB,QAAQ,EAAE,CAAC,YAAY,GAAG,UAAU,CAAC,GAAG,GAAG;YAC3C,cAAc,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;YACtC,UAAU,EAAE,OAAO,CAAC,eAAe;YACnC,YAAY,EAAE,OAAO,CAAC,iBAAiB;YACvC,MAAM,EAAE,UAAU;SACnB,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,YAAY,CAAC,UAAmB;QACtC,IAAI,CAAC,UAAU;YAAE,OAAO,SAAS,CAAC;QAElC,IAAI,UAAU,CAAC,QAAQ,CAAC,wDAAwD,CAAC,EAAE,CAAC;YAClF,OAAO,KAAK,CAAC;QACf,CAAC;aAAM,IAAI,UAAU,CAAC,QAAQ,CAAC,0DAA0D,CAAC,EAAE,CAAC;YAC3F,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;OAEG;IACK,kBAAkB,CAAC,OAAgB;QACzC,MAAM,UAAU,GAA2B;YACzC,OAAO,EAAE,GAAG;YACZ,cAAc,EAAE,GAAG;YACnB,aAAa,EAAE,GAAG;YAClB,aAAa,EAAE,GAAG;YAClB,eAAe,EAAE,GAAG;SACrB,CAAC;QAEF,OAAO,UAAU,CAAC,OAAO,IAAI,SAAS,CAAC,IAAI,GAAG,CAAC;IACjD,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,YAAY,CACvB,OAAiB,EACjB,UAAmB;QAEnB,qBAAqB;QACrB,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QAE7C,qCAAqC;QACrC,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACrC,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;YAC/C,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,OAAO,CAAC,IAAI,CAAC,8BAA8B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC9D,CAAC;QACH,CAAC;QAED,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE;YACxC,UAAU,EAAE,MAAM;YAClB,iBAAiB,EAAE,IAAI;YACvB,QAAQ,EAAE,IAAI;YACd,cAAc,EAAE,IAAI;SACrB,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACI,aAAa;QAClB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,sBAAsB;QAKjC,MAAM,SAAS,GAA8D,EAAE,CAAC;QAEhF,KAAK,MAAM,QAAQ,IAAI,CAAC,SAAS,EAAE,QAAQ,EAAE,WAAW,CAAU,EAAE,CAAC;YACnE,KAAK,MAAM,MAAM,IAAI,CAAC,KAAK,EAAE,KAAK,CAAU,EAAE,CAAC;gBAC7C,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;gBACtE,IAAI,cAAc,EAAE,CAAC;oBACnB,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC;gBAC7D,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;CACF;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,QAA4C,EAC5C,MAAqB;IAErB,MAAM,SAAS,GAAG,IAAI,mBAAmB,EAAE,CAAC;IAE5C,IAAI,CAAC;QACH,MAAM,SAAS,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACnD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,IAAI,CAAC,gCAAgC,QAAQ,IAAI,MAAM,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;IACvF,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC"}

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

@@ -0,0 +1,79 @@
+import type { ValidationResult } from './validation.types.js';
+/**
+ * Schematron validation options
+ */
+export interface SchematronOptions {
+    phase?: string;
+    parameters?: Record<string, any>;
+    includeWarnings?: boolean;
+    maxErrors?: number;
+}
+/**
+ * Schematron validation engine using Saxon-JS
+ * Provides official standards validation through Schematron rules
+ */
+export declare class SchematronValidator {
+    private compiledStylesheet;
+    private schematronRules;
+    private isCompiled;
+    constructor(schematronRules?: string);
+    /**
+     * Load Schematron rules from file or string
+     */
+    loadSchematron(source: string, isFilePath?: boolean): Promise<void>;
+    /**
+     * Compile Schematron to XSLT using ISO Schematron skeleton
+     */
+    private compileSchematron;
+    /**
+     * Validate an XML document against loaded Schematron rules
+     */
+    validate(xmlContent: string, options?: SchematronOptions): Promise<ValidationResult[]>;
+    /**
+     * Parse SVRL output to ValidationResult array
+     */
+    private parseSVRL;
+    /**
+     * Extract ValidationResult from SVRL element
+     */
+    private extractValidationResult;
+    /**
+     * Generate simplified XSLT from Schematron
+     * This is a placeholder - in production, use ISO Schematron skeleton
+     */
+    private generateXSLTFromSchematron;
+    /**
+     * Check if validator has rules loaded
+     */
+    hasRules(): boolean;
+    /**
+     * Get list of available phases from Schematron
+     */
+    getPhases(): Promise<string[]>;
+    /**
+     * Validate with specific phase activated
+     */
+    validateWithPhase(xmlContent: string, phase: string, options?: SchematronOptions): Promise<ValidationResult[]>;
+}
+/**
+ * Factory function to create validator with standard Schematron packs
+ */
+export declare function createStandardValidator(standard: 'EN16931' | 'XRECHNUNG' | 'PEPPOL' | 'FACTURX'): Promise<SchematronValidator>;
+/**
+ * Hybrid validator that combines TypeScript and Schematron validation
+ */
+export declare class HybridValidator {
+    private schematronValidator;
+    private tsValidators;
+    constructor(schematronValidator?: SchematronValidator);
+    /**
+     * Add a TypeScript validator to the pipeline
+     */
+    addTSValidator(validator: {
+        validate: (xml: string) => ValidationResult[];
+    }): void;
+    /**
+     * Run all validators and merge results
+     */
+    validate(xmlContent: string, options?: SchematronOptions): Promise<ValidationResult[]>;
+}