@endevops/peppol-schema 0.0.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/peppol-invoice-response-document-actual-response-schema.ts

@@ -0,0 +1,74 @@
+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 { 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 peppolInvoiceResponseDocumentActualResponseSchema = Schema.Union([
+  Schema.Struct({
+    /**
+     * @remarks
+     *   This is a rejection code that needs clarification in {@link status}
+     *
+     * @summary A code stating the status of the invoice in the process.
+     *
+     * @name `cbc:ResponseCode`
+     */
+    responseCode: withStatusCodes,
+    /**
+     * @description The date when the status became effective.
+     *
+     * @example
+     *   `2018-08-02`;
+     *
+     * @summary Status date
+     *
+     * @name `cbc:EffectiveDate`
+     */
+    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.
+     *
+     * @summary Clarification information
+     *
+     * @name `cac:Status`
+     */
+    status: Schema.Array(peppolInvoiceResponseDocumentActualResponseStatusSchema).check(Schema.isMinLength(1)),
+  }),
+  Schema.Struct({
+    /**
+     * @summary A code stating the status of the invoice in the process.
+     *
+     * @name `cbc:ResponseCode`
+     */
+    responseCode: withoutStatusCodes,
+    /**
+     * @description The date when the status became effective.
+     *
+     * @example
+     *   `2018-08-02`;
+     *
+     * @summary Status date
+     *
+     * @name `cbc:EffectiveDate`
+     */
+    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.
+     *
+     * @summary Clarification information
+     *
+     * @name `cac:Status`
+     */
+    status: Schema.optional(Schema.Array(peppolInvoiceResponseDocumentActualResponseStatusSchema)),
+  }),
+]);
+
+export type InvoiceResponseDocumentActualResponse = typeof peppolInvoiceResponseDocumentActualResponseSchema.Type;

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

@@ -0,0 +1,60 @@
+import { Schema } from 'effect';
+
+import { peppolInvoiceResponseStatusReasonCodeSchema } from './peppol-invoice-response-status-reason-code-schema';
+
+const invoiceResponseCondition = Schema.Struct({
+  /**
+   * @description A code defining the type of the detail.
+   *
+   * @example
+   *   `BT-75`;
+   *
+   * @summary Detail type code
+   *
+   * @name `cbc:AttributeId`
+   */
+  attributeId: Schema.String,
+  /**
+   * @description The value of the detail.
+   *
+   * @example
+   *   `EU123456789`;
+   *
+   * @summary Detail value
+   *
+   * @name `cbc:Description`
+   */
+  description: Schema.optional(Schema.String),
+});
+
+export type InvoiceResponseCondition = typeof invoiceResponseCondition.Type;
+
+export const peppolInvoiceResponseDocumentActualResponseStatusSchema = Schema.Struct({
+  /**
+   * @description A code defining a clarification given for the invoice status.
+   *
+   * @summary Clarification code
+   *
+   * @name `cbc:StatusReasonCode`
+   */
+  statusReasonCode: Schema.optional(peppolInvoiceResponseStatusReasonCodeSchema),
+  /**
+   * @description The description of the clarification given for the invoice status.
+   *
+   * @example
+   *   `TAX reference not found`;
+   *
+   * @summary Clarification description
+   *
+   * @name `cbc:StatusReason
+   */
+  statusReason: Schema.optional(Schema.String),
+  /**
+   * @summary Condition
+   *
+   * @name `cac:Condition`
+   */
+  condition: Schema.optional(Schema.Array(invoiceResponseCondition)),
+});
+
+export type InvoiceResponseDocumentActualResponseStatus = typeof peppolInvoiceResponseDocumentActualResponseStatusSchema.Type;

package/src/effect/peppol-invoice-response-schema.ts

@@ -0,0 +1,169 @@
+import { Schema, Struct } from 'effect';
+
+import { INVOICE_RESPONSE_PROFILE_ID } from '#/constants/invoice-response-profile-id';
+
+import { identifierSchema } from './fields/identifier-schema';
+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';
+
+export const peppolInvoiceResponsePartySchema = peppolMessageLevelResponsePartySchema.pipe(
+  Schema.fieldsAssign({
+    /**
+     * @summary Party partyIdentification
+     */
+    partyIdentification: Schema.optional(identifierSchema()),
+    partyLegalEntity: peppolPartyLegalEntitySchema.mapFields(Struct.pick(['registrationName'])),
+  })
+);
+
+export const peppolInvoiceResponseSenderPartySchema = peppolInvoiceResponsePartySchema.pipe(
+  Schema.fieldsAssign({
+    /**
+     * @summary Contact information
+     *
+     * @name `cac:Contact`
+     */
+    contact: Schema.optional(peppolContactSchema),
+  })
+);
+
+export type PeppolInvoiceResponseParty = typeof peppolInvoiceResponsePartySchema.Type | typeof peppolInvoiceResponseSenderPartySchema.Type;
+
+/**
+ * @description Party schema used under `cac:DocumentReference/(cac:IssuerParty|cac:RecipientParty)`
+ */
+export const peppolInvoiceResponseDocumentResponsePartySchema = Schema.Struct({
+  /**
+   * @summary Party partyIdentification
+   */
+  partyIdentification: Schema.optional(identifierSchema()),
+  /**
+   * @example
+   *   Seller Business Name AS
+   *
+   * @name cac:PartyName
+   */
+  partyName: Schema.Struct({
+    /**
+     * @description - The party that issued the reference invoice
+     * - The party who the referenced invoice is issued.
+     *
+     * @summary Seller/Buyer party name
+     *
+     * @name `cbc:Name`
+     */
+    name: Schema.String,
+  }),
+});
+
+export type PeppolInvoiceDocumentResponseParty = typeof peppolInvoiceResponseDocumentResponsePartySchema.Type;
+
+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.
+   *
+   * @example
+   *   `inv-99876`;
+   *
+   * @summary Invoice identifier
+   *
+   * @name `cbc:ID`
+   */
+  id: Schema.String,
+  /**
+   * @description The date on which the referenced invoice was issued.
+   *
+   * @example
+   *   `2018-08-01`;
+   *
+   * @summary Invoice issue date
+   *
+   * @name `cbc:IssueDate`
+   */
+  issueDate: Schema.optional(peppolIsoDateStringSchema),
+  /**
+   * @example
+   *   `380`;
+   *
+   * @summary Identifier type code
+   */
+  documentTypeCode: peppolDocumentTypeCodeSchema(),
+});
+
+export type PeppolInvoiceResponseDocumentReference = typeof peppolInvoiceResponseDocumentReferenceSchema.Type;
+
+export const peppolInvoiceResponseDocumentResponseSchema = Schema.Struct({
+  /**
+   * @summary Response information
+   *
+   * @name `cac:Response`
+   *
+   * @cardinality (1..1)
+   */
+  response: peppolInvoiceResponseDocumentActualResponseSchema,
+  /**
+   * @summary Document reference
+   *
+   * @name `cac:DocumentReference`
+   */
+  documentReference: peppolInvoiceResponseDocumentReferenceSchema,
+  /**
+   * @summary Seller party information
+   *
+   * @name `cac:IssuerParty`
+   */
+  issuerParty: Schema.optional(peppolInvoiceResponseDocumentResponsePartySchema),
+  /**
+   * @summary Buyer party information
+   *
+   * @name `cac:RecipientParty`
+   */
+  recipientParty: Schema.optional(peppolInvoiceResponseDocumentResponsePartySchema),
+});
+
+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 peppolInvoiceResponseSchema = peppolMessageLevelResponseSchema.pipe(
+  Schema.fieldsAssign({
+    profileId: Schema.Literal(INVOICE_RESPONSE_PROFILE_ID),
+    /**
+     * @description The party sending an electronic message level response message back to the sending party of the business document.
+     *
+     * @summary Sender information
+     */
+    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: peppolInvoiceResponsePartySchema,
+    /**
+     * @description General comments or instructions that are revelant to the response as a whole.
+     *
+     * @example
+     *   `Please refere to previous email exchange regarding this invoice.`;
+     *
+     * @summary Invoice response note
+     */
+    note: Schema.optional(Schema.String),
+    /**
+     * @summary Document response
+     */
+    documentResponse: peppolInvoiceResponseDocumentResponseSchema,
+  })
+);
+
+export type PeppolInvoiceResponse = typeof peppolInvoiceResponseSchema.Type;

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

@@ -0,0 +1,31 @@
+import { Schema } from 'effect';
+
+import { opStatusActionSchema } from './values/op-status-action-schema';
+import { opStatusReasonSchema } from './values/op-status-reason-schema';
+
+export const peppolInvoiceResponseStatusReasonCodeSchema = Schema.Union([
+  Schema.Struct({
+    value: opStatusActionSchema(),
+    /**
+     * @description List identifier for clarification.
+     *
+     * @summary List identifier
+     *
+     * @name `@listId`
+     */
+    listId: Schema.Literal('OPStatusAction'),
+  }),
+  Schema.Struct({
+    value: opStatusReasonSchema(),
+    /**
+     * @description List identifier for clarification.
+     *
+     * @summary List identifier
+     *
+     * @name `@listId`
+     */
+    listId: Schema.Literal('OPStatusReason'),
+  }),
+]);
+
+export type InvoiceResponseStatusReasonCode = typeof peppolInvoiceResponseStatusReasonCodeSchema.Type;

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

@@ -0,0 +1,48 @@
+import { Schema } from 'effect';
+
+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, ...)` →
+ * `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 peppolInvoiceSchema = peppolBillingBaseSchema.pipe(
+  Schema.fieldsAssign({
+    /**
+     * @example
+     *   2017 - 11 - 01;
+     *
+     * @summary Payment due date
+     *
+     * @name cbc:DueDate
+     */
+    dueDate: Schema.optional(peppolIsoDateStringSchema),
+    /**
+     * @summary INVOICE LINE
+     *
+     * @name cac:InvoiceLine
+     */
+    invoiceLines: Schema.Array(peppolInvoiceLineSchema).check(Schema.isMinLength(1)),
+    /**
+     * @example
+     *   380;
+     *
+     * @summary Invoice type code
+     *
+     * @name cbc:InvoiceTypeCode
+     */
+    invoiceTypeCode: invoiceTypeCodeSchema(),
+    /**
+     * @summary PROJECT REFERENCE
+     *
+     * @name cac:ProjectReference
+     */
+    projectReference: Schema.optional(Schema.Struct({ id: Schema.String })),
+  })
+);
+
+export type PeppolInvoice = typeof peppolInvoiceSchema.Type;

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

@@ -0,0 +1,13 @@
+import { Schema } from 'effect';
+
+/**
+ * @description ISO 8601 calendar date string (`YYYY-MM-DD`). Effect port of `dateOnly` (`z.iso.date()`): keeps the value as a plain string and only validates the
+ * shape — no `Date` conversion.
+ *
+ * @format date
+ *
+ * @see PEPPOL-EN16931-F001: A date MUST be formatted YYYY-MM-DD.
+ */
+export const peppolIsoDateStringSchema = Schema.String.check(Schema.isPattern(/^\d{4}-\d{2}-\d{2}$/));
+
+export type IsoDateString = typeof peppolIsoDateStringSchema.Type;

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

@@ -0,0 +1,33 @@
+import { Schema } from 'effect';
+
+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 peppolMessageLevelResponseDocumentResponseSchema = Schema.Struct({
+  /**
+   * @summary Response information
+   *
+   * @name `cac:Response`
+   *
+   * @cardinality (1..1)
+   */
+  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`
+   * **MUST** contain the instance identifier of the envelope of the original business document.
+   *
+   * @summary Document reference
+   */
+  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(peppolDocumentResponseLineResponseSchema),
+});
+
+export type PeppolMessageLevelMessageLevelResponseDocumentResponse = typeof peppolMessageLevelResponseDocumentResponseSchema.Type;

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

@@ -0,0 +1,19 @@
+import { Schema } from 'effect';
+
+import { identifierSchema } from './fields/identifier-schema';
+
+export const peppolMessageLevelResponsePartySchema = Schema.Struct({
+  /**
+   * @description Identifies the sender party's electronic address.
+   *
+   * @example
+   *   7300010000001;
+   *
+   * @summary Sender/Receiver party's electronic address
+   *
+   * @name `cbc:EndpointID (+ @schemeID)`
+   */
+  endpointId: Schema.optional(identifierSchema()),
+});
+
+export type PeppolMessageLevelResponseParty = typeof peppolMessageLevelResponsePartySchema.Type;

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

@@ -0,0 +1,98 @@
+import { Schema } from 'effect';
+
+import { MESSAGE_LEVEL_RESPONSE_PROFILE_ID } from '#/constants/message-level-response-profile-id';
+
+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 peppolMessageLevelResponseSchema = Schema.Struct({
+  /**
+   * @description Identifies the specification of content and rules that apply to the transaction.
+   *
+   * @default `urn:fdc:peppol.eu:poacc:trns:mlr:3`
+   *
+   * @summary Specification identification
+   *
+   * @name `cbc:CustomizationID`
+   *
+   * @cardinality 1..1
+   */
+  customizationId: Schema.String,
+  /**
+   * @description Identifies the BII profile or business process context in which the transaction appears.
+   *
+   * @remarks
+   *   Fixed value to `urn:fdc:peppol.eu:poacc:bis:mlr:3`
+   *
+   * @default `urn:fdc:peppol.eu:poacc:bis:mlr:3`
+   *
+   * @summary Business process type identifier
+   *
+   * @name `cbc:ProfileID`
+   */
+  profileId: Schema.Literal(MESSAGE_LEVEL_RESPONSE_PROFILE_ID),
+  /**
+   * @description A transaction instance must contain an identifier. The identifier enables positive referencing the transaction instance for various puropses
+   * including referencing between transactions that are part of the same process.
+   *
+   * @example
+   *   23;
+   *
+   * @summary Response identifier
+   *
+   * @name cbc:ID
+   */
+  id: Schema.String,
+  /**
+   * @description The date on which the transaction instance was issued.
+   *
+   * @example
+   *   2017 - 11 - 01;
+   *
+   * @summary Response issue date
+   *
+   * @format `YYYY-MM-DD`
+   *
+   * @name cbc:IssueDate
+   */
+  issueDate: peppolIsoDateStringSchema,
+  /**
+   * @description The time at which the transaction instance was issued.
+   *
+   * @example
+   *   12:01:34
+   *
+   * @summary Response issue time
+   *
+   * @format `hh:mm:ss`
+   *
+   * @name cbc:IssueDate
+   */
+  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: 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: 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.
+   *
+   * @summary Document response
+   *
+   * @name `cac:DocumentResponse`
+   */
+  documentResponse: peppolMessageLevelResponseDocumentResponseSchema,
+});
+
+export type PeppolMessageLevelResponse = typeof peppolMessageLevelResponseSchema.Type;

package/src/effect/utils/format-quantity-with-unit.ts

@@ -0,0 +1 @@
+export { formatQuantityWithUnit } from '#/schemas/utils/format-quantity-with-unit';

package/src/effect/utils/get-credit-note-type-code-description.ts

@@ -0,0 +1 @@
+export { getCreditNoteTypeCodeDescription } from '#/schemas/utils/get-credit-note-type-code-description';

package/src/effect/utils/get-invoice-type-code-description.ts

@@ -0,0 +1 @@
+export { getInvoiceTypeCodeDescription } from '#/schemas/utils/get-invoice-type-code-description';

package/src/effect/utils/index.ts

@@ -0,0 +1,10 @@
+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';
+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 './peppol-vat-regex-schema';
+export * from './peppol-xsd-time-schema';

package/src/effect/utils/is-valid-credit-note-type-code.ts

@@ -0,0 +1 @@
+export { isValidCreditNoteTypeCode } from '#/schemas/utils/is-valid-credit-note-type-code';