@fin.cx/einvoice 5.0.3 → 5.1.2

package/dist_ts_install/download-test-samples.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * Download official EN16931 and PEPPOL test samples for conformance testing
+ */
+interface TestSampleSource {
+    name: string;
+    description: string;
+    repository: string;
+    branch: string;
+    paths: string[];
+    targetDir: string;
+}
+declare const TEST_SAMPLE_SOURCES: TestSampleSource[];
+/**
+ * Main function
+ */
+declare function main(): Promise<void>;
+export default main;
+export { TEST_SAMPLE_SOURCES };

package/dist_ts_install/download-test-samples.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+/**
+ * Download official EN16931 and PEPPOL test samples for conformance testing
+ */
+import * as https from 'https';
+import * as fs from 'fs';
+import * as path from 'path';
+import { createWriteStream } from 'fs';
+import { pipeline } from 'stream/promises';
+import { fileURLToPath } from 'url';
+const TEST_SAMPLE_SOURCES = [
+    {
+        name: 'PEPPOL BIS 3.0 Examples',
+        description: 'Official PEPPOL BIS Billing 3.0 example files',
+        repository: 'OpenPEPPOL/peppol-bis-invoice-3',
+        branch: 'master',
+        paths: [
+            'rules/examples/Allowance-example.xml',
+            'rules/examples/base-example.xml',
+            'rules/examples/base-negative-inv-correction.xml',
+            'rules/examples/vat-category-E.xml',
+            'rules/examples/vat-category-O.xml',
+            'rules/examples/vat-category-S.xml',
+            'rules/examples/vat-category-Z.xml',
+            'rules/examples/vat-category-AE.xml',
+            'rules/examples/vat-category-K.xml',
+            'rules/examples/vat-category-G.xml'
+        ],
+        targetDir: 'peppol-bis3'
+    },
+    {
+        name: 'CEN TC434 Test Files',
+        description: 'European Committee for Standardization test files',
+        repository: 'ConnectingEurope/eInvoicing-EN16931',
+        branch: 'master',
+        paths: [
+            'ubl/examples/ubl-tc434-example1.xml',
+            'ubl/examples/ubl-tc434-example2.xml',
+            'ubl/examples/ubl-tc434-example3.xml',
+            'ubl/examples/ubl-tc434-example4.xml',
+            'ubl/examples/ubl-tc434-example5.xml',
+            'ubl/examples/ubl-tc434-example6.xml',
+            'ubl/examples/ubl-tc434-example7.xml',
+            'ubl/examples/ubl-tc434-example8.xml',
+            'ubl/examples/ubl-tc434-example9.xml',
+            'cii/examples/cii-tc434-example1.xml',
+            'cii/examples/cii-tc434-example2.xml',
+            'cii/examples/cii-tc434-example3.xml',
+            'cii/examples/cii-tc434-example4.xml',
+            'cii/examples/cii-tc434-example5.xml',
+            'cii/examples/cii-tc434-example6.xml',
+            'cii/examples/cii-tc434-example7.xml',
+            'cii/examples/cii-tc434-example8.xml',
+            'cii/examples/cii-tc434-example9.xml'
+        ],
+        targetDir: 'cen-tc434'
+    },
+    {
+        name: 'PEPPOL Validation Artifacts',
+        description: 'PEPPOL validation test files',
+        repository: 'OpenPEPPOL/peppol-bis-invoice-3',
+        branch: 'master',
+        paths: [
+            'rules/unit-UBL/PEPPOL-EN16931-UBL.xml'
+        ],
+        targetDir: 'peppol-validation'
+    }
+];
+/**
+ * Download a file from GitHub
+ */
+async function downloadFile(repo, branch, filePath, targetPath) {
+    const url = `https://raw.githubusercontent.com/${repo}/${branch}/${filePath}`;
+    return new Promise((resolve, reject) => {
+        https.get(url, (response) => {
+            if (response.statusCode === 404) {
+                console.warn(`  ⚠️  File not found: ${filePath}`);
+                resolve();
+                return;
+            }
+            if (response.statusCode !== 200) {
+                reject(new Error(`Failed to download ${url}: ${response.statusCode}`));
+                return;
+            }
+            const dir = path.dirname(targetPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            const file = createWriteStream(targetPath);
+            response.pipe(file);
+            file.on('finish', () => {
+                file.close();
+                console.log(`  ✅ Downloaded: ${path.basename(filePath)}`);
+                resolve();
+            });
+            file.on('error', (err) => {
+                fs.unlink(targetPath, () => { }); // Delete incomplete file
+                reject(err);
+            });
+        }).on('error', reject);
+    });
+}
+/**
+ * Download test samples from a source
+ */
+async function downloadTestSamples(source) {
+    console.log(`\n📦 ${source.name}`);
+    console.log(`   ${source.description}`);
+    console.log(`   Repository: ${source.repository}`);
+    const baseDir = path.join('test-samples', source.targetDir);
+    for (const filePath of source.paths) {
+        const fileName = path.basename(filePath);
+        const targetPath = path.join(baseDir, fileName);
+        try {
+            await downloadFile(source.repository, source.branch, filePath, targetPath);
+        }
+        catch (error) {
+            console.error(`  ❌ Error downloading ${fileName}: ${error.message}`);
+        }
+    }
+}
+/**
+ * Create metadata file for downloaded samples
+ */
+function createMetadata(sources) {
+    const metadata = {
+        downloadDate: new Date().toISOString(),
+        sources: sources.map(s => ({
+            name: s.name,
+            repository: s.repository,
+            branch: s.branch,
+            fileCount: s.paths.length
+        })),
+        totalFiles: sources.reduce((sum, s) => sum + s.paths.length, 0)
+    };
+    const metadataPath = path.join('test-samples', 'metadata.json');
+    fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+    console.log('\n📝 Created metadata.json');
+}
+/**
+ * Main function
+ */
+async function main() {
+    console.log('🚀 Downloading official EN16931 test samples...\n');
+    // Create base directory
+    if (!fs.existsSync('test-samples')) {
+        fs.mkdirSync('test-samples');
+    }
+    // Download samples from each source
+    for (const source of TEST_SAMPLE_SOURCES) {
+        await downloadTestSamples(source);
+    }
+    // Create metadata file
+    createMetadata(TEST_SAMPLE_SOURCES);
+    console.log('\n✨ Test sample download complete!');
+    console.log('📁 Samples saved to: test-samples/');
+    // Count total files
+    const totalFiles = TEST_SAMPLE_SOURCES.reduce((sum, s) => sum + s.paths.length, 0);
+    console.log(`📊 Total files: ${totalFiles}`);
+}
+// Run if executed directly
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch(console.error);
+}
+export default main;
+export { TEST_SAMPLE_SOURCES };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG93bmxvYWQtdGVzdC1zYW1wbGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfaW5zdGFsbC9kb3dubG9hZC10ZXN0LXNhbXBsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUVBOztHQUVHO0FBRUgsT0FBTyxLQUFLLEtBQUssTUFBTSxPQUFPLENBQUM7QUFDL0IsT0FBTyxLQUFLLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFDekIsT0FBTyxLQUFLLElBQUksTUFBTSxNQUFNLENBQUM7QUFDN0IsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3ZDLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMzQyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBV3BDLE1BQU0sbUJBQW1CLEdBQXVCO0lBQzlDO1FBQ0UsSUFBSSxFQUFFLHlCQUF5QjtRQUMvQixXQUFXLEVBQUUsK0NBQStDO1FBQzVELFVBQVUsRUFBRSxpQ0FBaUM7UUFDN0MsTUFBTSxFQUFFLFFBQVE7UUFDaEIsS0FBSyxFQUFFO1lBQ0wsc0NBQXNDO1lBQ3RDLGlDQUFpQztZQUNqQyxpREFBaUQ7WUFDakQsbUNBQW1DO1lBQ25DLG1DQUFtQztZQUNuQyxtQ0FBbUM7WUFDbkMsbUNBQW1DO1lBQ25DLG9DQUFvQztZQUNwQyxtQ0FBbUM7WUFDbkMsbUNBQW1DO1NBQ3BDO1FBQ0QsU0FBUyxFQUFFLGFBQWE7S0FDekI7SUFDRDtRQUNFLElBQUksRUFBRSxzQkFBc0I7UUFDNUIsV0FBVyxFQUFFLG1EQUFtRDtRQUNoRSxVQUFVLEVBQUUscUNBQXFDO1FBQ2pELE1BQU0sRUFBRSxRQUFRO1FBQ2hCLEtBQUssRUFBRTtZQUNMLHFDQUFxQztZQUNyQyxxQ0FBcUM7WUFDckMscUNBQXFDO1lBQ3JDLHFDQUFxQztZQUNyQyxxQ0FBcUM7WUFDckMscUNBQXFDO1lBQ3JDLHFDQUFxQztZQUNyQyxxQ0FBcUM7WUFDckMscUNBQXFDO1lBQ3JDLHFDQUFxQztZQUNyQyxxQ0FBcUM7WUFDckMscUNBQXFDO1lBQ3JDLHFDQUFxQztZQUNyQyxxQ0FBcUM7WUFDckMscUNBQXFDO1lBQ3JDLHFDQUFxQztZQUNyQyxxQ0FBcUM7WUFDckMscUNBQXFDO1NBQ3RDO1FBQ0QsU0FBUyxFQUFFLFdBQVc7S0FDdkI7SUFDRDtRQUNFLElBQUksRUFBRSw2QkFBNkI7UUFDbkMsV0FBVyxFQUFFLDhCQUE4QjtRQUMzQyxVQUFVLEVBQUUsaUNBQWlDO1FBQzdDLE1BQU0sRUFBRSxRQUFRO1FBQ2hCLEtBQUssRUFBRTtZQUNMLHVDQUF1QztTQUN4QztRQUNELFNBQVMsRUFBRSxtQkFBbUI7S0FDL0I7Q0FDRixDQUFDO0FBRUY7O0dBRUc7QUFDSCxLQUFLLFVBQVUsWUFBWSxDQUN6QixJQUFZLEVBQ1osTUFBYyxFQUNkLFFBQWdCLEVBQ2hCLFVBQWtCO0lBRWxCLE1BQU0sR0FBRyxHQUFHLHFDQUFxQyxJQUFJLElBQUksTUFBTSxJQUFJLFFBQVEsRUFBRSxDQUFDO0lBRTlFLE9BQU8sSUFBSSxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUU7UUFDckMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxRQUFRLEVBQUUsRUFBRTtZQUMxQixJQUFJLFFBQVEsQ0FBQyxVQUFVLEtBQUssR0FBRyxFQUFFLENBQUM7Z0JBQ2hDLE9BQU8sQ0FBQyxJQUFJLENBQUMseUJBQXlCLFFBQVEsRUFBRSxDQUFDLENBQUM7Z0JBQ2xELE9BQU8sRUFBRSxDQUFDO2dCQUNWLE9BQU87WUFDVCxDQUFDO1lBRUQsSUFBSSxRQUFRLENBQUMsVUFBVSxLQUFLLEdBQUcsRUFBRSxDQUFDO2dCQUNoQyxNQUFNLENBQUMsSUFBSSxLQUFLLENBQUMsc0JBQXNCLEdBQUcsS0FBSyxRQUFRLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQyxDQUFDO2dCQUN2RSxPQUFPO1lBQ1QsQ0FBQztZQUVELE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUM7WUFDckMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQztnQkFDeEIsRUFBRSxDQUFDLFNBQVMsQ0FBQyxHQUFHLEVBQUUsRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztZQUN6QyxDQUFDO1lBRUQsTUFBTSxJQUFJLEdBQUcsaUJBQWlCLENBQUMsVUFBVSxDQUFDLENBQUM7WUFDM0MsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUVwQixJQUFJLENBQUMsRUFBRSxDQUFDLFFBQVEsRUFBRSxHQUFHLEVBQUU7Z0JBQ3JCLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztnQkFDYixPQUFPLENBQUMsR0FBRyxDQUFDLG1CQUFtQixJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUMsQ0FBQztnQkFDMUQsT0FBTyxFQUFFLENBQUM7WUFDWixDQUFDLENBQUMsQ0FBQztZQUVILElBQUksQ0FBQyxFQUFFLENBQUMsT0FBTyxFQUFFLENBQUMsR0FBRyxFQUFFLEVBQUU7Z0JBQ3ZCLEVBQUUsQ0FBQyxNQUFNLENBQUMsVUFBVSxFQUFFLEdBQUcsRUFBRSxHQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMseUJBQXlCO2dCQUMxRCxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7WUFDZCxDQUFDLENBQUMsQ0FBQztRQUNMLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxPQUFPLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDekIsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDO0FBRUQ7O0dBRUc7QUFDSCxLQUFLLFVBQVUsbUJBQW1CLENBQUMsTUFBd0I7SUFDekQsT0FBTyxDQUFDLEdBQUcsQ0FBQyxRQUFRLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQ25DLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxNQUFNLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQztJQUN4QyxPQUFPLENBQUMsR0FBRyxDQUFDLGtCQUFrQixNQUFNLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQztJQUVuRCxNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLGNBQWMsRUFBRSxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUM7SUFFNUQsS0FBSyxNQUFNLFFBQVEsSUFBSSxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDcEMsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUN6QyxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxRQUFRLENBQUMsQ0FBQztRQUVoRCxJQUFJLENBQUM7WUFDSCxNQUFNLFlBQVksQ0FBQyxNQUFNLENBQUMsVUFBVSxFQUFFLE1BQU0sQ0FBQyxNQUFNLEVBQUUsUUFBUSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQzdFLENBQUM7UUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1lBQ2YsT0FBTyxDQUFDLEtBQUssQ0FBQyx5QkFBeUIsUUFBUSxLQUFLLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO1FBQ3ZFLENBQUM7SUFDSCxDQUFDO0FBQ0gsQ0FBQztBQUVEOztHQUVHO0FBQ0gsU0FBUyxjQUFjLENBQUMsT0FBMkI7SUFDakQsTUFBTSxRQUFRLEdBQUc7UUFDZixZQUFZLEVBQUUsSUFBSSxJQUFJLEVBQUUsQ0FBQyxXQUFXLEVBQUU7UUFDdEMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1lBQ3pCLElBQUksRUFBRSxDQUFDLENBQUMsSUFBSTtZQUNaLFVBQVUsRUFBRSxDQUFDLENBQUMsVUFBVTtZQUN4QixNQUFNLEVBQUUsQ0FBQyxDQUFDLE1BQU07WUFDaEIsU0FBUyxFQUFFLENBQUMsQ0FBQyxLQUFLLENBQUMsTUFBTTtTQUMxQixDQUFDLENBQUM7UUFDSCxVQUFVLEVBQUUsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsR0FBRyxDQUFDLENBQUMsS0FBSyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUM7S0FDaEUsQ0FBQztJQUVGLE1BQU0sWUFBWSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsY0FBYyxFQUFFLGVBQWUsQ0FBQyxDQUFDO0lBQ2hFLEVBQUUsQ0FBQyxhQUFhLENBQUMsWUFBWSxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsUUFBUSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ2xFLE9BQU8sQ0FBQyxHQUFHLENBQUMsNEJBQTRCLENBQUMsQ0FBQztBQUM1QyxDQUFDO0FBRUQ7O0dBRUc7QUFDSCxLQUFLLFVBQVUsSUFBSTtJQUNqQixPQUFPLENBQUMsR0FBRyxDQUFDLG1EQUFtRCxDQUFDLENBQUM7SUFFakUsd0JBQXdCO0lBQ3hCLElBQUksQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLGNBQWMsQ0FBQyxFQUFFLENBQUM7UUFDbkMsRUFBRSxDQUFDLFNBQVMsQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUMvQixDQUFDO0lBRUQsb0NBQW9DO0lBQ3BDLEtBQUssTUFBTSxNQUFNLElBQUksbUJBQW1CLEVBQUUsQ0FBQztRQUN6QyxNQUFNLG1CQUFtQixDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ3BDLENBQUM7SUFFRCx1QkFBdUI7SUFDdkIsY0FBYyxDQUFDLG1CQUFtQixDQUFDLENBQUM7SUFFcEMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxvQ0FBb0MsQ0FBQyxDQUFDO0lBQ2xELE9BQU8sQ0FBQyxHQUFHLENBQUMsb0NBQW9DLENBQUMsQ0FBQztJQUVsRCxvQkFBb0I7SUFDcEIsTUFBTSxVQUFVLEdBQUcsbUJBQW1CLENBQUMsTUFBTSxDQUFDLENBQUMsR0FBRyxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsR0FBRyxHQUFHLENBQUMsQ0FBQyxLQUFLLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ25GLE9BQU8sQ0FBQyxHQUFHLENBQUMsbUJBQW1CLFVBQVUsRUFBRSxDQUFDLENBQUM7QUFDL0MsQ0FBQztBQUVELDJCQUEyQjtBQUMzQixNQUFNLFVBQVUsR0FBRyxhQUFhLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNsRCxNQUFNLFNBQVMsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQUFDO0FBRTNDLElBQUksTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLEtBQUssVUFBVSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQztJQUNwRCxJQUFJLEVBQUUsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDO0FBQzlCLENBQUM7QUFFRCxlQUFlLElBQUksQ0FBQztBQUNwQixPQUFPLEVBQUUsbUJBQW1CLEVBQUUsQ0FBQyJ9

package/dist_ts_install/download-xrechnung-rules.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env tsx
+/**
+ * Downloads official XRechnung Schematron validation rules
+ * from the KoSIT repositories
+ */
+declare function downloadXRechnungRules(): Promise<void>;
+export default downloadXRechnungRules;

package/dist_ts_install/download-xrechnung-rules.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env tsx
+/**
+ * Downloads official XRechnung Schematron validation rules
+ * from the KoSIT repositories
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+const XRECHNUNG_VERSION = '3.0.2'; // Latest version as of 2025
+const VALIDATOR_VERSION = '2025-07-31'; // Next release date
+const REPOS = {
+    schematron: {
+        url: 'https://github.com/itplr-kosit/xrechnung-schematron/archive/refs/tags/release-3.0.2.zip',
+        dir: 'xrechnung-schematron'
+    },
+    validator: {
+        url: 'https://github.com/itplr-kosit/validator-configuration-xrechnung/releases/download/release-2024-07-31/validator-configuration-xrechnung_3.0.1_2024-07-31.zip',
+        dir: 'xrechnung-validator'
+    }
+};
+const ASSETS_DIR = path.join(process.cwd(), 'assets', 'schematron', 'xrechnung');
+async function downloadFile(url, destination) {
+    console.log(`Downloading ${url}...`);
+    try {
+        // Use curl to download the file
+        execSync(`curl -L -o "${destination}" "${url}"`, { stdio: 'inherit' });
+        console.log(`Downloaded to ${destination}`);
+    }
+    catch (error) {
+        console.error(`Failed to download ${url}:`, error);
+        throw error;
+    }
+}
+async function extractZip(zipFile, destination) {
+    console.log(`Extracting ${zipFile}...`);
+    try {
+        // Create destination directory if it doesn't exist
+        fs.mkdirSync(destination, { recursive: true });
+        // Extract using unzip
+        execSync(`unzip -o "${zipFile}" -d "${destination}"`, { stdio: 'inherit' });
+        console.log(`Extracted to ${destination}`);
+    }
+    catch (error) {
+        console.error(`Failed to extract ${zipFile}:`, error);
+        throw error;
+    }
+}
+async function downloadXRechnungRules() {
+    console.log('Starting XRechnung Schematron rules download...\n');
+    // Create assets directory
+    fs.mkdirSync(ASSETS_DIR, { recursive: true });
+    const tempDir = path.join(ASSETS_DIR, 'temp');
+    fs.mkdirSync(tempDir, { recursive: true });
+    // Download and extract Schematron rules
+    console.log('1. Downloading XRechnung Schematron rules...');
+    const schematronZip = path.join(tempDir, 'xrechnung-schematron.zip');
+    await downloadFile(REPOS.schematron.url, schematronZip);
+    const schematronDir = path.join(ASSETS_DIR, REPOS.schematron.dir);
+    await extractZip(schematronZip, schematronDir);
+    // Find the actual Schematron files
+    const schematronExtractedDir = path.join(schematronDir, `xrechnung-schematron-release-${XRECHNUNG_VERSION}`);
+    const schematronValidationDir = path.join(schematronExtractedDir, 'validation', 'schematron');
+    if (fs.existsSync(schematronValidationDir)) {
+        console.log('\nFound Schematron validation files:');
+        // List UBL Schematron files
+        const ublDir = path.join(schematronValidationDir, 'ubl-inv');
+        if (fs.existsSync(ublDir)) {
+            const ublFiles = fs.readdirSync(ublDir).filter(f => f.endsWith('.sch') || f.endsWith('.xsl'));
+            console.log('  UBL Invoice Schematron:', ublFiles.join(', '));
+        }
+        // List CII Schematron files
+        const ciiDir = path.join(schematronValidationDir, 'cii');
+        if (fs.existsSync(ciiDir)) {
+            const ciiFiles = fs.readdirSync(ciiDir).filter(f => f.endsWith('.sch') || f.endsWith('.xsl'));
+            console.log('  CII Schematron:', ciiFiles.join(', '));
+        }
+        // Copy to final location
+        const finalUblDir = path.join(ASSETS_DIR, 'ubl');
+        const finalCiiDir = path.join(ASSETS_DIR, 'cii');
+        fs.mkdirSync(finalUblDir, { recursive: true });
+        fs.mkdirSync(finalCiiDir, { recursive: true });
+        // Copy UBL files
+        if (fs.existsSync(ublDir)) {
+            const ublFiles = fs.readdirSync(ublDir);
+            for (const file of ublFiles) {
+                if (file.endsWith('.sch') || file.endsWith('.xsl')) {
+                    fs.copyFileSync(path.join(ublDir, file), path.join(finalUblDir, file));
+                }
+            }
+            console.log(`\nCopied UBL Schematron files to ${finalUblDir}`);
+        }
+        // Copy CII files
+        if (fs.existsSync(ciiDir)) {
+            const ciiFiles = fs.readdirSync(ciiDir);
+            for (const file of ciiFiles) {
+                if (file.endsWith('.sch') || file.endsWith('.xsl')) {
+                    fs.copyFileSync(path.join(ciiDir, file), path.join(finalCiiDir, file));
+                }
+            }
+            console.log(`Copied CII Schematron files to ${finalCiiDir}`);
+        }
+    }
+    // Download validator configuration (contains additional rules and scenarios)
+    console.log('\n2. Downloading XRechnung validator configuration...');
+    const validatorZip = path.join(tempDir, 'xrechnung-validator.zip');
+    await downloadFile(REPOS.validator.url, validatorZip);
+    const validatorDir = path.join(ASSETS_DIR, REPOS.validator.dir);
+    await extractZip(validatorZip, validatorDir);
+    // Create metadata file
+    const metadata = {
+        version: XRECHNUNG_VERSION,
+        validatorVersion: VALIDATOR_VERSION,
+        downloadDate: new Date().toISOString(),
+        sources: {
+            schematron: REPOS.schematron.url,
+            validator: REPOS.validator.url
+        },
+        files: {
+            ubl: fs.existsSync(path.join(ASSETS_DIR, 'ubl'))
+                ? fs.readdirSync(path.join(ASSETS_DIR, 'ubl')).filter(f => f.endsWith('.sch'))
+                : [],
+            cii: fs.existsSync(path.join(ASSETS_DIR, 'cii'))
+                ? fs.readdirSync(path.join(ASSETS_DIR, 'cii')).filter(f => f.endsWith('.sch'))
+                : []
+        }
+    };
+    fs.writeFileSync(path.join(ASSETS_DIR, 'metadata.json'), JSON.stringify(metadata, null, 2));
+    // Clean up temp directory
+    console.log('\n3. Cleaning up...');
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    console.log('\n✅ XRechnung Schematron rules downloaded successfully!');
+    console.log(`📁 Files are located in: ${ASSETS_DIR}`);
+    console.log('\nNext steps:');
+    console.log('1. Run Saxon-JS to compile .sch files to SEF format');
+    console.log('2. Integrate with SchematronValidator');
+    console.log('3. Add XRechnung-specific TypeScript validators');
+}
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    downloadXRechnungRules().catch(error => {
+        console.error('Failed to download XRechnung rules:', error);
+        process.exit(1);
+    });
+}
+export default downloadXRechnungRules;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"download-xrechnung-rules.js","sourceRoot":"","sources":["../ts_install/download-xrechnung-rules.ts"],"names":[],"mappings":";AACA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AACzB,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,MAAM,iBAAiB,GAAG,OAAO,CAAC,CAAC,4BAA4B;AAC/D,MAAM,iBAAiB,GAAG,YAAY,CAAC,CAAC,oBAAoB;AAE5D,MAAM,KAAK,GAAG;IACZ,UAAU,EAAE;QACV,GAAG,EAAE,yFAAyF;QAC9F,GAAG,EAAE,sBAAsB;KAC5B;IACD,SAAS,EAAE;QACT,GAAG,EAAE,8JAA8J;QACnK,GAAG,EAAE,qBAAqB;KAC3B;CACF,CAAC;AAEF,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAE,WAAW,CAAC,CAAC;AAEjF,KAAK,UAAU,YAAY,CAAC,GAAW,EAAE,WAAmB;IAC1D,OAAO,CAAC,GAAG,CAAC,eAAe,GAAG,KAAK,CAAC,CAAC;IAErC,IAAI,CAAC;QACH,gCAAgC;QAChC,QAAQ,CAAC,eAAe,WAAW,MAAM,GAAG,GAAG,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;QACvE,OAAO,CAAC,GAAG,CAAC,iBAAiB,WAAW,EAAE,CAAC,CAAC;IAC9C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,sBAAsB,GAAG,GAAG,EAAE,KAAK,CAAC,CAAC;QACnD,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,KAAK,UAAU,UAAU,CAAC,OAAe,EAAE,WAAmB;IAC5D,OAAO,CAAC,GAAG,CAAC,cAAc,OAAO,KAAK,CAAC,CAAC;IAExC,IAAI,CAAC;QACH,mDAAmD;QACnD,EAAE,CAAC,SAAS,CAAC,WAAW,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAE/C,sBAAsB;QACtB,QAAQ,CAAC,aAAa,OAAO,SAAS,WAAW,GAAG,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;QAC5E,OAAO,CAAC,GAAG,CAAC,gBAAgB,WAAW,EAAE,CAAC,CAAC;IAC7C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,qBAAqB,OAAO,GAAG,EAAE,KAAK,CAAC,CAAC;QACtD,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,KAAK,UAAU,sBAAsB;IACnC,OAAO,CAAC,GAAG,CAAC,mDAAmD,CAAC,CAAC;IAEjE,0BAA0B;IAC1B,EAAE,CAAC,SAAS,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAE9C,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAC9C,EAAE,CAAC,SAAS,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAE3C,wCAAwC;IACxC,OAAO,CAAC,GAAG,CAAC,8CAA8C,CAAC,CAAC;IAC5D,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,0BAA0B,CAAC,CAAC;IACrE,MAAM,YAAY,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC;IAExD,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IAClE,MAAM,UAAU,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IAE/C,mCAAmC;IACnC,MAAM,sBAAsB,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,gCAAgC,iBAAiB,EAAE,CAAC,CAAC;IAC7G,MAAM,uBAAuB,GAAG,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;IAE9F,IAAI,EAAE,CAAC,UAAU,CAAC,uBAAuB,CAAC,EAAE,CAAC;QAC3C,OAAO,CAAC,GAAG,CAAC,sCAAsC,CAAC,CAAC;QAEpD,4BAA4B;QAC5B,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,uBAAuB,EAAE,SAAS,CAAC,CAAC;QAC7D,IAAI,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1B,MAAM,QAAQ,GAAG,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;YAC9F,OAAO,CAAC,GAAG,CAAC,2BAA2B,EAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAChE,CAAC;QAED,4BAA4B;QAC5B,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,uBAAuB,EAAE,KAAK,CAAC,CAAC;QACzD,IAAI,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1B,MAAM,QAAQ,GAAG,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;YAC9F,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QACxD,CAAC;QAED,yBAAyB;QACzB,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QACjD,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QAEjD,EAAE,CAAC,SAAS,CAAC,WAAW,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/C,EAAE,CAAC,SAAS,CAAC,WAAW,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAE/C,iBAAiB;QACjB,IAAI,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1B,MAAM,QAAQ,GAAG,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YACxC,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;gBAC5B,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;oBACnD,EAAE,CAAC,YAAY,CACb,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,EACvB,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,CAC7B,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,OAAO,CAAC,GAAG,CAAC,oCAAoC,WAAW,EAAE,CAAC,CAAC;QACjE,CAAC;QAED,iBAAiB;QACjB,IAAI,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1B,MAAM,QAAQ,GAAG,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YACxC,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;gBAC5B,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;oBACnD,EAAE,CAAC,YAAY,CACb,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,EACvB,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,CAC7B,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,OAAO,CAAC,GAAG,CAAC,kCAAkC,WAAW,EAAE,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;IAED,6EAA6E;IAC7E,OAAO,CAAC,GAAG,CAAC,uDAAuD,CAAC,CAAC;IACrE,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,yBAAyB,CAAC,CAAC;IACnE,MAAM,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;IAEtD,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAChE,MAAM,UAAU,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;IAE7C,uBAAuB;IACvB,MAAM,QAAQ,GAAG;QACf,OAAO,EAAE,iBAAiB;QAC1B,gBAAgB,EAAE,iBAAiB;QACnC,YAAY,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACtC,OAAO,EAAE;YACP,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,GAAG;YAChC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG;SAC/B;QACD,KAAK,EAAE;YACL,GAAG,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;gBAC9C,CAAC,CAAC,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBAC9E,CAAC,CAAC,EAAE;YACN,GAAG,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;gBAC9C,CAAC,CAAC,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBAC9E,CAAC,CAAC,EAAE;SACP;KACF,CAAC;IAEF,EAAE,CAAC,aAAa,CACd,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,eAAe,CAAC,EACtC,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAClC,CAAC;IAEF,0BAA0B;IAC1B,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;IACnC,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IAErD,OAAO,CAAC,GAAG,CAAC,yDAAyD,CAAC,CAAC;IACvE,OAAO,CAAC,GAAG,CAAC,4BAA4B,UAAU,EAAE,CAAC,CAAC;IACtD,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;IAC7B,OAAO,CAAC,GAAG,CAAC,qDAAqD,CAAC,CAAC;IACnE,OAAO,CAAC,GAAG,CAAC,uCAAuC,CAAC,CAAC;IACrD,OAAO,CAAC,GAAG,CAAC,iDAAiD,CAAC,CAAC;AACjE,CAAC;AAED,2BAA2B;AAC3B,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,UAAU,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;IACpD,sBAAsB,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;QACrC,OAAO,CAAC,KAAK,CAAC,qCAAqC,EAAE,KAAK,CAAC,CAAC;QAC5D,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,eAAe,sBAAsB,CAAC"}

package/dist_ts_install/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Post-install script to download required validation resources
+ * This script is automatically run after npm/pnpm install
+ * All users need validation capabilities, so this is mandatory
+ */
+declare function main(): Promise<void>;
+export default main;

package/dist_ts_install/index.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+/**
+ * Post-install script to download required validation resources
+ * This script is automatically run after npm/pnpm install
+ * All users need validation capabilities, so this is mandatory
+ */
+import { SchematronDownloader } from '../dist_ts/formats/validation/schematron.downloader.js';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as crypto from 'crypto';
+// Version for cache invalidation
+const RESOURCES_VERSION = '1.0.0';
+/**
+ * Check if we're in a proper npm install context
+ */
+function isValidInstallContext() {
+    // Skip if we're in a git install or similar
+    if (process.env.npm_lifecycle_event !== 'postinstall') {
+        return false;
+    }
+    // Skip in CI if explicitly disabled
+    if (process.env.CI && process.env.EINVOICE_SKIP_RESOURCES) {
+        console.log('⏭️  Skipping resource download (EINVOICE_SKIP_RESOURCES set)');
+        return false;
+    }
+    return true;
+}
+/**
+ * Create a checksum for a file
+ */
+function getFileChecksum(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        const content = fs.readFileSync(filePath);
+        return crypto.createHash('sha256').update(content).digest('hex');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if resources are already downloaded and valid
+ */
+function checkExistingResources() {
+    const versionFile = path.join('assets_downloaded', 'schematron', '.version');
+    try {
+        if (!fs.existsSync(versionFile))
+            return false;
+        const version = fs.readFileSync(versionFile, 'utf-8').trim();
+        if (version !== RESOURCES_VERSION) {
+            console.log('📦 Resource version mismatch, re-downloading...');
+            return false;
+        }
+        // Check if key files exist
+        const keyFiles = [
+            'assets_downloaded/schematron/EN16931-UBL-v1.3.14.sch',
+            'assets_downloaded/schematron/EN16931-CII-v1.3.14.sch',
+            'assets_downloaded/schematron/PEPPOL-EN16931-UBL-v3.0.17.sch'
+        ];
+        for (const file of keyFiles) {
+            if (!fs.existsSync(file)) {
+                console.log(`📦 Missing ${file}, re-downloading resources...`);
+                return false;
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Save version file after successful download
+ */
+function saveVersionFile() {
+    const versionFile = path.join('assets_downloaded', 'schematron', '.version');
+    try {
+        fs.mkdirSync(path.dirname(versionFile), { recursive: true });
+        fs.writeFileSync(versionFile, RESOURCES_VERSION);
+    }
+    catch (error) {
+        console.warn('⚠️  Could not save version file:', error.message);
+    }
+}
+async function downloadSchematron() {
+    console.log('📥 Downloading Schematron validation files...\n');
+    const downloader = new SchematronDownloader('assets_downloaded/schematron');
+    await downloader.initialize();
+    let successCount = 0;
+    let failCount = 0;
+    // Download EN16931 Schematron files
+    console.log('🔵 Downloading EN16931 Schematron files...');
+    try {
+        const en16931Files = await downloader.downloadStandard('EN16931');
+        console.log(`✅ Downloaded ${en16931Files.length} EN16931 files`);
+        successCount += en16931Files.length;
+    }
+    catch (error) {
+        console.error(`⚠️  Failed to download EN16931: ${error.message}`);
+        failCount++;
+    }
+    // Download PEPPOL Schematron files
+    console.log('\n🔵 Downloading PEPPOL Schematron files...');
+    try {
+        const peppolFiles = await downloader.downloadStandard('PEPPOL');
+        console.log(`✅ Downloaded ${peppolFiles.length} PEPPOL files`);
+        successCount += peppolFiles.length;
+    }
+    catch (error) {
+        console.error(`⚠️  Failed to download PEPPOL: ${error.message}`);
+        failCount++;
+    }
+    // Download XRechnung Schematron files
+    console.log('\n🔵 Downloading XRechnung Schematron files...');
+    try {
+        const xrechnungFiles = await downloader.downloadStandard('XRECHNUNG');
+        console.log(`✅ Downloaded ${xrechnungFiles.length} XRechnung files`);
+        successCount += xrechnungFiles.length;
+    }
+    catch (error) {
+        console.error(`⚠️  Failed to download XRechnung: ${error.message}`);
+        failCount++;
+    }
+    // Report results
+    if (successCount > 0) {
+        saveVersionFile();
+        console.log(`\n✅ Successfully downloaded ${successCount} validation files`);
+    }
+    if (failCount > 0) {
+        console.log(`⚠️  Failed to download ${failCount} resource sets`);
+        console.log('   Some validation features may be limited');
+    }
+    return { successCount, failCount };
+}
+async function main() {
+    // Check if we should run
+    if (!isValidInstallContext()) {
+        return;
+    }
+    console.log('='.repeat(60));
+    console.log('🚀 @fin.cx/einvoice - Validation Resources Setup');
+    console.log('='.repeat(60));
+    console.log();
+    try {
+        // Check if resources already exist and are current
+        if (checkExistingResources()) {
+            console.log('✅ Validation resources already installed and up-to-date');
+            console.log();
+            return;
+        }
+        // Check if we're in the right directory
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+        if (!fs.existsSync(packageJsonPath)) {
+            console.error('❌ Error: package.json not found');
+            console.error('   Installation context issue - skipping resource download');
+            return;
+        }
+        // Check if dist_ts exists (module should be built)
+        const distPath = path.join(process.cwd(), 'dist_ts');
+        if (!fs.existsSync(distPath)) {
+            console.log('⚠️  Module not yet built - skipping resource download');
+            console.log('   Resources will be downloaded on first use');
+            return;
+        }
+        // Check network connectivity (simple DNS check)
+        try {
+            await import('dns').then(dns => new Promise((resolve, reject) => {
+                dns.lookup('github.com', (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(true);
+                });
+            }));
+        }
+        catch {
+            console.log('⚠️  No network connectivity detected');
+            console.log('   Validation resources will be downloaded on first use');
+            console.log('   when network is available');
+            return;
+        }
+        // Download resources with retry logic
+        let attempts = 0;
+        const maxAttempts = 3;
+        let lastError;
+        while (attempts < maxAttempts) {
+            attempts++;
+            if (attempts > 1) {
+                console.log(`\n🔄 Retry attempt ${attempts}/${maxAttempts}...`);
+            }
+            try {
+                const { successCount, failCount } = await downloadSchematron();
+                if (successCount > 0) {
+                    console.log();
+                    console.log('='.repeat(60));
+                    console.log('✅ Validation resources installed successfully!');
+                    console.log('='.repeat(60));
+                    console.log();
+                    return;
+                }
+                if (failCount > 0 && attempts < maxAttempts) {
+                    console.log(`\n⚠️  Some downloads failed, retrying...`);
+                    await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2s before retry
+                    continue;
+                }
+                break;
+            }
+            catch (error) {
+                lastError = error;
+                if (attempts < maxAttempts) {
+                    console.log(`\n⚠️  Download failed: ${error.message}`);
+                    console.log('   Retrying...');
+                    await new Promise(resolve => setTimeout(resolve, 3000)); // Wait 3s before retry
+                }
+            }
+        }
+        // If we get here, downloads failed after retries
+        console.error();
+        console.error('⚠️  Could not download all validation resources');
+        console.error('   The library will work but validation features may be limited');
+        console.error('   Resources will be attempted again on first use');
+        console.error();
+        if (lastError) {
+            console.error('   Last error:', lastError.message);
+        }
+    }
+    catch (error) {
+        // Catch-all for unexpected errors
+        console.error();
+        console.error('⚠️  Unexpected error during resource setup:', error.message);
+        console.error('   This won\'t affect library installation');
+        console.error('   Resources will be downloaded on first use');
+        console.error();
+    }
+}
+// Only run if this is the main module
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch(error => {
+        console.error('⚠️  Resource setup error:', error.message);
+        // Never fail the install
+        process.exit(0);
+    });
+}
+export default main;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts_install/index.ts"],"names":[],"mappings":"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"}