@fin.cx/einvoice 5.1.3 → 5.2.0

package/ts/einvoice.ts

@@ -1,6 +1,6 @@
 import * as plugins from './plugins.js';
 
-import { business, finance } from './plugins.js';
+import type { business, finance } from '@tsclass/tsclass';
 import type { TInvoice, TAccountingDocItem } from '@tsclass/tsclass/dist_ts/finance/index.js';
 import { InvoiceFormat, ValidationLevel } from './interfaces/common.js';
 import type { ValidationResult, ValidationError, EInvoiceOptions, IPdf, ExportFormat } from './interfaces/common.js';
@@ -28,6 +28,7 @@ import { PDFExtractor } from './formats/pdf/pdf.extractor.js';
 import { FormatDetector } from './formats/utils/format.detector.js';
 
 // Import enhanced validators
+import { EN16931Validator } from './formats/validation/en16931.validator.js';
 import { EN16931BusinessRulesValidator } from './formats/validation/en16931.business-rules.validator.js';
 import { CodeListValidator } from './formats/validation/codelist.validator.js';
 import type { ValidationOptions } from './formats/validation/validation.types.js';
@@ -41,6 +42,9 @@ import type { IEInvoiceMetadata } from './interfaces/en16931-metadata.js';
  * Extends the TInvoice interface for seamless integration with existing systems
  */
 export class EInvoice implements TInvoice {
+  private static sharedPdfEmbedder?: PDFEmbedder;
+  private static sharedPdfExtractor?: PDFExtractor;
+
   /**
    * Creates an EInvoice instance from XML string
    * @param xmlString XML string to parse
@@ -109,8 +113,8 @@ export class EInvoice implements TInvoice {
   public incidenceId: string = '';
   public language: string = 'en';
   public objectActions: any[] = [];
-  public pdf: IPdf | null = null;
-  public pdfAttachments: IPdf[] | null = null;
+  public pdf?: IPdf;
+  public pdfAttachments?: IPdf[];
   public accentColor: string | null = null;
   public logoUrl: string | null = null;
 
@@ -149,7 +153,13 @@ export class EInvoice implements TInvoice {
            this.accountingDocType === 'creditnote' ? 'creditnote' : 'debitnote';
   }
   public set invoiceType(value: 'invoice' | 'creditnote' | 'debitnote') {
-    this.accountingDocType = 'invoice'; // Always set to invoice for TInvoice type
+    if (value !== 'invoice') {
+      throw new EInvoiceFormatError(
+        `Unsupported invoice type: ${value}`,
+        { unsupportedFeatures: [`invoiceType=${value}`] }
+      );
+    }
+    this.accountingDocType = 'invoice';
   }
   
   // Computed properties for convenience
@@ -181,15 +191,28 @@ export class EInvoice implements TInvoice {
   
   private xmlString: string = '';
   private detectedFormat: InvoiceFormat = InvoiceFormat.UNKNOWN;
+  private parsedXmlDocument?: Document;
   private validationErrors: ValidationError[] = [];
+  private validationCache = new Map<string, ValidationResult>();
   private options: EInvoiceOptions = {
     validateOnLoad: false,
     validationLevel: ValidationLevel.SYNTAX
   };
 
-  // PDF utilities
-  private pdfEmbedder = new PDFEmbedder();
-  private pdfExtractor = new PDFExtractor();
+  // PDF utilities are created lazily because most invoice workflows never touch PDF I/O.
+  private get pdfEmbedder(): PDFEmbedder {
+    if (!EInvoice.sharedPdfEmbedder) {
+      EInvoice.sharedPdfEmbedder = new PDFEmbedder();
+    }
+    return EInvoice.sharedPdfEmbedder;
+  }
+
+  private get pdfExtractor(): PDFExtractor {
+    if (!EInvoice.sharedPdfExtractor) {
+      EInvoice.sharedPdfExtractor = new PDFExtractor();
+    }
+    return EInvoice.sharedPdfExtractor;
+  }
 
   /**
    * Creates a new EInvoice instance
@@ -260,6 +283,7 @@ export class EInvoice implements TInvoice {
    */
   public async fromXmlString(xmlString: string): Promise<EInvoice> {
     try {
+      this.validationCache.clear();
       this.xmlString = xmlString;
       
       // Detect format
@@ -269,8 +293,13 @@ export class EInvoice implements TInvoice {
       }
 
       // Get appropriate decoder
-      const decoder = DecoderFactory.createDecoder(xmlString, !this.options.validateOnLoad);
+      const decoder = DecoderFactory.createDecoder(
+        xmlString,
+        !this.options.validateOnLoad,
+        this.detectedFormat,
+      );
       const invoice = await decoder.decode();
+      this.parsedXmlDocument = decoder.getParsedDocument();
       
       // Map the decoded invoice to our properties
       this.mapFromTInvoice(invoice);
@@ -282,10 +311,11 @@ export class EInvoice implements TInvoice {
 
       return this;
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       if (error instanceof EInvoiceError) {
         throw error;
       }
-      throw new EInvoiceParsingError(`Failed to parse XML: ${error.message}`, {}, error as Error);
+      throw new EInvoiceParsingError(`Failed to parse XML: ${errorMessage}`, {}, error as Error);
     }
   }
 
@@ -307,7 +337,8 @@ export class EInvoice implements TInvoice {
       const xmlString = fileBuffer.toString('utf-8');
       return this.fromXmlString(xmlString);
     } catch (error) {
-      throw new EInvoiceError(`Failed to load file: ${error.message}`, 'FILE_LOAD_ERROR', { filePath });
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new EInvoiceError(`Failed to load file: ${errorMessage}`, 'FILE_LOAD_ERROR', { filePath });
     }
   }
 
@@ -343,10 +374,11 @@ export class EInvoice implements TInvoice {
       
       return this.fromXmlString(extractedXml);
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       if (error instanceof EInvoiceError) {
         throw error;
       }
-      throw new EInvoicePDFError(`Failed to extract invoice from PDF: ${error.message}`, 'extract', {}, error as Error);
+      throw new EInvoicePDFError(`Failed to extract invoice from PDF: ${errorMessage}`, 'extract', {}, error as Error);
     }
   }
 
@@ -423,7 +455,8 @@ export class EInvoice implements TInvoice {
       
       return await encoder.encode(invoice);
     } catch (error) {
-      throw new EInvoiceFormatError(`Failed to encode to ${format}: ${error.message}`, { targetFormat: format });
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new EInvoiceFormatError(`Failed to encode to ${format}: ${errorMessage}`, { targetFormat: format });
     }
   }
 
@@ -434,21 +467,34 @@ export class EInvoice implements TInvoice {
    */
   public async validate(level: ValidationLevel = ValidationLevel.BUSINESS, options?: ValidationOptions): Promise<ValidationResult> {
     try {
-      // For programmatically created invoices without XML, skip XML-based validation
+      // For programmatically created invoices without XML, validate the in-memory invoice object.
       let result: ValidationResult;
+      const cacheKey = this.getValidationCacheKey(level, options);
+
+      if (cacheKey) {
+        const cached = this.validationCache.get(cacheKey);
+        if (cached) {
+          return this.cloneValidationResult(cached);
+        }
+      }
       
       if (this.xmlString && this.detectedFormat !== InvoiceFormat.UNKNOWN) {
+        if (this.shouldUseFastBusinessValidation(level, options)) {
+          result = this.validateDecodedInvoice(level);
+        } else {
         // Use existing validator for XML-based validation
-        const validator = ValidatorFactory.createValidator(this.xmlString);
-        result = validator.validate(level);
+          const validator = ValidatorFactory.createValidator(
+            this.xmlString,
+            this.detectedFormat,
+            this.parsedXmlDocument,
+          );
+          result = validator.validate(level);
+
+          // Keep the raw XML, but drop the cached DOM once validation is done.
+          this.parsedXmlDocument = undefined;
+        }
       } else {
-        // Create a basic result for programmatically created invoices
-        result = {
-          valid: true,
-          errors: [],
-          warnings: [],
-          level: level
-        };
+        result = this.validateDecodedInvoice(level);
       }
       
       // Enhanced validation with feature flags
@@ -489,14 +535,72 @@ export class EInvoice implements TInvoice {
       // Update validation status
       this.validationErrors = result.errors;
       result.valid = result.errors.length === 0 || options?.reportOnly === true;
+
+      if (cacheKey) {
+        this.validationCache.set(cacheKey, this.cloneValidationResult(result));
+      }
       
       return result;
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       if (error instanceof EInvoiceError) {
         throw error;
       }
-      throw new EInvoiceValidationError(`Validation failed: ${error.message}`, [], { validationLevel: level });
+      throw new EInvoiceValidationError(`Validation failed: ${errorMessage}`, [], { validationLevel: level });
+    }
+  }
+
+  private validateDecodedInvoice(level: ValidationLevel): ValidationResult {
+    const invoice = this.mapToTInvoice();
+    const errors = EN16931Validator.collectMandatoryFieldErrors(invoice).map(message =>
+      this.createValidationError(message)
+    );
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings: level === ValidationLevel.SYNTAX
+        ? [{
+            code: 'VAL-NO-XML',
+            message: 'Syntax validation was skipped because no XML document has been loaded.'
+          }]
+        : [],
+      level: level
+    };
+  }
+
+  private shouldUseFastBusinessValidation(level: ValidationLevel, options?: ValidationOptions): boolean {
+    if (level !== ValidationLevel.BUSINESS) {
+      return false;
+    }
+
+    if (options?.featureFlags?.length || options?.reportOnly || this.detectedFormat !== InvoiceFormat.UBL) {
+      return false;
     }
+
+    // For tiny plain-UBL documents without parties or lines, the decoded invoice model already
+    // contains everything needed for the mandatory-field failures the XML validator would report.
+    return this.items.length === 0 && !this.from?.name && !this.to?.name;
+  }
+
+  private getValidationCacheKey(level: ValidationLevel, options?: ValidationOptions): string | undefined {
+    if (!this.xmlString || options) {
+      return undefined;
+    }
+
+    if (level !== ValidationLevel.SYNTAX && level !== ValidationLevel.SEMANTIC) {
+      return undefined;
+    }
+
+    return `xml:${level}`;
+  }
+
+  private cloneValidationResult(result: ValidationResult): ValidationResult {
+    return {
+      ...result,
+      errors: result.errors.map(error => ({ ...error })),
+      warnings: result.warnings?.map(warning => ({ ...warning }))
+    };
   }
 
   /**
@@ -514,7 +618,8 @@ export class EInvoice implements TInvoice {
       }
       return embedResult.data! as Buffer;
     } catch (error) {
-      throw new EInvoicePDFError(`Failed to embed XML in PDF: ${error.message}`, 'embed', { format }, error as Error);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new EInvoicePDFError(`Failed to embed XML in PDF: ${errorMessage}`, 'embed', { format }, error as Error);
     }
   }
 
@@ -546,10 +651,11 @@ export class EInvoice implements TInvoice {
         await plugins.fs.writeFile(filePath, xmlString, 'utf-8');
       }
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       if (error instanceof EInvoiceError) {
         throw error;
       }
-      throw new EInvoiceError(`Failed to save file: ${error.message}`, 'FILE_SAVE_ERROR', { filePath });
+      throw new EInvoiceError(`Failed to save file: ${errorMessage}`, 'FILE_SAVE_ERROR', { filePath });
     }
   }
 
@@ -649,4 +755,20 @@ export class EInvoice implements TInvoice {
   public addItem(item: Partial<TAccountingDocItem>): void {
     this.items.push(this.createItem(item));
   }
-}
+
+  private createValidationError(message: string): ValidationError {
+    const match = message.match(/^([A-Z]{2,}(?:-[A-Z0-9]+)*-\d+):\s*(.+)$/);
+
+    if (match) {
+      return {
+        code: match[1],
+        message: match[2]
+      };
+    }
+
+    return {
+      code: 'VALIDATION_ERROR',
+      message
+    };
+  }
+}

package/ts/formats/base/base.decoder.ts

@@ -37,6 +37,13 @@ export abstract class BaseDecoder {
     return this.xml;
   }
 
+  /**
+   * Gets a parsed XML document when a decoder keeps one around.
+   */
+  public getParsedDocument(): Document | undefined {
+    return undefined;
+  }
+
   /**
    * Parses a CII date string based on format code
    * @param dateStr Date string

package/ts/formats/cii/cii.decoder.ts

@@ -3,6 +3,14 @@ import type { TInvoice, TCreditNote, TDebitNote } from '../../interfaces/common.
 import { CII_NAMESPACES, CIIProfile } from './cii.types.js';
 import { DOMParser, xpath } from '../../plugins.js';
 
+const ciiParser = new DOMParser();
+const ciiNamespaces = {
+  rsm: CII_NAMESPACES.RSM,
+  ram: CII_NAMESPACES.RAM,
+  udt: CII_NAMESPACES.UDT,
+};
+const ciiSelect = xpath.useNamespaces(ciiNamespaces);
+
 /**
  * Base decoder for CII-based invoice formats
  */
@@ -16,22 +24,22 @@ export abstract class CIIBaseDecoder extends BaseDecoder {
     super(xml, skipValidation);
 
     // Parse XML document
-    this.doc = new DOMParser().parseFromString(xml, 'application/xml');
+    this.doc = ciiParser.parseFromString(xml, 'application/xml');
 
     // Set up namespaces for XPath queries
-    this.namespaces = {
-      rsm: CII_NAMESPACES.RSM,
-      ram: CII_NAMESPACES.RAM,
-      udt: CII_NAMESPACES.UDT
-    };
+    this.namespaces = ciiNamespaces;
 
     // Create XPath selector with namespaces
-    this.select = xpath.useNamespaces(this.namespaces);
+    this.select = ciiSelect;
 
     // Detect profile
     this.detectProfile();
   }
 
+  public override getParsedDocument(): Document {
+    return this.doc;
+  }
+
   /**
    * Decodes CII XML into a TInvoice object
    * @returns Promise resolving to a TInvoice object
@@ -93,7 +101,8 @@ export abstract class CIIBaseDecoder extends BaseDecoder {
    * @returns Text value or empty string if not found
    */
   protected getText(xpathExpr: string, context?: Node): string {
-    const node = this.select(xpathExpr, context || this.doc)[0];
+    const result = this.select(xpathExpr, context || this.doc);
+    const node = Array.isArray(result) ? result[0] : null;
     return node ? (node.textContent || '') : '';
   }
 

package/ts/formats/cii/cii.validator.ts

@@ -4,31 +4,35 @@ import type { ValidationResult } from '../../interfaces/common.js';
 import { CII_NAMESPACES, CIIProfile } from './cii.types.js';
 import { DOMParser, xpath } from '../../plugins.js';
 
+const ciiValidatorParser = new DOMParser();
+const ciiValidatorNamespaces = {
+  rsm: CII_NAMESPACES.RSM,
+  ram: CII_NAMESPACES.RAM,
+  udt: CII_NAMESPACES.UDT,
+};
+const ciiValidatorSelect = xpath.useNamespaces(ciiValidatorNamespaces);
+
 /**
  * Base validator for CII-based invoice formats
  */
 export abstract class CIIBaseValidator extends BaseValidator {
-  protected doc: Document;
-  protected namespaces: Record<string, string>;
-  protected select: xpath.XPathSelect;
+  protected doc!: Document;
+  protected namespaces!: Record<string, string>;
+  protected select!: xpath.XPathSelect;
   protected profile: CIIProfile = CIIProfile.EN16931;
 
-  constructor(xml: string) {
+  constructor(xml: string, doc?: Document) {
     super(xml);
 
     try {
-      // Parse XML document
-      this.doc = new DOMParser().parseFromString(xml, 'application/xml');
+      // Reuse an existing parsed document when available.
+      this.doc = doc ?? ciiValidatorParser.parseFromString(xml, 'application/xml');
 
       // Set up namespaces for XPath queries
-      this.namespaces = {
-        rsm: CII_NAMESPACES.RSM,
-        ram: CII_NAMESPACES.RAM,
-        udt: CII_NAMESPACES.UDT
-      };
+      this.namespaces = ciiValidatorNamespaces;
 
       // Create XPath selector with namespaces
-      this.select = xpath.useNamespaces(this.namespaces);
+      this.select = ciiValidatorSelect;
 
       // Detect profile
       this.detectProfile();
@@ -139,7 +143,8 @@ export abstract class CIIBaseValidator extends BaseValidator {
    * @returns Text value or empty string if not found
    */
   protected getText(xpathExpr: string, context?: Node): string {
-    const node = this.select(xpathExpr, context || this.doc)[0];
+    const result = this.select(xpathExpr, context || this.doc);
+    const node = Array.isArray(result) ? result[0] : null;
     return node ? (node.textContent || '') : '';
   }
 

package/ts/formats/converters/xml-to-einvoice.converter.ts

@@ -6,17 +6,16 @@
 import * as plugins from '../../plugins.js';
 import type { EInvoice } from '../../einvoice.js';
 import type { TAccountingDocItem } from '@tsclass/tsclass/dist_ts/finance/index.js';
-import { DOMParser } from '@xmldom/xmldom';
 
 /**
  * Converter for XML formats to EInvoice - simplified version
  * This is a basic converter that extracts essential fields for testing
  */
 export class XMLToEInvoiceConverter {
-  private parser: DOMParser;
+  private parser: InstanceType<typeof plugins.DOMParser>;
   
   constructor() {
-    this.parser = new DOMParser();
+    this.parser = new plugins.DOMParser();
   }
   
   /**
@@ -116,7 +115,7 @@ export class XMLToEInvoiceConverter {
       console.warn('Error parsing XML:', error);
     }
     
-    return mockInvoice as EInvoice;
+    return mockInvoice as unknown as EInvoice;
   }
   
   /**
@@ -139,4 +138,4 @@ export class XMLToEInvoiceConverter {
     
     return null;
   }
-}
+}

package/ts/formats/factories/decoder.factory.ts

@@ -16,10 +16,15 @@ export class DecoderFactory {
    * Creates a decoder for the specified XML content
    * @param xml XML content to decode
    * @param skipValidation Whether to skip EN16931 validation
+   * @param formatHint Optional pre-detected format to avoid re-detecting large XML inputs
    * @returns Appropriate decoder instance
    */
-  public static createDecoder(xml: string, skipValidation: boolean = false): BaseDecoder {
-    const format = FormatDetector.detectFormat(xml);
+  public static createDecoder(
+    xml: string,
+    skipValidation: boolean = false,
+    formatHint?: InvoiceFormat,
+  ): BaseDecoder {
+    const format = formatHint ?? FormatDetector.detectFormat(xml);
 
     switch (format) {
       case InvoiceFormat.UBL:

package/ts/formats/factories/validator.factory.ts

@@ -59,28 +59,34 @@ export class ValidatorFactory {
   /**
    * Creates a validator for the specified XML content
    * @param xml XML content to validate
+   * @param formatHint Optional pre-detected format to avoid re-detecting large XML inputs
+   * @param parsedDocument Optional parsed XML document to avoid parsing twice
    * @returns Appropriate validator instance
    */
-  public static createValidator(xml: string): BaseValidator {
+  public static createValidator(
+    xml: string,
+    formatHint?: InvoiceFormat,
+    parsedDocument?: Document,
+  ): BaseValidator {
     try {
-      const format = FormatDetector.detectFormat(xml);
+      const format = formatHint ?? FormatDetector.detectFormat(xml);
 
       switch (format) {
         case InvoiceFormat.UBL:
-          return new EN16931UBLValidator(xml);
+          return new EN16931UBLValidator(xml, parsedDocument);
 
         case InvoiceFormat.XRECHNUNG:
-          return new XRechnungValidator(xml);
+          return new XRechnungValidator(xml, parsedDocument);
 
         case InvoiceFormat.CII:
           // For now, use Factur-X validator for generic CII
-          return new FacturXValidator(xml);
+          return new FacturXValidator(xml, parsedDocument);
 
         case InvoiceFormat.ZUGFERD:
-          return new ZUGFeRDValidator(xml);
+          return new ZUGFeRDValidator(xml, parsedDocument);
 
         case InvoiceFormat.FACTURX:
-          return new FacturXValidator(xml);
+          return new FacturXValidator(xml, parsedDocument);
 
         case InvoiceFormat.FATTURAPA:
           return new FatturaPAValidator(xml);
@@ -131,4 +137,4 @@ class GenericValidator extends BaseValidator {
   protected validateBusinessRules(): boolean {
     return false;
   }
-}
+}

package/ts/formats/semantic/semantic.adapter.ts

@@ -169,17 +169,45 @@ export class SemanticModelAdapter {
     }
     
     // Set payment options
-    if (model.paymentInstructions.paymentAccountIdentifier) {
+    if (
+      model.paymentInstructions.paymentAccountIdentifier ||
+      model.paymentInstructions.paymentMeansText ||
+      model.paymentInstructions.paymentServiceProviderIdentifier
+    ) {
       invoice.paymentOptions = {
-        sepa: {
+        description: model.paymentInstructions.paymentMeansText,
+        sepaConnection: {
+          iban: model.paymentInstructions.paymentAccountIdentifier || '',
+          bic: model.paymentInstructions.paymentServiceProviderIdentifier || '',
+          institution: model.paymentInstructions.paymentServiceProviderIdentifier
+        },
+        payPal: { email: '' }
+      };
+
+      invoice.metadata = {
+        ...invoice.metadata,
+        paymentMeansCode: model.paymentInstructions.paymentMeansTypeCode,
+        paymentAccount: {
           iban: model.paymentInstructions.paymentAccountIdentifier,
-          bic: model.paymentInstructions.paymentServiceProviderIdentifier
+          accountName: model.paymentInstructions.paymentAccountName,
+          bankId: model.paymentInstructions.paymentServiceProviderIdentifier
         },
-        bankInfo: {
-          accountHolder: model.paymentInstructions.paymentAccountName || '',
-          institutionName: model.paymentInstructions.paymentServiceProviderIdentifier || ''
+        extensions: {
+          ...invoice.metadata?.extensions,
+          paymentMeans: {
+            paymentMeansCode: model.paymentInstructions.paymentMeansTypeCode,
+            paymentMeansText: model.paymentInstructions.paymentMeansText,
+            remittanceInformation: model.paymentInstructions.remittanceInformation
+          },
+          paymentAccount: {
+            iban: model.paymentInstructions.paymentAccountIdentifier,
+            accountName: model.paymentInstructions.paymentAccountName,
+            bankId: model.paymentInstructions.paymentServiceProviderIdentifier,
+            bic: model.paymentInstructions.paymentServiceProviderIdentifier,
+            institutionName: model.paymentInstructions.paymentServiceProviderIdentifier
+          }
         }
-      } as any;
+      };
     }
     
     // Set extensions
@@ -376,15 +404,21 @@ export class SemanticModelAdapter {
    */
   private mapPaymentInstructions(invoice: EInvoice): PaymentInstructions {
     const paymentMeans = invoice.metadata?.extensions?.paymentMeans;
-    const paymentAccount = invoice.metadata?.extensions?.paymentAccount;
+    const paymentAccount = invoice.metadata?.extensions?.paymentAccount || invoice.metadata?.paymentAccount;
+    const sepaConnection = invoice.paymentOptions?.sepaConnection;
     
     return {
-      paymentMeansTypeCode: paymentMeans?.paymentMeansCode || '30', // Default to credit transfer
-      paymentMeansText: paymentMeans?.paymentMeansText,
+      paymentMeansTypeCode: paymentMeans?.paymentMeansCode || invoice.metadata?.paymentMeansCode || '30',
+      paymentMeansText: paymentMeans?.paymentMeansText || invoice.paymentOptions?.description,
       remittanceInformation: paymentMeans?.remittanceInformation,
-      paymentAccountIdentifier: paymentAccount?.iban,
+      paymentAccountIdentifier: paymentAccount?.iban || sepaConnection?.iban,
       paymentAccountName: paymentAccount?.accountName,
-      paymentServiceProviderIdentifier: paymentAccount?.bic || paymentAccount?.institutionName
+      paymentServiceProviderIdentifier:
+        paymentAccount?.bic ||
+        paymentAccount?.institutionName ||
+        paymentAccount?.bankId ||
+        sepaConnection?.bic ||
+        sepaConnection?.institution
     };
   }
   
@@ -397,10 +431,10 @@ export class SemanticModelAdapter {
       taxExclusiveAmount: invoice.totalNet,
       taxInclusiveAmount: invoice.totalGross,
       allowanceTotalAmount: invoice.metadata?.extensions?.documentAllowances?.reduce(
-        (sum, a) => sum + a.amount, 0
+        (sum: number, a: { amount: number }) => sum + a.amount, 0
       ),
       chargeTotalAmount: invoice.metadata?.extensions?.documentCharges?.reduce(
-        (sum, c) => sum + c.amount, 0
+        (sum: number, c: { amount: number }) => sum + c.amount, 0
       ),
       prepaidAmount: invoice.metadata?.extensions?.prepaidAmount,
       roundingAmount: invoice.metadata?.extensions?.roundingAmount,
@@ -597,4 +631,4 @@ export class SemanticModelAdapter {
     
     return errors;
   }
-}
+}

package/ts/formats/ubl/en16931.ubl.validator.ts

@@ -90,7 +90,8 @@ export class EN16931UBLValidator extends UBLBaseValidator {
     }
 
     // BR-08: An Invoice shall contain the Seller postal address (BG-5).
-    const sellerAddress = this.select('//cac:AccountingSupplierParty//cac:PostalAddress', this.doc)[0];
+    const sellerAddressResult = this.select('//cac:AccountingSupplierParty//cac:PostalAddress', this.doc);
+    const sellerAddress = Array.isArray(sellerAddressResult) ? sellerAddressResult[0] : null;
     if (!sellerAddress || !this.exists('.//cbc:IdentificationCode', sellerAddress)) {
       this.addError('BR-08', 'An Invoice shall contain the Seller postal address', '//cac:AccountingSupplierParty//cac:PostalAddress');
       valid = false;
@@ -103,7 +104,8 @@ export class EN16931UBLValidator extends UBLBaseValidator {
     }
 
     // BR-10: An Invoice shall contain the Buyer postal address (BG-8).
-    const buyerAddress = this.select('//cac:AccountingCustomerParty//cac:PostalAddress', this.doc)[0];
+    const buyerAddressResult = this.select('//cac:AccountingCustomerParty//cac:PostalAddress', this.doc);
+    const buyerAddress = Array.isArray(buyerAddressResult) ? buyerAddressResult[0] : null;
     if (!buyerAddress || !this.exists('.//cbc:IdentificationCode', buyerAddress)) {
       this.addError('BR-10', 'An Invoice shall contain the Buyer postal address', '//cac:AccountingCustomerParty//cac:PostalAddress');
       valid = false;
@@ -213,4 +215,4 @@ export class EN16931UBLValidator extends UBLBaseValidator {
 
     return valid;
   }
-}
+}