@endevops/peppol-schema 0.1.0-beta.1 → 0.1.0-beta.2

package/src/effect/peppol-document-schema.ts

@@ -0,0 +1,107 @@
+import type { AllUnionFields } from 'type-fest';
+
+import { Effect, Equal, Predicate, Schema, SchemaGetter, SchemaIssue } from 'effect';
+import XMLBuilder from 'fast-xml-builder';
+import { XMLParser } from 'fast-xml-parser';
+
+import type { peppolCreditNoteLineSchema } from '#/effect/fields/peppol-credit-note-line-schema';
+import type { peppolInvoiceLineSchema } from '#/effect/fields/peppol-invoice-line-schema';
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolCreditNote as ZodPeppolCreditNote } from '#/schemas/credit-note';
+import type { PeppolInvoice as ZodPeppolInvoice } from '#/schemas/invoice';
+import type { PeppolInvoiceResponse as ZodPeppolInvoiceResponse } from '#/schemas/invoice-response-schema';
+import type { PeppolMessageLevelResponse as ZodPeppolMessageLevelResponse } from '#/schemas/message-level-response-schema';
+
+import { INVOICE_RESPONSE_PROFILE_ID } from '#/constants/invoice-response-profile-id';
+import { MESSAGE_LEVEL_RESPONSE_PROFILE_ID } from '#/constants/message-level-response-profile-id';
+import { decodeCreditNote } from '#/decoders/decode-credit-note';
+import { decodeInvoice } from '#/decoders/decode-invoice';
+import { decodeInvoiceResponse } from '#/decoders/decode-invoice-response';
+import { decodeMessageLevelResponse } from '#/decoders/decode-message-level-response';
+import { encodeCreditNote } from '#/decoders/encode-credit-note';
+import { encodeInvoice } from '#/decoders/encode-invoice';
+import { encodeInvoiceResponse } from '#/decoders/encode-invoice-response';
+import { encodeMessageLevelResponse } from '#/decoders/encode-message-level-response';
+import { strOrUnd } from '#/helpers/str-or-und';
+import { builderOptions } from '#/xml/builder-options';
+import { parserOptions } from '#/xml/parser-options';
+
+import { peppolCreditNoteSchema } from './peppol-credit-note-schema';
+import { peppolInvoiceResponseSchema } from './peppol-invoice-response-schema';
+import { peppolInvoiceSchema } from './peppol-invoice-schema';
+import { peppolMessageLevelResponseSchema } from './peppol-message-level-response-schema';
+
+export class PeppolInvalidDocumentType extends Schema.TaggedError<PeppolInvalidDocumentType>()('PeppolInvalidDocumentType', {
+  message: Schema.String,
+  rootNodes: Schema.Array(Schema.String),
+}) {}
+
+/**
+ * @description Union of every supported PEPPOL business document (Effect port of the `z.xor` side of `documentParser`). Members discriminate cleanly: invoice vs
+ * credit note via `invoiceLines`/`creditNoteLines`, message-level vs invoice response via the `profileId` literal.
+ */
+export const peppolDocumentSchema = Schema.Union([
+  peppolInvoiceSchema,
+  peppolCreditNoteSchema,
+  peppolMessageLevelResponseSchema,
+  peppolInvoiceResponseSchema,
+]).pipe(
+  Schema.encodeTo(Schema.String, {
+    encode: SchemaGetter.transformEffect(
+      Effect.fn(function* (document) {
+        let content: unknown;
+        if (Predicate.hasProperty(document, 'invoiceLines')) {
+          content = encodeInvoice(document as unknown as ZodPeppolInvoice);
+        } else if (Predicate.hasProperty(document, 'creditNoteLines')) {
+          content = encodeCreditNote(document as unknown as ZodPeppolCreditNote);
+        } else if (Predicate.hasProperty(document, 'documentResponse')) {
+          if (Equal.equals(document.profileId, MESSAGE_LEVEL_RESPONSE_PROFILE_ID)) {
+            content = encodeMessageLevelResponse(document as unknown as ZodPeppolMessageLevelResponse);
+          } else if (Equal.equals(document.profileId, INVOICE_RESPONSE_PROFILE_ID)) {
+            content = encodeInvoiceResponse(document as unknown as ZodPeppolInvoiceResponse);
+          }
+        }
+
+        const builder = new XMLBuilder(builderOptions);
+        return builder.build(content);
+      })
+    ),
+    decode: SchemaGetter.transformEffect(
+      Effect.fn(function* (value, options) {
+        const parser = new XMLParser({ ...parserOptions, removeNSPrefix: true });
+        const parsed: XmlNode = parser.parse(value);
+
+        if (Predicate.isNotNullish(parsed.Invoice)) {
+          return decodeInvoice(parsed) as typeof peppolInvoiceSchema.Type;
+        } else if (Predicate.isNotNullish(parsed.CreditNote)) {
+          return decodeCreditNote(parsed) as typeof peppolCreditNoteSchema.Type;
+        } else if (Predicate.isNotNullish(parsed.ApplicationResponse)) {
+          const profile = strOrUnd(parsed.ApplicationResponse, 'cbc:ProfileID');
+          if (Equal.equals(profile, MESSAGE_LEVEL_RESPONSE_PROFILE_ID)) {
+            return decodeMessageLevelResponse(parsed) as typeof peppolMessageLevelResponseSchema.Type;
+          } else if (Equal.equals(profile, INVOICE_RESPONSE_PROFILE_ID)) {
+            return decodeInvoiceResponse(parsed) as typeof peppolInvoiceResponseSchema.Type;
+          }
+        }
+
+        return yield* Effect.fail(
+          new SchemaIssue.InvalidValue({ message: `Unsupported document type: ${Object.keys(parsed).join(',')}` }, value, options)
+        );
+      })
+    ),
+  })
+);
+
+export type PeppolDocumentEncoded = string;
+export interface PeppolDocumentDecoded extends AllUnionFields<typeof peppolDocumentSchema.Type> {}
+
+/**
+ * @description This defines the types of documents that are sent/received through the peppol network.
+ */
+export interface PeppolDocument extends AllUnionFields<typeof peppolInvoiceSchema.Type | typeof peppolCreditNoteSchema.Type> {}
+/**
+ * @description This defines the types of message that are sent/received through the peppol network.
+ */
+export interface PeppolMessage extends AllUnionFields<typeof peppolMessageLevelResponseSchema.Type | typeof peppolInvoiceResponseSchema.Type> {}
+export interface PeppolAllDocuments extends AllUnionFields<PeppolDocument | PeppolMessage> {}
+export interface PeppolDocumentLine extends AllUnionFields<typeof peppolInvoiceLineSchema.Type | typeof peppolCreditNoteLineSchema.Type> {}

package/src/effect/{invoice-response-document-actual-response.ts → peppol-invoice-response-document-actual-response-schema.ts}

@@ -3,13 +3,13 @@ import { Schema } from 'effect';
 import { invoiceResponseCodeNeedsSchema } from '#/invoice-response-codes/invoice-response-code-needs-schema';
 import { invoiceResponseCodeNotNeedsSchema } from '#/invoice-response-codes/invoice-response-code-not-needs-schema';
 
-import { invoiceReponseDocumentActualResponseStatus } from './invoice-response-document-actual-response-status';
-import { IsoDateString } from './iso-date-string';
+import { peppolInvoiceResponseDocumentActualResponseStatusSchema } from './peppol-invoice-response-document-actual-response-status-schema';
+import { peppolIsoDateStringSchema } from './peppol-iso-date-string-schema';
 
 const withStatusCodes = Schema.Literals(invoiceResponseCodeNeedsSchema);
 const withoutStatusCodes = Schema.Literals(invoiceResponseCodeNotNeedsSchema);
 
-export const invoiceResponseDocumentActualResponse = Schema.Union([
+export const peppolInvoiceResponseDocumentActualResponseSchema = Schema.Union([
   Schema.Struct({
     /**
      * @remarks
@@ -30,7 +30,7 @@ export const invoiceResponseDocumentActualResponse = Schema.Union([
      *
      * @name `cbc:EffectiveDate`
      */
-    effectiveDate: Schema.optional(IsoDateString),
+    effectiveDate: Schema.optional(peppolIsoDateStringSchema),
     /**
      * @description Clarification is mendatory when the status is UQ-`under query`,RE-`rejected` and `CA`-Conditionally accepted. Clarification may be given as a
      * code, a description or both. If both are used, they must indicate the same clarification.
@@ -39,7 +39,7 @@ export const invoiceResponseDocumentActualResponse = Schema.Union([
      *
      * @name `cac:Status`
      */
-    status: Schema.Array(invoiceReponseDocumentActualResponseStatus).check(Schema.isMinLength(1)),
+    status: Schema.Array(peppolInvoiceResponseDocumentActualResponseStatusSchema).check(Schema.isMinLength(1)),
   }),
   Schema.Struct({
     /**
@@ -58,7 +58,7 @@ export const invoiceResponseDocumentActualResponse = Schema.Union([
      *
      * @name `cbc:EffectiveDate`
      */
-    effectiveDate: Schema.optional(IsoDateString),
+    effectiveDate: Schema.optional(peppolIsoDateStringSchema),
     /**
      * @description Clarification is mendatory when the status is UQ-`under query`,RE-`rejected` and `CA`-Conditionally accepted. Clarification may be given as a
      * code, a description or both. If both are used, they must indicate the same clarification.
@@ -67,8 +67,8 @@ export const invoiceResponseDocumentActualResponse = Schema.Union([
      *
      * @name `cac:Status`
      */
-    status: Schema.optional(Schema.Array(invoiceReponseDocumentActualResponseStatus)),
+    status: Schema.optional(Schema.Array(peppolInvoiceResponseDocumentActualResponseStatusSchema)),
   }),
 ]);
 
-export type InvoiceResponseDocumentActualResponse = typeof invoiceResponseDocumentActualResponse.Type;
+export type InvoiceResponseDocumentActualResponse = typeof peppolInvoiceResponseDocumentActualResponseSchema.Type;

package/src/effect/{invoice-response-document-actual-response-status.ts → peppol-invoice-response-document-actual-response-status-schema.ts}

@@ -1,6 +1,6 @@
 import { Schema } from 'effect';
 
-import { invoiceResponseStatusReasonCode } from './invoice-response-status-reason-code';
+import { peppolInvoiceResponseStatusReasonCodeSchema } from './peppol-invoice-response-status-reason-code-schema';
 
 const invoiceResponseCondition = Schema.Struct({
   /**
@@ -29,7 +29,7 @@ const invoiceResponseCondition = Schema.Struct({
 
 export type InvoiceResponseCondition = typeof invoiceResponseCondition.Type;
 
-export const invoiceReponseDocumentActualResponseStatus = Schema.Struct({
+export const peppolInvoiceResponseDocumentActualResponseStatusSchema = Schema.Struct({
   /**
    * @description A code defining a clarification given for the invoice status.
    *
@@ -37,7 +37,7 @@ export const invoiceReponseDocumentActualResponseStatus = Schema.Struct({
    *
    * @name `cbc:StatusReasonCode`
    */
-  statusReasonCode: Schema.optional(invoiceResponseStatusReasonCode),
+  statusReasonCode: Schema.optional(peppolInvoiceResponseStatusReasonCodeSchema),
   /**
    * @description The description of the clarification given for the invoice status.
    *
@@ -57,4 +57,4 @@ export const invoiceReponseDocumentActualResponseStatus = Schema.Struct({
   condition: Schema.optional(Schema.Array(invoiceResponseCondition)),
 });
 
-export type InvoiceReponseDocumentActualResponseStatus = typeof invoiceReponseDocumentActualResponseStatus.Type;
+export type InvoiceResponseDocumentActualResponseStatus = typeof peppolInvoiceResponseDocumentActualResponseStatusSchema.Type;

package/src/effect/{invoice-response-schema.ts → peppol-invoice-response-schema.ts}

@@ -2,42 +2,42 @@ import { Schema, Struct } from 'effect';
 
 import { INVOICE_RESPONSE_PROFILE_ID } from '#/constants/invoice-response-profile-id';
 
-import { contactSchema } from './fields/contact-schema';
 import { identifierSchema } from './fields/identifier-schema';
-import { partyLegalEntitySchema } from './fields/party-legal-entity-schema';
-import { invoiceResponseDocumentActualResponse } from './invoice-response-document-actual-response';
-import { IsoDateString } from './iso-date-string';
-import { messageLevelResponsePartySchema } from './message-level-response-party-schema';
-import { messageLevelResponse } from './message-level-response-schema';
-import { documentTypeCodeSchema } from './values/document-type-codes';
+import { peppolContactSchema } from './fields/peppol-contact-schema';
+import { peppolPartyLegalEntitySchema } from './fields/peppol-party-legal-entity-schema';
+import { peppolInvoiceResponseDocumentActualResponseSchema } from './peppol-invoice-response-document-actual-response-schema';
+import { peppolIsoDateStringSchema } from './peppol-iso-date-string-schema';
+import { peppolMessageLevelResponsePartySchema } from './peppol-message-level-response-party-schema';
+import { peppolMessageLevelResponseSchema } from './peppol-message-level-response-schema';
+import { peppolDocumentTypeCodeSchema } from './values/peppol-document-type-code-schema';
 
-const invoiceResponsePartySchema = messageLevelResponsePartySchema.pipe(
+export const peppolInvoiceResponsePartySchema = peppolMessageLevelResponsePartySchema.pipe(
   Schema.fieldsAssign({
     /**
      * @summary Party partyIdentification
      */
     partyIdentification: Schema.optional(identifierSchema()),
-    partyLegalEntity: partyLegalEntitySchema.mapFields(Struct.pick(['registrationName'])),
+    partyLegalEntity: peppolPartyLegalEntitySchema.mapFields(Struct.pick(['registrationName'])),
   })
 );
 
-const invoiceResponseSenderPartySchema = invoiceResponsePartySchema.pipe(
+export const peppolInvoiceResponseSenderPartySchema = peppolInvoiceResponsePartySchema.pipe(
   Schema.fieldsAssign({
     /**
      * @summary Contact information
      *
      * @name `cac:Contact`
      */
-    contact: Schema.optional(contactSchema),
+    contact: Schema.optional(peppolContactSchema),
   })
 );
 
-export type InvoiceResponseParty = typeof invoiceResponsePartySchema.Type | typeof invoiceResponseSenderPartySchema.Type;
+export type PeppolInvoiceResponseParty = typeof peppolInvoiceResponsePartySchema.Type | typeof peppolInvoiceResponseSenderPartySchema.Type;
 
 /**
  * @description Party schema used under `cac:DocumentReference/(cac:IssuerParty|cac:RecipientParty)`
  */
-const invoiceResponseDocumentResponseParty = Schema.Struct({
+export const peppolInvoiceResponseDocumentResponsePartySchema = Schema.Struct({
   /**
    * @summary Party partyIdentification
    */
@@ -61,9 +61,9 @@ const invoiceResponseDocumentResponseParty = Schema.Struct({
   }),
 });
 
-export type InvoiceDocumentResponseParty = typeof invoiceResponseDocumentResponseParty.Type;
+export type PeppolInvoiceDocumentResponseParty = typeof peppolInvoiceResponseDocumentResponsePartySchema.Type;
 
-const invoiceResponseDocumentReferenceSchema = Schema.Struct({
+export const peppolInvoiceResponseDocumentReferenceSchema = Schema.Struct({
   /**
    * @description An identifier for the invoice that the status applies to. The invoice identifier must be of the main invoice number that appears in the invoice
    * itself.
@@ -86,19 +86,19 @@ const invoiceResponseDocumentReferenceSchema = Schema.Struct({
    *
    * @name `cbc:IssueDate`
    */
-  issueDate: Schema.optional(IsoDateString),
+  issueDate: Schema.optional(peppolIsoDateStringSchema),
   /**
    * @example
    *   `380`;
    *
    * @summary Identifier type code
    */
-  documentTypeCode: documentTypeCodeSchema(),
+  documentTypeCode: peppolDocumentTypeCodeSchema(),
 });
 
-export type InvoiceResponseDocumentReference = typeof invoiceResponseDocumentReferenceSchema.Type;
+export type PeppolInvoiceResponseDocumentReference = typeof peppolInvoiceResponseDocumentReferenceSchema.Type;
 
-const invoiceResponseDocumentResponseSchema = Schema.Struct({
+export const peppolInvoiceResponseDocumentResponseSchema = Schema.Struct({
   /**
    * @summary Response information
    *
@@ -106,44 +106,35 @@ const invoiceResponseDocumentResponseSchema = Schema.Struct({
    *
    * @cardinality (1..1)
    */
-  response: invoiceResponseDocumentActualResponse,
+  response: peppolInvoiceResponseDocumentActualResponseSchema,
   /**
    * @summary Document reference
    *
    * @name `cac:DocumentReference`
    */
-  documentReference: invoiceResponseDocumentReferenceSchema,
+  documentReference: peppolInvoiceResponseDocumentReferenceSchema,
   /**
    * @summary Seller party information
    *
    * @name `cac:IssuerParty`
    */
-  issuerParty: Schema.optional(invoiceResponseDocumentResponseParty),
+  issuerParty: Schema.optional(peppolInvoiceResponseDocumentResponsePartySchema),
   /**
    * @summary Buyer party information
    *
    * @name `cac:RecipientParty`
    */
-  recipientParty: Schema.optional(invoiceResponseDocumentResponseParty),
+  recipientParty: Schema.optional(peppolInvoiceResponseDocumentResponsePartySchema),
 });
 
-export type InvoiceResponseDocumentResponse = typeof invoiceResponseDocumentResponseSchema.Type;
-
-// Export nested party/reference/response schemas for reuse and barrel parity with zod module.
-export {
-  invoiceResponseDocumentReferenceSchema,
-  invoiceResponseDocumentResponseParty,
-  invoiceResponseDocumentResponseSchema,
-  invoiceResponsePartySchema,
-  invoiceResponseSenderPartySchema,
-};
+export type PeppolInvoiceResponseDocumentResponse = typeof peppolInvoiceResponseDocumentResponseSchema.Type;
 
 /**
  * @description The invoice response is a descendant of the message level response with more fields. Effect port of `invoiceResponseSchema`
  * (`z.extend(messageLevelResponse, ...)` → `messageLevelResponse.pipe(Schema.fieldsAssign(...))`), overriding `profileId` with
  * `Schema.Literal(INVOICE_RESPONSE_PROFILE_ID)` plus sender/receiver/documentResponse.
  */
-export const invoiceResponseSchema = messageLevelResponse.pipe(
+export const peppolInvoiceResponseSchema = peppolMessageLevelResponseSchema.pipe(
   Schema.fieldsAssign({
     profileId: Schema.Literal(INVOICE_RESPONSE_PROFILE_ID),
     /**
@@ -151,14 +142,14 @@ export const invoiceResponseSchema = messageLevelResponse.pipe(
      *
      * @summary Sender information
      */
-    senderParty: invoiceResponseSenderPartySchema,
+    senderParty: peppolInvoiceResponseSenderPartySchema,
     /**
      * @description The party, an electronic message level response was addressed to, and who is supposed to process the message level response. This is the same
      * party as the sender of the business document.
      *
      * @summary Receiver information
      */
-    receiverParty: invoiceResponsePartySchema,
+    receiverParty: peppolInvoiceResponsePartySchema,
     /**
      * @description General comments or instructions that are revelant to the response as a whole.
      *
@@ -171,8 +162,8 @@ export const invoiceResponseSchema = messageLevelResponse.pipe(
     /**
      * @summary Document response
      */
-    documentResponse: invoiceResponseDocumentResponseSchema,
+    documentResponse: peppolInvoiceResponseDocumentResponseSchema,
   })
 );
 
-export type PeppolInvoiceResponse = typeof invoiceResponseSchema.Type;
+export type PeppolInvoiceResponse = typeof peppolInvoiceResponseSchema.Type;

package/src/effect/{invoice-response-status-reason-code.ts → peppol-invoice-response-status-reason-code-schema.ts}

@@ -1,9 +1,9 @@
 import { Schema } from 'effect';
 
-import { opStatusActionSchema } from './values/op-status-action';
-import { opStatusReasonSchema } from './values/op-status-reason';
+import { opStatusActionSchema } from './values/op-status-action-schema';
+import { opStatusReasonSchema } from './values/op-status-reason-schema';
 
-export const invoiceResponseStatusReasonCode = Schema.Union([
+export const peppolInvoiceResponseStatusReasonCodeSchema = Schema.Union([
   Schema.Struct({
     value: opStatusActionSchema(),
     /**
@@ -28,4 +28,4 @@ export const invoiceResponseStatusReasonCode = Schema.Union([
   }),
 ]);
 
-export type InvoiceResponseStatusReasonCode = typeof invoiceResponseStatusReasonCode.Type;
+export type InvoiceResponseStatusReasonCode = typeof peppolInvoiceResponseStatusReasonCodeSchema.Type;

package/src/effect/{invoice.ts → peppol-invoice-schema.ts}

@@ -1,16 +1,16 @@
 import { Schema } from 'effect';
 
-import { billingBaseSchema } from './billing-base';
-import { invoiceLineSchema } from './fields/invoice-line-schema';
-import { IsoDateString } from './iso-date-string';
+import { peppolInvoiceLineSchema } from './fields/peppol-invoice-line-schema';
+import { peppolBillingBaseSchema } from './peppol-billing-base-schema';
+import { peppolIsoDateStringSchema } from './peppol-iso-date-string-schema';
 import { invoiceTypeCodeSchema } from './values/invoice-type-code-schema';
 
 /**
  * @description Main UBL Invoice schema (camelCase properties) Effect port of `invoiceSchema` (`z.extend(billingBaseSchema, ...)` →
- * `billingBaseSchema.pipe(Schema.fieldsAssign(...))`). `dueDate` stays a validated plain string via `IsoDateString` (no `Date` conversion);
- * `z.optional` maps to `Schema.optional` (accepts explicit `undefined`, matching decoder output).
+ * `peppolBillingBaseSchema.pipe(Schema.fieldsAssign(...))`). `dueDate` stays a validated plain string via `peppolIsoDateStringSchema` (no `Date`
+ * conversion); `z.optional` maps to `Schema.optional` (accepts explicit `undefined`, matching decoder output).
  */
-export const invoiceSchema = billingBaseSchema.pipe(
+export const peppolInvoiceSchema = peppolBillingBaseSchema.pipe(
   Schema.fieldsAssign({
     /**
      * @example
@@ -20,13 +20,13 @@ export const invoiceSchema = billingBaseSchema.pipe(
      *
      * @name cbc:DueDate
      */
-    dueDate: Schema.optional(IsoDateString),
+    dueDate: Schema.optional(peppolIsoDateStringSchema),
     /**
      * @summary INVOICE LINE
      *
      * @name cac:InvoiceLine
      */
-    invoiceLines: Schema.Array(invoiceLineSchema).check(Schema.isMinLength(1)),
+    invoiceLines: Schema.Array(peppolInvoiceLineSchema).check(Schema.isMinLength(1)),
     /**
      * @example
      *   380;
@@ -45,4 +45,4 @@ export const invoiceSchema = billingBaseSchema.pipe(
   })
 );
 
-export type PeppolInvoice = typeof invoiceSchema.Type;
+export type PeppolInvoice = typeof peppolInvoiceSchema.Type;

package/src/effect/{iso-date-string.ts → peppol-iso-date-string-schema.ts}

@@ -8,6 +8,6 @@ import { Schema } from 'effect';
  *
  * @see PEPPOL-EN16931-F001: A date MUST be formatted YYYY-MM-DD.
  */
-export const IsoDateString = Schema.String.check(Schema.isPattern(/^\d{4}-\d{2}-\d{2}$/));
+export const peppolIsoDateStringSchema = Schema.String.check(Schema.isPattern(/^\d{4}-\d{2}-\d{2}$/));
 
-export type IsoDateString = typeof IsoDateString.Type;
+export type IsoDateString = typeof peppolIsoDateStringSchema.Type;

package/src/effect/{message-level-response-document-response-schema.ts → peppol-message-level-response-document-response-schema.ts}

@@ -1,10 +1,10 @@
 import { Schema } from 'effect';
 
-import { documentResponseDocumentReferenceSchema } from './document-response-document-reference-schema';
-import { documentResponseDocumentSchema } from './document-response-document-schema';
-import { documentResponseLineResponseSchema } from './document-response-line-response-schema';
+import { peppolDocumentResponseDocumentReferenceSchema } from './peppol-document-response-document-reference-schema';
+import { peppolDocumentResponseDocumentSchema } from './peppol-document-response-document-schema';
+import { peppolDocumentResponseLineResponseSchema } from './peppol-document-response-line-response-schema';
 
-export const messageLevelResponseDocumentResponseSchema = Schema.Struct({
+export const peppolMessageLevelResponseDocumentResponseSchema = Schema.Struct({
   /**
    * @summary Response information
    *
@@ -12,7 +12,7 @@ export const messageLevelResponseDocumentResponseSchema = Schema.Struct({
    *
    * @cardinality (1..1)
    */
-  response: documentResponseDocumentSchema,
+  response: peppolDocumentResponseDocumentSchema,
   /**
    * @description The document reference is used to provide a reference to the envelope of the business document on which the message level response is based. The
    * message level response message may only cover exactly one business document. The element `cac:DocumentResponse/cac:DocumentReference/cbc:ID`
@@ -20,14 +20,14 @@ export const messageLevelResponseDocumentResponseSchema = Schema.Struct({
    *
    * @summary Document reference
    */
-  documentReference: documentResponseDocumentReferenceSchema,
+  documentReference: peppolDocumentResponseDocumentReferenceSchema,
   /**
    * @description A response to a particular line in the document. If the document response is negative (code='RE'), the line response element is used to specify
    * the errors in the business document.
    *
    * @summary Line response information
    */
-  lineResponse: Schema.Array(documentResponseLineResponseSchema),
+  lineResponse: Schema.Array(peppolDocumentResponseLineResponseSchema),
 });
 
-export type PeppolMessageLevelMessageLevelResponseDocumentResponse = typeof messageLevelResponseDocumentResponseSchema.Type;
+export type PeppolMessageLevelMessageLevelResponseDocumentResponse = typeof peppolMessageLevelResponseDocumentResponseSchema.Type;

package/src/effect/{message-level-response-party-schema.ts → peppol-message-level-response-party-schema.ts}

@@ -2,7 +2,7 @@ import { Schema } from 'effect';
 
 import { identifierSchema } from './fields/identifier-schema';
 
-export const messageLevelResponsePartySchema = Schema.Struct({
+export const peppolMessageLevelResponsePartySchema = Schema.Struct({
   /**
    * @description Identifies the sender party's electronic address.
    *
@@ -16,4 +16,4 @@ export const messageLevelResponsePartySchema = Schema.Struct({
   endpointId: Schema.optional(identifierSchema()),
 });
 
-export type PeppolMessageLevelResponseParty = typeof messageLevelResponsePartySchema.Type;
+export type PeppolMessageLevelResponseParty = typeof peppolMessageLevelResponsePartySchema.Type;

package/src/effect/{message-level-response-schema.ts → peppol-message-level-response-schema.ts}

@@ -2,12 +2,12 @@ import { Schema } from 'effect';
 
 import { MESSAGE_LEVEL_RESPONSE_PROFILE_ID } from '#/constants/message-level-response-profile-id';
 
-import { IsoDateString } from './iso-date-string';
-import { messageLevelResponseDocumentResponseSchema } from './message-level-response-document-response-schema';
-import { messageLevelResponsePartySchema } from './message-level-response-party-schema';
-import { xsdTime } from './utils/xsd-time';
+import { peppolIsoDateStringSchema } from './peppol-iso-date-string-schema';
+import { peppolMessageLevelResponseDocumentResponseSchema } from './peppol-message-level-response-document-response-schema';
+import { peppolMessageLevelResponsePartySchema } from './peppol-message-level-response-party-schema';
+import { peppolXsdTimeSchema } from './utils/peppol-xsd-time-schema';
 
-export const messageLevelResponse = Schema.Struct({
+export const peppolMessageLevelResponseSchema = Schema.Struct({
   /**
    * @description Identifies the specification of content and rules that apply to the transaction.
    *
@@ -57,7 +57,7 @@ export const messageLevelResponse = Schema.Struct({
    *
    * @name cbc:IssueDate
    */
-  issueDate: IsoDateString,
+  issueDate: peppolIsoDateStringSchema,
   /**
    * @description The time at which the transaction instance was issued.
    *
@@ -70,20 +70,20 @@ export const messageLevelResponse = Schema.Struct({
    *
    * @name cbc:IssueDate
    */
-  issueTime: Schema.optional(xsdTime),
+  issueTime: Schema.optional(peppolXsdTimeSchema),
   /**
    * @description The party sending an electronic message level response message back to the sending party of the business document.
    *
    * @summary Sender information
    */
-  senderParty: messageLevelResponsePartySchema,
+  senderParty: peppolMessageLevelResponsePartySchema,
   /**
    * @description The party, an electronic message level response was addressed to, and who is supposed to process the message level response. This is the same
    * party as the sender of the business document.
    *
    * @summary Receiver information
    */
-  receiverParty: messageLevelResponsePartySchema,
+  receiverParty: peppolMessageLevelResponsePartySchema,
   /**
    * @description The document response is used to indicate the result of business document validation. The element
    * `cac:DocumentResponse/cac:Response/cbc:ResponseCode` MUST contain the overall result code.
@@ -92,7 +92,7 @@ export const messageLevelResponse = Schema.Struct({
    *
    * @name `cac:DocumentResponse`
    */
-  documentResponse: messageLevelResponseDocumentResponseSchema,
+  documentResponse: peppolMessageLevelResponseDocumentResponseSchema,
 });
 
-export type PeppolMessageLevelResponse = typeof messageLevelResponse.Type;
+export type PeppolMessageLevelResponse = typeof peppolMessageLevelResponseSchema.Type;

package/src/effect/utils/index.ts

@@ -1,4 +1,4 @@
-export * from './base-64';
+export * from './peppol-base-64-schema';
 export * from './format-quantity-with-unit';
 export * from './get-credit-note-type-code-description';
 export * from './get-invoice-type-code-description';
@@ -6,5 +6,5 @@ export * from './is-valid-credit-note-type-code';
 export * from './is-valid-invoice-type-code';
 export * from './is-valid-process';
 export * from './quantity-unit-code-to-intl-unit';
-export * from './vat-regex';
-export * from './xsd-time';
+export * from './peppol-vat-regex-schema';
+export * from './peppol-xsd-time-schema';

package/src/effect/utils/{base-64.ts → peppol-base-64-schema.ts}

@@ -26,8 +26,8 @@ const BASE64_RE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=
  * @description RFC 4648 base64 string (PEM / MIME / XML line endings tolerated). Effect port of `base64Schema` (`z.string().check(z.refine(...))`): strips CRLF /
  * LF line endings before testing the quantum regex.
  */
-export const base64Schema = Schema.String.check(Schema.makeFilter((val: string) => BASE64_RE.test(val.replace(/\r?\n/g, '')))).annotate({
+export const peppolBase64Schema = Schema.String.check(Schema.makeFilter((val: string) => BASE64_RE.test(val.replace(/\r?\n/g, '')))).annotate({
   message: 'Invalid base64',
 });
 
-export type Base64 = typeof base64Schema.Type;
+export type Base64 = typeof peppolBase64Schema.Type;

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

@@ -17,7 +17,7 @@ const belgianVat = Schema.String.check(
  * @description EU VAT identification number (one member per member-state prefix/pattern). Effect port of `vatRegexSchema` (`z.union([...])` of
  * `z.string().check(...)` members): each member keeps its original prefix + pattern checks as `Schema.String.check` filters.
  */
-export const vatRegexSchema = Schema.Union([
+export const peppolVatRegexSchema = Schema.Union([
   belgianVat,
   Schema.String.check(Schema.isStartsWith('AT'), Schema.isPattern(/^ATU\d{8}$/)),
   Schema.String.check(Schema.isStartsWith('BG'), Schema.isPattern(/^BG\d{9,10}$/)),
@@ -48,4 +48,4 @@ export const vatRegexSchema = Schema.Union([
   Schema.String.check(Schema.isStartsWith('SK'), Schema.isPattern(/^SK\d{10}$/)),
 ]);
 
-export type VatRegex = typeof vatRegexSchema.Type;
+export type VatRegex = typeof peppolVatRegexSchema.Type;

package/src/effect/utils/{xsd-time.ts → peppol-xsd-time-schema.ts}

@@ -4,10 +4,10 @@ import { Schema } from 'effect';
  * @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 const xsdTime = Schema.String.check(
+export const peppolXsdTimeSchema = 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' });
 
-export type XsdTime = typeof xsdTime.Type;
+export type XsdTime = typeof peppolXsdTimeSchema.Type;