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

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

@@ -0,0 +1,73 @@
+import { Schema } from 'effect';
+
+import { peppolInvoiceResponseDocumentActualResponseStatusSchema } from '#/effect/peppol-invoice-response-document-actual-response-status-schema';
+import { peppolIsoDateStringSchema } from '#/effect/peppol-iso-date-string-schema';
+import { invoiceResponseCodeNeedsSchema } from '#/invoice-response-codes/invoice-response-code-needs-schema';
+import { invoiceResponseCodeNotNeedsSchema } from '#/invoice-response-codes/invoice-response-code-not-needs-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 '#/effect/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,168 @@
+import { Schema, Struct } from 'effect';
+
+import { INVOICE_RESPONSE_PROFILE_ID } from '#/constants/invoice-response-profile-id';
+import { peppolContactSchema } from '#/effect/fields/peppol-contact-schema';
+import { peppolIdentifierSchema } from '#/effect/fields/peppol-identifier-schema';
+import { peppolPartyLegalEntitySchema } from '#/effect/fields/peppol-party-legal-entity-schema';
+import { peppolInvoiceResponseDocumentActualResponseSchema } from '#/effect/peppol-invoice-response-document-actual-response-schema';
+import { peppolIsoDateStringSchema } from '#/effect/peppol-iso-date-string-schema';
+import { peppolMessageLevelResponsePartySchema } from '#/effect/peppol-message-level-response-party-schema';
+import { peppolMessageLevelResponseSchema } from '#/effect/peppol-message-level-response-schema';
+import { peppolDocumentTypeCodeSchema } from '#/effect/values/peppol-document-type-code-schema';
+
+export const peppolInvoiceResponsePartySchema = peppolMessageLevelResponsePartySchema.pipe(
+  Schema.fieldsAssign({
+    /**
+     * @summary Party partyIdentification
+     */
+    partyIdentification: Schema.optional(peppolIdentifierSchema),
+    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(peppolIdentifierSchema),
+  /**
+   * @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 '#/effect/values/op-status-action-schema';
+import { opStatusReasonSchema } from '#/effect/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,42 @@
+import { Schema } from 'effect';
+
+import { peppolInvoiceLineSchema } from '#/effect/fields/peppol-invoice-line-schema';
+import { peppolBillingBaseSchema } from '#/effect/peppol-billing-base-schema';
+import { peppolIsoDateStringSchema } from '#/effect/peppol-iso-date-string-schema';
+import { invoiceTypeCodeSchema } from '#/effect/values/invoice-type-code-schema';
+
+export const peppolInvoiceSchema = Schema.Struct({
+  ...peppolBillingBaseSchema.fields,
+  /**
+   * @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 interface PeppolInvoice extends Schema.Schema.Type<typeof peppolInvoiceSchema> {}

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

@@ -0,0 +1,19 @@
+import { DateTime, Schema, SchemaGetter } 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}Z?$/)).pipe(
+  Schema.decodeTo(Schema.DateTimeUtc, {
+    decode: SchemaGetter.dateTimeUtcFromInput().map(DateTime.removeTime),
+    encode: SchemaGetter.transform(DateTime.formatIsoDate),
+  })
+);
+
+export type PeppolIsoDateString = typeof peppolIsoDateStringSchema.Type;
+export type PeppolIsoDateEncoded = typeof peppolIsoDateStringSchema.Encoded;

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

@@ -0,0 +1,33 @@
+import { Schema } from 'effect';
+
+import { peppolDocumentResponseDocumentReferenceSchema } from '#/effect/peppol-document-response-document-reference-schema';
+import { peppolDocumentResponseDocumentSchema } from '#/effect/peppol-document-response-document-schema';
+import { peppolDocumentResponseLineResponseSchema } from '#/effect/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 { peppolIdentifierSchema } from '#/effect/fields/peppol-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(peppolIdentifierSchema),
+});
+
+export type PeppolMessageLevelResponseParty = typeof peppolMessageLevelResponsePartySchema.Type;

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

@@ -0,0 +1,97 @@
+import { Schema } from 'effect';
+
+import { MESSAGE_LEVEL_RESPONSE_PROFILE_ID } from '#/constants/message-level-response-profile-id';
+import { peppolIsoDateStringSchema } from '#/effect/peppol-iso-date-string-schema';
+import { peppolMessageLevelResponseDocumentResponseSchema } from '#/effect/peppol-message-level-response-document-response-schema';
+import { peppolMessageLevelResponsePartySchema } from '#/effect/peppol-message-level-response-party-schema';
+import { peppolXsdTimeSchema } from '#/effect/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/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/peppol-base-64-schema.ts

@@ -0,0 +1,33 @@
+import { Schema } from 'effect';
+
+// RFC 4648 §4 — Base 64 Encoding
+//
+// Alphabet: A-Z a-z 0-9 + /  (pad: =)
+// Encoding quanta: 4 characters represent 3 bytes.
+// Padding rules (only at the very end):
+//   • 0 pad chars  → last quantum is xxxx  (input length % 3 === 0)
+//   • 1 pad char   → last quantum is xxx=  (input length % 3 === 2)
+//   • 2 pad chars  → last quantum is xx==  (input length % 3 === 1)
+//
+// §3.1: CRLF / LF line endings are treated as non-alphabet characters
+//        and stripped before validation (as in PEM / MIME / XML).
+// §3.3: Implementations MUST reject data with non-alphabet characters
+//        (other than the allowed line endings stripped above).
+//
+// The regex below encodes all three quantum variants in a single pass:
+//   ([A-Za-z0-9+/]{4})*   — zero or more full quanta (no padding)
+//   followed by one of:
+//     [A-Za-z0-9+/]{2}==  — 2-pad quantum  (1 remaining input byte)
+//     [A-Za-z0-9+/]{3}=   — 1-pad quantum  (2 remaining input bytes)
+//     (empty)             — no trailing partial quantum
+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 peppolBase64Schema = Schema.String.check(Schema.makeFilter((val: string) => BASE64_RE.test(val.replace(/\r?\n/g, '')))).annotate({
+  message: 'Invalid base64',
+});
+
+export type Base64 = typeof peppolBase64Schema.Type;

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

@@ -0,0 +1,51 @@
+import { Schema } from 'effect';
+
+import { isValidMod97_0208 } from '#/peppol-validations/is-valid-mod97-0208';
+
+/**
+ * @description Belgian VAT number (`BE` + 10 digits with mod 97-0208 check digits). Effect port of the `BE` member of `vatRegexSchema`: prefix, exact length,
+ * pattern, and mod 97 check-digit validation share the original `'Invalid belgian vat number'` message.
+ */
+const belgianVat = Schema.String.check(
+  Schema.isStartsWith('BE'),
+  Schema.isLengthBetween(12, 12),
+  Schema.isPattern(/^BE[01]\d{9}$/),
+  Schema.makeFilter((value: string) => isValidMod97_0208(value.substring(2)).success)
+).annotate({ message: 'Invalid belgian vat number' });
+
+/**
+ * @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 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}$/)),
+  Schema.String.check(Schema.isStartsWith('CY'), Schema.isPattern(/^CY\d{8}L$/)),
+  Schema.String.check(Schema.isStartsWith('CZ'), Schema.isPattern(/^CZ\d{8,10}$/)),
+  Schema.String.check(Schema.isStartsWith('DE'), Schema.isPattern(/^DE\d{9}$/)),
+  Schema.String.check(Schema.isStartsWith('DK'), Schema.isPattern(/^DK\d{8}$/)),
+  Schema.String.check(Schema.isStartsWith('EE'), Schema.isPattern(/^EE\d{9}$/)),
+  Schema.String.check(Schema.isStartsWith('EL'), Schema.isPattern(/^EL\d{9}$/)),
+  Schema.String.check(Schema.isStartsWith('GR'), Schema.isPattern(/^GR\d{9}$/)),
+  Schema.String.check(Schema.isStartsWith('ES'), Schema.isPattern(/^ES[0-9A-Z]\d{7}[0-9A-Z]$/)),
+  Schema.String.check(Schema.isStartsWith('FI'), Schema.isPattern(/^FI\d{8}$/)),
+  Schema.String.check(Schema.isStartsWith('FR'), Schema.isPattern(/^FR[0-9A-Z]{2}\d{9}$/)),
+  Schema.String.check(Schema.isStartsWith('GB'), Schema.isPattern(/^GB(\d{9}(\d{3})?|[A-Z]{2}\d{3})$/)),
+  Schema.String.check(Schema.isStartsWith('HU'), Schema.isPattern(/^HU\d{8}$/)),
+  Schema.String.check(Schema.isStartsWith('IE'), Schema.isPattern(/^IE\dS\d{5}L$/)),
+  Schema.String.check(Schema.isStartsWith('IT'), Schema.isPattern(/^IT\d{11}$/)),
+  Schema.String.check(Schema.isStartsWith('LT'), Schema.isPattern(/^LT(\d{9}|\d{12})$/)),
+  Schema.String.check(Schema.isStartsWith('LU'), Schema.isPattern(/^LU\d{8}$/)),
+  Schema.String.check(Schema.isStartsWith('LV'), Schema.isPattern(/^LV\d{11}$/)),
+  Schema.String.check(Schema.isStartsWith('MT'), Schema.isPattern(/^MT\d{8}$/)),
+  Schema.String.check(Schema.isStartsWith('NL'), Schema.isPattern(/^NL\d{9}B\d{2}$/)),
+  Schema.String.check(Schema.isStartsWith('PL'), Schema.isPattern(/^PL\d{10}$/)),
+  Schema.String.check(Schema.isStartsWith('PT'), Schema.isPattern(/^PT\d{9}$/)),
+  Schema.String.check(Schema.isStartsWith('RO'), Schema.isPattern(/^RO\d{2,10}$/)),
+  Schema.String.check(Schema.isStartsWith('SE'), Schema.isPattern(/^SE\d{12}$/)),
+  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/effect/utils/peppol-xsd-time-schema.ts

@@ -0,0 +1,13 @@
+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 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 peppolXsdTimeSchema.Type;