@endevops/peppol-schema 0.1.3 → 0.1.4

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

@@ -1,21 +1,19 @@
 import { Schema } from 'effect';
 
+import { opaque } from '#/schemas/utils/opaque.ts';
 import { invoiceTypeCodesKeys } from '#/values/invoice-type-codes.generated';
 
 /**
- * @description An invoice type code as defined by the PEPPOL subset of UNCL 1001 (invoice).
+ * @description An invoice type code from the PEPPOL subset of UNCL 1001.
  *
- * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL1001-inv/
- */
-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 An Effect schema that accepts only valid invoice type codes.
+ * @example
+ *   ```ts
+ *   '71';
+ *   ```;
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL1001-inv/
+ * @see {@link invoiceTypeCodesKeys}
  */
-export const invoiceTypeCodeSchema = Schema.Literals(invoiceTypeCodesKeys).pipe(Schema.brand('PeppolInvoiceTypeCode'));
+export class PeppolInvoiceTypeCode extends opaque<PeppolInvoiceTypeCode>()(
+  Schema.Literals(invoiceTypeCodesKeys).pipe(Schema.brand('PeppolInvoiceTypeCode'))
+) {}

package/src/schemas/values/item-classification-codes-schema.ts

@@ -1,24 +1,22 @@
 import { Schema } from 'effect';
 
+import { opaque } from '#/schemas/utils/opaque.ts';
 import { itemClassificationCodesKeys } from '#/values/item-classification-code.generated';
 
 /**
- * @description An item classification code as defined by the PEPPOL subset of UNCL 7143.
+ * @description An item classification code from the PEPPOL subset of UNCL 7143.
  *
- * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL7143/
- */
-export type PeppolItemClassificationCode = typeof itemClassificationCodesSchema.Type;
-
-/**
- * @description Validates an item classification code against the PEPPOL subset of UNCL 7143.
- *
- * @param error - The custom error message to use when validation fails.
- *
- * @returns An Effect schema that accepts only valid item classification codes.
+ * @example
+ *   ```ts
+ *   'AA';
+ *   ```;
  *
  * @validations
  * - BR-CL-13: Item classification scheme MUST be a valid UNTDID 7143 code.
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL7143/
+ * @see {@link itemClassificationCodesKeys}
  */
-export const itemClassificationCodesSchema = Schema.Literals(itemClassificationCodesKeys).pipe(Schema.brand('PeppolItemClassificationCode'));
+export class PeppolItemClassificationCode extends opaque<PeppolItemClassificationCode>()(
+  Schema.Literals(itemClassificationCodesKeys).pipe(Schema.brand('PeppolItemClassificationCode'))
+) {}

package/src/schemas/values/mime-codes-schema.ts

@@ -1,26 +1,24 @@
 import { Schema } from 'effect';
 
+import { opaque } from '#/schemas/utils/opaque.ts';
 import { mimeCodesKeys } from '#/values/mime-codes.generated';
 
 /**
- * @description A MIME media type code (e.g. `application/pdf`) as used for attached documents.
+ * @description A MIME media type from the PEPPOL MIME code list.
  *
- * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/MimeCode/
- */
-export type PeppolMimeCode = typeof mimeCodesSchema.Type;
-
-/**
- * @description Validates a MIME media type against the PEPPOL MIME code list.
- *
- * @param error - The custom error message to use when validation fails.
- *
- * @returns An Effect schema that accepts only valid MIME types.
+ * @example
+ *   ```ts
+ *   'text/csv';
+ *   ```;
  *
  * @validations
  * - PEPPOL-EN16931-CL001: Attachment (MIME) type MUST come from the allowed list.
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/MimeCode/
+ * @see {@link mimeCodesKeys}
  */
-export const mimeCodesSchema = Schema.Literals(mimeCodesKeys)
-  .pipe(Schema.brand('PeppolMimeCode'))
-  .annotate({ documentation: 'PEPPOL-EN16931-CL001: Mime code must be according to subset of IANA code list.' });
+export class PeppolMimeCode extends opaque<PeppolMimeCode>()(
+  Schema.Literals(mimeCodesKeys)
+    .pipe(Schema.brand('PeppolMimeCode'))
+    .annotate({ documentation: 'PEPPOL-EN16931-CL001: Mime code must be according to subset of IANA code list.' })
+) {}

package/src/schemas/values/op-status-action-schema.ts

@@ -1,21 +1,19 @@
 import { Schema } from 'effect';
 
+import { opaque } from '#/schemas/utils/opaque.ts';
 import { opStatusActionKeys } from '#/values/op-status-action.generated';
 
 /**
- * @description An OpenPeppol operation status action code (e.g. the outcome of a message response).
+ * @description An OpenPeppol operation status action code from the OPStatusAction codelist.
  *
- * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/OPStatusAction/
- */
-export type PeppolOpStatusAction = typeof opStatusActionSchema.Type;
-
-/**
- * @description Validates an OpenPeppol operation status action code against the OPStatusAction codelist.
- *
- * @param error - The custom error message to use when validation fails.
- *
- * @returns An Effect schema that accepts only valid operation status action codes.
+ * @example
+ *   ```ts
+ *   'NOA';
+ *   ```;
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/OPStatusAction/
+ * @see {@link opStatusActionKeys}
  */
-export const opStatusActionSchema = Schema.Literals(opStatusActionKeys).pipe(Schema.brand('PeppolOpStatusAction'));
+export class PeppolOpStatusAction extends opaque<PeppolOpStatusAction>()(
+  Schema.Literals(opStatusActionKeys).pipe(Schema.brand('PeppolOpStatusAction'))
+) {}

package/src/schemas/values/op-status-reason-schema.ts

@@ -1,21 +1,19 @@
 import { Schema } from 'effect';
 
+import { opaque } from '#/schemas/utils/opaque.ts';
 import { opStatusReasonKeys } from '#/values/op-status-reason.generated';
 
 /**
- * @description An OpenPeppol operation status reason code (e.g. the reason for a message response outcome).
+ * @description An OpenPeppol operation status reason code from the OPStatusReason codelist.
  *
- * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/OPStatusReason/
- */
-export type PeppolOpStatusReason = typeof opStatusReasonSchema.Type;
-
-/**
- * @description Validates an OpenPeppol operation status reason code against the OPStatusReason codelist.
- *
- * @param error - The custom error message to use when validation fails.
- *
- * @returns An Effect schema that accepts only valid operation status reason codes.
+ * @example
+ *   ```ts
+ *   'NON';
+ *   ```;
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/OPStatusReason/
+ * @see {@link opStatusReasonKeys}
  */
-export const opStatusReasonSchema = Schema.Literals(opStatusReasonKeys).pipe(Schema.brand('PeppolOpStatusReason'));
+export class PeppolOpStatusReason extends opaque<PeppolOpStatusReason>()(
+  Schema.Literals(opStatusReasonKeys).pipe(Schema.brand('PeppolOpStatusReason'))
+) {}

package/src/schemas/values/participant-identifier-code-schema.ts

@@ -1,21 +1,18 @@
 import { Schema } from 'effect';
 
+import { opaque } from '#/schemas/utils/opaque.ts';
 import { participantIdentifierSchemesKeys } from '#/values/participant-identifier-schemes.generated';
 
 /**
- * @description A PEPPOL participant identifier scheme, identifying the scheme of a participant identifier (e.g. EAS codes).
+ * @description A PEPPOL participant identifier scheme from the participant identifier schemes codelist.
  *
- * @see https://docs.peppol.eu/poacc/billing/3.0/
- */
-export type PeppolParticipantIdentifierCode = typeof participantIdentifierCodeSchema.Type;
-
-/**
- * @description Validates a PEPPOL participant identifier scheme against the participant identifier schemes list.
- *
- * @param error - The custom error message to use when validation fails.
+ * @example
+ *   ```ts
+ *   '0002';
+ *   ```;
  *
- * @returns An Effect schema that accepts only valid participant identifier schemes.
+ * @see {@link participantIdentifierSchemesKeys}
  */
-export const participantIdentifierCodeSchema = Schema.Literals(participantIdentifierSchemesKeys).pipe(
-  Schema.brand('PeppolParticipantIdentifierCode')
-);
+export class PeppolParticipantIdentifierCode extends opaque<PeppolParticipantIdentifierCode>()(
+  Schema.Literals(participantIdentifierSchemesKeys).pipe(Schema.brand('PeppolParticipantIdentifierCode'))
+) {}

package/src/schemas/values/payment-means-code-schema.ts

@@ -8,25 +8,23 @@
 
 import { Schema } from 'effect';
 
+import { opaque } from '#/schemas/utils/opaque.ts';
 import { paymentMeansCodesKeys } from '#/values/payment-means-codes.generated';
 
 /**
- * @description A payment means code as defined by the PEPPOL subset of UNCL 4461.
+ * @description A payment means code from the PEPPOL subset of UNCL 4461.
  *
- * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL4461/
- */
-export type PeppolPaymentMeansCode = typeof paymentMeansCodeSchema.Type;
-
-/**
- * @description Validates a payment means code against the PEPPOL subset of UNCL 4461.
- *
- * @param error - The custom error message to use when validation fails.
- *
- * @returns An Effect schema that accepts only valid payment means codes.
+ * @example
+ *   ```ts
+ *   '1';
+ *   ```;
  *
  * @validations
  * - BR-CL-16: Payment means code MUST be a valid UNCL 4461 code.
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL4461/
+ * @see {@link paymentMeansCodesKeys}
  */
-export const paymentMeansCodeSchema = Schema.Literals(paymentMeansCodesKeys).pipe(Schema.brand('PeppolPaymentMeansCode'));
+export class PeppolPaymentMeansCodeValue extends opaque<PeppolPaymentMeansCodeValue>()(
+  Schema.Literals(paymentMeansCodesKeys).pipe(Schema.brand('PeppolPaymentMeansCodeValue'))
+) {}

package/src/schemas/values/peppol-country-code-schema.ts

@@ -9,22 +9,23 @@
 
 import { Schema } from 'effect';
 
+import { opaque } from '#/schemas/utils/opaque.ts';
 import { countryCodesKeys } from '#/values/country-code.generated';
 
 /**
- * @description An ISO 3166-1 alpha-2 country code as defined by the PEPPOL subset.
+ * @description A two character ISO 3166-1 alpha-2 country code from the PEPPOL codelist. The literal union enforces the length.
  *
- * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/ISO3166/
- */
-export type PeppolCountryCode = typeof peppolCountryCodeSchema.Type;
-
-/**
- * @description Validates a two character ISO 3166-1 alpha-2 country code against the PEPPOL codelist. All codes in the codelist are exactly 2 characters, so the
- * literals union implies the length check.
+ * @example
+ *   ```ts
+ *   'AD';
+ *   ```;
  *
  * @validations
  * - BR-CL-14 / BR-CL-15: Country code MUST be a valid ISO 3166-1 alpha-2 code.
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/ISO3166/
+ * @see {@link countryCodesKeys}
  */
-export const peppolCountryCodeSchema = Schema.Literals(countryCodesKeys).pipe(Schema.brand('PeppolCountryCode'));
+export class PeppolCountryCodeValue extends opaque<PeppolCountryCodeValue>()(
+  Schema.Literals(countryCodesKeys).pipe(Schema.brand('PeppolCountryCodeValue'))
+) {}

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

@@ -1,21 +1,19 @@
 import { Schema } from 'effect';
 
+import { opaque } from '#/schemas/utils/opaque.ts';
 import { documentTypeCodesKeys } from '#/values/document-type-codes.generated';
 
 /**
- * @description A document type code as defined by the PEPPOL subset of UNCL 1001 (document/message name code).
+ * @description A document type code from the PEPPOL subset of UNCL 1001.
  *
- * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL1001/
- */
-export type PeppolDocumentTypeCode = typeof peppolDocumentTypeCodeSchema.Type;
-
-/**
- * @description Validates a document type code against the PEPPOL subset of UNCL 1001.
- *
- * @param error - The custom error message to use when validation fails.
- *
- * @returns An Effect schema that accepts only valid document type codes.
+ * @example
+ *   ```ts
+ *   '1';
+ *   ```;
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL1001/
+ * @see {@link documentTypeCodesKeys}
  */
-export const peppolDocumentTypeCodeSchema = Schema.Literals(documentTypeCodesKeys).pipe(Schema.brand('PeppolDocumentTypeCode'));
+export class PeppolDocumentTypeCode extends opaque<PeppolDocumentTypeCode>()(
+  Schema.Literals(documentTypeCodesKeys).pipe(Schema.brand('PeppolDocumentTypeCode'))
+) {}

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

@@ -2,30 +2,21 @@ import { Predicate, Schema } from 'effect';
 
 import type { DocumentTypesTableKeys } from '#/values/document-type.generated';
 
+import { opaque } from '#/schemas/utils/opaque.ts';
 import { documentTypesTable, documentTypesTableKeys } from '#/values/document-type.generated';
 
 /**
- * @description One of the PEPPOL document type schemes (e.g. `busdox-docid-qns`, `peppol-doctype-wildcard`).
+ * @description A full PEPPOL document type identifier in `<scheme>::<value>` form. The scheme prefix and value must both be known.
  *
  * @see {@link documentTypesTable}
  */
-export type PeppolDocumentType = typeof peppolDocumentTypeSchema.Type;
-
-/**
- * @description Validates a full PEPPOL document type identifier (`<scheme>::<value>`) against the known document type table. The scheme prefix must be a known key
- * and the full identifier must exist in the document type table (checked via a filter).
- *
- * @param error - The custom error message to use when validation fails. Defaults to `'invalid peppol document type'`.
- *
- * @returns An Effect schema that matches a valid `scheme::value` document type identifier.
- *
- * @see {@link documentTypesTable}
- */
-export const peppolDocumentTypeSchema = Schema.TemplateLiteral([Schema.Literals(documentTypesTableKeys), Schema.Literal('::'), Schema.String]).check(
-  Schema.makeFilter((val: string) => {
-    const [prefix, ...suffix] = val.split('::');
-    if (Predicate.isNullish(prefix) || !documentTypesTableKeys.includes(prefix as never)) return false;
-    const info = documentTypesTable[prefix as DocumentTypesTableKeys];
-    return Predicate.isNotNullish(info) && info.some(v => v === suffix.join('::'));
-  })
-);
+export class PeppolDocumentType extends opaque<PeppolDocumentType>()(
+  Schema.TemplateLiteral([Schema.Literals(documentTypesTableKeys), Schema.Literal('::'), Schema.String]).check(
+    Schema.makeFilter((val: string) => {
+      const [prefix, ...suffix] = val.split('::');
+      if (Predicate.isNullish(prefix) || !documentTypesTableKeys.includes(prefix as never)) return false;
+      const info = documentTypesTable[prefix as DocumentTypesTableKeys];
+      return Predicate.isNotNullish(info) && info.some(v => v === suffix.join('::'));
+    })
+  )
+) {}

package/src/schemas/values/peppol-process-schema.ts

@@ -2,29 +2,33 @@ import { Schema } from 'effect';
 
 import type { ProcessesKeys } from '#/values/processes.generated';
 
+import { opaque } from '#/schemas/utils/opaque.ts';
 import { processes, processesKeys } from '#/values/processes.generated';
 
 /**
- * @description A PEPPOL business process identifier key as defined by the processes codelist.
+ * @description A full PEPPOL business process identifier in `<scheme>::<value>` form from the known processes table.
+ *
+ * @example
+ *   ```ts
+ *   'cenbii-procid-ubl::urn:fdc:peppol.eu:2017:poacc:billing:01:1.0';
+ *   ```;
  *
  * @see {@link processes}
  */
-export type PeppolProcesses = typeof peppolProcessSchema.Encoded;
+export class PeppolProcess extends opaque<PeppolProcess>()(
+  Schema.TemplateLiteral([Schema.Literals(processesKeys), Schema.Literal('::'), Schema.String]).check(
+    Schema.makeFilter((val: string) => {
+      const [prefix, suffix] = val.split('::');
+      if (prefix === undefined || suffix === undefined) return false;
+      const info = processes[prefix as ProcessesKeys];
+      return info !== undefined && info.some(v => v === suffix);
+    })
+  )
+) {}
 
 /**
- * @description Validates a full PEPPOL business process identifier (`<scheme>::<value>`) against the known processes.
- *
- * @param error - The custom error message to use when validation fails. Defaults to `'invalid peppol process identifier'`.
- *
- * @returns An Effect schema that matches a valid `scheme::value` process identifier.
+ * @description A PEPPOL business process identifier key as defined by the processes codelist.
  *
  * @see {@link processes}
  */
-export const peppolProcessSchema = Schema.TemplateLiteral([Schema.Literals(processesKeys), Schema.Literal('::'), Schema.String]).check(
-  Schema.makeFilter((val: string) => {
-    const [prefix, suffix] = val.split('::');
-    if (prefix === undefined || suffix === undefined) return false;
-    const info = processes[prefix as ProcessesKeys];
-    return info !== undefined && info.some(v => v === suffix);
-  })
-);
+export type PeppolProcesses = Schema.Codec.Encoded<typeof PeppolProcess>;

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

@@ -2,7 +2,7 @@ import { Schema } from 'effect';
 
 import type { PeppolDocumentType } from '#/schemas/values/peppol-document-type-schema.ts';
 
-import { peppolProcessSchema } from '#/schemas/values/peppol-process-schema.ts';
+import { PeppolProcess } from '#/schemas/values/peppol-process-schema.ts';
 import { documentTypesProcessIds } from '#/values/document-type.generated';
 
 /**
@@ -13,13 +13,13 @@ import { documentTypesProcessIds } from '#/values/document-type.generated';
  *
  * @returns An Effect schema that matches only processes allowed for the given document type.
  *
- * @see {@link peppolProcessSchema}
+ * @see {@link PeppolProcess}
  * @see {@link documentTypesProcessIds}
  */
 export function processFromDocumentTypeSchema(documentType: PeppolDocumentType, error = 'invalid process type for document type') {
   const allowed = documentTypesProcessIds[documentType as keyof typeof documentTypesProcessIds];
   if (allowed === undefined) {
-    return peppolProcessSchema;
+    return PeppolProcess;
   }
   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,24 +1,22 @@
 import { Schema } from 'effect';
 
+import { opaque } from '#/schemas/utils/opaque.ts';
 import { quantityUnitCodesKeys } from '#/values/quantity-unit-codes.generated';
 
 /**
- * @description A unit of measure code as defined by the PEPPOL subset of UN/ECE Recommendation 20.
+ * @description A unit of measure code from the PEPPOL subset of UN/ECE Recommendation 20.
  *
- * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNECERec20/
- */
-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 An Effect schema that accepts only valid quantity unit codes.
+ * @example
+ *   ```ts
+ *   '10';
+ *   ```;
  *
  * @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/
+ * @see {@link quantityUnitCodesKeys}
  */
-export const quantityUnitCodesSchema = Schema.Literals(quantityUnitCodesKeys).pipe(Schema.brand('PeppolQuantityUnitCode'));
+export class PeppolQuantityUnitCode extends opaque<PeppolQuantityUnitCode>()(
+  Schema.Literals(quantityUnitCodesKeys).pipe(Schema.brand('PeppolQuantityUnitCode'))
+) {}

package/src/schemas/values/vat-date-code-schema.ts

@@ -1,13 +1,20 @@
 import { Schema } from 'effect';
 
-import type { VatDateCodesKeys } from '#/values/vat-dates.generated';
-
+import { opaque } from '#/schemas/utils/opaque.ts';
 import { vatDateCodesKeys } from '#/values/vat-dates.generated';
 
-export type PeppolVatDateCode = VatDateCodesKeys;
-
 /**
+ * @description A VAT date code from the PEPPOL subset of UNCL 2005 (invoice period description code).
+ *
+ * @example
+ *   ```ts
+ *   '3';
+ *   ```;
+ *
  * @validations
  * - PEPPOL-EN16931-CL006: Invoice period description code must be according to UNCL 2005 D.16B.
+ *
+ * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL2005/
+ * @see {@link vatDateCodesKeys}
  */
-export const vatDateCodeSchema = Schema.Literals(vatDateCodesKeys);
+export class PeppolVatDateCode extends opaque<PeppolVatDateCode>()(Schema.Literals(vatDateCodesKeys)) {}

package/src/schemas/values/vatex-code-schema.ts

@@ -1,24 +1,20 @@
 import { Schema } from 'effect';
 
+import { opaque } from '#/schemas/utils/opaque.ts';
 import { vatexCodesKeys } from '#/values/vatex-codes.generated';
 
 /**
- * @description A VAT exemption reason code as defined by the CEF VATEX codelist.
+ * @description A VAT exemption reason code from the CEF VATEX codelist.
  *
- * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/vatex/
- */
-export type PeppolVatexCode = typeof vatexCodeSchema.Type;
-
-/**
- * @description Validates a VAT exemption reason code against the CEF VATEX codelist.
- *
- * @param error - The custom error message to use when validation fails.
- *
- * @returns An Effect schema that accepts only valid VAT exemption reason codes.
+ * @example
+ *   ```ts
+ *   'VATEX-EU-79-C';
+ *   ```;
  *
  * @validations
  * - BR-CL-22: VAT exemption reason code MUST be a valid CEF VATEX code.
  *
  * @see https://docs.peppol.eu/poacc/billing/3.0/codelist/vatex/
+ * @see {@link vatexCodesKeys}
  */
-export const vatexCodeSchema = Schema.Literals(vatexCodesKeys).pipe(Schema.brand('PeppolVatexCode'));
+export class PeppolVatexCode extends opaque<PeppolVatexCode>()(Schema.Literals(vatexCodesKeys).pipe(Schema.brand('PeppolVatexCode'))) {}

package/src/schematron/errors.ts

@@ -2,6 +2,13 @@ import { Schema } from 'effect';
 
 /**
  * @description Failure of a single schematron rule against a document.
+ *
+ * @example
+ *   ```ts
+ *   new SchematronRuleError({ id: 'PEPPOL-EN16931-R001', level: 'fatal', message: 'The document must carry a number.' });
+ *   ```;
+ *
+ * @see {@link SchematronValidationError}
  */
 export class SchematronRuleError extends Schema.TaggedError<SchematronRuleError>()('SchematronRuleError', {
   id: Schema.String,
@@ -11,6 +18,13 @@ export class SchematronRuleError extends Schema.TaggedError<SchematronRuleError>
 
 /**
  * @description Failure of a schematron validation run, wrapping every rule that failed.
+ *
+ * @example
+ *   ```ts
+ *   new SchematronValidationError({ errors: [ruleError] });
+ *   ```;
+ *
+ * @see {@link SchematronRuleError}
  */
 export class SchematronValidationError extends Schema.TaggedError<SchematronValidationError>()('SchematronValidationError', {
   errors: Schema.Array(SchematronRuleError),