@stafyniaksacha/facturx/dist/index.mjs

Factur-X and Order-X generation library for European e-invoicing standard

export { c as check } from './shared/facturx.BLNAZCZq.mjs';
import { parseXmlAsync } from 'libxmljs';
export { e as extract } from './shared/facturx.D6xVK8Fx.mjs';
export { g as generate } from './shared/facturx.C3hlN7bj.mjs';
import { AccountingAccountTypeCodeType, AdvancePaymentType, AllowanceChargeReasonCodeType, AmountType, BinaryObjectType, CodeType, ContactTypeCodeType, CountryIDType, CreditorFinancialAccountType, CreditorFinancialInstitutionType, CrossIndustryInvoiceType, CurrencyCodeType, DateTimeType, DateType, DebtorFinancialAccountType, DeliveryTermsCodeType, DocumentCodeType, DocumentContextParameterType, DocumentLineDocumentType, ExchangedDocumentContextType, ExchangedDocumentType, FormattedDateTimeType, HeaderTradeAgreementType, HeaderTradeDeliveryType, HeaderTradeSettlementType, IDType, IndicatorType, LegalOrganizationType, LineStatusCodeType, LineTradeAgreementType, LineTradeDeliveryType, LineTradeSettlementType, LogisticsServiceChargeType, LogisticsTransportMovementType, MeasureType, NoteType, NumericType, PartyRoleCodeType, PaymentMeansCodeType, PercentType, ProcuringProjectType, ProductCharacteristicType, ProductClassificationType, QuantityType, RateType, ReferenceCodeType, ReferencedDocumentType, ReferencedProductType, SpecifiedPeriodType, SupplyChainConsignmentType, SupplyChainEventType, SupplyChainTradeLineItemType, SupplyChainTradeTransactionType, TaxCategoryCodeType, TaxRegistrationType, TaxTypeCodeType, TextType, TimeReferenceCodeType, TradeAccountingAccountType, TradeAddressType, TradeAllowanceChargeType, TradeContactType, TradeCountryType, TradeCurrencyExchangeType, TradeDeliveryTermsType, TradePartyType, TradePaymentDiscountTermsType, TradePaymentPenaltyTermsType, TradePaymentTermsType, TradePriceType, TradeProductInstanceType, TradeProductType, TradeSettlementFinancialCardType, TradeSettlementHeaderMonetarySummationType, TradeSettlementLineMonetarySummationType, TradeSettlementPaymentMeansType, TradeTaxType, TransportModeCodeType, UniversalCommunicationType } from './models.mjs';
import 'pdf-lib';
import 'date-fns';
import 'node:fs/promises';
import 'node:path';
import 'node:buffer';
import 'node:crypto';
import './shared/facturx.DVqxPZ0W.mjs';

async function invoiceToXml(invoice) {
  const xmlString = `<?xml version="1.0" encoding="UTF-8"?>
<rsm:CrossIndustryInvoice 
  xmlns:rsm="urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100" 
  xmlns:qdt="urn:un:unece:uncefact:data:standard:QualifiedDataType:100"
  xmlns:ram="urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100"
  xmlns:udt="urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
</rsm:CrossIndustryInvoice>`;
  const doc = await parseXmlAsync(xmlString);
  const rootElement = doc.root();
  convertExchangedDocumentContext(invoice.exchangedDocumentContext, rootElement);
  convertExchangedDocument(invoice.exchangedDocument, rootElement);
  convertSupplyChainTradeTransaction(invoice.supplyChainTradeTransaction, rootElement);
  return doc;
}
function convertAmount({ value, currencyID }, parent) {
  parent.text(value.toFixed(2));
  if (currencyID) {
    parent.attr({ currencyID });
  }
  return parent;
}
function convertID({ value, schemeID }, parent) {
  parent.text(value);
  if (schemeID) {
    parent.attr({ schemeID });
  }
  return parent;
}
function convertText({ value }, parent) {
  parent.text(value);
  return parent;
}
function convertDateTime({ dateTimeString, format }, parent) {
  const dateTimeStringElement = parent.node("udt:DateTimeString", dateTimeString);
  dateTimeStringElement.attr({ format });
  return parent;
}
function convertDate({ dateString, format }, parent) {
  const dateStringElement = parent.node("udt:DateString", dateString);
  dateStringElement.attr({ format });
  return parent;
}
function convertIndicator({ indicator }, parent) {
  parent.node("udt:Indicator", String(indicator));
  return parent;
}
function convertExchangedDocumentContext({
  testIndicator,
  businessProcessSpecifiedDocumentContextParameter,
  guidelineSpecifiedDocumentContextParameter
}, parent) {
  const context = parent.node("rsm:ExchangedDocumentContext");
  if (testIndicator) {
    const testIndicatorEl = context.node("ram:TestIndicator");
    convertIndicator(testIndicator, testIndicatorEl);
  }
  if (businessProcessSpecifiedDocumentContextParameter) {
    const businessProcessEl = context.node("ram:BusinessProcessSpecifiedDocumentContextParameter");
    convertDocumentContextParameter(businessProcessSpecifiedDocumentContextParameter, businessProcessEl);
  }
  const guidelineEl = context.node("ram:GuidelineSpecifiedDocumentContextParameter");
  convertDocumentContextParameter(guidelineSpecifiedDocumentContextParameter, guidelineEl);
}
function convertDocumentContextParameter({ id }, parent) {
  const idEl = parent.node("ram:ID");
  convertID(id, idEl);
}
function convertExchangedDocument({ id, name, typeCode, issueDateTime, copyIndicator, languageID, includedNote, effectiveSpecifiedPeriod }, parent) {
  const doc = parent.node("rsm:ExchangedDocument");
  const idEl = doc.node("ram:ID");
  convertID(id, idEl);
  if (name) {
    const nameEl = doc.node("ram:Name");
    convertText(name, nameEl);
  }
  const typeCodeEl = doc.node("ram:TypeCode");
  typeCodeEl.text(typeCode.value);
  const issueDateTimeEl = doc.node("ram:IssueDateTime");
  convertDateTime(issueDateTime, issueDateTimeEl);
  if (copyIndicator) {
    const copyIndicatorEl = doc.node("ram:CopyIndicator");
    convertIndicator(copyIndicator, copyIndicatorEl);
  }
  if (languageID && languageID.length > 0) {
    languageID.forEach((lang) => {
      const langEl = doc.node("ram:LanguageID");
      convertID(lang, langEl);
    });
  }
  if (includedNote && includedNote.length > 0) {
    includedNote.forEach((note) => convertNote(note, doc));
  }
  if (effectiveSpecifiedPeriod) {
    const periodEl = doc.node("ram:EffectiveSpecifiedPeriod");
    convertSpecifiedPeriod(effectiveSpecifiedPeriod, periodEl);
  }
}
function convertNote({ content, subjectCode }, parent) {
  const noteEl = parent.node("ram:IncludedNote");
  const contentEl = noteEl.node("ram:Content");
  convertText(content, contentEl);
  if (subjectCode) {
    const subjectCodeEl = noteEl.node("ram:SubjectCode");
    convertText(subjectCode, subjectCodeEl);
  }
}
function convertSpecifiedPeriod({ startDateTime, endDateTime, completeDateTime, description }, parent) {
  if (startDateTime) {
    const startDateTimeEl = parent.node("ram:StartDateTime");
    convertDateTime(startDateTime, startDateTimeEl);
  }
  if (endDateTime) {
    const endDateTimeEl = parent.node("ram:EndDateTime");
    convertDateTime(endDateTime, endDateTimeEl);
  }
  if (completeDateTime) {
    const completeDateTimeEl = parent.node("ram:CompleteDateTime");
    convertDateTime(completeDateTime, completeDateTimeEl);
  }
  if (description) {
    const descriptionEl = parent.node("ram:Description");
    convertText(description, descriptionEl);
  }
}
function convertSupplyChainTradeTransaction({
  includedSupplyChainTradeLineItem,
  applicableHeaderTradeAgreement,
  applicableHeaderTradeDelivery,
  applicableHeaderTradeSettlement
}, parent) {
  const transaction = parent.node("rsm:SupplyChainTradeTransaction");
  if (includedSupplyChainTradeLineItem && includedSupplyChainTradeLineItem.length > 0) {
    includedSupplyChainTradeLineItem.forEach((lineItem) => {
      const lineItemEl = transaction.node("ram:IncludedSupplyChainTradeLineItem");
      convertSupplyChainTradeLineItem(lineItem, lineItemEl);
    });
  }
  const agreementEl = transaction.node("ram:ApplicableHeaderTradeAgreement");
  convertHeaderTradeAgreement(applicableHeaderTradeAgreement, agreementEl);
  const deliveryEl = transaction.node("ram:ApplicableHeaderTradeDelivery");
  convertHeaderTradeDelivery(applicableHeaderTradeDelivery, deliveryEl);
  const settlementEl = transaction.node("ram:ApplicableHeaderTradeSettlement");
  convertHeaderTradeSettlement(applicableHeaderTradeSettlement, settlementEl);
}
function convertSupplyChainTradeLineItem(lineItem, parent) {
  if (lineItem.associatedDocumentLineDocument) {
    const docLineEl = parent.node("ram:AssociatedDocumentLineDocument");
    if (lineItem.associatedDocumentLineDocument.lineID) {
      const lineIDEl = docLineEl.node("ram:LineID");
      convertID(lineItem.associatedDocumentLineDocument.lineID, lineIDEl);
    }
  }
  if (lineItem.specifiedTradeProduct) {
    const productEl = parent.node("ram:SpecifiedTradeProduct");
    if (lineItem.specifiedTradeProduct.globalID) {
      const globalIDEl = productEl.node("ram:GlobalID");
      convertID(lineItem.specifiedTradeProduct.globalID, globalIDEl);
    }
    if (lineItem.specifiedTradeProduct.name) {
      const nameEl = productEl.node("ram:Name");
      convertText(lineItem.specifiedTradeProduct.name, nameEl);
    }
    if (lineItem.specifiedTradeProduct.description) {
      const descEl = productEl.node("ram:Description");
      convertText(lineItem.specifiedTradeProduct.description, descEl);
    }
  }
  if (lineItem.specifiedLineTradeAgreement) {
    const agreementEl = parent.node("ram:SpecifiedLineTradeAgreement");
    convertLineTradeAgreement(lineItem.specifiedLineTradeAgreement, agreementEl);
  }
  if (lineItem.specifiedLineTradeDelivery) {
    const deliveryEl = parent.node("ram:SpecifiedLineTradeDelivery");
    convertLineTradeDelivery(lineItem.specifiedLineTradeDelivery, deliveryEl);
  }
  if (lineItem.specifiedLineTradeSettlement) {
    const settlementEl = parent.node("ram:SpecifiedLineTradeSettlement");
    convertLineTradeSettlement(lineItem.specifiedLineTradeSettlement, settlementEl);
  }
}
function convertHeaderTradeAgreement({
  buyerReference,
  sellerTradeParty,
  buyerTradeParty,
  buyerOrderReferencedDocument,
  additionalReferencedDocument,
  applicableTradeDeliveryTerms,
  buyerAgentTradeParty,
  buyerTaxRepresentativeTradeParty,
  contractReferencedDocument,
  productEndUserTradeParty,
  quotationReferencedDocument,
  salesAgentTradeParty,
  sellerOrderReferencedDocument,
  sellerTaxRepresentativeTradeParty,
  specifiedProcuringProject,
  ultimateCustomerOrderReferencedDocument
}, parent) {
  if (buyerReference) {
    const refEl = parent.node("ram:BuyerReference");
    convertText(buyerReference, refEl);
  }
  const sellerPartyEl = parent.node("ram:SellerTradeParty");
  convertTradeParty(sellerTradeParty, sellerPartyEl);
  const buyerPartyEl = parent.node("ram:BuyerTradeParty");
  convertTradeParty(buyerTradeParty, buyerPartyEl);
  if (buyerOrderReferencedDocument) {
    const docEl = parent.node("ram:BuyerOrderReferencedDocument");
    if (buyerOrderReferencedDocument.issuerAssignedID) {
      const idEl = docEl.node("ram:IssuerAssignedID");
      convertID(buyerOrderReferencedDocument.issuerAssignedID, idEl);
    }
  }
  if (additionalReferencedDocument) {
    additionalReferencedDocument.forEach((doc) => {
      const docEl = parent.node("ram:AdditionalReferencedDocument");
      convertReferencedDocument(doc, docEl);
    });
  }
  if (salesAgentTradeParty) {
    const agentEl = parent.node("ram:SalesAgentTradeParty");
    convertTradeParty(salesAgentTradeParty, agentEl);
  }
  if (buyerAgentTradeParty) {
    const agentEl = parent.node("ram:BuyerAgentTradeParty");
    convertTradeParty(buyerAgentTradeParty, agentEl);
  }
  if (buyerTaxRepresentativeTradeParty) {
    const taxEl = parent.node("ram:BuyerTaxRepresentativeTradeParty");
    convertTradeParty(buyerTaxRepresentativeTradeParty, taxEl);
  }
  if (sellerTaxRepresentativeTradeParty) {
    const taxEl = parent.node("ram:SellerTaxRepresentativeTradeParty");
    convertTradeParty(sellerTaxRepresentativeTradeParty, taxEl);
  }
  if (productEndUserTradeParty) {
    const endUserEl = parent.node("ram:ProductEndUserTradeParty");
    convertTradeParty(productEndUserTradeParty, endUserEl);
  }
  if (quotationReferencedDocument) {
    const docEl = parent.node("ram:QuotationReferencedDocument");
    convertReferencedDocument(quotationReferencedDocument, docEl);
  }
  if (contractReferencedDocument) {
    const docEl = parent.node("ram:ContractReferencedDocument");
    convertReferencedDocument(contractReferencedDocument, docEl);
  }
  if (sellerOrderReferencedDocument) {
    const docEl = parent.node("ram:SellerOrderReferencedDocument");
    convertReferencedDocument(sellerOrderReferencedDocument, docEl);
  }
  if (ultimateCustomerOrderReferencedDocument) {
    ultimateCustomerOrderReferencedDocument.forEach((doc) => {
      const docEl = parent.node("ram:UltimateCustomerOrderReferencedDocument");
      convertReferencedDocument(doc, docEl);
    });
  }
}
function convertTradeParty({
  name,
  specifiedLegalOrganization,
  postalTradeAddress,
  specifiedTaxRegistration,
  definedTradeContact,
  description,
  globalID,
  id,
  roleCode,
  uriUniversalCommunication
}, parent) {
  if (name) {
    const nameEl = parent.node("ram:Name");
    convertText(name, nameEl);
  }
  if (specifiedLegalOrganization) {
    const orgEl = parent.node("ram:SpecifiedLegalOrganization");
    if (specifiedLegalOrganization.id) {
      const idEl = orgEl.node("ram:ID");
      convertID(specifiedLegalOrganization.id, idEl);
    }
  }
  if (postalTradeAddress) {
    const addressEl = parent.node("ram:PostalTradeAddress");
    convertTradeAddress(postalTradeAddress, addressEl);
  }
  if (specifiedTaxRegistration && specifiedTaxRegistration.length > 0) {
    specifiedTaxRegistration.forEach((tax) => {
      const taxEl = parent.node("ram:SpecifiedTaxRegistration");
      if (tax.id) {
        const idEl = taxEl.node("ram:ID");
        convertID(tax.id, idEl);
      }
    });
  }
  if (description) {
    const descriptionEl = parent.node("ram:Description");
    convertText(description, descriptionEl);
  }
  if (globalID) {
    globalID.forEach((id2) => {
      const globalIDEl = parent.node("ram:GlobalID");
      convertID(id2, globalIDEl);
    });
  }
  if (roleCode) {
    const roleCodeEl = parent.node("ram:RoleCode");
    convertText(roleCode, roleCodeEl);
  }
}
function convertTradeAddress({ countryID, postcodeCode, cityName, lineOne }, parent) {
  if (postcodeCode) {
    const postcodeEl = parent.node("ram:PostcodeCode");
    convertText(postcodeCode, postcodeEl);
  }
  if (lineOne) {
    const lineOneEl = parent.node("ram:LineOne");
    convertText(lineOne, lineOneEl);
  }
  if (cityName) {
    const cityNameEl = parent.node("ram:CityName");
    convertText(cityName, cityNameEl);
  }
  if (countryID) {
    const countryIDEl = parent.node("ram:CountryID");
    countryIDEl.text(countryID.value);
  }
}
function convertHeaderTradeDelivery(delivery, parent) {
  if (delivery.shipToTradeParty) {
    const shipToEl = parent.node("ram:ShipToTradeParty");
    convertTradeParty(delivery.shipToTradeParty, shipToEl);
  }
}
function convertHeaderTradeSettlement({
  invoiceCurrencyCode,
  applicableTradeTax,
  specifiedTradeSettlementHeaderMonetarySummation,
  specifiedTradeSettlementPaymentMeans,
  billingSpecifiedPeriod,
  specifiedTradeAllowanceCharge,
  creditorReferenceID,
  paymentReference,
  taxCurrencyCode,
  invoiceIssuerReference,
  invoicerTradeParty,
  invoiceeTradeParty,
  payeeTradeParty,
  payerTradeParty
}, parent) {
  if (creditorReferenceID) {
    const creditorReferenceIDEl = parent.node("ram:CreditorReferenceID");
    convertID(creditorReferenceID, creditorReferenceIDEl);
  }
  if (paymentReference) {
    const paymentReferenceEl = parent.node("ram:PaymentReference");
    convertText(paymentReference, paymentReferenceEl);
  }
  if (taxCurrencyCode) {
    const taxCurrencyCodeEl = parent.node("ram:TaxCurrencyCode");
    taxCurrencyCodeEl.text(taxCurrencyCode.value);
  }
  const currencyEl = parent.node("ram:InvoiceCurrencyCode");
  currencyEl.text(invoiceCurrencyCode.value);
  if (invoiceIssuerReference) {
    const invoiceIssuerReferenceEl = parent.node("ram:InvoiceIssuerReference");
    convertID(invoiceIssuerReference, invoiceIssuerReferenceEl);
  }
  if (invoicerTradeParty) {
    const invoicerEl = parent.node("ram:InvoicerTradeParty");
    convertTradeParty(invoicerTradeParty, invoicerEl);
  }
  if (invoiceeTradeParty) {
    const invoiceeEl = parent.node("ram:InvoiceeTradeParty");
    convertTradeParty(invoiceeTradeParty, invoiceeEl);
  }
  if (payeeTradeParty) {
    const payeeEl = parent.node("ram:PayeeTradeParty");
    convertTradeParty(payeeTradeParty, payeeEl);
  }
  if (payerTradeParty) {
    const payerEl = parent.node("ram:PayerTradeParty");
    convertTradeParty(payerTradeParty, payerEl);
  }
  if (specifiedTradeSettlementPaymentMeans && specifiedTradeSettlementPaymentMeans.length > 0) {
    specifiedTradeSettlementPaymentMeans.forEach((paymentMeans) => {
      const paymentMeansEl = parent.node("ram:SpecifiedTradeSettlementPaymentMeans");
      if (paymentMeans.typeCode) {
        const typeCodeEl = paymentMeansEl.node("ram:TypeCode");
        typeCodeEl.text(paymentMeans.typeCode.value);
      }
    });
  }
  if (applicableTradeTax && applicableTradeTax.length > 0) {
    applicableTradeTax.forEach((tax) => {
      const taxEl = parent.node("ram:ApplicableTradeTax");
      convertTradeTax(tax, taxEl);
    });
  }
  if (billingSpecifiedPeriod) {
    const billingPeriodEl = parent.node("ram:BillingSpecifiedPeriod");
    convertSpecifiedPeriod(billingSpecifiedPeriod, billingPeriodEl);
  }
  if (specifiedTradeAllowanceCharge && specifiedTradeAllowanceCharge.length > 0) {
    specifiedTradeAllowanceCharge.forEach((allowanceCharge) => {
      const allowanceChargeEl = parent.node("ram:SpecifiedTradeAllowanceCharge");
      convertAllowanceCharge(allowanceCharge, allowanceChargeEl);
    });
  }
  const summationEl = parent.node("ram:SpecifiedTradeSettlementHeaderMonetarySummation");
  convertTradeSettlementHeaderMonetarySummation(specifiedTradeSettlementHeaderMonetarySummation, summationEl);
}
function convertTradeTax({
  typeCode,
  categoryCode,
  rateApplicablePercent,
  allowanceChargeBasisAmount,
  basisAmount,
  lineTotalBasisAmount,
  exemptionReason,
  exemptionReasonCode,
  taxPointDate,
  dueDateTypeCode,
  calculatedAmount
}, parent) {
  if (typeCode) {
    const typeCodeEl = parent.node("ram:TypeCode");
    typeCodeEl.text(typeCode.value);
  }
  if (categoryCode) {
    const categoryCodeEl = parent.node("ram:CategoryCode");
    categoryCodeEl.text(categoryCode.value);
  }
  if (rateApplicablePercent) {
    const rateEl = parent.node("ram:RateApplicablePercent");
    rateEl.text(String(rateApplicablePercent.value));
  }
  if (allowanceChargeBasisAmount) {
    const basisAmountEl = parent.node("ram:AllowanceChargeBasisAmount");
    convertAmount(allowanceChargeBasisAmount, basisAmountEl);
  }
  if (lineTotalBasisAmount) {
    const lineTotalBasisAmountEl = parent.node("ram:LineTotalBasisAmount");
    convertAmount(lineTotalBasisAmount, lineTotalBasisAmountEl);
  }
  if (exemptionReason) {
    const exemptionReasonEl = parent.node("ram:ExemptionReason");
    convertText(exemptionReason, exemptionReasonEl);
  }
  if (exemptionReasonCode) {
    const exemptionReasonCodeEl = parent.node("ram:ExemptionReasonCode");
    convertText(exemptionReasonCode, exemptionReasonCodeEl);
  }
  if (taxPointDate) {
    const taxPointDateEl = parent.node("ram:TaxPointDate");
    convertDate(taxPointDate, taxPointDateEl);
  }
  if (dueDateTypeCode) {
    const dueDateTypeCodeEl = parent.node("ram:DueDateTypeCode");
    dueDateTypeCodeEl.text(dueDateTypeCode.value);
  }
  if (calculatedAmount) {
    const calculatedAmountEl = parent.node("ram:CalculatedAmount");
    convertAmount(calculatedAmount, calculatedAmountEl);
  }
}
function convertTradeSettlementHeaderMonetarySummation({
  lineTotalAmount,
  taxBasisTotalAmount,
  taxTotalAmount,
  grandTotalAmount,
  duePayableAmount,
  allowanceTotalAmount,
  chargeTotalAmount,
  roundingAmount,
  totalPrepaidAmount
}, parent) {
  if (lineTotalAmount) {
    const lineTotalEl = parent.node("ram:LineTotalAmount");
    convertAmount(lineTotalAmount, lineTotalEl);
  }
  if (chargeTotalAmount) {
    const chargeTotalEl = parent.node("ram:ChargeTotalAmount");
    convertAmount(chargeTotalAmount, chargeTotalEl);
  }
  if (allowanceTotalAmount) {
    const allowanceTotalEl = parent.node("ram:AllowanceTotalAmount");
    convertAmount(allowanceTotalAmount, allowanceTotalEl);
  }
  if (taxBasisTotalAmount && taxBasisTotalAmount.length > 0) {
    taxBasisTotalAmount.forEach((amount) => {
      const taxBasisEl = parent.node("ram:TaxBasisTotalAmount");
      convertAmount(amount, taxBasisEl);
    });
  }
  if (taxTotalAmount && taxTotalAmount.length > 0) {
    taxTotalAmount.forEach((amount) => {
      const taxTotalEl = parent.node("ram:TaxTotalAmount");
      convertAmount(amount, taxTotalEl);
    });
  }
  if (roundingAmount) {
    const roundingEl = parent.node("ram:RoundingAmount");
    convertAmount(roundingAmount, roundingEl);
  }
  if (grandTotalAmount && grandTotalAmount.length > 0) {
    grandTotalAmount.forEach((amount) => {
      const grandTotalEl = parent.node("ram:GrandTotalAmount");
      convertAmount(amount, grandTotalEl);
    });
  }
  if (totalPrepaidAmount) {
    const totalPrepaidEl = parent.node("ram:TotalPrepaidAmount");
    convertAmount(totalPrepaidAmount, totalPrepaidEl);
  }
  if (duePayableAmount) {
    const duePayableEl = parent.node("ram:DuePayableAmount");
    convertAmount(duePayableAmount, duePayableEl);
  }
}
function convertLineTradeAgreement({
  buyerOrderReferencedDocument,
  quotationReferencedDocument,
  contractReferencedDocument,
  additionalReferencedDocument,
  grossPriceProductTradePrice,
  netPriceProductTradePrice,
  ultimateCustomerOrderReferencedDocument
}, parent) {
  if (buyerOrderReferencedDocument) {
    const docEl = parent.node("ram:BuyerOrderReferencedDocument");
    convertReferencedDocument(buyerOrderReferencedDocument, docEl);
  }
  if (quotationReferencedDocument) {
    const docEl = parent.node("ram:QuotationReferencedDocument");
    convertReferencedDocument(quotationReferencedDocument, docEl);
  }
  if (contractReferencedDocument) {
    const docEl = parent.node("ram:ContractReferencedDocument");
    convertReferencedDocument(contractReferencedDocument, docEl);
  }
  if (additionalReferencedDocument && additionalReferencedDocument.length > 0) {
    additionalReferencedDocument.forEach((doc) => {
      const docEl = parent.node("ram:AdditionalReferencedDocument");
      convertReferencedDocument(doc, docEl);
    });
  }
  if (grossPriceProductTradePrice) {
    const priceEl = parent.node("ram:GrossPriceProductTradePrice");
    convertTradePrice(grossPriceProductTradePrice, priceEl);
  }
  const netPriceEl = parent.node("ram:NetPriceProductTradePrice");
  convertTradePrice(netPriceProductTradePrice, netPriceEl);
  if (ultimateCustomerOrderReferencedDocument && ultimateCustomerOrderReferencedDocument.length > 0) {
    ultimateCustomerOrderReferencedDocument.forEach((doc) => {
      const docEl = parent.node("ram:UltimateCustomerOrderReferencedDocument");
      convertReferencedDocument(doc, docEl);
    });
  }
}
function convertReferencedDocument({ issuerAssignedID, lineID }, parent) {
  if (issuerAssignedID) {
    const idEl = parent.node("ram:IssuerAssignedID");
    convertID(issuerAssignedID, idEl);
  }
  if (lineID) {
    const idEl = parent.node("ram:LineID");
    convertID(lineID, idEl);
  }
}
function convertTradePrice({ chargeAmount, basisQuantity }, parent) {
  if (chargeAmount) {
    const amountEl = parent.node("ram:ChargeAmount");
    convertAmount(chargeAmount, amountEl);
  }
  if (basisQuantity) {
    const quantityEl = parent.node("ram:BasisQuantity");
    convertQuantity(basisQuantity, quantityEl);
  }
}
function convertQuantity({ value, unitCode }, parent) {
  parent.text(String(value));
  if (unitCode) {
    parent.attr({ unitCode });
  }
}
function convertAllowanceCharge({ chargeIndicator, actualAmount, reasonCode, reason }, parent) {
  if (chargeIndicator) {
    const indicatorEl = parent.node("ram:ChargeIndicator");
    convertIndicator(chargeIndicator, indicatorEl);
  }
  if (actualAmount) {
    const amountEl = parent.node("ram:ActualAmount");
    convertAmount(actualAmount, amountEl);
  }
  if (reasonCode) {
    const codeEl = parent.node("ram:ReasonCode");
    convertText(reasonCode, codeEl);
  }
  if (reason) {
    const reasonEl = parent.node("ram:Reason");
    convertText(reason, reasonEl);
  }
}
function convertLineTradeDelivery({
  billedQuantity,
  chargeFreeQuantity,
  packageQuantity,
  shipToTradeParty,
  ultimateShipToTradeParty,
  actualDeliverySupplyChainEvent,
  despatchAdviceReferencedDocument,
  receivingAdviceReferencedDocument,
  deliveryNoteReferencedDocument
}, parent) {
  const billedQuantityEl = parent.node("ram:BilledQuantity");
  convertQuantity(billedQuantity, billedQuantityEl);
  if (chargeFreeQuantity) {
    const quantityEl = parent.node("ram:ChargeFreeQuantity");
    convertQuantity(chargeFreeQuantity, quantityEl);
  }
  if (packageQuantity) {
    const quantityEl = parent.node("ram:PackageQuantity");
    convertQuantity(packageQuantity, quantityEl);
  }
  if (shipToTradeParty) {
    const partyEl = parent.node("ram:ShipToTradeParty");
    convertTradeParty(shipToTradeParty, partyEl);
  }
  if (ultimateShipToTradeParty) {
    const partyEl = parent.node("ram:UltimateShipToTradeParty");
    convertTradeParty(ultimateShipToTradeParty, partyEl);
  }
  if (actualDeliverySupplyChainEvent) {
    const eventEl = parent.node("ram:ActualDeliverySupplyChainEvent");
    convertSupplyChainEvent(actualDeliverySupplyChainEvent, eventEl);
  }
  if (despatchAdviceReferencedDocument) {
    const docEl = parent.node("ram:DespatchAdviceReferencedDocument");
    convertReferencedDocument(despatchAdviceReferencedDocument, docEl);
  }
  if (receivingAdviceReferencedDocument) {
    const docEl = parent.node("ram:ReceivingAdviceReferencedDocument");
    convertReferencedDocument(receivingAdviceReferencedDocument, docEl);
  }
  if (deliveryNoteReferencedDocument) {
    const docEl = parent.node("ram:DeliveryNoteReferencedDocument");
    convertReferencedDocument(deliveryNoteReferencedDocument, docEl);
  }
}
function convertSupplyChainEvent({ occurrenceDateTime }, parent) {
  if (occurrenceDateTime) {
    const dateTimeEl = parent.node("ram:OccurrenceDateTime");
    convertDateTime(occurrenceDateTime, dateTimeEl);
  }
}
function convertLineTradeSettlement({
  applicableTradeTax,
  billingSpecifiedPeriod,
  specifiedTradeAllowanceCharge,
  specifiedTradeSettlementLineMonetarySummation,
  invoiceReferencedDocument,
  additionalReferencedDocument,
  receivableSpecifiedTradeAccountingAccount
}, parent) {
  if (applicableTradeTax && applicableTradeTax.length > 0) {
    applicableTradeTax.forEach((tax) => {
      const taxEl = parent.node("ram:ApplicableTradeTax");
      convertTradeTax(tax, taxEl);
    });
  }
  if (billingSpecifiedPeriod) {
    const periodEl = parent.node("ram:BillingSpecifiedPeriod");
    convertSpecifiedPeriod(billingSpecifiedPeriod, periodEl);
  }
  if (specifiedTradeAllowanceCharge && specifiedTradeAllowanceCharge.length > 0) {
    specifiedTradeAllowanceCharge.forEach((charge) => {
      const chargeEl = parent.node("ram:SpecifiedTradeAllowanceCharge");
      convertAllowanceCharge(charge, chargeEl);
    });
  }
  const summationEl = parent.node("ram:SpecifiedTradeSettlementLineMonetarySummation");
  convertTradeSettlementLineMonetarySummation(specifiedTradeSettlementLineMonetarySummation, summationEl);
  if (invoiceReferencedDocument) {
    const docEl = parent.node("ram:InvoiceReferencedDocument");
    convertReferencedDocument(invoiceReferencedDocument, docEl);
  }
  if (additionalReferencedDocument && additionalReferencedDocument.length > 0) {
    additionalReferencedDocument.forEach((doc) => {
      const docEl = parent.node("ram:AdditionalReferencedDocument");
      convertReferencedDocument(doc, docEl);
    });
  }
  if (receivableSpecifiedTradeAccountingAccount) {
    const accountEl = parent.node("ram:ReceivableSpecifiedTradeAccountingAccount");
    convertTradeAccountingAccount(receivableSpecifiedTradeAccountingAccount, accountEl);
  }
}
function convertTradeSettlementLineMonetarySummation({
  lineTotalAmount,
  chargeTotalAmount,
  allowanceTotalAmount,
  taxTotalAmount,
  grandTotalAmount,
  totalAllowanceChargeAmount
}, parent) {
  if (lineTotalAmount) {
    const amountEl = parent.node("ram:LineTotalAmount");
    convertAmount(lineTotalAmount, amountEl);
  }
  if (chargeTotalAmount) {
    const amountEl = parent.node("ram:ChargeTotalAmount");
    convertAmount(chargeTotalAmount, amountEl);
  }
  if (allowanceTotalAmount) {
    const amountEl = parent.node("ram:AllowanceTotalAmount");
    convertAmount(allowanceTotalAmount, amountEl);
  }
  if (taxTotalAmount) {
    const amountEl = parent.node("ram:TaxTotalAmount");
    convertAmount(taxTotalAmount, amountEl);
  }
  if (grandTotalAmount) {
    const amountEl = parent.node("ram:GrandTotalAmount");
    convertAmount(grandTotalAmount, amountEl);
  }
  if (totalAllowanceChargeAmount) {
    const amountEl = parent.node("ram:TotalAllowanceChargeAmount");
    convertAmount(totalAllowanceChargeAmount, amountEl);
  }
}
function convertTradeAccountingAccount({ id }, parent) {
  if (id) {
    const idEl = parent.node("ram:ID");
    convertID(id, idEl);
  }
}

const index = {
  __proto__: null,
  AccountingAccountTypeCodeType: AccountingAccountTypeCodeType,
  AdvancePaymentType: AdvancePaymentType,
  AllowanceChargeReasonCodeType: AllowanceChargeReasonCodeType,
  AmountType: AmountType,
  BinaryObjectType: BinaryObjectType,
  CodeType: CodeType,
  ContactTypeCodeType: ContactTypeCodeType,
  CountryIDType: CountryIDType,
  CreditorFinancialAccountType: CreditorFinancialAccountType,
  CreditorFinancialInstitutionType: CreditorFinancialInstitutionType,
  CrossIndustryInvoiceType: CrossIndustryInvoiceType,
  CurrencyCodeType: CurrencyCodeType,
  DateTimeType: DateTimeType,
  DateType: DateType,
  DebtorFinancialAccountType: DebtorFinancialAccountType,
  DeliveryTermsCodeType: DeliveryTermsCodeType,
  DocumentCodeType: DocumentCodeType,
  DocumentContextParameterType: DocumentContextParameterType,
  DocumentLineDocumentType: DocumentLineDocumentType,
  ExchangedDocumentContextType: ExchangedDocumentContextType,
  ExchangedDocumentType: ExchangedDocumentType,
  FormattedDateTimeType: FormattedDateTimeType,
  HeaderTradeAgreementType: HeaderTradeAgreementType,
  HeaderTradeDeliveryType: HeaderTradeDeliveryType,
  HeaderTradeSettlementType: HeaderTradeSettlementType,
  IDType: IDType,
  IndicatorType: IndicatorType,
  LegalOrganizationType: LegalOrganizationType,
  LineStatusCodeType: LineStatusCodeType,
  LineTradeAgreementType: LineTradeAgreementType,
  LineTradeDeliveryType: LineTradeDeliveryType,
  LineTradeSettlementType: LineTradeSettlementType,
  LogisticsServiceChargeType: LogisticsServiceChargeType,
  LogisticsTransportMovementType: LogisticsTransportMovementType,
  MeasureType: MeasureType,
  NoteType: NoteType,
  NumericType: NumericType,
  PartyRoleCodeType: PartyRoleCodeType,
  PaymentMeansCodeType: PaymentMeansCodeType,
  PercentType: PercentType,
  ProcuringProjectType: ProcuringProjectType,
  ProductCharacteristicType: ProductCharacteristicType,
  ProductClassificationType: ProductClassificationType,
  QuantityType: QuantityType,
  RateType: RateType,
  ReferenceCodeType: ReferenceCodeType,
  ReferencedDocumentType: ReferencedDocumentType,
  ReferencedProductType: ReferencedProductType,
  SpecifiedPeriodType: SpecifiedPeriodType,
  SupplyChainConsignmentType: SupplyChainConsignmentType,
  SupplyChainEventType: SupplyChainEventType,
  SupplyChainTradeLineItemType: SupplyChainTradeLineItemType,
  SupplyChainTradeTransactionType: SupplyChainTradeTransactionType,
  TaxCategoryCodeType: TaxCategoryCodeType,
  TaxRegistrationType: TaxRegistrationType,
  TaxTypeCodeType: TaxTypeCodeType,
  TextType: TextType,
  TimeReferenceCodeType: TimeReferenceCodeType,
  TradeAccountingAccountType: TradeAccountingAccountType,
  TradeAddressType: TradeAddressType,
  TradeAllowanceChargeType: TradeAllowanceChargeType,
  TradeContactType: TradeContactType,
  TradeCountryType: TradeCountryType,
  TradeCurrencyExchangeType: TradeCurrencyExchangeType,
  TradeDeliveryTermsType: TradeDeliveryTermsType,
  TradePartyType: TradePartyType,
  TradePaymentDiscountTermsType: TradePaymentDiscountTermsType,
  TradePaymentPenaltyTermsType: TradePaymentPenaltyTermsType,
  TradePaymentTermsType: TradePaymentTermsType,
  TradePriceType: TradePriceType,
  TradeProductInstanceType: TradeProductInstanceType,
  TradeProductType: TradeProductType,
  TradeSettlementFinancialCardType: TradeSettlementFinancialCardType,
  TradeSettlementHeaderMonetarySummationType: TradeSettlementHeaderMonetarySummationType,
  TradeSettlementLineMonetarySummationType: TradeSettlementLineMonetarySummationType,
  TradeSettlementPaymentMeansType: TradeSettlementPaymentMeansType,
  TradeTaxType: TradeTaxType,
  TransportModeCodeType: TransportModeCodeType,
  UniversalCommunicationType: UniversalCommunicationType
};

async function xmlToInvoice(xml) {
  const doc = await parseXmlAsync(xml);
  const root = doc.root();
  if (!root) {
    throw new Error("Invalid XML: no root element");
  }
  const namespaces = {
    rsm: "urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100",
    ram: "urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100",
    udt: "urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100",
    qdt: "urn:un:unece:uncefact:data:standard:QualifiedDataType:100"
  };
  const exchangedDocumentContext = parseExchangedDocumentContext(root, namespaces);
  const exchangedDocument = parseExchangedDocument(root, namespaces);
  const supplyChainTradeTransaction = parseSupplyChainTradeTransaction(root, namespaces);
  return new CrossIndustryInvoiceType({
    exchangedDocumentContext,
    exchangedDocument,
    supplyChainTradeTransaction
  });
}
function parseExchangedDocumentContext(root, ns) {
  const contextNode = root.get("./rsm:ExchangedDocumentContext", ns);
  if (!contextNode) {
    throw new Error("Invalid XML: no ExchangedDocumentContext element");
  }
  const guidelineNode = contextNode.get("./ram:GuidelineSpecifiedDocumentContextParameter", ns);
  const guidelineIDNode = guidelineNode?.get("./ram:ID", ns);
  const guidelineID = guidelineIDNode?.text() || "";
  const guidelineParameter = new DocumentContextParameterType({
    id: new IDType({ value: guidelineID })
  });
  const businessProcessNode = contextNode.get("./ram:BusinessProcessSpecifiedDocumentContextParameter", ns);
  let businessProcessParameter;
  if (businessProcessNode) {
    const businessProcessIDNode = businessProcessNode.get("./ram:ID", ns);
    const businessProcessID = businessProcessIDNode?.text() || "";
    businessProcessParameter = new DocumentContextParameterType({
      id: new IDType({ value: businessProcessID })
    });
  }
  const testIndicatorNode = contextNode.get("./ram:TestIndicator", ns);
  let testIndicator;
  if (testIndicatorNode) {
    const indicatorValueNode = testIndicatorNode.get("./udt:Indicator", ns);
    const indicatorValue = indicatorValueNode?.text() === "true";
    testIndicator = new IndicatorType({ indicator: indicatorValue });
  }
  return new ExchangedDocumentContextType({
    guidelineSpecifiedDocumentContextParameter: guidelineParameter,
    businessProcessSpecifiedDocumentContextParameter: businessProcessParameter,
    testIndicator
  });
}
function parseExchangedDocument(root, ns) {
  const documentNode = root.get("./rsm:ExchangedDocument", ns);
  const idNode = documentNode.get("./ram:ID", ns);
  const id = idNode?.text() || "";
  const typeCodeNode = documentNode.get("./ram:TypeCode", ns);
  const typeCode = typeCodeNode?.text() || "";
  const issueDateTimeNode = documentNode.get("./ram:IssueDateTime/udt:DateTimeString", ns);
  const issueDateTimeValue = issueDateTimeNode?.text() || "";
  const issueDateTimeFormat = "102";
  return new ExchangedDocumentType({
    id: new IDType({ value: id }),
    typeCode: new DocumentCodeType({ value: typeCode }),
    issueDateTime: new DateTimeType({
      dateTimeString: issueDateTimeValue,
      format: issueDateTimeFormat
    })
  });
}
function parseSupplyChainTradeTransaction(root, ns) {
  const transactionNode = root.get("./rsm:SupplyChainTradeTransaction", ns);
  const headerTradeAgreement = parseHeaderTradeAgreement(transactionNode, ns);
  const headerTradeDelivery = parseHeaderTradeDelivery();
  const headerTradeSettlement = parseHeaderTradeSettlement(transactionNode, ns);
  return new SupplyChainTradeTransactionType({
    applicableHeaderTradeAgreement: headerTradeAgreement,
    applicableHeaderTradeDelivery: headerTradeDelivery,
    applicableHeaderTradeSettlement: headerTradeSettlement
  });
}
function parseHeaderTradeAgreement(transactionNode, ns) {
  const agreementNode = transactionNode.get("./ram:ApplicableHeaderTradeAgreement", ns);
  const sellerNode = agreementNode.get("./ram:SellerTradeParty", ns);
  const sellerTradeParty = parseTradeParty(sellerNode, ns);
  const buyerNode = agreementNode.get("./ram:BuyerTradeParty", ns);
  const buyerTradeParty = parseTradeParty(buyerNode, ns);
  const orderRefNode = agreementNode.get("./ram:BuyerOrderReferencedDocument", ns);
  let buyerOrderRef;
  if (orderRefNode) {
    const issuerAssignedIDNode = orderRefNode.get("./ram:IssuerAssignedID", ns);
    const issuerAssignedID = issuerAssignedIDNode?.text() || "";
    buyerOrderRef = new ReferencedDocumentType({
      issuerAssignedID: new IDType({ value: issuerAssignedID })
    });
  }
  return new HeaderTradeAgreementType({
    sellerTradeParty,
    buyerTradeParty,
    buyerOrderReferencedDocument: buyerOrderRef
  });
}
function parseTradeParty(partyNode, ns) {
  const nameNode = partyNode.get("./ram:Name", ns);
  const name = nameNode?.text() || "";
  const legalOrgNode = partyNode.get("./ram:SpecifiedLegalOrganization", ns);
  let legalOrganization;
  if (legalOrgNode) {
    const id = legalOrgNode.get("./ram:ID", ns);
    let idValue = "";
    let schemeID = "";
    if (id) {
      idValue = id.text() || "";
      const schemeAttr = id.getAttribute("schemeID");
      if (schemeAttr) {
        schemeID = schemeAttr.value();
      }
    }
    legalOrganization = new LegalOrganizationType({
      id: new IDType({
        value: idValue,
        schemeID
      })
    });
  }
  const addressNode = partyNode.get("./ram:PostalTradeAddress", ns);
  let postalAddress;
  if (addressNode) {
    const countryIDNode = addressNode.get("./ram:CountryID", ns);
    const countryID = countryIDNode?.text() || "";
    postalAddress = new TradeAddressType({
      countryID: new CountryIDType({ value: countryID })
    });
  }
  const taxRegNodes = partyNode.find("./ram:SpecifiedTaxRegistration", ns) || [];
  let taxRegistration;
  if (taxRegNodes.length > 0) {
    taxRegistration = [];
    for (const taxRegNode of taxRegNodes) {
      const id = taxRegNode.get("./ram:ID", ns);
      if (id) {
        const idValue = id.text() || "";
        let schemeID = "VA";
        const schemeAttr = id.getAttribute("schemeID");
        if (schemeAttr) {
          schemeID = schemeAttr.value();
        }
        if (idValue) {
          taxRegistration.push(
            new TaxRegistrationType({
              id: new IDType({
                value: idValue,
                schemeID
              })
            })
          );
        }
      }
    }
    if (taxRegistration.length === 0) {
      taxRegistration = void 0;
    }
  }
  return new TradePartyType({
    name: new TextType({ value: name }),
    specifiedLegalOrganization: legalOrganization,
    postalTradeAddress: postalAddress,
    specifiedTaxRegistration: taxRegistration
  });
}
function parseHeaderTradeDelivery(_transactionNode, _ns) {
  return new HeaderTradeDeliveryType({});
}
function parseHeaderTradeSettlement(transactionNode, ns) {
  const settlementNode = transactionNode.get("./ram:ApplicableHeaderTradeSettlement", ns);
  const currencyCodeNode = settlementNode.get("./ram:InvoiceCurrencyCode", ns);
  const currencyCode = currencyCodeNode?.text() || "EUR";
  const summationNode = settlementNode.get("./ram:SpecifiedTradeSettlementHeaderMonetarySummation", ns);
  const monetarySummation = parseMonetarySummation(summationNode, ns, currencyCode);
  return new HeaderTradeSettlementType({
    invoiceCurrencyCode: new CurrencyCodeType({ value: currencyCode }),
    specifiedTradeSettlementHeaderMonetarySummation: monetarySummation
  });
}
function parseMonetarySummation(summationNode, ns, defaultCurrency) {
  const lineTotalNode = summationNode.get("./ram:LineTotalAmount", ns);
  const lineTotal = lineTotalNode ? parseAmount(lineTotalNode, defaultCurrency) : void 0;
  const taxBasisTotalNode = summationNode.get("./ram:TaxBasisTotalAmount", ns);
  const taxBasisTotal = taxBasisTotalNode ? parseAmount(taxBasisTotalNode, defaultCurrency) : void 0;
  const taxTotalNode = summationNode.get("./ram:TaxTotalAmount", ns);
  const taxTotal = taxTotalNode ? parseAmount(taxTotalNode, defaultCurrency) : void 0;
  const grandTotalNode = summationNode.get("./ram:GrandTotalAmount", ns);
  const grandTotal = grandTotalNode ? parseAmount(grandTotalNode, defaultCurrency) : void 0;
  const totalPrepaidNode = summationNode.get("./ram:TotalPrepaidAmount", ns);
  const totalPrepaid = totalPrepaidNode ? parseAmount(totalPrepaidNode, defaultCurrency) : void 0;
  const duePayableNode = summationNode.get("./ram:DuePayableAmount", ns);
  const duePayable = duePayableNode ? parseAmount(duePayableNode, defaultCurrency) : new AmountType({ value: 0, currencyID: defaultCurrency });
  return new TradeSettlementHeaderMonetarySummationType({
    lineTotalAmount: lineTotal,
    taxBasisTotalAmount: taxBasisTotal ? [taxBasisTotal] : [],
    taxTotalAmount: taxTotal ? [taxTotal] : [],
    grandTotalAmount: grandTotal ? [grandTotal] : [],
    totalPrepaidAmount: totalPrepaid,
    duePayableAmount: duePayable
  });
}
function parseAmount(amountNode, defaultCurrency) {
  const value = Number.parseFloat(amountNode.text() || "0");
  let currencyID = defaultCurrency;
  const currencyAttr = amountNode.getAttribute("currencyID");
  if (currencyAttr) {
    currencyID = currencyAttr.value();
  }
  return new AmountType({
    value,
    currencyID
  });
}

export { index as Models, invoiceToXml, xmlToInvoice };