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

package/src/schemas/utils/is-valid-process.ts

@@ -1,4 +1,4 @@
-import type { PeppolProcesses } from '#/schemas/values/process-schema';
+import type { PeppolProcesses } from '#/schemas/values/peppol-process-schema';
 
 import { processesList } from '#/values/processes.generated';
 

package/src/schemas/utils/opaque.ts

@@ -0,0 +1,19 @@
+import type { Schema } from 'effect';
+
+/**
+ * @description Nominal type produced by {@link opaque}. Equivalent to the type returned by `Schema.Opaque<Self>()(schema)`. Declaring the intersection once behind
+ * a named type keeps declaration emit compact: the wrapped struct is referenced a single time instead of being expanded in both `Schema.Opaque` and
+ * `Omit`.
+ */
+export type OpaqueSchema<Self, S extends Schema.Top> = Schema.Opaque<Self, S, {}> & Omit<S, keyof Schema.Top>;
+
+/**
+ * @description Lightweight replacement for `Schema.Opaque<Self>()` that produces the same runtime value and type with a smaller declaration footprint.
+ *
+ * @param Self - The nominal type the decoded value should be branded as.
+ *
+ * @returns A function that wraps a struct schema into an opaque schema typed as {@link OpaqueSchema}.
+ */
+export function opaque<Self>() {
+  return <S extends Schema.Top>(schema: S): OpaqueSchema<Self, S> => schema as unknown as OpaqueSchema<Self, S>;
+}

package/src/{effect → schemas}/utils/peppol-vat-regex-schema.ts

@@ -47,5 +47,3 @@ export const peppolVatRegexSchema = Schema.Union([
   Schema.String.check(Schema.isStartsWith('SI'), Schema.isPattern(/^SI\d{8}$/)),
   Schema.String.check(Schema.isStartsWith('SK'), Schema.isPattern(/^SK\d{10}$/)),
 ]);
-
-export type VatRegex = typeof peppolVatRegexSchema.Type;

package/src/schemas/utils/peppol-xsd-time-schema.ts

@@ -0,0 +1,79 @@
+import { Clock, Option, DateTime, Effect, Predicate, Schema, SchemaGetter, SchemaIssue, SchemaParser } from 'effect';
+
+import { formatXsdTime } from '#/schemas/utils/format-xsd-time';
+import { opaque } from '#/schemas/utils/opaque';
+
+const timeRegex =
+  /^(?<hours>[01]\d|2[0-3]):(?<minutes>[0-5]\d):(?<seconds>[0-5]\d)(?<nanoseconds>\.\d{1,9})?(?<tz>(?:Z|-0[1-9]|-1\d|-2[0-3]|-00:?(?:0[1-9]|[1-5]\d)|\+[01]\d|\+2[0-3])?(?:|:?[0-5]\d))$/;
+const timeZoneRegex = /^(?:(?<utc>Z)|[-+](?<hours>0[1-9]|1\d|2[0-3]|00):?(?<minutes>[0-5]\d))$/;
+const numberFromString = SchemaParser.decodeSync(
+  Schema.UndefinedOr(Schema.String.pipe(Schema.withDecodingDefault(Effect.succeed('0')))).pipe(
+    Schema.decodeTo(Schema.Number, { encode: SchemaGetter.String(), decode: SchemaGetter.Number() }),
+    Schema.catchDecoding(() => Effect.succeedSome(0))
+  )
+);
+
+/**
+ * @description Parse a timezone offset from a string. The string must be in the format `(+|-)HH:MM` where `HH` and `MM` are two digits.
+ *
+ * @param tz - The timzeone offset string.
+ *
+ * @returns
+ *
+ * @internal
+ */
+export const parseZoneOffsetFromString = (tz: `+${number}:${number}` | `-${number}:${number}` | (string & {})) => {
+  const tzRegexResult = timeZoneRegex.exec(tz);
+  if (Predicate.isNullish(tzRegexResult)) {
+    return undefined;
+  }
+  const [_tzParsed, _isUtc, tzHours, tzMinutes] = tzRegexResult;
+  const offset = DateTime.zoneMakeOffset((numberFromString(tzHours) * 60 + numberFromString(tzMinutes)) * 60 * 1000);
+  return offset;
+};
+
+/**
+ * @description XSD `time` lexical value (`HH:MM:SS` with optional fractional seconds and timezone). Effect port of `xsdTime` (`z.string().check(z.regex(...))`):
+ * keeps the value as a plain string and only validates the shape.
+ */
+export class PeppolXsdTime extends opaque<PeppolXsdTime>()(
+  Schema.String.check(
+    Schema.isPattern(
+      /^(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d{1,9})?(?:Z|-0[1-9]|-1\d|-2[0-3]|-00:?(?:0[1-9]|[1-5]\d)|\+[01]\d|\+2[0-3])?(?:|:?[0-5]\d)$/
+    ).annotate({ message: 'Invalid ISO time' })
+  )
+    .pipe(
+      Schema.decodeTo(Schema.DateTimeUtc, {
+        decode: SchemaGetter.transformEffect((input, options) =>
+          Clock.currentTimeMillis.pipe(
+            Effect.map(millis => DateTime.make(millis)),
+            Effect.flatMap(option => Effect.fromOption(option)),
+            Effect.map(date =>
+              DateTime.withDate(date, date => {
+                const regexResult = timeRegex.exec(input);
+                if (Predicate.isNullish(regexResult)) return Option.none();
+                const [_time, hours, minutes, seconds, nanoseconds, tz] = regexResult;
+
+                date.setUTCHours(numberFromString(hours), numberFromString(minutes), numberFromString(seconds), numberFromString(nanoseconds));
+                if (Predicate.isUndefined(tz) || tz === 'Z') {
+                  return DateTime.make(date.getTime());
+                }
+                const offset = parseZoneOffsetFromString(tz);
+                if (Predicate.isNullish(offset)) {
+                  return DateTime.make(date.getTime());
+                }
+
+                return DateTime.makeZoned(date.getTime(), { adjustForTimeZone: false, timeZone: offset }).pipe(
+                  Option.map(date => DateTime.toUtc(date))
+                );
+              })
+            ),
+            Effect.flatMap(option => Effect.fromOption(option)),
+            Effect.catchTag('NoSuchElementError', () => Effect.fail(new SchemaIssue.InvalidValue({ message: 'Invalid date input' }, input, options)))
+          )
+        ),
+        encode: SchemaGetter.transform(self => formatXsdTime(self)),
+      })
+    )
+    .annotate({ message: 'Invalid ISO time' })
+) {}

package/src/schemas/utils/quantity-unit-code-to-intl-unit.ts

@@ -1,6 +1,6 @@
 import type { PeppolQuantityUnitCode } from '#/schemas/values/quantity-unit-codes-schema';
 
-type BaseIntlUnit =
+export type BaseIntlUnit =
   | 'acre'
   | 'bit'
   | 'byte'
@@ -36,7 +36,7 @@ type BaseIntlUnit =
   | 'terabit'
   | 'terabyte'
   | 'yard';
-type TimeIntlUnit = 'nanosecond' | 'microsecond' | 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';
+export type TimeIntlUnit = 'nanosecond' | 'microsecond' | 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';
 
 export type IntlUnit = BaseIntlUnit | TimeIntlUnit | `${BaseIntlUnit}-per-${TimeIntlUnit}`;
 

package/src/schemas/values/credit-note-type-code-schema.ts

@@ -1,4 +1,4 @@
-import * as z from 'zod/mini';
+import { Schema } from 'effect';
 
 import type { CreditNoteTypeCodesKeys } from '#/values/credit-notes-type-codes.generated';
 
@@ -16,10 +16,8 @@ export type PeppolCreditNoteTypeCode = CreditNoteTypeCodesKeys;
  *
  * @param error - The custom error message to use when validation fails.
  *
- * @returns A Zod string schema that accepts only valid credit note type codes.
+ * @returns An Effect schema that accepts only valid credit note type codes.
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL1001-cn/
  */
-export function creditNoteTypeCodeSchema(error?: string) {
-  return z.string().check(z.refine(val => creditNoteTypeCodesKeys.includes(val as never), error));
-}
+export const creditNoteTypeCodeSchema = Schema.Literals(creditNoteTypeCodesKeys);

package/src/schemas/values/document-type-schemes-schema.ts

@@ -1,4 +1,4 @@
-import * as z from 'zod/mini';
+import { Schema } from 'effect';
 
 import { documentTypesScheme } from '#/values/document-type.generated';
 
@@ -7,10 +7,8 @@ import { documentTypesScheme } from '#/values/document-type.generated';
  *
  * @param error - The error message to use when validation fails. Defaults to `'invalid Peppol document type scheme'`.
  *
- * @returns A Zod string schema that accepts only valid document type schemes.
+ * @returns An Effect schema that accepts only valid document type schemes.
  *
  * @see {@link documentTypesScheme}
  */
-export function documentTypeSchemesSchema(error = 'invalid Peppol document type scheme') {
-  return z.string(error).check(z.refine(val => documentTypesScheme.includes(val as never), error));
-}
+export const documentTypeSchemesSchema = Schema.Literals(documentTypesScheme as [string, ...Array<string>]);

package/src/schemas/values/document-type-values-schema.ts

@@ -1,19 +1,16 @@
-import { Record } from 'effect';
-import * as z from 'zod/mini';
+import { Record, Schema } from 'effect';
 
 import { documentTypesTable } from '#/values/document-type.generated';
 
-const entries = /* @__PURE__ */ Record.toEntries(documentTypesTable);
+const values = Record.values(documentTypesTable).flat();
 
 /**
  * @description Validates the value part of a PEPPOL document type identifier (the portion after the scheme prefix) against the known document type table.
  *
  * @param error - The error message to use when validation fails. Defaults to `'invalid Peppol document type value'`.
  *
- * @returns A Zod string schema that accepts only valid document type values.
+ * @returns An Effect schema that accepts only valid document type values.
  *
  * @see {@link documentTypesTable}
  */
-export function documentTypeValuesSchema(error = 'invalid Peppol document type value') {
-  return z.string(error).check(z.refine(val => entries.flatMap(([, value]) => value).includes(val as never)));
-}
+export const documentTypeValuesSchema = Schema.String.check(Schema.makeFilter((val: string) => values.includes(val as never)));

package/src/{effect → schemas}/values/duty-tax-fee-category-schema.ts

@@ -7,8 +7,8 @@ import { dutyTaxFeeCategoriesKeys } from '#/values/duty-tax-fee-categories.gener
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL5305/
  */
-export type PeppolDutyTaxFeeCategoryCode = typeof dutyTaxFeeCategorySchema.Type;
-export type PeppolDutyTaxFeeCategoryCodeEncoded = typeof dutyTaxFeeCategorySchema.Encoded;
+export type PeppolDutyTaxFeeCategoryCode = typeof peppolDutyTaxFeeCategorySchema.Type;
+export type PeppolDutyTaxFeeCategoryCodeEncoded = typeof peppolDutyTaxFeeCategorySchema.Encoded;
 
 /**
  * @description Validates a duty, tax or fee category code against the PEPPOL subset of UNCL 5305 (VAT category code).
@@ -22,4 +22,4 @@ export type PeppolDutyTaxFeeCategoryCodeEncoded = typeof dutyTaxFeeCategorySchem
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL5305/
  */
-export const dutyTaxFeeCategorySchema = Schema.Literals(dutyTaxFeeCategoriesKeys).pipe(Schema.brand('PeppolDutyTaxFeeCategoryCode'));
+export const peppolDutyTaxFeeCategorySchema = Schema.Literals(dutyTaxFeeCategoriesKeys).pipe(Schema.brand('PeppolDutyTaxFeeCategoryCode'));

package/src/schemas/values/invoice-type-code-schema.ts

@@ -1,6 +1,4 @@
-import * as z from 'zod/mini';
-
-import type { InvoiceTypeCodesKeys } from '#/values/invoice-type-codes.generated';
+import { Schema } from 'effect';
 
 import { invoiceTypeCodesKeys } from '#/values/invoice-type-codes.generated';
 
@@ -9,17 +7,15 @@ import { invoiceTypeCodesKeys } from '#/values/invoice-type-codes.generated';
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL1001-inv/
  */
-export type PeppolInvoiceTypeCode = InvoiceTypeCodesKeys;
+export type PeppolInvoiceTypeCode = typeof invoiceTypeCodeSchema.Type;
 
 /**
  * @description Validates an invoice type code against the PEPPOL subset of UNCL 1001 (invoice).
  *
  * @param error - The custom error message to use when validation fails.
  *
- * @returns A Zod string schema that accepts only valid invoice type codes.
+ * @returns An Effect schema that accepts only valid invoice type codes.
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL1001-inv/
  */
-export function invoiceTypeCodeSchema(error?: string) {
-  return z.string(error).check(z.refine(val => invoiceTypeCodesKeys.includes(val as never), error));
-}
+export const invoiceTypeCodeSchema = Schema.Literals(invoiceTypeCodesKeys).pipe(Schema.brand('PeppolInvoiceTypeCode'));

package/src/schemas/values/process-from-document-type-schema.ts

@@ -1,8 +1,8 @@
-import * as z from 'zod/mini';
+import { Schema } from 'effect';
 
-import type { PeppolDocumentType } from '#/schemas/values/document-type-schema';
+import type { PeppolDocumentType } from '#/schemas/values/peppol-document-type-schema';
 
-import { processSchema } from '#/schemas/values/process-schema';
+import { peppolProcessSchema } from '#/schemas/values/peppol-process-schema';
 import { documentTypesProcessIds } from '#/values/document-type.generated';
 
 /**
@@ -11,18 +11,16 @@ import { documentTypesProcessIds } from '#/values/document-type.generated';
  * @param documentType - The PEPPOL document type scheme whose allowed processes should be used.
  * @param error - The custom error message to use when validation fails. Defaults to `'invalid process type for document type'`.
  *
- * @returns A Zod template-literal schema that matches only processes allowed for the given document type.
+ * @returns An Effect schema that matches only processes allowed for the given document type.
  *
- * @see {@link processSchema}
+ * @see {@link peppolProcessSchema}
  * @see {@link documentTypesProcessIds}
  */
 export function processFromDocumentTypeSchema(documentType: PeppolDocumentType, error = 'invalid process type for document type') {
-  const processes = documentTypesProcessIds[documentType as keyof typeof documentTypesProcessIds];
-  if (!processes) {
-    return processSchema(error);
+  const allowed = documentTypesProcessIds[documentType as keyof typeof documentTypesProcessIds];
+  if (allowed === undefined) {
+    return peppolProcessSchema;
   }
-
-  return z
-    .templateLiteral([z.string(), z.literal('::'), z.string()], error)
-    .check(z.refine(val => processes.map(p => `${p.scheme}::${p.value}`).includes(val)));
+  const values = allowed.map(p => `${p.scheme}::${p.value}`);
+  return Schema.String.check(Schema.makeFilter((val: string) => values.includes(val as never))).annotate({ message: error });
 }

package/src/schemas/values/quantity-unit-codes-schema.ts

@@ -1,6 +1,4 @@
-import * as z from 'zod/mini';
-
-import type { QuantityUnitCodesKeys } from '#/values/quantity-unit-codes.generated';
+import { Schema } from 'effect';
 
 import { quantityUnitCodesKeys } from '#/values/quantity-unit-codes.generated';
 
@@ -9,20 +7,18 @@ import { quantityUnitCodesKeys } from '#/values/quantity-unit-codes.generated';
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNECERec20/
  */
-export type PeppolQuantityUnitCode = QuantityUnitCodesKeys;
+export type PeppolQuantityUnitCode = typeof quantityUnitCodesSchema.Type;
 
 /**
  * @description Validates a unit of measure code against the PEPPOL subset of UN/ECE Recommendation 20.
  *
  * @param error - The custom error message to use when validation fails.
  *
- * @returns A Zod string schema that accepts only valid quantity unit codes.
+ * @returns An Effect schema that accepts only valid quantity unit codes.
  *
  * @validations
  * - BR-CL-23: Unit of measure code MUST be a valid UN/ECE Rec 20 code.
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNECERec20/
  */
-export function quantityUnitCodesSchema(error?: string) {
-  return z.string(error).check(z.refine(val => quantityUnitCodesKeys.includes(val as never)));
-}
+export const quantityUnitCodesSchema = Schema.Literals(quantityUnitCodesKeys).pipe(Schema.brand('PeppolQuantityUnitCode'));

package/src/schematron/cen/ae/cen-en16931-br-ae-01.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 { countVatBreakdownCode, hasAnyVatCategoryCode, schematronResult } from '#/schematron/helpers';
+import { countVatBreakdownCode, hasAnyVatCategoryCode, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'CEN-EN16931-BR-AE-01',
@@ -11,7 +10,9 @@ const rule = {
     'An Invoice that contains an Invoice line (BG-25), a Document level allowance (BG-20) or a Document level charge (BG-21) where the VAT category code (BT-151, BT-95 or BT-102) is "Reverse charge" shall contain in the VAT Breakdown (BG-23) exactly one VAT category code (BT-118) equal with "VAT reverse charge".',
 } as const satisfies SchematronRule;
 
-export function validateCenEn16931BrAe01(document: PeppolDocument): SchematronRuleResult {
+function evaluateCenEn16931BrAe01(document: PeppolDocument): boolean {
   const passed = !hasAnyVatCategoryCode(document, 'AE') || countVatBreakdownCode(document, 'AE') === 1;
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateCenEn16931BrAe01 = schematronRule(rule, evaluateCenEn16931BrAe01);

package/src/schematron/cen/ae/cen-en16931-br-ae-02.ts

@@ -1,6 +1,5 @@
-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 {
   hasBuyerLegalCompanyId,
@@ -8,7 +7,7 @@ import {
   hasLineVatCategoryCode,
   hasSellerTaxIdentifier,
   hasTaxRepresentativeVatCompanyId,
-  schematronResult,
+  schematronRule,
 } from '#/schematron/helpers';
 
 const rule = {
@@ -18,10 +17,12 @@ const rule = {
     'An Invoice that contains an Invoice line (BG-25) where the Invoiced item VAT category code (BT-151) is "Reverse charge" shall contain the Seller VAT Identifier (BT-31), the Seller Tax registration identifier (BT-32) and/or the Seller tax representative VAT identifier (BT-63) and the Buyer VAT identifier (BT-48) and/or the Buyer legal registration identifier (BT-47).',
 } as const satisfies SchematronRule;
 
-export function validateCenEn16931BrAe02(document: PeppolDocument): SchematronRuleResult {
+function evaluateCenEn16931BrAe02(document: PeppolDocument): boolean {
   const passed =
     !hasLineVatCategoryCode(document, 'AE') ||
     ((hasSellerTaxIdentifier(document) || hasTaxRepresentativeVatCompanyId(document)) &&
       (hasBuyerVatCompanyId(document) || hasBuyerLegalCompanyId(document)));
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateCenEn16931BrAe02 = schematronRule(rule, evaluateCenEn16931BrAe02);

package/src/schematron/cen/ae/cen-en16931-br-ae-03.ts

@@ -1,6 +1,5 @@
-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 {
   hasBuyerLegalCompanyId,
@@ -8,7 +7,7 @@ import {
   hasDocumentAllowanceVatCategoryCode,
   hasSellerTaxIdentifier,
   hasTaxRepresentativeVatCompanyId,
-  schematronResult,
+  schematronRule,
 } from '#/schematron/helpers';
 
 const rule = {
@@ -18,10 +17,12 @@ const rule = {
     'An Invoice that contains a Document level allowance (BG-20) where the Document level allowance VAT category code (BT-95) is "Reverse charge" shall contain the Seller VAT Identifier (BT-31), the Seller tax registration identifier (BT-32) and/or the Seller tax representative VAT identifier (BT-63) and the Buyer VAT identifier (BT-48) and/or the Buyer legal registration identifier (BT-47).',
 } as const satisfies SchematronRule;
 
-export function validateCenEn16931BrAe03(document: PeppolDocument): SchematronRuleResult {
+function evaluateCenEn16931BrAe03(document: PeppolDocument): boolean {
   const passed =
     !hasDocumentAllowanceVatCategoryCode(document, 'AE') ||
     ((hasSellerTaxIdentifier(document) || hasTaxRepresentativeVatCompanyId(document)) &&
       (hasBuyerVatCompanyId(document) || hasBuyerLegalCompanyId(document)));
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateCenEn16931BrAe03 = schematronRule(rule, evaluateCenEn16931BrAe03);

package/src/schematron/cen/ae/cen-en16931-br-ae-04.ts

@@ -1,6 +1,5 @@
-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 {
   hasBuyerLegalCompanyId,
@@ -8,7 +7,7 @@ import {
   hasDocumentChargeVatCategoryCode,
   hasSellerTaxIdentifier,
   hasTaxRepresentativeVatCompanyId,
-  schematronResult,
+  schematronRule,
 } from '#/schematron/helpers';
 
 const rule = {
@@ -18,10 +17,12 @@ const rule = {
     'An Invoice that contains a Document level charge (BG-21) where the Document level charge VAT category code (BT-102) is "Reverse charge" shall contain the Seller VAT Identifier (BT-31), the Seller tax registration identifier (BT-32) and/or the Seller tax representative VAT identifier (BT-63) and the Buyer VAT identifier (BT-48) and/or the Buyer legal registration identifier (BT-47).',
 } as const satisfies SchematronRule;
 
-export function validateCenEn16931BrAe04(document: PeppolDocument): SchematronRuleResult {
+function evaluateCenEn16931BrAe04(document: PeppolDocument): boolean {
   const passed =
     !hasDocumentChargeVatCategoryCode(document, 'AE') ||
     ((hasSellerTaxIdentifier(document) || hasTaxRepresentativeVatCompanyId(document)) &&
       (hasBuyerVatCompanyId(document) || hasBuyerLegalCompanyId(document)));
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateCenEn16931BrAe04 = schematronRule(rule, evaluateCenEn16931BrAe04);

package/src/schematron/cen/ae/cen-en16931-br-ae-05.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 { everyLineCategoryPercent, schematronResult } from '#/schematron/helpers';
+import { everyLineCategoryPercent, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'CEN-EN16931-BR-AE-05',
@@ -11,7 +10,9 @@ const rule = {
     'In an Invoice line (BG-25) where the Invoiced item VAT category code (BT-151) is "Reverse charge" the Invoiced item VAT rate (BT-152) shall be 0 (zero).',
 } as const satisfies SchematronRule;
 
-export function validateCenEn16931BrAe05(document: PeppolDocument): SchematronRuleResult {
+function evaluateCenEn16931BrAe05(document: PeppolDocument): boolean {
   const passed = everyLineCategoryPercent(document, 'AE', percent => percent === 0);
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateCenEn16931BrAe05 = schematronRule(rule, evaluateCenEn16931BrAe05);

package/src/schematron/cen/ae/cen-en16931-br-ae-06.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 { everyDocumentAllowanceCategoryPercent, schematronResult } from '#/schematron/helpers';
+import { everyDocumentAllowanceCategoryPercent, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'CEN-EN16931-BR-AE-06',
@@ -11,7 +10,9 @@ const rule = {
     'In a Document level allowance (BG-20) where the Document level allowance VAT category code (BT-95) is "Reverse charge" the Document level allowance VAT rate (BT-96) shall be 0 (zero).',
 } as const satisfies SchematronRule;
 
-export function validateCenEn16931BrAe06(document: PeppolDocument): SchematronRuleResult {
+function evaluateCenEn16931BrAe06(document: PeppolDocument): boolean {
   const passed = everyDocumentAllowanceCategoryPercent(document, 'AE', percent => percent === 0);
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateCenEn16931BrAe06 = schematronRule(rule, evaluateCenEn16931BrAe06);

package/src/schematron/cen/ae/cen-en16931-br-ae-07.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 { everyDocumentChargeCategoryPercent, schematronResult } from '#/schematron/helpers';
+import { everyDocumentChargeCategoryPercent, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'CEN-EN16931-BR-AE-07',
@@ -11,7 +10,9 @@ const rule = {
     'In a Document level charge (BG-21) where the Document level charge VAT category code (BT-102) is "Reverse charge" the Document level charge VAT rate (BT-103) shall be 0 (zero).',
 } as const satisfies SchematronRule;
 
-export function validateCenEn16931BrAe07(document: PeppolDocument): SchematronRuleResult {
+function evaluateCenEn16931BrAe07(document: PeppolDocument): boolean {
   const passed = everyDocumentChargeCategoryPercent(document, 'AE', percent => percent === 0);
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateCenEn16931BrAe07 = schematronRule(rule, evaluateCenEn16931BrAe07);

package/src/schematron/cen/ae/cen-en16931-br-ae-08.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 { amountsEqual, categoryTaxableSum, getTaxSubtotalsWithCode, schematronResult } from '#/schematron/helpers';
+import { amountsEqual, categoryTaxableSum, getTaxSubtotalsWithCode, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'CEN-EN16931-BR-AE-08',
@@ -11,7 +10,9 @@ const rule = {
     'In a VAT breakdown (BG-23) where the VAT category code (BT-118) is "Reverse charge" the VAT category taxable amount (BT-116) shall equal the sum of Invoice line net amounts (BT-131) minus the sum of Document level allowance amounts (BT-92) plus the sum of Document level charge amounts (BT-99) where the VAT category codes (BT-151, BT-95, BT-102) are "Reverse charge".',
 } as const satisfies SchematronRule;
 
-export function validateCenEn16931BrAe08(document: PeppolDocument): SchematronRuleResult {
+function evaluateCenEn16931BrAe08(document: PeppolDocument): boolean {
   const passed = getTaxSubtotalsWithCode(document, 'AE').every(st => amountsEqual(st.taxableAmount, categoryTaxableSum(document, 'AE')));
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateCenEn16931BrAe08 = schematronRule(rule, evaluateCenEn16931BrAe08);

package/src/schematron/cen/ae/cen-en16931-br-ae-09.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 { getTaxSubtotalsWithCode, schematronResult } from '#/schematron/helpers';
+import { getTaxSubtotalsWithCode, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'CEN-EN16931-BR-AE-09',
@@ -11,7 +10,9 @@ const rule = {
     'The VAT category tax amount (BT-117) in a VAT breakdown (BG-23) where the VAT category code (BT-118) is "Reverse charge" shall be 0 (zero).',
 } as const satisfies SchematronRule;
 
-export function validateCenEn16931BrAe09(document: PeppolDocument): SchematronRuleResult {
+function evaluateCenEn16931BrAe09(document: PeppolDocument): boolean {
   const passed = getTaxSubtotalsWithCode(document, 'AE').every(st => st.taxAmount === 0);
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateCenEn16931BrAe09 = schematronRule(rule, evaluateCenEn16931BrAe09);

package/src/schematron/cen/ae/cen-en16931-br-ae-10.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 { getTaxSubtotalsWithCode, schematronResult } from '#/schematron/helpers';
+import { getTaxSubtotalsWithCode, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'CEN-EN16931-BR-AE-10',
@@ -11,9 +10,11 @@ const rule = {
     'A VAT breakdown (BG-23) with VAT Category code (BT-118) "Reverse charge" shall have a VAT exemption reason code (BT-121), meaning "Reverse charge" or the VAT exemption reason text (BT-120) "Reverse charge" (or the equivalent standard text in another language).',
 } as const satisfies SchematronRule;
 
-export function validateCenEn16931BrAe10(document: PeppolDocument): SchematronRuleResult {
+function evaluateCenEn16931BrAe10(document: PeppolDocument): boolean {
   const passed = getTaxSubtotalsWithCode(document, 'AE').every(
     st => typeof st.taxCategory.taxExemptionReason === 'string' || typeof st.taxCategory.taxExemptionReasonCode === 'string'
   );
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateCenEn16931BrAe10 = schematronRule(rule, evaluateCenEn16931BrAe10);

package/src/schematron/cen/af/cen-en16931-br-af-01.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 { countVatBreakdownCode, hasAnyVatCategoryCode, schematronResult } from '#/schematron/helpers';
+import { countVatBreakdownCode, hasAnyVatCategoryCode, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'CEN-EN16931-BR-AF-01',
@@ -11,7 +10,9 @@ const rule = {
     'An Invoice that contains an Invoice line (BG-25), a Document level allowance (BG-20) or a Document level charge (BG-21) where the VAT category code (BT-151, BT-95 or BT-102) is "IGIC" shall contain in the VAT breakdown (BG-23) at least one VAT category code (BT-118) equal with "IGIC".',
 } as const satisfies SchematronRule;
 
-export function validateCenEn16931BrAf01(document: PeppolDocument): SchematronRuleResult {
+function evaluateCenEn16931BrAf01(document: PeppolDocument): boolean {
   const passed = !hasAnyVatCategoryCode(document, 'L') || countVatBreakdownCode(document, 'L') > 0;
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateCenEn16931BrAf01 = schematronRule(rule, evaluateCenEn16931BrAf01);

package/src/schematron/cen/af/cen-en16931-br-af-02.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 { hasLineVatCategoryCode, hasSellerTaxIdentifier, hasTaxRepresentativeVatCompanyId, schematronResult } from '#/schematron/helpers';
+import { hasLineVatCategoryCode, hasSellerTaxIdentifier, hasTaxRepresentativeVatCompanyId, schematronRule } from '#/schematron/helpers';
 
 const rule = {
   id: 'CEN-EN16931-BR-AF-02',
@@ -11,7 +10,9 @@ const rule = {
     'An Invoice that contains an Invoice line (BG-25) where the Invoiced item VAT category code (BT-151) is "IGIC" shall contain the Seller VAT Identifier (BT-31), the Seller tax registration identifier (BT-32) and/or the Seller tax representative VAT identifier (BT-63).',
 } as const satisfies SchematronRule;
 
-export function validateCenEn16931BrAf02(document: PeppolDocument): SchematronRuleResult {
+function evaluateCenEn16931BrAf02(document: PeppolDocument): boolean {
   const passed = !hasLineVatCategoryCode(document, 'L') || hasSellerTaxIdentifier(document) || hasTaxRepresentativeVatCompanyId(document);
-  return schematronResult(rule, passed);
+  return passed;
 }
+
+export const validateCenEn16931BrAf02 = schematronRule(rule, evaluateCenEn16931BrAf02);