@fin.cx/einvoice 5.0.2

package/dist_ts/errors.js

@@ -0,0 +1,241 @@
+/**
+ * Base error class for all EInvoice-related errors
+ */
+export class EInvoiceError extends Error {
+    constructor(message, code, details, cause) {
+        super(message);
+        this.name = 'EInvoiceError';
+        this.code = code;
+        this.details = details;
+        this.cause = cause;
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * Returns a detailed error message including cause if available
+     */
+    getDetailedMessage() {
+        let message = `${this.name} [${this.code}]: ${this.message}`;
+        if (this.details) {
+            message += `\nDetails: ${JSON.stringify(this.details, null, 2)}`;
+        }
+        if (this.cause) {
+            message += `\nCaused by: ${this.cause.message}`;
+        }
+        return message;
+    }
+}
+/**
+ * Error thrown when XML parsing fails
+ */
+export class EInvoiceParsingError extends EInvoiceError {
+    constructor(message, details, cause) {
+        super(message, 'PARSE_ERROR', details, cause);
+        this.name = 'EInvoiceParsingError';
+        this.line = details?.line;
+        this.column = details?.column;
+        this.xmlSnippet = details?.xmlSnippet;
+    }
+    /**
+     * Returns a user-friendly error message with location information
+     */
+    getLocationMessage() {
+        let message = this.message;
+        if (this.line !== undefined && this.column !== undefined) {
+            message += ` at line ${this.line}, column ${this.column}`;
+        }
+        if (this.xmlSnippet) {
+            message += `\nNear: ${this.xmlSnippet}`;
+        }
+        return message;
+    }
+}
+/**
+ * Error thrown when validation fails
+ */
+export class EInvoiceValidationError extends EInvoiceError {
+    constructor(message, validationErrors, details) {
+        super(message, 'VALIDATION_ERROR', details);
+        this.name = 'EInvoiceValidationError';
+        this.validationErrors = validationErrors;
+    }
+    /**
+     * Returns a formatted validation report
+     */
+    getValidationReport() {
+        let report = `${this.message}\n\nValidation errors:\n`;
+        for (const error of this.validationErrors) {
+            report += `- [${error.code}] ${error.message}`;
+            if (error.location) {
+                report += ` (at ${error.location})`;
+            }
+            if (error.severity) {
+                report += ` [${error.severity.toUpperCase()}]`;
+            }
+            report += '\n';
+        }
+        return report;
+    }
+    /**
+     * Gets validation errors by severity
+     */
+    getErrorsBySeverity(severity) {
+        return this.validationErrors.filter(e => (e.severity || 'error') === severity);
+    }
+}
+/**
+ * Error thrown during PDF operations
+ */
+export class EInvoicePDFError extends EInvoiceError {
+    constructor(message, operation, details, cause) {
+        super(message, `PDF_${operation.toUpperCase()}_ERROR`, details, cause);
+        this.name = 'EInvoicePDFError';
+        this.operation = operation;
+        this.pdfInfo = details?.pdfInfo;
+    }
+    /**
+     * Returns recovery suggestions based on the operation
+     */
+    getRecoverySuggestions() {
+        const suggestions = [];
+        switch (this.operation) {
+            case 'extract':
+                suggestions.push('Ensure the PDF contains embedded XML data', 'Check if the PDF is a valid PDF/A-3 document', 'Try using a different extraction method', 'Verify the PDF is not corrupted');
+                break;
+            case 'embed':
+                suggestions.push('Ensure the source PDF is valid', 'Check that the XML data is well-formed', 'Verify sufficient memory is available', 'Try with a smaller XML payload');
+                break;
+            case 'create':
+                suggestions.push('Verify all required invoice data is provided', 'Check that the template PDF exists', 'Ensure write permissions for output directory');
+                break;
+            case 'validate':
+                suggestions.push('Check PDF/A-3 compliance', 'Verify XML attachment structure', 'Ensure proper PDF metadata');
+                break;
+        }
+        return suggestions;
+    }
+}
+/**
+ * Error thrown for format-specific issues
+ */
+export class EInvoiceFormatError extends EInvoiceError {
+    constructor(message, details, cause) {
+        super(message, 'FORMAT_ERROR', details, cause);
+        this.name = 'EInvoiceFormatError';
+        this.sourceFormat = details.sourceFormat;
+        this.targetFormat = details.targetFormat;
+        this.unsupportedFeatures = details.unsupportedFeatures;
+    }
+    /**
+     * Returns a compatibility report
+     */
+    getCompatibilityReport() {
+        let report = this.message;
+        if (this.sourceFormat && this.targetFormat) {
+            report += `\n\nConversion: ${this.sourceFormat} → ${this.targetFormat}`;
+        }
+        if (this.unsupportedFeatures && this.unsupportedFeatures.length > 0) {
+            report += '\n\nUnsupported features:';
+            for (const feature of this.unsupportedFeatures) {
+                report += `\n- ${feature}`;
+            }
+        }
+        return report;
+    }
+}
+/**
+ * Error recovery helper class
+ */
+export class ErrorRecovery {
+    /**
+     * Attempts to recover from a parsing error by cleaning the XML
+     */
+    static async attemptXMLRecovery(xmlString, error) {
+        try {
+            let cleanedXml = xmlString;
+            // Remove BOM if present
+            if (cleanedXml.charCodeAt(0) === 0xFEFF) {
+                cleanedXml = cleanedXml.slice(1);
+            }
+            // Fix common encoding issues
+            cleanedXml = cleanedXml
+                .replace(/&(?!(amp|lt|gt|apos|quot);)/g, '&')
+                .replace(/</g, (match, offset) => {
+                // Don't replace if it's part of <![CDATA[
+                const before = cleanedXml.substring(Math.max(0, offset - 10), offset);
+                if (before.includes('CDATA['))
+                    return match;
+                return '&lt;';
+            });
+            // Try to fix unclosed tags if we have location info
+            if (error.line && error.xmlSnippet) {
+                // This is a simplified approach - real implementation would be more sophisticated
+                const lines = cleanedXml.split('\n');
+                if (lines[error.line - 1]) {
+                    // Attempt basic fixes based on the error
+                    // This is just a placeholder for more sophisticated recovery
+                }
+            }
+            return {
+                success: true,
+                cleanedXml,
+                message: 'Applied basic XML cleaning and encoding fixes'
+            };
+        }
+        catch (recoveryError) {
+            return {
+                success: false,
+                message: `Recovery failed: ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`
+            };
+        }
+    }
+    /**
+     * Provides partial data extraction on validation failure
+     */
+    static extractPartialData(xmlString, format) {
+        try {
+            // This would implement format-specific partial extraction
+            // For now, returning a placeholder
+            return {
+                success: false,
+                message: 'Partial data extraction not yet implemented'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Partial extraction failed: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+}
+/**
+ * Error context builder for detailed error information
+ */
+export class ErrorContext {
+    constructor() {
+        this.context = new Map();
+    }
+    add(key, value) {
+        this.context.set(key, value);
+        return this;
+    }
+    addTimestamp() {
+        this.context.set('timestamp', new Date().toISOString());
+        return this;
+    }
+    addEnvironment() {
+        this.context.set('environment', {
+            nodeVersion: process.version,
+            platform: process.platform,
+            arch: process.arch
+        });
+        return this;
+    }
+    build() {
+        return Object.fromEntries(this.context);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"errors.js","sourceRoot":"","sources":["../ts/errors.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,32 @@
+import type { TInvoice } from '../../interfaces/common.js';
+/**
+ * Base decoder class that defines common decoding functionality
+ * for all invoice format decoders
+ */
+export declare abstract class BaseDecoder {
+    protected xml: string;
+    protected skipValidation: boolean;
+    constructor(xml: string, skipValidation?: boolean);
+    /**
+     * Decodes XML into a TInvoice object
+     * @returns Promise resolving to a TInvoice object
+     */
+    abstract decode(): Promise<TInvoice>;
+    /**
+     * Gets letter data in the standard format
+     * @returns Promise resolving to a TInvoice object
+     */
+    getLetterData(): Promise<TInvoice>;
+    /**
+     * Gets the raw XML content
+     * @returns XML string
+     */
+    getXml(): string;
+    /**
+     * Parses a CII date string based on format code
+     * @param dateStr Date string
+     * @param format Format code (e.g., '102' for YYYYMMDD)
+     * @returns Timestamp in milliseconds
+     */
+    protected parseCIIDate(dateStr: string, format?: string): number;
+}

package/dist_ts/formats/base/base.decoder.js

@@ -0,0 +1,52 @@
+import { ValidationLevel } from '../../interfaces/common.js';
+/**
+ * Base decoder class that defines common decoding functionality
+ * for all invoice format decoders
+ */
+export class BaseDecoder {
+    constructor(xml, skipValidation = false) {
+        this.xml = xml;
+        this.skipValidation = skipValidation;
+    }
+    /**
+     * Gets letter data in the standard format
+     * @returns Promise resolving to a TInvoice object
+     */
+    async getLetterData() {
+        return this.decode();
+    }
+    /**
+     * Gets the raw XML content
+     * @returns XML string
+     */
+    getXml() {
+        return this.xml;
+    }
+    /**
+     * Parses a CII date string based on format code
+     * @param dateStr Date string
+     * @param format Format code (e.g., '102' for YYYYMMDD)
+     * @returns Timestamp in milliseconds
+     */
+    parseCIIDate(dateStr, format) {
+        if (!dateStr)
+            return Date.now();
+        // Format 102 is YYYYMMDD
+        if (format === '102' && dateStr.length === 8) {
+            const year = parseInt(dateStr.substring(0, 4));
+            const month = parseInt(dateStr.substring(4, 6)) - 1; // Month is 0-indexed in JS
+            const day = parseInt(dateStr.substring(6, 8));
+            return new Date(year, month, day).getTime();
+        }
+        // Format 610 is YYYYMM  
+        if (format === '610' && dateStr.length === 6) {
+            const year = parseInt(dateStr.substring(0, 4));
+            const month = parseInt(dateStr.substring(4, 6)) - 1;
+            return new Date(year, month, 1).getTime();
+        }
+        // Try to parse as ISO date or other standard formats
+        const parsed = Date.parse(dateStr);
+        return isNaN(parsed) ? Date.now() : parsed;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5kZWNvZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvZm9ybWF0cy9iYXNlL2Jhc2UuZGVjb2Rlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFHN0Q7OztHQUdHO0FBQ0gsTUFBTSxPQUFnQixXQUFXO0lBSS9CLFlBQVksR0FBVyxFQUFFLGlCQUEwQixLQUFLO1FBQ3RELElBQUksQ0FBQyxHQUFHLEdBQUcsR0FBRyxDQUFDO1FBQ2YsSUFBSSxDQUFDLGNBQWMsR0FBRyxjQUFjLENBQUM7SUFDdkMsQ0FBQztJQVFEOzs7T0FHRztJQUNJLEtBQUssQ0FBQyxhQUFhO1FBQ3hCLE9BQU8sSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO0lBQ3ZCLENBQUM7SUFFRDs7O09BR0c7SUFDSSxNQUFNO1FBQ1gsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDO0lBQ2xCLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNPLFlBQVksQ0FBQyxPQUFlLEVBQUUsTUFBZTtRQUNyRCxJQUFJLENBQUMsT0FBTztZQUFFLE9BQU8sSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBRWhDLHlCQUF5QjtRQUN6QixJQUFJLE1BQU0sS0FBSyxLQUFLLElBQUksT0FBTyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUM3QyxNQUFNLElBQUksR0FBRyxRQUFRLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUMvQyxNQUFNLEtBQUssR0FBRyxRQUFRLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQywyQkFBMkI7WUFDaEYsTUFBTSxHQUFHLEdBQUcsUUFBUSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDOUMsT0FBTyxJQUFJLElBQUksQ0FBQyxJQUFJLEVBQUUsS0FBSyxFQUFFLEdBQUcsQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQzlDLENBQUM7UUFFRCx5QkFBeUI7UUFDekIsSUFBSSxNQUFNLEtBQUssS0FBSyxJQUFJLE9BQU8sQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDN0MsTUFBTSxJQUFJLEdBQUcsUUFBUSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDL0MsTUFBTSxLQUFLLEdBQUcsUUFBUSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ3BELE9BQU8sSUFBSSxJQUFJLENBQUMsSUFBSSxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUMsQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUM1QyxDQUFDO1FBRUQscURBQXFEO1FBQ3JELE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDbkMsT0FBTyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDO0lBQzdDLENBQUM7Q0FDRiJ9

package/dist_ts/formats/base/base.encoder.d.ts

@@ -0,0 +1,13 @@
+import type { TInvoice } from '../../interfaces/common.js';
+/**
+ * Base encoder class that defines common encoding functionality
+ * for all invoice format encoders
+ */
+export declare abstract class BaseEncoder {
+    /**
+     * Encodes a TInvoice object into XML
+     * @param invoice TInvoice object to encode
+     * @returns XML string
+     */
+    abstract encode(invoice: TInvoice): Promise<string>;
+}

package/dist_ts/formats/base/base.encoder.js

@@ -0,0 +1,7 @@
+/**
+ * Base encoder class that defines common encoding functionality
+ * for all invoice format encoders
+ */
+export class BaseEncoder {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5lbmNvZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvZm9ybWF0cy9iYXNlL2Jhc2UuZW5jb2Rlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7O0dBR0c7QUFDSCxNQUFNLE9BQWdCLFdBQVc7Q0FPaEMifQ==

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

@@ -0,0 +1,44 @@
+import { ValidationLevel } from '../../interfaces/common.js';
+import type { ValidationResult, ValidationError } from '../../interfaces/common.js';
+/**
+ * Base validator class that defines common validation functionality
+ * for all invoice format validators
+ */
+export declare abstract class BaseValidator {
+    protected xml: string;
+    protected errors: ValidationError[];
+    constructor(xml: string);
+    /**
+     * Validates XML against the specified level of validation
+     * @param level Validation level (syntax, semantic, business)
+     * @returns Result of validation
+     */
+    abstract validate(level?: ValidationLevel): ValidationResult;
+    /**
+     * Gets all validation errors found during validation
+     * @returns Array of validation errors
+     */
+    getValidationErrors(): ValidationError[];
+    /**
+     * Checks if the document is valid
+     * @returns True if no validation errors were found
+     */
+    isValid(): boolean;
+    /**
+     * Validates XML against schema
+     * @returns True if schema validation passed
+     */
+    protected abstract validateSchema(): boolean;
+    /**
+     * Validates business rules
+     * @returns True if business rule validation passed
+     */
+    protected abstract validateBusinessRules(): boolean;
+    /**
+     * Adds an error to the validation errors list
+     * @param code Error code
+     * @param message Error message
+     * @param location Location in the XML where the error occurred
+     */
+    protected addError(code: string, message: string, location?: string): void;
+}

package/dist_ts/formats/base/base.validator.js

@@ -0,0 +1,39 @@
+import { ValidationLevel } from '../../interfaces/common.js';
+/**
+ * Base validator class that defines common validation functionality
+ * for all invoice format validators
+ */
+export class BaseValidator {
+    constructor(xml) {
+        this.errors = [];
+        this.xml = xml;
+    }
+    /**
+     * Gets all validation errors found during validation
+     * @returns Array of validation errors
+     */
+    getValidationErrors() {
+        return this.errors;
+    }
+    /**
+     * Checks if the document is valid
+     * @returns True if no validation errors were found
+     */
+    isValid() {
+        return this.errors.length === 0;
+    }
+    /**
+     * Adds an error to the validation errors list
+     * @param code Error code
+     * @param message Error message
+     * @param location Location in the XML where the error occurred
+     */
+    addError(code, message, location = '') {
+        this.errors.push({
+            code,
+            message,
+            location
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS52YWxpZGF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9mb3JtYXRzL2Jhc2UvYmFzZS52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRzdEOzs7R0FHRztBQUNILE1BQU0sT0FBZ0IsYUFBYTtJQUlqQyxZQUFZLEdBQVc7UUFGYixXQUFNLEdBQXNCLEVBQUUsQ0FBQztRQUd2QyxJQUFJLENBQUMsR0FBRyxHQUFHLEdBQUcsQ0FBQztJQUNqQixDQUFDO0lBU0Q7OztPQUdHO0lBQ0ksbUJBQW1CO1FBQ3hCLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQztJQUNyQixDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksT0FBTztRQUNaLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLEtBQUssQ0FBQyxDQUFDO0lBQ2xDLENBQUM7SUFjRDs7Ozs7T0FLRztJQUNPLFFBQVEsQ0FBQyxJQUFZLEVBQUUsT0FBZSxFQUFFLFdBQW1CLEVBQUU7UUFDckUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUM7WUFDZixJQUFJO1lBQ0osT0FBTztZQUNQLFFBQVE7U0FDVCxDQUFDLENBQUM7SUFDTCxDQUFDO0NBQ0YifQ==

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

@@ -0,0 +1,19 @@
+import * as plugins from '../plugins.js';
+/**
+ * Base decoder class for all invoice XML formats.
+ * Provides common functionality and interfaces for different format decoders.
+ */
+export declare abstract class BaseDecoder {
+    protected xmlString: string;
+    constructor(xmlString: string);
+    /**
+     * Abstract method that each format-specific decoder must implement.
+     * Converts XML into a structured letter object based on the XML format.
+     */
+    abstract getLetterData(): Promise<plugins.tsclass.business.ILetter>;
+    /**
+     * Creates a default letter object with minimal data.
+     * Used as a fallback when parsing fails.
+     */
+    protected createDefaultLetter(): plugins.tsclass.business.ILetter;
+}

package/dist_ts/formats/base.decoder.js

@@ -0,0 +1,130 @@
+import * as plugins from '../plugins.js';
+/**
+ * Base decoder class for all invoice XML formats.
+ * Provides common functionality and interfaces for different format decoders.
+ */
+export class BaseDecoder {
+    constructor(xmlString) {
+        if (!xmlString) {
+            throw new Error('No XML string provided to decoder');
+        }
+        this.xmlString = xmlString;
+    }
+    /**
+     * Creates a default letter object with minimal data.
+     * Used as a fallback when parsing fails.
+     */
+    createDefaultLetter() {
+        // Create a default seller
+        const seller = {
+            name: 'Unknown Seller',
+            type: 'company',
+            description: 'Unknown Seller',
+            address: {
+                streetName: 'Unknown',
+                houseNumber: '0',
+                city: 'Unknown',
+                country: 'Unknown',
+                postalCode: 'Unknown',
+            },
+            registrationDetails: {
+                vatId: 'Unknown',
+                registrationId: 'Unknown',
+                registrationName: 'Unknown'
+            },
+            foundedDate: {
+                year: 2000,
+                month: 1,
+                day: 1
+            },
+            closedDate: {
+                year: 9999,
+                month: 12,
+                day: 31
+            },
+            status: 'active'
+        };
+        // Create a default buyer
+        const buyer = {
+            name: 'Unknown Buyer',
+            type: 'company',
+            description: 'Unknown Buyer',
+            address: {
+                streetName: 'Unknown',
+                houseNumber: '0',
+                city: 'Unknown',
+                country: 'Unknown',
+                postalCode: 'Unknown',
+            },
+            registrationDetails: {
+                vatId: 'Unknown',
+                registrationId: 'Unknown',
+                registrationName: 'Unknown'
+            },
+            foundedDate: {
+                year: 2000,
+                month: 1,
+                day: 1
+            },
+            closedDate: {
+                year: 9999,
+                month: 12,
+                day: 31
+            },
+            status: 'active'
+        };
+        // Create default invoice data
+        const invoiceData = {
+            id: 'Unknown',
+            status: null,
+            type: 'debitnote',
+            billedBy: seller,
+            billedTo: buyer,
+            deliveryDate: Date.now(),
+            dueInDays: 30,
+            periodOfPerformance: null,
+            printResult: null,
+            currency: 'EUR',
+            notes: [],
+            items: [
+                {
+                    name: 'Unknown Item',
+                    unitQuantity: 1,
+                    unitNetPrice: 0,
+                    vatPercentage: 0,
+                    position: 0,
+                    unitType: 'units',
+                }
+            ],
+            reverseCharge: false,
+        };
+        // Return a default letter
+        return {
+            versionInfo: {
+                type: 'draft',
+                version: '1.0.0',
+            },
+            type: 'invoice',
+            date: Date.now(),
+            subject: 'Unknown Invoice',
+            from: seller,
+            to: buyer,
+            content: {
+                invoiceData: invoiceData,
+                textData: null,
+                timesheetData: null,
+                contractData: null,
+            },
+            needsCoverSheet: false,
+            objectActions: [],
+            pdf: null,
+            incidenceId: null,
+            language: null,
+            legalContact: null,
+            logoUrl: null,
+            pdfAttachments: null,
+            accentColor: null,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,44 @@
+import { ValidationLevel } from '../interfaces.js';
+import type { ValidationResult, ValidationError } from '../interfaces.js';
+/**
+ * Base validator class that defines common validation functionality
+ * for all invoice format validators
+ */
+export declare abstract class BaseValidator {
+    protected xml: string;
+    protected errors: ValidationError[];
+    constructor(xml: string);
+    /**
+     * Validates XML against the specified level of validation
+     * @param level Validation level (syntax, semantic, business)
+     * @returns Result of validation
+     */
+    abstract validate(level?: ValidationLevel): ValidationResult;
+    /**
+     * Gets all validation errors found during validation
+     * @returns Array of validation errors
+     */
+    getValidationErrors(): ValidationError[];
+    /**
+     * Checks if the document is valid
+     * @returns True if no validation errors were found
+     */
+    isValid(): boolean;
+    /**
+     * Validates XML against schema
+     * @returns True if schema validation passed
+     */
+    protected abstract validateSchema(): boolean;
+    /**
+     * Validates business rules
+     * @returns True if business rule validation passed
+     */
+    protected abstract validateBusinessRules(): boolean;
+    /**
+     * Adds an error to the validation errors list
+     * @param code Error code
+     * @param message Error message
+     * @param location Location in the XML where the error occurred
+     */
+    protected addError(code: string, message: string, location?: string): void;
+}