@endevops/peppol-schema 0.1.0-beta.4 → 0.1.0-beta.5

package/src/schematron/peppol/r/peppol-en16931-r043.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getAllAllowanceCharges, schematronResult } from '#/schematron/helpers';
+import { getAllAllowanceCharges, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'PEPPOL-EN16931-R043',
@@ -10,8 +9,10 @@ const rule = {
   message: "Allowance/charge ChargeIndicator value MUST equal 'true' or 'false'",
 } as const satisfies SchematronRule;
 
-export function validatePeppolEn16931R043(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R043(document: PeppolDocument): boolean {
   const allowanceCharges = getAllAllowanceCharges(document);
   const passed = allowanceCharges.every(ac => typeof ac.chargeIndicator === 'boolean');
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validatePeppolEn16931R043 = schematronRule(rule, evaluatePeppolEn16931R043);

package/src/schematron/peppol/r/peppol-en16931-r044.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getLines, schematronResult } from '#/schematron/helpers';
+import { getLines, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'PEPPOL-EN16931-R044',
@@ -10,7 +9,9 @@ const rule = {
   message: "Charge on price level is NOT allowed. Only value 'false' allowed.",
 } as const satisfies SchematronRule;
 
-export function validatePeppolEn16931R044(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R044(document: PeppolDocument): boolean {
   const passed = getLines(document).every(line => !line.price.allowanceCharge || !line.price.allowanceCharge.chargeIndicator);
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validatePeppolEn16931R044 = schematronRule(rule, evaluatePeppolEn16931R044);

package/src/schematron/peppol/r/peppol-en16931-r046.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getLines, schematronResult, slack } from '#/schematron/helpers';
+import { getLines, schematronRule, slack } from '#/schematron/helpers';
 
 const rule = {
   id: 'PEPPOL-EN16931-R046',
@@ -10,7 +9,7 @@ const rule = {
   message: 'Item net price MUST equal (Gross price - Allowance amount) when gross price is provided.',
 } as const satisfies SchematronRule;
 
-export function validatePeppolEn16931R046(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R046(document: PeppolDocument): boolean {
   const passed = getLines(document).every(line => {
     const price = line.price;
     const allowance = price.allowanceCharge;
@@ -19,5 +18,7 @@ export function validatePeppolEn16931R046(document: PeppolDocument): SchematronR
     }
     return slack(allowance.baseAmount.value - (allowance.amount?.value ?? 0), price.priceAmount.value, 0.02);
   });
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validatePeppolEn16931R046 = schematronRule(rule, evaluatePeppolEn16931R046);

package/src/schematron/peppol/r/peppol-en16931-r051.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getLines, schematronResult } from '#/schematron/helpers';
+import { getLines, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'PEPPOL-EN16931-R051',
@@ -11,7 +10,7 @@ const rule = {
     'All currencyID attributes must have the same value as the invoice currency code (BT-5), except for the invoice total VAT amount in accounting currency (BT-111).',
 } as const satisfies SchematronRule;
 
-export function validatePeppolEn16931R051(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R051(document: PeppolDocument): boolean {
   const documentCurrency = document.documentCurrencyCode;
   const checkCurrency = (currencyId: string | undefined): boolean => currencyId === documentCurrency;
 
@@ -48,5 +47,7 @@ export function validatePeppolEn16931R051(document: PeppolDocument): SchematronR
     (!totals.payableRoundingAmount || checkCurrency(totals.payableRoundingAmount.currencyId)) &&
     checkCurrency(totals.payableAmount.currencyId);
 
-  return schematronResult(rule, documentAllowancesOk && linesOk && taxTotalsOk && totalsOk);
+  return documentAllowancesOk && linesOk && taxTotalsOk && totalsOk;
 }
+
+export const validatePeppolEn16931R051 = schematronRule(rule, evaluatePeppolEn16931R051);

package/src/schematron/peppol/r/peppol-en16931-r053.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { schematronResult } from '#/schematron/helpers';
+import { schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'PEPPOL-EN16931-R053',
@@ -10,7 +9,9 @@ const rule = {
   message: 'Only one tax total with tax subtotals MUST be provided.',
 } as const satisfies SchematronRule;
 
-export function validatePeppolEn16931R053(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R053(document: PeppolDocument): boolean {
   const withSubtotals = document.taxTotals.filter(total => (total.taxSubtotals?.length ?? 0) > 0);
-  return schematronResult(rule, withSubtotals.length === 1);
+  return withSubtotals.length === 1;
 }
+
+export const validatePeppolEn16931R053 = schematronRule(rule, evaluatePeppolEn16931R053);

package/src/schematron/peppol/r/peppol-en16931-r054.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { schematronResult } from '#/schematron/helpers';
+import { schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'PEPPOL-EN16931-R054',
@@ -10,8 +9,10 @@ const rule = {
   message: 'Only one tax total without tax subtotals MUST be provided when tax currency code is provided.',
 } as const satisfies SchematronRule;
 
-export function validatePeppolEn16931R054(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R054(document: PeppolDocument): boolean {
   const withoutSubtotals = document.taxTotals.filter(total => (total.taxSubtotals?.length ?? 0) === 0);
   const expected = document.taxCurrencyCode ? 1 : 0;
-  return schematronResult(rule, withoutSubtotals.length === expected);
+  return withoutSubtotals.length === expected;
 }
+
+export const validatePeppolEn16931R054 = schematronRule(rule, evaluatePeppolEn16931R054);

package/src/schematron/peppol/r/peppol-en16931-r055.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { schematronResult } from '#/schematron/helpers';
+import { schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'PEPPOL-EN16931-R055',
@@ -10,17 +9,19 @@ const rule = {
   message: 'Invoice total VAT amount and Invoice total VAT amount in accounting currency MUST have the same operational sign',
 } as const satisfies SchematronRule;
 
-export function validatePeppolEn16931R055(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R055(document: PeppolDocument): boolean {
   const taxCurrency = document.taxCurrencyCode;
   if (!taxCurrency) {
-    return schematronResult(rule, true);
+    return true;
   }
   const documentCurrencyAmount = document.taxTotals.find(total => total.taxAmount.currencyId === document.documentCurrencyCode)?.taxAmount.value;
   const taxCurrencyAmount = document.taxTotals.find(total => total.taxAmount.currencyId === taxCurrency)?.taxAmount.value;
   if (typeof documentCurrencyAmount !== 'number' || typeof taxCurrencyAmount !== 'number') {
-    return schematronResult(rule, false);
+    return false;
   }
   const bothNonPositive = documentCurrencyAmount <= 0 && taxCurrencyAmount <= 0;
   const bothNonNegative = documentCurrencyAmount >= 0 && taxCurrencyAmount >= 0;
-  return schematronResult(rule, bothNonPositive || bothNonNegative);
+  return bothNonPositive || bothNonNegative;
 }
+
+export const validatePeppolEn16931R055 = schematronRule(rule, evaluatePeppolEn16931R055);

package/src/schematron/peppol/r/peppol-en16931-r061.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { schematronResult } from '#/schematron/helpers';
+import { schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'PEPPOL-EN16931-R061',
@@ -12,7 +11,7 @@ const rule = {
 
 const DIRECT_DEBIT_CODES = new Set(['49', '59']);
 
-export function validatePeppolEn16931R061(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R061(document: PeppolDocument): boolean {
   const passed = (document.paymentMeans ?? []).every(payment => {
     if (!DIRECT_DEBIT_CODES.has(payment.paymentMeansCode.code)) {
       return true;
@@ -20,5 +19,7 @@ export function validatePeppolEn16931R061(document: PeppolDocument): SchematronR
     const mandateId = payment.paymentMandate?.id;
     return typeof mandateId === 'string' && mandateId.trim() !== '';
   });
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validatePeppolEn16931R061 = schematronRule(rule, evaluatePeppolEn16931R061);

package/src/schematron/peppol/r/peppol-en16931-r100.ts

@@ -1,12 +1,13 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getLines, schematronResult } from '#/schematron/helpers';
+import { getLines, schematronRule } from '#/schematron/helpers';
 
 const rule = { id: 'PEPPOL-EN16931-R100', level: 'fatal', message: 'Only one invoiced object is allowed pr line' } as const satisfies SchematronRule;
 
-export function validatePeppolEn16931R100(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R100(document: PeppolDocument): boolean {
   const passed = getLines(document).every(line => (line.documentReference?.length ?? 0) <= 1);
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validatePeppolEn16931R100 = schematronRule(rule, evaluatePeppolEn16931R100);

package/src/schematron/peppol/r/peppol-en16931-r101.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getLines, schematronResult } from '#/schematron/helpers';
+import { getLines, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'PEPPOL-EN16931-R101',
@@ -10,10 +9,12 @@ const rule = {
   message: 'Element Document reference can only be used for Invoice line object',
 } as const satisfies SchematronRule;
 
-export function validatePeppolEn16931R101(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R101(document: PeppolDocument): boolean {
   const passed = getLines(document).every(line => {
     const references = line.documentReference ?? [];
     return references.every(ref => ref.documentTypeCode === '130');
   });
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validatePeppolEn16931R101 = schematronRule(rule, evaluatePeppolEn16931R101);

package/src/schematron/peppol/r/peppol-en16931-r110.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getLines, schematronResult } from '#/schematron/helpers';
+import { getLines, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'PEPPOL-EN16931-R110',
@@ -10,14 +9,16 @@ const rule = {
   message: 'Start date of line period MUST be within invoice period.',
 } as const satisfies SchematronRule;
 
-export function validatePeppolEn16931R110(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R110(document: PeppolDocument): boolean {
   const invoicePeriodStart = document.invoicePeriod?.startDate;
   if (!invoicePeriodStart) {
-    return schematronResult(rule, true);
+    return true;
   }
   const passed = getLines(document).every(line => {
     const lineStart = line.invoicePeriod?.startDate;
     return !lineStart || lineStart >= invoicePeriodStart;
   });
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validatePeppolEn16931R110 = schematronRule(rule, evaluatePeppolEn16931R110);

package/src/schematron/peppol/r/peppol-en16931-r111.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getLines, schematronResult } from '#/schematron/helpers';
+import { getLines, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'PEPPOL-EN16931-R111',
@@ -10,14 +9,16 @@ const rule = {
   message: 'End date of line period MUST be within invoice period.',
 } as const satisfies SchematronRule;
 
-export function validatePeppolEn16931R111(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R111(document: PeppolDocument): boolean {
   const invoicePeriodEnd = document.invoicePeriod?.endDate;
   if (!invoicePeriodEnd) {
-    return schematronResult(rule, true);
+    return true;
   }
   const passed = getLines(document).every(line => {
     const lineEnd = line.invoicePeriod?.endDate;
     return !lineEnd || lineEnd <= invoicePeriodEnd;
   });
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validatePeppolEn16931R111 = schematronRule(rule, evaluatePeppolEn16931R111);

package/src/schematron/peppol/r/peppol-en16931-r120.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getLineQuantity, getLines, schematronResult, slack } from '#/schematron/helpers';
+import { getLineQuantity, getLines, schematronRule, slack } from '#/schematron/helpers';
 
 const rule = {
   id: 'PEPPOL-EN16931-R120',
@@ -11,7 +10,7 @@ const rule = {
     'Invoice line net amount MUST equal (Invoiced quantity * (Item net price/item price base quantity) + Sum of invoice line charge amount - sum of invoice line allowance amount',
 } as const satisfies SchematronRule;
 
-export function validatePeppolEn16931R120(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R120(document: PeppolDocument): boolean {
   const passed = getLines(document).every(line => {
     const lineExtensionAmount = line.lineExtensionAmount.value;
     const quantity = getLineQuantity(line);
@@ -22,5 +21,7 @@ export function validatePeppolEn16931R120(document: PeppolDocument): SchematronR
     const expected = quantity * (priceAmount / baseQuantity) + chargesTotal - allowancesTotal;
     return slack(expected, lineExtensionAmount, 0.02);
   });
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validatePeppolEn16931R120 = schematronRule(rule, evaluatePeppolEn16931R120);

package/src/schematron/peppol/r/peppol-en16931-r121.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getLines, schematronResult } from '#/schematron/helpers';
+import { getLines, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'PEPPOL-EN16931-R121',
@@ -10,10 +9,12 @@ const rule = {
   message: 'Base quantity MUST be a positive number above zero.',
 } as const satisfies SchematronRule;
 
-export function validatePeppolEn16931R121(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R121(document: PeppolDocument): boolean {
   const passed = getLines(document).every(line => {
     const baseQuantity = line.price.baseQuantity?.value;
     return baseQuantity === undefined || baseQuantity > 0;
   });
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validatePeppolEn16931R121 = schematronRule(rule, evaluatePeppolEn16931R121);

package/src/schematron/peppol/r/peppol-en16931-r130.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getLines, schematronResult } from '#/schematron/helpers';
+import { getLines, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'PEPPOL-EN16931-R130',
@@ -10,7 +9,7 @@ const rule = {
   message: 'Unit code of price base quantity MUST be same as invoiced quantity.',
 } as const satisfies SchematronRule;
 
-export function validatePeppolEn16931R130(document: PeppolDocument): SchematronRuleResult {
+function evaluatePeppolEn16931R130(document: PeppolDocument): boolean {
   const passed = getLines(document).every(line => {
     const baseQuantity = line.price.baseQuantity;
     if (!baseQuantity?.unitCode) {
@@ -22,5 +21,7 @@ export function validatePeppolEn16931R130(document: PeppolDocument): SchematronR
     }
     return baseQuantity.unitCode === quantity.unitCode;
   });
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validatePeppolEn16931R130 = schematronRule(rule, evaluatePeppolEn16931R130);

package/src/schematron/run-all-rules.ts

@@ -1,5 +1,4 @@
-import type { PeppolDocument } from '#/document';
-import type { SchematronRuleResult } from '#/schematron/types';
+import type { SchematronDocumentValidator } from '#/schematron/helpers';
 
 import { validateCenEn16931BrAe01 } from '#/schematron/cen/ae/cen-en16931-br-ae-01';
 import { validateCenEn16931BrAe02 } from '#/schematron/cen/ae/cen-en16931-br-ae-02';
@@ -362,7 +361,7 @@ import { validateSeR011 } from '#/schematron/se/se-r-011';
 import { validateSeR012 } from '#/schematron/se/se-r-012';
 import { validateSeR013 } from '#/schematron/se/se-r-013';
 
-const ruleValidators: Array<(document: PeppolDocument) => SchematronRuleResult> = [
+export const ruleValidators: ReadonlyArray<SchematronDocumentValidator> = [
   validateCenEn16931BrAe01,
   validateCenEn16931BrAe02,
   validateCenEn16931BrAe03,
@@ -724,7 +723,3 @@ const ruleValidators: Array<(document: PeppolDocument) => SchematronRuleResult>
   validateSeR012,
   validateSeR013,
 ];
-
-export function runAllRules(document: PeppolDocument): Array<SchematronRuleResult> {
-  return ruleValidators.map(validate => validate(document));
-}

package/src/schematron/schematron.ts

@@ -0,0 +1,36 @@
+import type { Result } from 'effect';
+
+import { Context, Effect, Layer } from 'effect';
+
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
+
+import { SchematronValidationError } from '#/schematron/errors';
+import { ruleValidators } from '#/schematron/run-all-rules';
+
+/**
+ * @description The `Schematron` service validates a document against every schematron rule.
+ */
+export interface SchematronShape {
+  /**
+   * @description Runs every schematron rule against the document, failing with a single `SchematronValidationError` that wraps each failed rule.
+   */
+  readonly run: (document: PeppolDocument) => Effect.Effect<Result.Result<void, SchematronValidationError>>;
+}
+
+/**
+ * @description Runs the schematron rules of this library against a PEPPOL document.
+ */
+export class Schematron extends Context.Service<Schematron, SchematronShape>()('@endevops/peppol-schema/schematron/Schematron') {
+  static readonly layer = Layer.effect(
+    Schematron,
+    Effect.gen(function* () {
+      const run = Effect.fn('Schematron.run')(function* (document: PeppolDocument) {
+        const [errors] = yield* Effect.partition(ruleValidators, validator => validator(document));
+        if (errors.length > 0) {
+          return yield* new SchematronValidationError({ errors });
+        }
+      }, Effect.result);
+      return Schematron.of({ run });
+    })
+  );
+}

package/src/schematron/se/se-r-001.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+import { getSupplierCountry, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'SE-R-001',
@@ -10,10 +9,12 @@ const rule = {
   message: 'For Swedish suppliers, Swedish VAT-numbers must consist of 14 characters.',
 } as const satisfies SchematronRule;
 
-export function validateSeR001(document: PeppolDocument): SchematronRuleResult {
+function evaluateSeR001(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'SE') {
-    return schematronResult(rule, true);
+    return true;
   }
   const vatCompanyId = document.accountingSupplierParty.partyTaxSchemes?.find(scheme => scheme.taxSchemeId.id === 'VAT')?.companyId;
-  return schematronResult(rule, vatCompanyId?.trim().length === 14);
+  return vatCompanyId?.trim().length === 14;
 }
+
+export const validateSeR001 = schematronRule(rule, evaluateSeR001);

package/src/schematron/se/se-r-002.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+import { getSupplierCountry, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'SE-R-002',
@@ -10,10 +9,12 @@ const rule = {
   message: 'For Swedish suppliers, the Swedish VAT-numbers must have the trailing 12 characters in numeric form',
 } as const satisfies SchematronRule;
 
-export function validateSeR002(document: PeppolDocument): SchematronRuleResult {
+function evaluateSeR002(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'SE') {
-    return schematronResult(rule, true);
+    return true;
   }
   const vatCompanyId = document.accountingSupplierParty.partyTaxSchemes?.find(scheme => scheme.taxSchemeId.id === 'VAT')?.companyId;
-  return schematronResult(rule, vatCompanyId !== undefined && /^\d{12}$/.test(vatCompanyId.slice(2)));
+  return vatCompanyId !== undefined && /^\d{12}$/.test(vatCompanyId.slice(2));
 }
+
+export const validateSeR002 = schematronRule(rule, evaluateSeR002);

package/src/schematron/se/se-r-003.ts

@@ -1,15 +1,16 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+import { getSupplierCountry, schematronRule } from '#/schematron/helpers';
 
 const rule = { id: 'SE-R-003', level: 'fatal', message: 'Swedish organisation numbers should be numeric.' } as const satisfies SchematronRule;
 
-export function validateSeR003(document: PeppolDocument): SchematronRuleResult {
+function evaluateSeR003(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'SE') {
-    return schematronResult(rule, true);
+    return true;
   }
   const companyId = document.accountingSupplierParty.partyLegalEntity.companyId;
-  return schematronResult(rule, companyId === undefined || /^\d+$/.test(companyId.id));
+  return companyId === undefined || /^\d+$/.test(companyId.id);
 }
+
+export const validateSeR003 = schematronRule(rule, evaluateSeR003);

package/src/schematron/se/se-r-004.ts

@@ -1,15 +1,16 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+import { getSupplierCountry, schematronRule } from '#/schematron/helpers';
 
 const rule = { id: 'SE-R-004', level: 'fatal', message: 'Swedish organisation numbers consist of 10 characters.' } as const satisfies SchematronRule;
 
-export function validateSeR004(document: PeppolDocument): SchematronRuleResult {
+function evaluateSeR004(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'SE') {
-    return schematronResult(rule, true);
+    return true;
   }
   const companyId = document.accountingSupplierParty.partyLegalEntity.companyId;
-  return schematronResult(rule, companyId === undefined || companyId.id.trim().length === 10);
+  return companyId === undefined || companyId.id.trim().length === 10;
 }
+
+export const validateSeR004 = schematronRule(rule, evaluateSeR004);

package/src/schematron/se/se-r-005.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+import { getSupplierCountry, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'SE-R-005',
@@ -10,13 +9,15 @@ const rule = {
   message: "For Swedish suppliers, when using Seller tax registration identifier, 'Godkänd för F-skatt' must be stated",
 } as const satisfies SchematronRule;
 
-export function validateSeR005(document: PeppolDocument): SchematronRuleResult {
+function evaluateSeR005(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'SE') {
-    return schematronResult(rule, true);
+    return true;
   }
   const nonVatScheme = document.accountingSupplierParty.partyTaxSchemes?.find(scheme => scheme.taxSchemeId.id.toUpperCase() !== 'VAT');
   if (!nonVatScheme) {
-    return schematronResult(rule, true);
+    return true;
   }
-  return schematronResult(rule, nonVatScheme.companyId.trim().toUpperCase() === 'GODKÄND FÖR F-SKATT');
+  return nonVatScheme.companyId.trim().toUpperCase() === 'GODKÄND FÖR F-SKATT';
 }
+
+export const validateSeR005 = schematronRule(rule, evaluateSeR005);

package/src/schematron/se/se-r-006.ts

@@ -1,8 +1,7 @@
-import type { PeppolDocument } from '#/document';
+import type { PeppolDocument } from '#/schemas/peppol-document-schema';
 import type { SchematronRule } from '#/schematron/helpers';
-import type { SchematronRuleResult } from '#/schematron/types';
 
-import { getLines, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+import { getLines, getSupplierCountry, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'SE-R-006',
@@ -12,13 +11,15 @@ const rule = {
 
 const ALLOWED_RATES = new Set([6, 12, 25]);
 
-export function validateSeR006(document: PeppolDocument): SchematronRuleResult {
+function evaluateSeR006(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'SE') {
-    return schematronResult(rule, true);
+    return true;
   }
   const passed = getLines(document).every(line => {
     const percent = line.item.classifiedTaxCategory.percent;
     return percent === undefined || ALLOWED_RATES.has(percent);
   });
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateSeR006 = schematronRule(rule, evaluateSeR006);