@endevops/peppol-schema 0.0.1

package/src/decoders/encode-message-level-response.ts

@@ -0,0 +1,47 @@
+import type { PeppolMessageLevelMessageLevelResponseDocumentResponse } from '#/schemas/message-level-response-document-response-schema';
+import type { PeppolMessageLevelResponse } from '#/schemas/message-level-response-schema';
+
+import { encodeMessageParty } from '#/decoders/fields/encode-message-party';
+
+export function encodeMessageLevelResponse(messageResponse: PeppolMessageLevelResponse) {
+  return {
+    '?xml': { '@version': '1.0', '@encoding': 'UTF-8' },
+    ApplicationResponse: {
+      '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+      '@xsi:schemaLocation':
+        import.meta.env['MODE'] === 'test'
+          ? 'urn:oasis:names:specification:ubl:schema:xsd:ApplicationResponse-2 https://docs.oasis-open.org/ubl/os-UBL-2.4/xsd/maindoc/UBL-ApplicationResponse-2.4.xsd urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2 https://docs.oasis-open.org/ubl/os-UBL-2.4/xsd/common/UBL-CommonAggregateComponents-2.4.xsd urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2 https://docs.oasis-open.org/ubl/os-UBL-2.4/xsd/common/UBL-CommonBasicComponents-2.4.xsd'
+          : undefined,
+      '@xmlns:cac': 'urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2',
+      '@xmlns:cbc': 'urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2',
+      '@xmlns': 'urn:oasis:names:specification:ubl:schema:xsd:ApplicationResponse-2',
+      'cbc:CustomizationID': messageResponse.customizationId,
+      'cbc:ProfileID': messageResponse.profileId,
+      'cbc:ID': messageResponse.id,
+      'cbc:IssueDate': messageResponse.issueDate,
+      'cbc:IssueTime': messageResponse.issueTime,
+      'cac:SenderParty': encodeMessageParty(messageResponse.senderParty),
+      'cac:ReceiverParty': encodeMessageParty(messageResponse.receiverParty),
+      'cac:DocumentResponse': encodeMessageLevelDocumentResponse(messageResponse.documentResponse),
+    },
+  };
+}
+
+function encodeMessageLevelDocumentResponse(documentResponse: PeppolMessageLevelMessageLevelResponseDocumentResponse) {
+  return {
+    'cac:Response': { 'cbc:ResponseCode': documentResponse.response.responseCode, 'cbc:Description': documentResponse.response.description },
+    'cac:DocumentReference': {
+      'cbc:ID': documentResponse.documentReference.id,
+      'cbc:DocumentTypeCode': documentResponse.documentReference.documentTypeCode,
+      'cbc:VersionID': documentResponse.documentReference.versionId,
+    },
+    'cac:LineResponse': documentResponse.lineResponse.map(line => ({
+      'cac:LineReference': { 'cbc:LineID': line.lineReference.lineId },
+      'cac:Response': {
+        'cbc:ResponseCode': line.response.responseCode,
+        'cbc:Description': line.response.description,
+        'cac:Status': { 'cbc:StatusReasonCode': line.response.status.statusReasonCode },
+      },
+    })),
+  };
+}

package/src/decoders/fields/decode-additional-document-references.ts

@@ -0,0 +1,38 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolAdditionalDocumentReference } from '#/schemas/fields/additional-document-reference-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeIdentifier } from '#/decoders/fields/decode-identifier';
+import { getArray } from '#/helpers/get-array';
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeAdditionalDocumentReferences(doc: XmlNode): Array<RecursivePartial<PeppolAdditionalDocumentReference>> | undefined {
+  const arr = getArray(doc, 'cac:AdditionalDocumentReference');
+  if (arr.length === 0) {
+    return undefined;
+  }
+
+  return arr.map(additionalDocumentReference => {
+    const attachment = getProp(additionalDocumentReference, 'cac:Attachment');
+    const embeddedDocumentBinaryObject = getProp(attachment, 'cbc:EmbeddedDocumentBinaryObject');
+    const externalReference = getProp(attachment, 'cac:ExternalReference');
+    return {
+      attachment: attachment
+        ? {
+            embeddedDocumentBinaryObject: embeddedDocumentBinaryObject
+              ? {
+                  content: strOrUnd(embeddedDocumentBinaryObject),
+                  filename: strOrUnd(embeddedDocumentBinaryObject, '@filename'),
+                  mimeCode: strOrUnd(embeddedDocumentBinaryObject, '@mimeCode'),
+                }
+              : undefined,
+            externalReference: externalReference ? { uri: strOrUnd(externalReference, 'cbc:URI') } : undefined,
+          }
+        : undefined,
+      documentDescription: strOrUnd(additionalDocumentReference, 'cbc:DocumentDescription'),
+      documentTypeCode: strOrUnd(additionalDocumentReference, 'cbc:DocumentTypeCode'),
+      id: decodeIdentifier(additionalDocumentReference, 'cbc:ID'),
+    };
+  });
+}

package/src/decoders/fields/decode-address.ts

@@ -0,0 +1,32 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolAddress } from '#/schemas/fields/address-schema';
+import type { RecursivePartial } from '#/types';
+
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeAddress(address: XmlNode | undefined, ...path: Array<string>): RecursivePartial<PeppolAddress> | undefined {
+  const val = getProp(address, ...path);
+  if (!val) return undefined;
+  return {
+    additionalStreetName: strOrUnd(val, 'cbc:AdditionalStreetName'),
+    addressLine: decodeAddressLine(val, 'cac:AddressLine'),
+    cityName: strOrUnd(val, 'cbc:CityName'),
+    countryCode: decodeCountryCode(val, 'cac:Country'),
+    countrySubentity: strOrUnd(val, 'cbc:CountrySubentity'),
+    postalZone: strOrUnd(val, 'cbc:PostalZone'),
+    streetName: strOrUnd(val, 'cbc:StreetName'),
+  };
+}
+
+function decodeAddressLine(address: XmlNode, ...path: Array<string>): RecursivePartial<PeppolAddress['addressLine']> | undefined {
+  const val = getProp(address, ...path);
+  if (!val) return undefined;
+  return { line: strOrUnd(val, 'cbc:Line') };
+}
+
+function decodeCountryCode(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolAddress['countryCode']> | undefined {
+  const country = getProp(node, ...path);
+  if (!country) return undefined;
+  return { identificationCode: strOrUnd(country, 'cbc:IdentificationCode') };
+}

package/src/decoders/fields/decode-allowance-charges.ts

@@ -0,0 +1,33 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolAllowanceCharge } from '#/schemas/fields/allowance-charge-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeAmount } from '#/decoders/fields/decode-amount';
+import { decodeTaxCategory } from '#/decoders/fields/decode-tax-category';
+import { bool } from '#/helpers/bool';
+import { getArray } from '#/helpers/get-array';
+import { numOrUnd } from '#/helpers/num-or-und';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeAllowanceCharges(
+  allowanceCharges: XmlNode,
+  ...path: Array<string>
+): Array<RecursivePartial<PeppolAllowanceCharge>> | undefined {
+  const arr = getArray(allowanceCharges, ...path);
+  if (!arr.length) {
+    return undefined;
+  }
+
+  return arr.map(
+    allowanceCharge =>
+      ({
+        allowanceChargeReason: strOrUnd(allowanceCharge, 'cbc:AllowanceChargeReason'),
+        allowanceChargeReasonCode: strOrUnd(allowanceCharge, 'cbc:AllowanceChargeReasonCode'),
+        amount: decodeAmount(allowanceCharge, 'cbc:Amount'),
+        baseAmount: decodeAmount(allowanceCharge, 'cbc:BaseAmount'),
+        chargeIndicator: bool(allowanceCharge, 'cbc:ChargeIndicator'),
+        multiplierFactorNumeric: numOrUnd(allowanceCharge, 'cbc:MultiplierFactorNumeric'),
+        taxCategory: decodeTaxCategory(allowanceCharge, 'cac:TaxCategory'),
+      }) as RecursivePartial<PeppolAllowanceCharge>
+  );
+}

package/src/decoders/fields/decode-amount.ts

@@ -0,0 +1,17 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolAmount } from '#/schemas/fields/amount-schema';
+import type { PeppolCurrencyCode } from '#/schemas/values/currency-codes';
+import type { RecursivePartial } from '#/types';
+
+import { getProp } from '#/helpers/get-prop';
+
+export function decodeAmount(amount: XmlNode | undefined): RecursivePartial<PeppolAmount> | undefined;
+export function decodeAmount(amount: XmlNode | undefined, ...path: Array<string>): RecursivePartial<PeppolAmount> | undefined;
+export function decodeAmount(amount: XmlNode | undefined, ...path: Array<string>): RecursivePartial<PeppolAmount> | undefined {
+  const val = getProp(amount, ...path);
+  if (!val && val !== 0) return undefined;
+  if (typeof val === 'object') {
+    return { currencyId: String(val['@currencyID']) as PeppolCurrencyCode, value: parseFloat(String(val['#text'] ?? val)) };
+  }
+  return { currencyId: '' as PeppolCurrencyCode, value: parseFloat(String(val)) };
+}

package/src/decoders/fields/decode-billing-references.ts

@@ -0,0 +1,20 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolBillingReference } from '#/schemas/fields/billing-references-schema';
+import type { RecursivePartial } from '#/types';
+
+import { getArray } from '#/helpers/get-array';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeBillingReferences(doc: XmlNode, ...path: Array<string>): Array<RecursivePartial<PeppolBillingReference>> | undefined {
+  const arr = getArray(doc, ...path);
+  if (!arr.length) {
+    return undefined;
+  }
+
+  return arr.map(billingReference => ({
+    invoiceDocumentReference: {
+      id: strOrUnd(billingReference, 'cac:InvoiceDocumentReference', 'cbc:ID'),
+      issueDate: strOrUnd(billingReference, 'cac:InvoiceDocumentReference', 'cbc:IssueDate'),
+    },
+  }));
+}

package/src/decoders/fields/decode-credit-note-lines.ts

@@ -0,0 +1,17 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolCreditNoteLine } from '#/schemas/fields/credit-note-line-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeLineShared } from '#/decoders/fields/decode-line-shared';
+import { decodeQuantity } from '#/decoders/fields/decode-quantity';
+import { getArray } from '#/helpers/get-array';
+
+export function decodeCreditNoteLines(doc: XmlNode, ...path: Array<string>): Array<RecursivePartial<PeppolCreditNoteLine>> | undefined {
+  const arr = getArray(doc, ...path);
+  if (!arr.length) return undefined;
+
+  return arr.map(lineNode => {
+    const shared = decodeLineShared(lineNode);
+    return { ...shared, creditedQuantity: decodeQuantity(lineNode, 'cbc:CreditedQuantity')! };
+  });
+}

package/src/decoders/fields/decode-delivery.ts

@@ -0,0 +1,35 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolDelivery } from '#/schemas/fields/delivery-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeAddress } from '#/decoders/fields/decode-address';
+import { decodeIdentifier } from '#/decoders/fields/decode-identifier';
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeDelivery(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolDelivery> | undefined {
+  const val = getProp(node, ...path);
+  if (!val) return undefined;
+
+  return {
+    actualDeliveryDate: strOrUnd(val, 'cbc:ActualDeliveryDate'),
+    deliveryLocation: decodeDeliveryLocation(val, 'cac:DeliveryLocation'),
+    deliveryParty: decodeDeliveryParty(val, 'cac:DeliveryParty'),
+  };
+}
+
+function decodeDeliveryLocation(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolDelivery['deliveryLocation']> | undefined {
+  const val = getProp(node, ...path);
+  if (!val) return undefined;
+
+  return { address: decodeAddress(val, 'cac:Address'), id: decodeIdentifier(val, 'cbc:ID') };
+}
+
+function decodeDeliveryParty(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolDelivery['deliveryParty']> | undefined {
+  const val = getProp(node, ...path);
+  if (!val) return undefined;
+  const name = strOrUnd(val, 'cac:PartyName', 'cbc:Name');
+  if (!name) return undefined;
+
+  return { partyName: { name } };
+}

package/src/decoders/fields/decode-electronic-address.ts

@@ -0,0 +1,13 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolIdentifier } from '#/schemas/fields/identifier-schema';
+
+import { decodeIdentifier } from '#/decoders/fields/decode-identifier';
+
+export function decodeElectronicAddress<const T extends PeppolIdentifier['schemeId'] = string>(node: XmlNode | undefined, ...path: Array<string>) {
+  const value = decodeIdentifier<T>(node, ...path);
+  if (value?.schemeId) {
+    // @ts-expect-error I don't want to bother with the typecheck
+    value.schemeId = (value.schemeId as string).padStart(4, '0') as T;
+  }
+  return value;
+}

package/src/decoders/fields/decode-identifier.ts

@@ -0,0 +1,28 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolIdentifier } from '#/schemas/fields/identifier-schema';
+import type { RecursivePartial } from '#/types';
+
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export interface Identifier<T extends PeppolIdentifier['schemeId'] = string> extends PeppolIdentifier {
+  schemeId?: T;
+}
+
+export function decodeIdentifier<const T extends PeppolIdentifier['schemeId'] = string>(
+  node: XmlNode | undefined,
+  ...path: Array<string>
+): RecursivePartial<Identifier<T>> | undefined {
+  const val = getProp(node, ...path);
+  if (!val && val !== 0) return undefined;
+  const id = strOrUnd(val);
+  if ((typeof val === 'string' || typeof val === 'number') && id) {
+    return { id };
+  }
+  if (!id) return undefined;
+  return {
+    id,
+    // @ts-expect-error I don't want to bother with the typecheck
+    schemeId: strOrUnd(val, '@schemeID'),
+  };
+}

package/src/decoders/fields/decode-invoice-line-period.ts

@@ -0,0 +1,13 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolInvoiceLinePeriod } from '#/schemas/fields/invoice-line-period-schema';
+import type { RecursivePartial } from '#/types';
+
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeInvoiceLinePeriod(doc: XmlNode): RecursivePartial<PeppolInvoiceLinePeriod> | undefined;
+export function decodeInvoiceLinePeriod(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolInvoiceLinePeriod> | undefined;
+export function decodeInvoiceLinePeriod(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolInvoiceLinePeriod> | undefined {
+  const invoicePeriod = getProp(doc, ...path);
+  return invoicePeriod ? { endDate: strOrUnd(invoicePeriod, 'cbc:EndDate'), startDate: strOrUnd(invoicePeriod, 'cbc:StartDate') } : undefined;
+}

package/src/decoders/fields/decode-invoice-lines.ts

@@ -0,0 +1,17 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolInvoiceLine } from '#/schemas/fields/invoice-line-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeLineShared } from '#/decoders/fields/decode-line-shared';
+import { decodeQuantity } from '#/decoders/fields/decode-quantity';
+import { getArray } from '#/helpers/get-array';
+
+export function decodeInvoiceLines(doc: XmlNode, ...path: Array<string>): Array<RecursivePartial<PeppolInvoiceLine>> | undefined {
+  const arr = getArray(doc, ...path);
+  if (!arr.length) return undefined;
+
+  return arr.map(lineNode => {
+    const shared = decodeLineShared(lineNode);
+    return { ...shared, invoicedQuantity: decodeQuantity(lineNode, 'cbc:InvoicedQuantity') };
+  });
+}

package/src/decoders/fields/decode-invoice-message-document-party.ts

@@ -0,0 +1,20 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { InvoiceDocumentResponseParty } from '#/schemas/invoice-response-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeIdentifier } from '#/decoders/fields/decode-identifier';
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeInvoiceMessageDocumentParty(
+  party: XmlNode,
+  ...path: Array<string>
+): RecursivePartial<InvoiceDocumentResponseParty> | undefined {
+  const val = getProp(party, ...path);
+  if (!val) return undefined;
+  const partyName = getProp(val, 'cac:PartyName');
+  return {
+    partyIdentification: decodeIdentifier(val, 'cac:PartyIdentification', 'cbc:ID'),
+    partyName: partyName ? { name: strOrUnd(partyName, 'cbc:Name') } : undefined,
+  };
+}

package/src/decoders/fields/decode-invoice-message-party.ts

@@ -0,0 +1,43 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolContact } from '#/schemas/fields/contact-schema';
+import type { PeppolPartyLegalEntitySchema } from '#/schemas/fields/party-legal-entity-schema';
+import type { InvoiceResponseParty } from '#/schemas/invoice-response-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeElectronicAddress } from '#/decoders/fields/decode-electronic-address';
+import { decodeIdentifier } from '#/decoders/fields/decode-identifier';
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeInvoiceMessageParty(party: XmlNode, ...path: Array<string>): RecursivePartial<InvoiceResponseParty> | undefined {
+  const val = getProp(party, ...path);
+  if (!val) return undefined;
+  return {
+    contact: decodeContact(val, 'cac:Contact'),
+    endpointId: decodeElectronicAddress(val, 'cbc:EndpointID'),
+    partyIdentification: decodeIdentifier(val, 'cac:PartyIdentification', 'cbc:ID'),
+    partyLegalEntity: decodePartyLegalEntity(val, 'cac:PartyLegalEntity'),
+  };
+}
+
+function decodePartyLegalEntity(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolPartyLegalEntitySchema> | undefined {
+  const partyLegalEntityNode = getProp(node, ...path);
+  if (!partyLegalEntityNode) return undefined;
+
+  return {
+    companyId: decodeIdentifier(partyLegalEntityNode, 'cbc:CompanyID'),
+    companyLegalForm: strOrUnd(partyLegalEntityNode, 'cbc:CompanyLegalForm'),
+    registrationName: strOrUnd(partyLegalEntityNode, 'cbc:RegistrationName'),
+  };
+}
+
+function decodeContact(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolContact> | undefined {
+  const contactNode = getProp(node, ...path);
+  if (!contactNode) return undefined;
+
+  return {
+    electronicMail: strOrUnd(contactNode, 'cbc:ElectronicMail'),
+    name: strOrUnd(contactNode, 'cbc:Name'),
+    telephone: strOrUnd(contactNode, 'cbc:Telephone'),
+  };
+}

package/src/decoders/fields/decode-invoice-period.ts

@@ -0,0 +1,19 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolInvoicePeriod } from '#/schemas/fields/invoice-period-schema';
+import type { RecursivePartial } from '#/types';
+
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeInvoicePeriod(doc: XmlNode): RecursivePartial<PeppolInvoicePeriod> | undefined;
+export function decodeInvoicePeriod(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolInvoicePeriod> | undefined;
+export function decodeInvoicePeriod(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolInvoicePeriod> | undefined {
+  const invoicePeriod = getProp(doc, ...path);
+  return invoicePeriod
+    ? {
+        descriptionCode: strOrUnd(invoicePeriod, 'cbc:DescriptionCode'),
+        endDate: strOrUnd(invoicePeriod, 'cbc:EndDate'),
+        startDate: strOrUnd(invoicePeriod, 'cbc:StartDate'),
+      }
+    : undefined;
+}

package/src/decoders/fields/decode-legal-monetary-total.ts

@@ -0,0 +1,22 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolLegalMonetaryTotal } from '#/schemas/fields/legal-monetary-total-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeAmount } from '#/decoders/fields/decode-amount';
+import { getProp } from '#/helpers/get-prop';
+
+export function decodeLegalMonetaryTotal(node: XmlNode | undefined, ...path: Array<string>): RecursivePartial<PeppolLegalMonetaryTotal> | undefined {
+  const val = getProp(node, ...path);
+  if (!val) return undefined;
+
+  return {
+    allowanceTotalAmount: decodeAmount(val, 'cbc:AllowanceTotalAmount'),
+    chargeTotalAmount: decodeAmount(val, 'cbc:ChargeTotalAmount'),
+    lineExtensionAmount: decodeAmount(val, 'cbc:LineExtensionAmount'),
+    payableAmount: decodeAmount(val, 'cbc:PayableAmount'),
+    payableRoundingAmount: decodeAmount(val, 'cbc:PayableRoundingAmount'),
+    prepaidAmount: decodeAmount(val, 'cbc:PrepaidAmount'),
+    taxExclusiveAmount: decodeAmount(val, 'cbc:TaxExclusiveAmount'),
+    taxInclusiveAmount: decodeAmount(val, 'cbc:TaxInclusiveAmount'),
+  };
+}

package/src/decoders/fields/decode-line-allowance-charges.ts

@@ -0,0 +1,30 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolLineAllowanceCharge } from '#/schemas/fields/line-allowance-charge-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeAmount } from '#/decoders/fields/decode-amount';
+import { bool } from '#/helpers/bool';
+import { getArray } from '#/helpers/get-array';
+import { numOrUnd } from '#/helpers/num-or-und';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeLineAllowanceCharges(
+  allowanceCharges: XmlNode,
+  ...path: Array<string>
+): Array<RecursivePartial<PeppolLineAllowanceCharge>> | undefined {
+  const arr = getArray(allowanceCharges, ...path);
+  if (!arr.length) {
+    return undefined;
+  }
+  return arr.map(
+    allowanceCharge =>
+      ({
+        allowanceChargeReason: strOrUnd(allowanceCharge, 'cbc:AllowanceChargeReason'),
+        allowanceChargeReasonCode: strOrUnd(allowanceCharge, 'cbc:AllowanceChargeReasonCode'),
+        amount: decodeAmount(allowanceCharge, 'cbc:Amount'),
+        baseAmount: decodeAmount(allowanceCharge, 'cbc:BaseAmount'),
+        chargeIndicator: bool(allowanceCharge, 'cbc:ChargeIndicator'),
+        multiplierFactorNumeric: numOrUnd(allowanceCharge, 'cbc:MultiplierFactorNumeric'),
+      }) as RecursivePartial<PeppolLineAllowanceCharge>
+  );
+}

package/src/decoders/fields/decode-line-price.ts

@@ -0,0 +1,19 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolLinePrice } from '#/schemas/fields/price-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeAmount } from '#/decoders/fields/decode-amount';
+import { decodePriceAllowanceCharge } from '#/decoders/fields/decode-price-allowance-charge';
+import { decodeQuantity } from '#/decoders/fields/decode-quantity';
+import { getProp } from '#/helpers/get-prop';
+
+export function decodeLinePrice(price: XmlNode, ...path: Array<string>): RecursivePartial<PeppolLinePrice> | undefined {
+  const node = getProp(price, ...path);
+  if (!node) return undefined;
+
+  return {
+    allowanceCharge: decodePriceAllowanceCharge(node, 'cac:AllowanceCharge'),
+    baseQuantity: decodeQuantity(node, 'cbc:BaseQuantity'),
+    priceAmount: decodeAmount(node, 'cbc:PriceAmount'),
+  };
+}

package/src/decoders/fields/decode-line-shared.ts

@@ -0,0 +1,70 @@
+import type { PeppolDocumentLine } from '#/document';
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolBaseLine } from '#/schemas/fields/base-line-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeAmount } from '#/decoders/fields/decode-amount';
+import { decodeIdentifier } from '#/decoders/fields/decode-identifier';
+import { decodeInvoiceLinePeriod } from '#/decoders/fields/decode-invoice-line-period';
+import { decodeLineAllowanceCharges } from '#/decoders/fields/decode-line-allowance-charges';
+import { decodeLinePrice } from '#/decoders/fields/decode-line-price';
+import { decodeSimpleIdentifer } from '#/decoders/fields/decode-simple-identifier';
+import { decodeTaxCategory } from '#/decoders/fields/decode-tax-category';
+import { getArray } from '#/helpers/get-array';
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+type PeppolDocumentLineItem = PeppolDocumentLine['item'];
+
+export function decodeLineShared(lineShared: XmlNode): RecursivePartial<PeppolBaseLine> {
+  const item = getProp(lineShared, 'cac:Item');
+  const orderLineReference = getProp(lineShared, 'cac:OrderLineReference');
+
+  return {
+    accountingCost: strOrUnd(lineShared, 'cbc:AccountingCost'),
+    allowanceCharges: decodeLineAllowanceCharges(lineShared, 'cac:AllowanceCharge'),
+    documentReference: getArray(lineShared, 'cac:DocumentReference').map(documentReference => ({
+      documentTypeCode: strOrUnd(documentReference, 'cbc:DocumentTypeCode'),
+      id: strOrUnd(documentReference, 'cbc:ID'),
+      schemeId: strOrUnd(documentReference, 'cbc:ID', '@schemeID'),
+    })),
+    id: strOrUnd(lineShared, 'cbc:ID'),
+    invoicePeriod: decodeInvoiceLinePeriod(lineShared, 'cac:InvoicePeriod'),
+    item: {
+      additionalItemProperties: getArray(item, 'cac:AdditionalItemProperty').map(n => ({
+        name: strOrUnd(n, 'cbc:Name'),
+        value: strOrUnd(n, 'cbc:Value'),
+      })),
+      buyersItemIdentification: decodeSimpleIdentifer(item, 'cac:BuyersItemIdentification'),
+      classifiedTaxCategory: decodeTaxCategory(item, 'cac:ClassifiedTaxCategory'),
+      commodityClassifications: getArray(item, 'cac:CommodityClassification').map(commodityClassification => ({
+        itemClassification: {
+          id: strOrUnd(commodityClassification, 'cbc:ItemClassificationCode'),
+          listId: strOrUnd(commodityClassification, 'cbc:ItemClassificationCode', '@listID'),
+          listVersionId: strOrUnd(commodityClassification, 'cbc:ItemClassificationCode', '@listVersionID'),
+        },
+      })),
+      description: strOrUnd(item, 'cbc:Description'),
+      name: strOrUnd(item, 'cbc:Name'),
+      originCountryCode: decodeOriginCountryCode(item, 'cac:OriginCountry'),
+      sellersItemIdentification: decodeSimpleIdentifer(item, 'cac:SellersItemIdentification'),
+      standardItemIdentification: decodeStandardItem(item, 'cac:StandardItemIdentification'),
+    },
+    lineExtensionAmount: decodeAmount(lineShared, 'cbc:LineExtensionAmount'),
+    note: strOrUnd(lineShared, 'cbc:Note'),
+    orderLineReference: orderLineReference ? { lineId: strOrUnd(orderLineReference, 'cbc:LineID') } : undefined,
+    price: decodeLinePrice(lineShared, 'cac:Price'),
+  };
+}
+
+function decodeStandardItem(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolDocumentLineItem['standardItemIdentification']> {
+  const val = getProp(node, ...path);
+  if (!val) return;
+  return { id: decodeIdentifier(val, 'cbc:ID') };
+}
+
+function decodeOriginCountryCode(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolDocumentLineItem['originCountryCode']> {
+  const country = getProp(node, ...path);
+  if (!country) return undefined;
+  return { identificationCode: strOrUnd(country, 'cbc:IdentificationCode') };
+}

package/src/decoders/fields/decode-message-level-party.ts

@@ -0,0 +1,12 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolMessageLevelResponseParty } from '#/schemas/message-level-response-party-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeElectronicAddress } from '#/decoders/fields/decode-electronic-address';
+import { getProp } from '#/helpers/get-prop';
+
+export function decodeMessageLevelParty(party: XmlNode, ...path: Array<string>): RecursivePartial<PeppolMessageLevelResponseParty> | undefined {
+  const val = getProp(party, ...path);
+  if (!val) return undefined;
+  return { endpointId: decodeElectronicAddress(val, 'cbc:EndpointID') };
+}

package/src/decoders/fields/decode-order-reference.ts

@@ -0,0 +1,13 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolOrderReference } from '#/schemas/fields/order-reference-schema';
+import type { RecursivePartial } from '#/types';
+
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeOrderReference(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolOrderReference> | undefined {
+  const val = getProp(node, ...path);
+  if (!val) return undefined;
+
+  return { id: strOrUnd(val, 'cbc:ID'), salesOrderId: strOrUnd(val, 'cbc:SalesOrderID') };
+}

package/src/decoders/fields/decode-parties-tax-scheme.ts

@@ -0,0 +1,19 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolPartyTaxSchema } from '#/schemas/fields/party-tax-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodePartyTaxScheme } from '#/decoders/fields/decode-party-tax-scheme';
+import { getArray } from '#/helpers/get-array';
+
+export function decodePartiesTaxScheme(doc: XmlNode, ...path: Array<string>): RecursivePartial<Array<PeppolPartyTaxSchema>> | undefined {
+  const node = getArray(doc, ...path);
+  if (!node?.length) return undefined;
+
+  return node.reduce((prev, n) => {
+    const val = decodePartyTaxScheme(n);
+    if (val) {
+      prev.push(val);
+    }
+    return prev;
+  }, []);
+}

package/src/decoders/fields/decode-party-tax-scheme.ts

@@ -0,0 +1,14 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolPartyTaxSchema } from '#/schemas/fields/party-tax-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeSimpleIdentifer } from '#/decoders/fields/decode-simple-identifier';
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodePartyTaxScheme(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolPartyTaxSchema> | undefined {
+  const node = getProp(doc, ...path);
+  if (!node) return undefined;
+
+  return { companyId: strOrUnd(node, 'cbc:CompanyID'), taxSchemeId: decodeSimpleIdentifer(node, 'cac:TaxScheme') };
+}