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

package/src/schematron/gr/gr-r-001-3.ts

@@ -1,8 +1,10 @@
-import type { PeppolDocument } from '#/document';
+import { Schema } from 'effect';
+
+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 { PeppolIsoDateString } from '#/schemas/peppol-iso-date-string';
+import { getSupplierCountry, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'GR-R-001-3',
@@ -11,22 +13,25 @@ const rule = {
 } as const satisfies SchematronRule;
 
 const DATE_REGEX = /^(0?[1-9]|[12][0-9]|3[01])[-/]?(0?[1-9]|1[0-2])[-/]?((?:19|20)[0-9]{2})$/;
+const encodeDateSync = Schema.encodeSync(PeppolIsoDateString);
 
-export function validateGrR001_3(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR001_3(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
-    return schematronResult(rule, true);
+    return true;
   }
   const segments = document.id.split('|');
   const secondSegment = segments[1];
   if (!secondSegment || secondSegment.trim().length === 0) {
-    return schematronResult(rule, false);
+    return false;
   }
   const dateMatch = secondSegment.match(DATE_REGEX);
   if (!dateMatch) {
-    return schematronResult(rule, false);
+    return false;
   }
   const [, day, month, year] = dateMatch;
-  const issueDate = document.issueDate;
+  const issueDate = encodeDateSync(document.issueDate);
   const issueDateSegments = issueDate.split('-');
-  return schematronResult(rule, day === issueDateSegments[2] && month === issueDateSegments[1] && year === issueDateSegments[0]);
+  return day === issueDateSegments[2] && month === issueDateSegments[1] && year === issueDateSegments[0];
 }
+
+export const validateGrR001_3 = schematronRule(rule, evaluateGrR001_3);

package/src/schematron/gr/gr-r-001-4.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: 'GR-R-001-4',
@@ -10,14 +9,16 @@ const rule = {
   message: 'When Supplier is Greek, the Invoice Id third segment must be a positive integer',
 } as const satisfies SchematronRule;
 
-export function validateGrR001_4(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR001_4(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
-    return schematronResult(rule, true);
+    return true;
   }
   const segments = document.id.split('|');
   const thirdSegment = segments[2];
   if (!thirdSegment || thirdSegment.trim().length === 0) {
-    return schematronResult(rule, false);
+    return false;
   }
-  return schematronResult(rule, /^\d+$/.test(thirdSegment) && Number(thirdSegment) >= 0);
+  return /^\d+$/.test(thirdSegment) && Number(thirdSegment) >= 0;
 }
+
+export const validateGrR001_4 = schematronRule(rule, evaluateGrR001_4);

package/src/schematron/gr/gr-r-001-5.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: 'GR-R-001-5',
@@ -12,14 +11,16 @@ const rule = {
 
 const GREEK_DOCUMENT_TYPES = new Set(['1.1', '1.6', '2.1', '2.4', '5.1', '5.2']);
 
-export function validateGrR001_5(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR001_5(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
-    return schematronResult(rule, true);
+    return true;
   }
   const segments = document.id.split('|');
   const fourthSegment = segments[3];
   if (!fourthSegment || fourthSegment.trim().length === 0) {
-    return schematronResult(rule, false);
+    return false;
   }
-  return schematronResult(rule, GREEK_DOCUMENT_TYPES.has(fourthSegment));
+  return GREEK_DOCUMENT_TYPES.has(fourthSegment);
 }
+
+export const validateGrR001_5 = schematronRule(rule, evaluateGrR001_5);

package/src/schematron/gr/gr-r-001-6.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: 'GR-R-001-6',
@@ -10,10 +9,12 @@ const rule = {
   message: 'When Supplier is Greek, the Invoice Id fifth segment must not be empty',
 } as const satisfies SchematronRule;
 
-export function validateGrR001_6(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR001_6(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
-    return schematronResult(rule, true);
+    return true;
   }
   const segments = document.id.split('|');
-  return schematronResult(rule, (segments[4]?.length ?? 0) > 0);
+  return (segments[4]?.length ?? 0) > 0;
 }
+
+export const validateGrR001_6 = schematronRule(rule, evaluateGrR001_6);

package/src/schematron/gr/gr-r-001-7.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: 'GR-R-001-7',
@@ -10,10 +9,12 @@ const rule = {
   message: 'When Supplier is Greek, the Invoice Id sixth segment must not be empty',
 } as const satisfies SchematronRule;
 
-export function validateGrR001_7(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR001_7(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
-    return schematronResult(rule, true);
+    return true;
   }
   const segments = document.id.split('|');
-  return schematronResult(rule, (segments[5]?.length ?? 0) > 0);
+  return (segments[5]?.length ?? 0) > 0;
 }
+
+export const validateGrR001_7 = schematronRule(rule, evaluateGrR001_7);

package/src/schematron/gr/gr-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: 'GR-R-002',
@@ -11,10 +10,12 @@ const rule = {
     'Greek Suppliers must provide their full name as they are registered in the Greek Business Registry (G.E.MH.) as a legal entity or in the Tax Registry as a natural person ',
 } as const satisfies SchematronRule;
 
-export function validateGrR002(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR002(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
-    return schematronResult(rule, true);
+    return true;
   }
   const partyName = document.accountingSupplierParty.partyName?.name;
-  return schematronResult(rule, typeof partyName === 'string' && partyName.length > 0);
+  return typeof partyName === 'string' && partyName.length > 0;
 }
+
+export const validateGrR002 = schematronRule(rule, evaluateGrR002);

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

@@ -1,9 +1,8 @@
-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 { greekTinVerification } from '#/peppol-validations/greek-tin-verification';
-import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+import { getSupplierCountry, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'GR-R-003',
@@ -11,15 +10,17 @@ const rule = {
   message: "For the Greek Suppliers, the VAT must start with 'EL' and must be a valid TIN number",
 } as const satisfies SchematronRule;
 
-export function validateGrR003(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR003(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
-    return schematronResult(rule, true);
+    return true;
   }
   const vatCompanyId = document.accountingSupplierParty.partyTaxSchemes?.find(
     scheme => scheme.taxSchemeId.id.trim().toUpperCase() === 'VAT'
   )?.companyId;
   if (!vatCompanyId) {
-    return schematronResult(rule, false);
+    return false;
   }
-  return schematronResult(rule, vatCompanyId.startsWith('EL') && greekTinVerification(vatCompanyId.slice(2)));
+  return vatCompanyId.startsWith('EL') && greekTinVerification(vatCompanyId.slice(2));
 }
+
+export const validateGrR003 = schematronRule(rule, evaluateGrR003);

package/src/schematron/gr/gr-r-004-1.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: 'GR-R-004-1',
@@ -10,11 +9,13 @@ const rule = {
   message: ' When Supplier is Greek, there must be one MARK Number',
 } as const satisfies SchematronRule;
 
-export function validateGrR004_1(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR004_1(document: PeppolDocument): boolean {
   const isGreek = getSupplierCountry(document) === 'GR' || getSupplierCountry(document) === 'EL';
   if (!isGreek) {
-    return schematronResult(rule, true);
+    return true;
   }
   const markCount = (document.additionalDocumentReferences ?? []).filter(ref => ref.documentDescription === '##M.AR.K##').length;
-  return schematronResult(rule, markCount === 1);
+  return markCount === 1;
 }
+
+export const validateGrR004_1 = schematronRule(rule, evaluateGrR004_1);

package/src/schematron/gr/gr-r-004-2.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: 'GR-R-004-2',
@@ -10,11 +9,13 @@ const rule = {
   message: 'When Supplier is Greek, the MARK Number must be a positive integer',
 } as const satisfies SchematronRule;
 
-export function validateGrR004_2(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR004_2(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
-    return schematronResult(rule, true);
+    return true;
   }
   const markReferences = (document.additionalDocumentReferences ?? []).filter(ref => ref.documentDescription === '##M.AR.K##');
   const passed = markReferences.every(ref => /^[1-9][0-9]*$/.test(ref.id.id));
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateGrR004_2 = schematronRule(rule, evaluateGrR004_2);

package/src/schematron/gr/gr-r-005.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: 'GR-R-005', level: 'fatal', message: 'Greek Suppliers must provide the full name of the buyer' } as const satisfies SchematronRule;
 
-export function validateGrR005(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR005(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
-    return schematronResult(rule, true);
+    return true;
   }
   const partyName = document.accountingCustomerParty.partyName?.name;
-  return schematronResult(rule, typeof partyName === 'string' && partyName.length > 0);
+  return typeof partyName === 'string' && partyName.length > 0;
 }
+
+export const validateGrR005 = schematronRule(rule, evaluateGrR005);

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

@@ -1,9 +1,8 @@
-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 { greekTinVerification } from '#/peppol-validations/greek-tin-verification';
-import { getCustomerCountry, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+import { getCustomerCountry, getSupplierCountry, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'GR-R-006',
@@ -11,16 +10,18 @@ const rule = {
   message: 'Greek Suppliers must provide the VAT number of the buyer, if the buyer is Greek ',
 } as const satisfies SchematronRule;
 
-export function validateGrR006(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR006(document: PeppolDocument): boolean {
   const isGreekSupplier = getSupplierCountry(document) === 'GR' || getSupplierCountry(document) === 'EL';
   const isGreekCustomer = getCustomerCountry(document) === 'GR' || getCustomerCountry(document) === 'EL';
   if (!isGreekSupplier || !isGreekCustomer) {
-    return schematronResult(rule, true);
+    return true;
   }
   const vatSchemes = document.accountingCustomerParty.partyTaxSchemes?.filter(scheme => scheme.taxSchemeId.id.trim().toUpperCase() === 'VAT') ?? [];
   if (vatSchemes.length !== 1) {
-    return schematronResult(rule, false);
+    return false;
   }
   const companyId = vatSchemes[0]?.companyId ?? '';
-  return schematronResult(rule, companyId.startsWith('EL') && greekTinVerification(companyId.slice(2)));
+  return companyId.startsWith('EL') && greekTinVerification(companyId.slice(2));
 }
+
+export const validateGrR006 = schematronRule(rule, evaluateGrR006);

package/src/schematron/gr/gr-r-008-2.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: 'GR-R-008-2',
@@ -10,10 +9,12 @@ const rule = {
   message: 'When Supplier is Greek, there should be no more than one invoice url',
 } as const satisfies SchematronRule;
 
-export function validateGrR008_2(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR008_2(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
-    return schematronResult(rule, true);
+    return true;
   }
   const urlCount = (document.additionalDocumentReferences ?? []).filter(ref => ref.documentDescription === '##INVOICE|URL##').length;
-  return schematronResult(rule, urlCount <= 1);
+  return urlCount <= 1;
 }
+
+export const validateGrR008_2 = schematronRule(rule, evaluateGrR008_2);

package/src/schematron/gr/gr-r-008-3.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: 'GR-R-008-3',
@@ -10,14 +9,16 @@ const rule = {
   message: 'When Supplier is Greek and the INVOICE URL Document reference exists, the External Reference URI should be present',
 } as const satisfies SchematronRule;
 
-export function validateGrR008_3(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR008_3(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
-    return schematronResult(rule, true);
+    return true;
   }
   const urlReferences = (document.additionalDocumentReferences ?? []).filter(ref => ref.documentDescription === '##INVOICE|URL##');
   const passed = urlReferences.every(ref => {
     const uri = ref.attachment?.externalReference?.uri;
     return typeof uri === 'string' && uri.trim() !== '';
   });
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateGrR008_3 = schematronRule(rule, evaluateGrR008_3);

package/src/schematron/gr/gr-r-009.ts

@@ -1,9 +1,8 @@
-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 { greekTinVerification } from '#/peppol-validations/greek-tin-verification';
-import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+import { getSupplierCountry, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'GR-R-009',
@@ -12,11 +11,13 @@ const rule = {
     'Greek suppliers that send an invoice through the PEPPOL network must use a correct TIN number as an electronic address according to PEPPOL Electronic Address Identifier scheme (schemeID 9933).',
 } as const satisfies SchematronRule;
 
-export function validateGrR009(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR009(document: PeppolDocument): boolean {
   const supplierCountry = getSupplierCountry(document);
   if (supplierCountry !== 'GR' && supplierCountry !== 'EL') {
-    return schematronResult(rule, true);
+    return true;
   }
   const endpointId = document.accountingSupplierParty.endpointId;
-  return schematronResult(rule, endpointId?.schemeId === '9933' && greekTinVerification(endpointId.id));
+  return endpointId?.schemeId === '9933' && greekTinVerification(endpointId.id);
 }
+
+export const validateGrR009 = schematronRule(rule, evaluateGrR009);

package/src/schematron/gr/gr-r-010.ts

@@ -1,9 +1,8 @@
-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 { greekTinVerification } from '#/peppol-validations/greek-tin-verification';
-import { getCustomerCountry, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+import { getCustomerCountry, getSupplierCountry, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'GR-R-010',
@@ -12,12 +11,14 @@ const rule = {
     'Greek Suppliers that send an invoice through the PEPPOL network to a greek buyer must use a correct TIN number as an electronic address according to PEPPOL Electronic Address Identifier scheme (SchemeID 9933)',
 } as const satisfies SchematronRule;
 
-export function validateGrR010(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrR010(document: PeppolDocument): boolean {
   const isGreekSupplier = getSupplierCountry(document) === 'GR' || getSupplierCountry(document) === 'EL';
   const isGreekCustomer = getCustomerCountry(document) === 'GR' || getCustomerCountry(document) === 'EL';
   if (!isGreekSupplier || !isGreekCustomer) {
-    return schematronResult(rule, true);
+    return true;
   }
   const endpointId = document.accountingCustomerParty.endpointId;
-  return schematronResult(rule, endpointId?.schemeId === '9933' && greekTinVerification(endpointId.id));
+  return endpointId?.schemeId === '9933' && greekTinVerification(endpointId.id);
 }
+
+export const validateGrR010 = schematronRule(rule, evaluateGrR010);

package/src/schematron/gr/gr-s-008-1.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: 'GR-S-008-1',
@@ -10,10 +9,12 @@ const rule = {
   message: 'When Supplier is Greek, there should be one invoice url',
 } as const satisfies SchematronRule;
 
-export function validateGrS008_1(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrS008_1(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
-    return schematronResult(rule, true);
+    return true;
   }
   const urlCount = (document.additionalDocumentReferences ?? []).filter(ref => ref.documentDescription === '##INVOICE|URL##').length;
-  return schematronResult(rule, urlCount === 1);
+  return urlCount === 1;
 }
+
+export const validateGrS008_1 = schematronRule(rule, evaluateGrS008_1);

package/src/schematron/gr/gr-s-011.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: 'GR-S-011',
@@ -10,14 +9,16 @@ const rule = {
   message: 'Greek suppliers must provide their Seller Tax Registration Number, prefixed by the country code',
 } as const satisfies SchematronRule;
 
-export function validateGrS011(document: PeppolDocument): SchematronRuleResult {
+function evaluateGrS011(document: PeppolDocument): boolean {
   if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
-    return schematronResult(rule, true);
+    return true;
   }
   const vatSchemes = document.accountingSupplierParty.partyTaxSchemes?.filter(scheme => scheme.taxSchemeId.id.trim().toUpperCase() === 'VAT') ?? [];
   if (vatSchemes.length !== 1) {
-    return schematronResult(rule, false);
+    return false;
   }
   const companyId = vatSchemes[0]?.companyId ?? '';
-  return schematronResult(rule, companyId.startsWith('EL'));
+  return companyId.startsWith('EL');
 }
+
+export const validateGrS011 = schematronRule(rule, evaluateGrS011);

package/src/schematron/helpers.ts

@@ -1,10 +1,11 @@
-import type * as z from 'zod/mini';
+import { Effect } from 'effect';
 
-import type { PeppolDocument, PeppolDocumentLine } from '#/document';
-import type { invoicePeriodSchema } from '#/schemas/fields/invoice-period-schema';
-import type { taxSubtotalSchema } from '#/schemas/fields/tax-subtotal-schema';
-import type { SchematronRuleLevel, SchematronRuleResult } from '#/schematron/types';
+import type { PeppolInvoicePeriod } from '#/schemas/fields/peppol-invoice-period-schema';
+import type { PeppolTaxSubTotal } from '#/schemas/fields/peppol-tax-subtotal-schema';
+import type { PeppolDocument, PeppolDocumentLine } from '#/schemas/peppol-document-schema';
+import type { SchematronRuleLevel } from '#/schematron/types';
 
+import { SchematronRuleError } from '#/schematron/errors';
 import { chargeReasonCodesKeys } from '#/values/charge-reason-codes.generated';
 import { countryCodesKeys } from '#/values/country-code.generated';
 
@@ -20,10 +21,19 @@ export interface SchematronRule {
 }
 
 /**
- * @description Builds a `SchematronRuleResult` for the given rule.
+ * @description An effectful schematron rule validator. Fails with a `SchematronRuleError` when the document does not satisfy the rule.
  */
-export function schematronResult(rule: SchematronRule, passed: boolean): SchematronRuleResult {
-  return { id: rule.id, level: rule.level, message: rule.message, passed };
+export type SchematronDocumentValidator = (document: PeppolDocument) => Effect.Effect<void, SchematronRuleError>;
+
+/**
+ * @description Builds an effectful validator from rule metadata and a pure predicate.
+ */
+export function schematronRule(rule: SchematronRule, predicate: (document: PeppolDocument) => boolean): SchematronDocumentValidator {
+  return Effect.fn(`schematron.${rule.id}`)(function* (document: PeppolDocument) {
+    if (!predicate(document)) {
+      return yield* new SchematronRuleError({ id: rule.id, level: rule.level, message: rule.message });
+    }
+  });
 }
 
 /**
@@ -99,6 +109,21 @@ export function isCustomerGermany(document: PeppolDocument): boolean {
   return document.accountingCustomerParty.postalAddress.countryCode.identificationCode.toUpperCase() === 'DE';
 }
 
+/**
+ * @description Whether both the supplier and customer countries are Denmark, mirroring the schematron `$supplierCountryIsDK` and `$customerCountryIsDK` variables.
+ */
+export function isDanishSupplierAndCustomer(document: PeppolDocument): boolean {
+  return getSupplierCountry(document) === 'DK' && getCustomerCountry(document) === 'DK';
+}
+
+/**
+ * @description Whether both the supplier and customer postal address countries are Germany, mirroring the schematron `$supplierCountryIsDE` and
+ * `$customerCountryIsDE` variables.
+ */
+export function isGermanSupplierAndCustomer(document: PeppolDocument): boolean {
+  return isSupplierGermany(document) && isCustomerGermany(document);
+}
+
 /**
  * @description Returns the invoice lines or credit note lines of a document.
  */
@@ -436,7 +461,7 @@ export function allVatCompanyIdsHaveValidPrefix(document: PeppolDocument): boole
  * @description Whether every invoice period / line period has an end date after or equal to its start date, used by BR-29 and BR-30.
  */
 export function everyPeriodEndAfterStart(document: PeppolDocument): boolean {
-  const ok = (period: z.infer<typeof invoicePeriodSchema> | undefined): boolean => {
+  const ok = (period: PeppolInvoicePeriod | undefined): boolean => {
     if (!period?.startDate || !period.endDate) {
       return true;
     }
@@ -450,7 +475,7 @@ export function everyPeriodEndAfterStart(document: PeppolDocument): boolean {
  * @description Whether every invoice period has a start/end date or a description code, used by BR-CO-19 and BR-CO-20.
  */
 export function everyPeriodHasDateOrDescriptionCode(document: PeppolDocument): boolean {
-  const ok = (period: z.infer<typeof invoicePeriodSchema> | undefined): boolean => {
+  const ok = (period: PeppolInvoicePeriod | undefined): boolean => {
     if (!period) {
       return true;
     }
@@ -500,7 +525,7 @@ export function withinSlackOne(a: number, b: number): boolean {
  * @description Whether the VAT category tax amount (BT-117) equals the VAT category taxable amount (BT-116) multiplied by the VAT category rate (BT-119), allowing
  * for a slack of 1, mirroring BR-CO-17.
  */
-export function vatCategoryTaxAmountMatchesRate(subtotal: z.infer<typeof taxSubtotalSchema>): boolean {
+export function vatCategoryTaxAmountMatchesRate(subtotal: PeppolTaxSubTotal): boolean {
   const percent = subtotal.taxCategory.percent;
   if (percent === undefined) {
     return Math.round(subtotal.taxAmount.value) === 0;

package/src/schematron/index.ts

@@ -263,7 +263,6 @@ export { validateGrR009 } from './gr/gr-r-009';
 export { validateGrR010 } from './gr/gr-r-010';
 export { validateGrS008_1 } from './gr/gr-s-008-1';
 export { validateGrS011 } from './gr/gr-s-011';
-export {} from './index';
 export { validateIsR001 } from './is/is-r-001';
 export { validateIsR002 } from './is/is-r-002';
 export { validateIsR003 } from './is/is-r-003';
@@ -360,4 +359,10 @@ export { validateSeR011 } from './se/se-r-011';
 export { validateSeR012 } from './se/se-r-012';
 export { validateSeR013 } from './se/se-r-013';
 
+export { SchematronRuleError, SchematronValidationError } from './errors';
+export type { SchematronDocumentValidator } from './helpers';
+export { ruleValidators } from './run-all-rules';
+export { Schematron } from './schematron';
+export type { SchematronShape } from './schematron';
+
 export type * from './types';