@fin.cx/einvoice 9.0.0 → 10.0.1

package/ts/formats/validation/xrechnung.validator.ts

@@ -7,33 +7,15 @@
  */
 
 import type { EInvoice } from '../../einvoice.js';
-import type { ValidationResult } from './validation.types.js';
+import { EINVOICE_RULE_SOURCE, type ValidationResult } from './validation.types.js';
 import { UBL_CUSTOMIZATION_IDS } from '../ubl/ubl.types.js';
+import { getPartyContact } from '../utils/party.contact.js';
+import { GERMAN_VAT_ID_FORMAT_CODE, germanVatIdFormatMessage, isMalformedGermanVatId } from '../utils/vat.id.js';
 
 /**
  * XRechnung-specific validator implementing German CIUS rules
  */
 export class XRechnungValidator {
-  private static readonly LEITWEG_ID_PATTERN = /^[0-9]{2,3}-[0-9]{1,12}-[0-9]{2,30}$/;
-  private static readonly IBAN_PATTERNS: Record<string, { length: number; pattern: RegExp }> = {
-    DE: { length: 22, pattern: /^DE[0-9]{2}[0-9]{8}[0-9]{10}$/ },
-    AT: { length: 20, pattern: /^AT[0-9]{2}[0-9]{5}[0-9]{11}$/ },
-    CH: { length: 21, pattern: /^CH[0-9]{2}[0-9]{5}[0-9A-Z]{12}$/ },
-    FR: { length: 27, pattern: /^FR[0-9]{2}[0-9]{5}[0-9]{5}[0-9A-Z]{11}[0-9]{2}$/ },
-    NL: { length: 18, pattern: /^NL[0-9]{2}[A-Z]{4}[0-9]{10}$/ },
-    BE: { length: 16, pattern: /^BE[0-9]{2}[0-9]{3}[0-9]{7}[0-9]{2}$/ },
-    IT: { length: 27, pattern: /^IT[0-9]{2}[A-Z][0-9]{5}[0-9]{5}[0-9A-Z]{12}$/ },
-    ES: { length: 24, pattern: /^ES[0-9]{2}[0-9]{4}[0-9]{4}[0-9]{2}[0-9]{10}$/ }
-  };
-  private static readonly BIC_PATTERN = /^[A-Z]{6}[A-Z0-9]{2}([A-Z0-9]{3})?$/;
-  
-  // SEPA countries
-  private static readonly SEPA_COUNTRIES = new Set([
-    'AD', 'AT', 'BE', 'BG', 'CH', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FI',
-    'FR', 'GB', 'GI', 'GR', 'HR', 'HU', 'IE', 'IS', 'IT', 'LI', 'LT', 'LU',
-    'LV', 'MC', 'MT', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE', 'SI', 'SK', 'SM', 'VA'
-  ]);
-  
   /**
    * Validate XRechnung-specific requirements
    */
@@ -46,9 +28,7 @@ export class XRechnungValidator {
     }
     
     // Validate mandatory fields
-    results.push(...this.validateLeitwegId(invoice));
     results.push(...this.validateBuyerReference(invoice));
-    results.push(...this.validatePaymentDetails(invoice));
     results.push(...this.validateSellerContact(invoice));
     results.push(...this.validateTaxRegistration(invoice));
     
@@ -78,300 +58,69 @@ export class XRechnungValidator {
   }
   
   /**
-   * Validate Leitweg-ID (routing ID for German public administration)
-   * Pattern: [0-9]{2,3}-[0-9]{1,12}-[0-9]{2,30}
-   * Rule: XR-DE-01
-   */
-  private validateLeitwegId(invoice: EInvoice): ValidationResult[] {
-    const results: ValidationResult[] = [];
-    
-    // Leitweg-ID is typically in buyer reference (BT-10) for B2G
-    const buyerReference = invoice.metadata?.buyerReference || invoice.buyerReference || '';
-    
-    // Check if it looks like a Leitweg-ID
-    if (buyerReference && this.looksLikeLeitwegId(buyerReference)) {
-      if (!XRechnungValidator.LEITWEG_ID_PATTERN.test(buyerReference.trim())) {
-        results.push({
-          ruleId: 'XR-DE-01',
-          severity: 'error',
-          source: 'XRECHNUNG',
-          message: `Invalid Leitweg-ID format: ${buyerReference}. Expected pattern: [0-9]{2,3}-[0-9]{1,12}-[0-9]{2,30}`,
-          btReference: 'BT-10',
-          field: 'buyerReference',
-          value: buyerReference
-        });
-      }
-    }
-    
-    // For B2G invoices, Leitweg-ID might be mandatory
-    if (this.isB2GInvoice(invoice) && !buyerReference) {
-      results.push({
-        ruleId: 'XR-DE-15',
-        severity: 'error',
-        source: 'XRECHNUNG',
-        message: 'Buyer reference (Leitweg-ID) is mandatory for B2G invoices in Germany',
-        btReference: 'BT-10',
-        field: 'buyerReference'
-      });
-    }
-    
-    return results;
-  }
-  
-  /**
-   * Check if string looks like a Leitweg-ID
-   */
-  private looksLikeLeitwegId(value: string): boolean {
-    // Contains dashes and numbers in the right proportion
-    return value.includes('-') && /^\d+-\d+-\d+$/.test(value.trim());
-  }
-  
-  /**
-   * Check if this is a B2G invoice
-   */
-  private isB2GInvoice(invoice: EInvoice): boolean {
-    // Check if buyer is a public entity (simplified check)
-    const buyerName = invoice.to?.name?.toLowerCase() || '';
-    const buyerType = invoice.metadata?.extensions?.buyerType?.toLowerCase() || '';
-    
-    const publicIndicators = [
-      'bundesamt', 'landesamt', 'stadtverwaltung', 'gemeinde',
-      'ministerium', 'behörde', 'öffentlich', 'public', 'government'
-    ];
-    
-    return publicIndicators.some(indicator => 
-      buyerName.includes(indicator) || buyerType.includes(indicator)
-    );
-  }
-  
-  /**
-   * Validate mandatory buyer reference (BT-10)
-   * Rule: XR-DE-15
+   * The buyer reference (BT-10) is stated (BR-DE-15). In German public procurement it carries
+   * the Leitweg-ID; the XRechnung rules do not check its format.
    */
   private validateBuyerReference(invoice: EInvoice): ValidationResult[] {
-    const results: ValidationResult[] = [];
-    
-    const buyerReference = invoice.metadata?.buyerReference || invoice.buyerReference || '';
-    
-    // Skip if B2G invoice - already handled in validateLeitwegId
-    if (this.isB2GInvoice(invoice)) {
-      return results;
+    const buyerReference = invoice.buyerReference || '';
+    if (buyerReference.trim().length > 0) {
+      return [];
     }
-    
-    if (!buyerReference || buyerReference.trim().length === 0) {
-      results.push({
-        ruleId: 'XR-DE-15',
-        severity: 'error',
-        source: 'XRECHNUNG',
-        message: 'Buyer reference (BT-10) is mandatory in XRechnung',
-        btReference: 'BT-10',
-        field: 'buyerReference'
-      });
-    }
-    
-    return results;
+    return [{
+      ruleId: 'BR-DE-15',
+      severity: 'error',
+      source: 'XRECHNUNG',
+      message: 'The buyer reference (BT-10) is stated',
+      btReference: 'BT-10',
+      field: 'buyerReference'
+    }];
   }
   
   /**
-   * Validate payment details (IBAN/BIC for SEPA)
-   * Rules: XR-DE-19, XR-DE-20
-   */
-  private validatePaymentDetails(invoice: EInvoice): ValidationResult[] {
-    const results: ValidationResult[] = [];
-    
-    // Check payment means
-    const paymentMeans = invoice.metadata?.extensions?.paymentMeans as Array<{
-      type?: string;
-      iban?: string;
-      bic?: string;
-      accountName?: string;
-    }> | undefined;
-    if (!paymentMeans || paymentMeans.length === 0) {
-      return results; // No payment details to validate
-    }
-    
-    for (const payment of paymentMeans) {
-      // Validate IBAN if present
-      if (payment.iban) {
-        const ibanResult = this.validateIBAN(payment.iban);
-        if (!ibanResult.valid) {
-          results.push({
-            ruleId: 'XR-DE-19',
-            severity: 'error',
-            source: 'XRECHNUNG',
-            message: `Invalid IBAN: ${ibanResult.message}`,
-            btReference: 'BT-84',
-            field: 'iban',
-            value: payment.iban
-          });
-        }
-        
-        // Check if IBAN country is in SEPA zone
-        const countryCode = payment.iban.substring(0, 2);
-        if (!XRechnungValidator.SEPA_COUNTRIES.has(countryCode)) {
-          results.push({
-            ruleId: 'XR-DE-19',
-            severity: 'warning',
-            source: 'XRECHNUNG',
-            message: `IBAN country ${countryCode} is not in SEPA zone`,
-            btReference: 'BT-84',
-            field: 'iban',
-            value: payment.iban
-          });
-        }
-      }
-      
-      // Validate BIC if present
-      if (payment.bic) {
-        const bicResult = this.validateBIC(payment.bic);
-        if (!bicResult.valid) {
-          results.push({
-            ruleId: 'XR-DE-20',
-            severity: 'error',
-            source: 'XRECHNUNG',
-            message: `Invalid BIC: ${bicResult.message}`,
-            btReference: 'BT-86',
-            field: 'bic',
-            value: payment.bic
-          });
-        }
-      }
-      
-      // For German domestic payments, BIC is optional if IBAN starts with DE
-      if (payment.iban?.startsWith('DE') && !payment.bic) {
-        // This is fine, BIC is optional for domestic German payments
-      } else if (payment.iban && !payment.iban.startsWith('DE') && !payment.bic) {
-        results.push({
-          ruleId: 'XR-DE-20',
-          severity: 'warning',
-          source: 'XRECHNUNG',
-          message: 'BIC is recommended for international SEPA transfers',
-          btReference: 'BT-86',
-          field: 'bic'
-        });
-      }
-    }
-    
-    return results;
-  }
-  
-  /**
-   * Validate IBAN format and checksum
-   */
-  private validateIBAN(iban: string): { valid: boolean; message?: string } {
-    // Remove spaces and convert to uppercase
-    const cleanIBAN = iban.replace(/\s/g, '').toUpperCase();
-    
-    // Check basic format
-    if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]+$/.test(cleanIBAN)) {
-      return { valid: false, message: 'Invalid IBAN format' };
-    }
-    
-    // Get country code
-    const countryCode = cleanIBAN.substring(0, 2);
-    
-    // Check country-specific format
-    const countryFormat = XRechnungValidator.IBAN_PATTERNS[countryCode];
-    if (countryFormat) {
-      if (cleanIBAN.length !== countryFormat.length) {
-        return { 
-          valid: false, 
-          message: `Invalid IBAN length for ${countryCode}: expected ${countryFormat.length}, got ${cleanIBAN.length}` 
-        };
-      }
-      
-      if (!countryFormat.pattern.test(cleanIBAN)) {
-        return { 
-          valid: false, 
-          message: `Invalid IBAN format for ${countryCode}` 
-        };
-      }
-    }
-    
-    // Validate checksum using mod-97 algorithm
-    const rearranged = cleanIBAN.substring(4) + cleanIBAN.substring(0, 4);
-    const numeric = rearranged.replace(/[A-Z]/g, char => (char.charCodeAt(0) - 55).toString());
-    
-    // Calculate mod 97 for large numbers
-    let remainder = 0;
-    for (let i = 0; i < numeric.length; i++) {
-      remainder = (remainder * 10 + parseInt(numeric[i])) % 97;
-    }
-    
-    if (remainder !== 1) {
-      return { valid: false, message: 'Invalid IBAN checksum' };
-    }
-    
-    return { valid: true };
-  }
-  
-  /**
-   * Validate BIC format
-   */
-  private validateBIC(bic: string): { valid: boolean; message?: string } {
-    const cleanBIC = bic.replace(/\s/g, '').toUpperCase();
-    
-    if (!XRechnungValidator.BIC_PATTERN.test(cleanBIC)) {
-      return { 
-        valid: false, 
-        message: 'Invalid BIC format. Expected 8 or 11 alphanumeric characters' 
-      };
-    }
-    
-    // Additional validation could check if BIC exists in SWIFT directory
-    // but that requires external data
-    
-    return { valid: true };
-  }
-  
-  /**
-   * Validate seller contact details
-   * Rule: XR-DE-02
+   * The seller contact (BG-6), as the XRechnung encoder writes it from the seller
+   * (`metadata.contactInformation`, otherwise its name, telephone number and email address):
+   * BR-DE-2 asks for it, BR-DE-27 and BR-DE-28 ask a telephone number (BT-42) and an email
+   * address (BT-43) to have the forms the XRechnung rules state (warnings).
    */
   private validateSellerContact(invoice: EInvoice): ValidationResult[] {
     const results: ValidationResult[] = [];
+    const sellerContact = getPartyContact(invoice.from);
     
-    // Seller contact is mandatory in XRechnung
-    const sellerContact = invoice.metadata?.extensions?.sellerContact as {
-      name?: string;
-      email?: string;
-      phone?: string;
-    } | undefined;
-    
-    if (!sellerContact || (!sellerContact.name && !sellerContact.email && !sellerContact.phone)) {
+    if (!sellerContact) {
       results.push({
-        ruleId: 'XR-DE-02',
+        ruleId: 'BR-DE-2',
         severity: 'error',
         source: 'XRECHNUNG',
-        message: 'Seller contact information (name, email, or phone) is mandatory in XRechnung',
+        message: 'The seller contact (BG-6) is stated',
         bgReference: 'BG-6',
-        field: 'sellerContact'
+        field: 'from'
       });
+      return results;
     }
     
-    // Validate email format if present
-    if (sellerContact?.email && !this.isValidEmail(sellerContact.email)) {
+    // XR-TELEPHONE-REGEX of the XRechnung rules: at least three digits
+    if (sellerContact.phone && !/([0-9].*){3,}/.test(sellerContact.phone.trim())) {
       results.push({
-        ruleId: 'XR-DE-02',
+        ruleId: 'BR-DE-27',
         severity: 'warning',
         source: 'XRECHNUNG',
-        message: `Invalid email format: ${sellerContact.email}`,
-        btReference: 'BT-43',
-        field: 'email',
-        value: sellerContact.email
+        message: `The seller contact telephone number (BT-42) contains at least three digits: ${sellerContact.phone}`,
+        btReference: 'BT-42',
+        field: 'from.phone',
+        value: sellerContact.phone
       });
     }
     
-    // Validate phone format if present (basic validation)
-    if (sellerContact?.phone && !this.isValidPhone(sellerContact.phone)) {
+    // XR-EMAIL-REGEX of the XRechnung rules
+    if (sellerContact.email && !/^[^@\s]+@([^@.\s]+\.)+[^@.\s]+$/.test(sellerContact.email.trim())) {
       results.push({
-        ruleId: 'XR-DE-02',
+        ruleId: 'BR-DE-28',
         severity: 'warning',
         source: 'XRECHNUNG',
-        message: `Invalid phone format: ${sellerContact.phone}`,
-        btReference: 'BT-42',
-        field: 'phone',
-        value: sellerContact.phone
+        message: `The seller contact email address (BT-43) has exactly one @, with a domain after it: ${sellerContact.email}`,
+        btReference: 'BT-43',
+        field: 'from.email',
+        value: sellerContact.email
       });
     }
     
@@ -379,114 +128,44 @@ export class XRechnungValidator {
   }
   
   /**
-   * Validate email format
-   */
-  private isValidEmail(email: string): boolean {
-    const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    return emailPattern.test(email);
-  }
-  
-  /**
-   * Validate phone format (basic)
-   */
-  private isValidPhone(phone: string): boolean {
-    // Remove common formatting characters
-    const cleanPhone = phone.replace(/[\s\-\(\)\.]/g, '');
-    // Check if it contains only numbers and optional + at start
-    return /^\+?[0-9]{6,15}$/.test(cleanPhone);
-  }
-  
-  /**
-   * Validate tax registration details
-   * Rules: XR-DE-03, XR-DE-04
+   * The seller VAT identifier (BT-31) or tax registration identifier (BT-32) of the seller's
+   * registration details, `vatId` and `taxNumber` (BR-DE-16). The rule applies when a line
+   * states a VAT category code S, Z, E, AE, K, G, L or M; the encoders write S or AE for every
+   * line. It also accepts a tax representative (BG-11), which the envelope cannot state.
    */
   private validateTaxRegistration(invoice: EInvoice): ValidationResult[] {
     const results: ValidationResult[] = [];
     
-    const sellerVatId = invoice.metadata?.sellerTaxId || 
-                        (invoice.from?.type === 'company' ? (invoice.from as any).registrationDetails?.vatId : undefined) || 
-                        invoice.metadata?.extensions?.sellerVatId;
-    const sellerTaxId = invoice.metadata?.extensions?.sellerTaxId;
+    const sellerVatId = invoice.from?.registrationDetails?.vatId?.trim() || '';
+    const sellerTaxNumber = invoice.from?.registrationDetails?.taxNumber?.trim() || '';
     
-    // Either VAT ID or Tax ID must be present
-    if (!sellerVatId && !sellerTaxId) {
+    if ((invoice.items ?? []).length > 0 && !sellerVatId && !sellerTaxNumber) {
       results.push({
-        ruleId: 'XR-DE-03',
+        ruleId: 'BR-DE-16',
         severity: 'error',
         source: 'XRECHNUNG',
-        message: 'Either seller VAT ID (BT-31) or Tax ID (BT-32) must be provided',
+        message: 'The seller states its VAT identifier (BT-31) or tax registration identifier (BT-32), from.registrationDetails.vatId or .taxNumber',
         btReference: 'BT-31',
-        field: 'sellerTaxRegistration'
+        field: 'from.registrationDetails'
       });
     }
     
-    // Validate German VAT ID format if present
-    if (sellerVatId && sellerVatId.startsWith('DE')) {
-      if (!this.isValidGermanVatId(sellerVatId)) {
-        results.push({
-          ruleId: 'XR-DE-04',
-          severity: 'error',
-          source: 'XRECHNUNG',
-          message: `Invalid German VAT ID format: ${sellerVatId}`,
-          btReference: 'BT-31',
-          field: 'vatId',
-          value: sellerVatId
-        });
-      }
-    }
-    
-    // Validate German Tax ID format if present
-    if (sellerTaxId && this.looksLikeGermanTaxId(sellerTaxId)) {
-      if (!this.isValidGermanTaxId(sellerTaxId)) {
-        results.push({
-          ruleId: 'XR-DE-04',
-          severity: 'warning',
-          source: 'XRECHNUNG',
-          message: `Invalid German Tax ID format: ${sellerTaxId}`,
-          btReference: 'BT-32',
-          field: 'taxId',
-          value: sellerTaxId
-        });
-      }
+    // The package's own check of the German VAT identification number format (no official rule)
+    if (isMalformedGermanVatId(sellerVatId)) {
+      results.push({
+        ruleId: GERMAN_VAT_ID_FORMAT_CODE,
+        severity: 'error',
+        source: EINVOICE_RULE_SOURCE,
+        message: germanVatIdFormatMessage(sellerVatId),
+        btReference: 'BT-31',
+        field: 'from.registrationDetails.vatId',
+        value: sellerVatId
+      });
     }
     
     return results;
   }
   
-  /**
-   * Validate German VAT ID format
-   */
-  private isValidGermanVatId(vatId: string): boolean {
-    // German VAT ID: DE followed by 9 digits
-    const germanVatPattern = /^DE[0-9]{9}$/;
-    return germanVatPattern.test(vatId.replace(/\s/g, ''));
-  }
-  
-  /**
-   * Check if value looks like a German Tax ID
-   */
-  private looksLikeGermanTaxId(value: string): boolean {
-    const clean = value.replace(/[\s\/\-]/g, '');
-    return /^[0-9]{10,11}$/.test(clean);
-  }
-  
-  /**
-   * Validate German Tax ID format
-   */
-  private isValidGermanTaxId(taxId: string): boolean {
-    // German Tax ID: 11 digits with specific checksum algorithm
-    const clean = taxId.replace(/[\s\/\-]/g, '');
-    
-    if (!/^[0-9]{11}$/.test(clean)) {
-      return false;
-    }
-    
-    // Simplified validation - full algorithm would require checksum calculation
-    // At least check that not all digits are the same
-    const firstDigit = clean[0];
-    return !clean.split('').every(digit => digit === firstDigit);
-  }
-  
   /**
    * Create XRechnung profile validator instance
    */

package/ts/index.ts

@@ -99,6 +99,15 @@ export type {
   EInvoiceOptions
 } from './interfaces/common.js';
 
+// The values a received document states (EInvoice.statedValues), with their EN 16931 business terms
+export type {
+  IEInvoiceStatedValues,
+  IStatedDocumentTotals,
+  IStatedVatBreakdown,
+  IStatedLine,
+  IStatedAllowanceCharge,
+} from './interfaces/stated.values.js';
+
 export { ValidationLevel, InvoiceFormat } from './interfaces/common.js';
 
 // Export interfaces (legacy support)

package/ts/interfaces/en16931-metadata.ts

@@ -14,19 +14,15 @@ export interface IEInvoiceMetadata {
   format?: InvoiceFormat;
   version?: string;
   profile?: string;
-  customizationId?: string;
+  customizationId?: string;                     // BT-24 specification identifier; the decoders set it
   
   // EN16931 Business Terms
   vatAccountingCurrency?: string;                // BT-6
   documentTypeCode?: string;                     // BT-3
   paymentMeansCode?: string;                     // BT-81
-  amountDue?: number;                           // BT-115
   
-  // Tax identifiers
-  sellerTaxId?: string;                         // BT-31
-  buyerTaxId?: string;                          // BT-48
-  buyerReference?: string;                      // BT-10
-  profileId?: string;                           // BT-23
+  // References
+  profileId?: string;                           // BT-23 business process type (UBL cbc:ProfileID)
   paymentTerms?: string;                        // BT-20
   
   // Delivery information (BG-13)

package/ts/interfaces/stated.values.ts

@@ -0,0 +1,94 @@
+/**
+ * The amounts, VAT breakdown, line amounts and document level allowances and
+ * charges a received document states, read as they are written, with their
+ * EN 16931 business terms. They are not computed and not updated when the
+ * envelope changes, and no encoder writes them: the envelope computes its
+ * totals from quantity × net price (`computeDocumentTotals`), and cannot yet
+ * express document or line allowances and charges or a price base quantity.
+ * Every field is undefined when the document does not state it.
+ */
+export interface IEInvoiceStatedValues {
+  /** Document totals (BG-22) */
+  totals: IStatedDocumentTotals;
+  /** VAT breakdown (BG-23), in document order */
+  vatBreakdown: IStatedVatBreakdown[];
+  /** Invoice lines (BG-25), in document order */
+  lines: IStatedLine[];
+  /** Document level allowances (BG-20), in document order */
+  allowances: IStatedAllowanceCharge[];
+  /** Document level charges (BG-21), in document order */
+  charges: IStatedAllowanceCharge[];
+}
+
+/** Document totals (BG-22) as a document states them */
+export interface IStatedDocumentTotals {
+  /** Sum of Invoice line net amount (BT-106) */
+  lineTotal?: number;
+  /** Sum of allowances on document level (BT-107) */
+  allowanceTotal?: number;
+  /** Sum of charges on document level (BT-108) */
+  chargeTotal?: number;
+  /** Invoice total amount without VAT (BT-109) */
+  taxExclusiveTotal?: number;
+  /** Invoice total VAT amount (BT-110), in the document currency */
+  taxTotal?: number;
+  /** Invoice total VAT amount in accounting currency (BT-111), with the VAT accounting currency code (BT-6) */
+  taxTotalInAccountingCurrency?: { amount: number; currency: string };
+  /** Invoice total amount with VAT (BT-112) */
+  taxInclusiveTotal?: number;
+  /** Paid amount (BT-113) */
+  paidAmount?: number;
+  /** Rounding amount (BT-114) */
+  roundingAmount?: number;
+  /** Amount due for payment (BT-115) */
+  amountDue?: number;
+}
+
+/** One VAT breakdown (BG-23) as a document states it */
+export interface IStatedVatBreakdown {
+  /** VAT category taxable amount (BT-116) */
+  taxableAmount?: number;
+  /** VAT category tax amount (BT-117) */
+  taxAmount?: number;
+  /** VAT category code (BT-118), UNTDID 5305 */
+  categoryCode?: string;
+  /** VAT category rate (BT-119); a category not subject to VAT states none */
+  rate?: number;
+  /** VAT exemption reason text (BT-120) */
+  exemptionReason?: string;
+  /** VAT exemption reason code (BT-121) */
+  exemptionReasonCode?: string;
+}
+
+/** The amounts and the VAT category of one invoice line (BG-25) as a document states them */
+export interface IStatedLine {
+  /** Invoice line identifier (BT-126) */
+  lineId?: string;
+  /** Invoice line net amount (BT-131) */
+  netAmount?: number;
+  /** Invoiced item VAT category code (BT-151) */
+  vatCategoryCode?: string;
+  /** Invoiced item VAT rate (BT-152) */
+  vatRate?: number;
+}
+
+/**
+ * One document level allowance (BG-20: BT-92 to BT-98) or charge (BG-21:
+ * BT-99 to BT-105) as a document states it
+ */
+export interface IStatedAllowanceCharge {
+  /** Amount (BT-92, BT-99) */
+  amount?: number;
+  /** Base amount (BT-93, BT-100) */
+  baseAmount?: number;
+  /** Percentage (BT-94, BT-101) */
+  percentage?: number;
+  /** VAT category code (BT-95, BT-102) */
+  vatCategoryCode?: string;
+  /** VAT rate (BT-96, BT-103) */
+  vatRate?: number;
+  /** Reason (BT-97, BT-104) */
+  reason?: string;
+  /** Reason code (BT-98, BT-105) */
+  reasonCode?: string;
+}

package/ts/readme.md

@@ -40,7 +40,7 @@ const xml = await invoice.exportXml('facturx');
 | `xrechnung` | Yes | Yes | Yes | UBL export; UBL and CII import |
 | `cii` | Yes | Yes | Yes | Generic export currently routes through the Factur-X encoder path |
 | `facturx` | Yes | Yes | Yes | Main CII generation path |
-| `zugferd` | Yes | Yes | Yes | Input supports v1 and v2+; the v1 decoder reads nothing out of a v1 header, so a v1 document always decodes as `invoice` (known defect) |
+| `zugferd` | Yes | Yes | Yes | Input supports v1 and v2+; export writes the EN 16931 profile, and v2 reads back as `facturx`, as XML and from a PDF; the v1 decoder reads nothing out of a v1 header, so a v1 document always decodes as `invoice` (known defect) |
 | `fatturapa` | Yes | No | No | Detection only at the moment |
 
 ## Important implementation notes

package/dist_ts/formats/utils/eu.memberstates.d.ts

@@ -1,11 +0,0 @@
-/**
- * The member states of the European Union, by ISO 3166-1 alpha-2 code (27
- * since 1 February 2020). Greece is `GR` here, as in an address; its VAT
- * identification numbers carry the prefix `EL` instead.
- */
-export declare const EU_MEMBER_STATES: ReadonlySet<string>;
-/**
- * Whether an ISO 3166-1 alpha-2 country code is that of an EU member state
- * @param countryCode The country code, in upper case
- */
-export declare const isEuMemberState: (countryCode: string) => boolean;