@endevops/peppol-schema 0.0.1

package/src/schematron/de/de-r-030.ts

@@ -0,0 +1,25 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { isCustomerGermany, isSupplierGermany, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DE-R-030',
+  level: 'fatal',
+  message: 'If the group "DIRECT DEBIT" (BG-19) is delivered, the element "Bank assigned creditor identifier" (BT-90) shall be provided.',
+} as const satisfies SchematronRule;
+
+export function validateDeR030(document: PeppolDocument): SchematronRuleResult {
+  if (!isSupplierGermany(document) || !isCustomerGermany(document)) {
+    return schematronResult(rule, true);
+  }
+  const hasPaymentMandate = (document.paymentMeans ?? []).some(payment => Boolean(payment.paymentMandate));
+  if (!hasPaymentMandate) {
+    return schematronResult(rule, true);
+  }
+  const hasSepaCreditorId =
+    document.accountingSupplierParty.partyIdentification?.id?.schemeId === 'SEPA' ||
+    document.payeeParty?.partyIdentification?.id?.schemeId === 'SEPA';
+  return schematronResult(rule, hasSepaCreditorId);
+}

package/src/schematron/de/de-r-031.ts

@@ -0,0 +1,24 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { isCustomerGermany, isSupplierGermany, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DE-R-031',
+  level: 'fatal',
+  message: 'If the group "DIRECT DEBIT" (BG-19) is delivered, the element "Debited account identifier" (BT-91) shall be provided.',
+} as const satisfies SchematronRule;
+
+export function validateDeR031(document: PeppolDocument): SchematronRuleResult {
+  if (!isSupplierGermany(document) || !isCustomerGermany(document)) {
+    return schematronResult(rule, true);
+  }
+  const passed = (document.paymentMeans ?? []).every(payment => {
+    if (!payment.paymentMandate) {
+      return true;
+    }
+    return Boolean(payment.paymentMandate.payerFinancialAccountId?.id);
+  });
+  return schematronResult(rule, passed);
+}

package/src/schematron/dk/dk-r-002.ts

@@ -0,0 +1,15 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = { id: 'DK-R-002', level: 'fatal', message: 'Danish suppliers MUST provide legal entity (CVR-number)' } as const satisfies SchematronRule;
+
+export function validateDkR002(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'DK') {
+    return schematronResult(rule, true);
+  }
+  const companyId = document.accountingSupplierParty.partyLegalEntity.companyId?.id;
+  return schematronResult(rule, typeof companyId === 'string' && companyId.trim() !== '');
+}

package/src/schematron/dk/dk-r-003.ts

@@ -0,0 +1,29 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getCustomerCountry, getLines, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DK-R-003',
+  level: 'warning',
+  message: 'If ItemClassification is provided from Danish suppliers, UNSPSC version 19.05.01 or 26.08.01 should be used.',
+} as const satisfies SchematronRule;
+
+const ALLOWED_VERSIONS = new Set(['19.05.01', '19.0501', '26.08.01', '26.0801']);
+
+export function validateDkR003(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'DK' || getCustomerCountry(document) !== 'DK') {
+    return schematronResult(rule, true);
+  }
+  const passed = getLines(document).every(line =>
+    (line.item.commodityClassifications ?? []).every(classification => {
+      const classificationCode = classification.itemClassification;
+      return (
+        classificationCode.listId !== 'TST' ||
+        (classificationCode.listVersionId !== undefined && ALLOWED_VERSIONS.has(classificationCode.listVersionId))
+      );
+    })
+  );
+  return schematronResult(rule, passed);
+}

package/src/schematron/dk/dk-r-004.ts

@@ -0,0 +1,31 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getAllAllowanceCharges, getCustomerCountry, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DK-R-004',
+  level: 'fatal',
+  message:
+    'When specifying non-VAT Taxes for Danish customers, Danish suppliers MUST use the AllowanceChargeReasonCode="ZZZ" and MUST be specified in AllowanceChargeReason; Either as the 4-digit Tax category or must include a #, but the # is not allowed as first and last character',
+} as const satisfies SchematronRule;
+
+export function validateDkR004(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'DK' || getCustomerCountry(document) !== 'DK') {
+    return schematronResult(rule, true);
+  }
+  const passed = getAllAllowanceCharges(document).every(ac => {
+    if (ac.reasonCode !== 'ZZZ') {
+      return true;
+    }
+    const reason = ac.allowanceChargeReason;
+    if (reason === undefined) {
+      return false;
+    }
+    const is4DigitTaxCategory = /^\d{4}$/.test(reason) && Number(reason) >= 0 && Number(reason) <= 9999;
+    const hasHashInside = reason.includes('#') && !reason.startsWith('#') && !reason.endsWith('#');
+    return is4DigitTaxCategory || hasHashInside;
+  });
+  return schematronResult(rule, passed);
+}

package/src/schematron/dk/dk-r-005.ts

@@ -0,0 +1,21 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getCustomerCountry, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DK-R-005',
+  level: 'fatal',
+  message: 'For Danish suppliers the following Payment means codes are allowed: 1, 10, 31, 42, 48, 49, 50, 58, 59, 93 and 97',
+} as const satisfies SchematronRule;
+
+const ALLOWED_CODES = new Set(['1', '10', '31', '42', '48', '49', '50', '58', '59', '93', '97']);
+
+export function validateDkR005(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'DK' || getCustomerCountry(document) !== 'DK') {
+    return schematronResult(rule, true);
+  }
+  const passed = (document.paymentMeans ?? []).every(payment => ALLOWED_CODES.has(payment.paymentMeansCode.code));
+  return schematronResult(rule, passed);
+}

package/src/schematron/dk/dk-r-006.ts

@@ -0,0 +1,28 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getCustomerCountry, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DK-R-006',
+  level: 'fatal',
+  message: 'For Danish suppliers bank account and registration account is mandatory if payment means is 31 or 42',
+} as const satisfies SchematronRule;
+
+const REQUIRED_CODES = new Set(['31', '42']);
+
+export function validateDkR006(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'DK' || getCustomerCountry(document) !== 'DK') {
+    return schematronResult(rule, true);
+  }
+  const passed = (document.paymentMeans ?? []).every(payment => {
+    if (!REQUIRED_CODES.has(payment.paymentMeansCode.code)) {
+      return true;
+    }
+    const accountId = payment.payeeFinancialAccount?.id;
+    const branchId = payment.payeeFinancialAccount?.financialInstitutionBranch?.id;
+    return typeof accountId === 'string' && accountId.trim() !== '' && typeof branchId === 'string' && branchId.trim() !== '';
+  });
+  return schematronResult(rule, passed);
+}

package/src/schematron/dk/dk-r-007.ts

@@ -0,0 +1,26 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getCustomerCountry, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DK-R-007',
+  level: 'fatal',
+  message: 'For Danish suppliers PaymentMandate/ID and PayerFinancialAccount/ID are mandatory when payment means is 49',
+} as const satisfies SchematronRule;
+
+export function validateDkR007(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'DK' || getCustomerCountry(document) !== 'DK') {
+    return schematronResult(rule, true);
+  }
+  const passed = (document.paymentMeans ?? []).every(payment => {
+    if (payment.paymentMeansCode.code !== '49') {
+      return true;
+    }
+    const mandateId = payment.paymentMandate?.id;
+    const payerAccountId = payment.paymentMandate?.payerFinancialAccountId?.id;
+    return typeof mandateId === 'string' && mandateId.trim() !== '' && typeof payerAccountId === 'string' && payerAccountId.trim() !== '';
+  });
+  return schematronResult(rule, passed);
+}

package/src/schematron/dk/dk-r-008.ts

@@ -0,0 +1,28 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getCustomerCountry, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DK-R-008',
+  level: 'fatal',
+  message:
+    'For Danish Suppliers PaymentID is mandatory and MUST start with 01#, 04# or 15# (kortartkode), and PayeeFinancialAccount/ID (Giro kontonummer) is mandatory and must be 7 or 8 numerical characters long, when payment means equals 50 (Giro)',
+} as const satisfies SchematronRule;
+
+export function validateDkR008(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'DK' || getCustomerCountry(document) !== 'DK') {
+    return schematronResult(rule, true);
+  }
+  const passed = (document.paymentMeans ?? []).every(payment => {
+    if (payment.paymentMeansCode.code !== '50') {
+      return true;
+    }
+    const paymentId = payment.paymentId;
+    const giroAccountId = payment.payeeFinancialAccount?.id;
+    const startsWithValidPrefix = paymentId ? ['01#', '04#', '15#'].some(prefix => paymentId.startsWith(prefix)) : false;
+    return startsWithValidPrefix && typeof giroAccountId === 'string' && /^[0-9]{7,8}$/.test(giroAccountId);
+  });
+  return schematronResult(rule, passed);
+}

package/src/schematron/dk/dk-r-009.ts

@@ -0,0 +1,29 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getCustomerCountry, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DK-R-009',
+  level: 'fatal',
+  message:
+    'For Danish Suppliers if the PaymentID is prefixed with 04# or 15# the 16 digits instruction Id must be added to the PaymentID eg. "04#1234567890123456" when Payment means equals 50 (Giro)',
+} as const satisfies SchematronRule;
+
+export function validateDkR009(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'DK' || getCustomerCountry(document) !== 'DK') {
+    return schematronResult(rule, true);
+  }
+  const passed = (document.paymentMeans ?? []).every(payment => {
+    if (payment.paymentMeansCode.code !== '50' || !payment.paymentId) {
+      return true;
+    }
+    const paymentId = payment.paymentId;
+    if (paymentId.startsWith('04#') || paymentId.startsWith('15#')) {
+      return paymentId.length === 19;
+    }
+    return true;
+  });
+  return schematronResult(rule, passed);
+}

package/src/schematron/dk/dk-r-010.ts

@@ -0,0 +1,28 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getCustomerCountry, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DK-R-010',
+  level: 'fatal',
+  message:
+    'For Danish Suppliers using PaymentMeansCode 93, PaymentID is mandatory. The first three characters of the PaymentID MUST be 71#, 73# or 75# (kortartskode), and PayeeFinancialAccount/ID MUST be exactly 8 characters long.',
+} as const satisfies SchematronRule;
+
+export function validateDkR010(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'DK' || getCustomerCountry(document) !== 'DK') {
+    return schematronResult(rule, true);
+  }
+  const passed = (document.paymentMeans ?? []).every(payment => {
+    if (payment.paymentMeansCode.code !== '93') {
+      return true;
+    }
+    const paymentId = payment.paymentId;
+    const startsWithValidPrefix = paymentId ? ['71#', '73#', '75#'].some(prefix => paymentId.startsWith(prefix)) : false;
+    const accountId = payment.payeeFinancialAccount?.id;
+    return startsWithValidPrefix && typeof accountId === 'string' && accountId.length === 8;
+  });
+  return schematronResult(rule, passed);
+}

package/src/schematron/dk/dk-r-011.ts

@@ -0,0 +1,29 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getCustomerCountry, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DK-R-011',
+  level: 'fatal',
+  message:
+    'For Danish Suppliers if the PaymentID is prefixed with 71# or 75# the 15-16 digits instruction Id must be added to the PaymentID eg. "71#1234567890123456" when payment Method equals 93 (FIK)',
+} as const satisfies SchematronRule;
+
+export function validateDkR011(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'DK' || getCustomerCountry(document) !== 'DK') {
+    return schematronResult(rule, true);
+  }
+  const passed = (document.paymentMeans ?? []).every(payment => {
+    if (payment.paymentMeansCode.code !== '93' || !payment.paymentId) {
+      return true;
+    }
+    const paymentId = payment.paymentId;
+    if (paymentId.startsWith('71#') || paymentId.startsWith('75#')) {
+      return paymentId.length === 18 || paymentId.length === 19;
+    }
+    return true;
+  });
+  return schematronResult(rule, passed);
+}

package/src/schematron/dk/dk-r-013.ts

@@ -0,0 +1,24 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getCustomerCountry, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DK-R-013',
+  level: 'fatal',
+  message:
+    'For Danish Suppliers it is mandatory to use schemeID when PartyIdentification/ID is used for AccountingCustomerParty or AccountingSupplierParty',
+} as const satisfies SchematronRule;
+
+export function validateDkR013(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'DK' || getCustomerCountry(document) !== 'DK') {
+    return schematronResult(rule, true);
+  }
+  const parties = [document.accountingSupplierParty, document.accountingCustomerParty];
+  const passed = parties.every(party => {
+    const id = party.partyIdentification?.id;
+    return !id?.id || (typeof id.schemeId === 'string' && id.schemeId.trim() !== '');
+  });
+  return schematronResult(rule, passed);
+}

package/src/schematron/dk/dk-r-014.ts

@@ -0,0 +1,21 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DK-R-014',
+  level: 'fatal',
+  message:
+    'For Danish Suppliers it is mandatory to specify schemeID as "0184" (DK CVR-number) when PartyLegalEntity/CompanyID is used for AccountingSupplierParty',
+} as const satisfies SchematronRule;
+
+export function validateDkR014(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'DK') {
+    return schematronResult(rule, true);
+  }
+  const companyId = document.accountingSupplierParty.partyLegalEntity.companyId;
+  const passed = !companyId?.id || companyId.schemeId === '0184';
+  return schematronResult(rule, passed);
+}

package/src/schematron/dk/dk-r-016.ts

@@ -0,0 +1,18 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getCustomerCountry, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DK-R-016',
+  level: 'fatal',
+  message: 'For Danish Suppliers, a Credit note cannot have a negative total (PayableAmount)',
+} as const satisfies SchematronRule;
+
+export function validateDkR016(document: PeppolDocument): SchematronRuleResult {
+  if (!('creditNoteLines' in document) || getSupplierCountry(document) !== 'DK' || getCustomerCountry(document) !== 'DK') {
+    return schematronResult(rule, true);
+  }
+  return schematronResult(rule, document.legalMonetaryTotal.payableAmount.value >= 0);
+}

package/src/schematron/dk/dk-r-017.ts

@@ -0,0 +1,21 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getCustomerCountry, getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'DK-R-017',
+  level: 'warning',
+  message:
+    'For Danish Customers it is mandatory to specify schemeID as "0184" (DK CVR-number) when PartyLegalEntity/CompanyID is used for AccountingCustomerParty',
+} as const satisfies SchematronRule;
+
+export function validateDkR017(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'DK' || getCustomerCountry(document) !== 'DK') {
+    return schematronResult(rule, true);
+  }
+  const companyId = document.accountingCustomerParty.partyLegalEntity.companyId;
+  const passed = !companyId?.id || companyId.schemeId === '0184';
+  return schematronResult(rule, passed);
+}

package/src/schematron/gr/gr-r-001-1.ts

@@ -0,0 +1,19 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'GR-R-001-1',
+  level: 'fatal',
+  message: ' When the Supplier is Greek, the Invoice Id should consist of 6 segments',
+} as const satisfies SchematronRule;
+
+export function validateGrR001_1(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
+    return schematronResult(rule, true);
+  }
+  const segments = document.id.split('|');
+  return schematronResult(rule, segments.length === 6);
+}

package/src/schematron/gr/gr-r-001-2.ts

@@ -0,0 +1,30 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { greekTinVerification } from '#/peppol-validations/greek-tin-verification';
+import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'GR-R-001-2',
+  level: 'fatal',
+  message:
+    "When the Supplier is Greek, the Invoice Id first segment must be a valid TIN Number and match either the Supplier's or the Tax Representative's Tin Number",
+} as const satisfies SchematronRule;
+
+export function validateGrR001_2(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
+    return schematronResult(rule, true);
+  }
+  const segments = document.id.split('|');
+  const firstSegment = segments[0];
+  if (!firstSegment || firstSegment.trim().length !== 9) {
+    return schematronResult(rule, false);
+  }
+  const supplierTin = document.accountingSupplierParty.partyTaxSchemes
+    ?.find(scheme => scheme.taxSchemeId.id.trim().toUpperCase() === 'VAT')
+    ?.companyId.slice(2);
+  const taxRepTin = document.taxRepresentativeParty?.partyTaxScheme.companyId.slice(2);
+  const matchesTin = firstSegment === supplierTin || firstSegment === taxRepTin;
+  return schematronResult(rule, greekTinVerification(firstSegment) && matchesTin);
+}

package/src/schematron/gr/gr-r-001-3.ts

@@ -0,0 +1,32 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'GR-R-001-3',
+  level: 'fatal',
+  message: 'When the Supplier is Greek, the Invoice Id second segment must be a valid Date that matches the invoice Issue Date',
+} as const satisfies SchematronRule;
+
+const DATE_REGEX = /^(0?[1-9]|[12][0-9]|3[01])[-/]?(0?[1-9]|1[0-2])[-/]?((?:19|20)[0-9]{2})$/;
+
+export function validateGrR001_3(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
+    return schematronResult(rule, true);
+  }
+  const segments = document.id.split('|');
+  const secondSegment = segments[1];
+  if (!secondSegment || secondSegment.trim().length === 0) {
+    return schematronResult(rule, false);
+  }
+  const dateMatch = secondSegment.match(DATE_REGEX);
+  if (!dateMatch) {
+    return schematronResult(rule, false);
+  }
+  const [, day, month, year] = dateMatch;
+  const issueDate = document.issueDate;
+  const issueDateSegments = issueDate.split('-');
+  return schematronResult(rule, day === issueDateSegments[2] && month === issueDateSegments[1] && year === issueDateSegments[0]);
+}

package/src/schematron/gr/gr-r-001-4.ts

@@ -0,0 +1,23 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'GR-R-001-4',
+  level: 'fatal',
+  message: 'When Supplier is Greek, the Invoice Id third segment must be a positive integer',
+} as const satisfies SchematronRule;
+
+export function validateGrR001_4(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
+    return schematronResult(rule, true);
+  }
+  const segments = document.id.split('|');
+  const thirdSegment = segments[2];
+  if (!thirdSegment || thirdSegment.trim().length === 0) {
+    return schematronResult(rule, false);
+  }
+  return schematronResult(rule, /^\d+$/.test(thirdSegment) && Number(thirdSegment) >= 0);
+}

package/src/schematron/gr/gr-r-001-5.ts

@@ -0,0 +1,25 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'GR-R-001-5',
+  level: 'fatal',
+  message: 'When Supplier is Greek, the Invoice Id in the fourth segment must be a valid greek document type',
+} as const satisfies SchematronRule;
+
+const GREEK_DOCUMENT_TYPES = new Set(['1.1', '1.6', '2.1', '2.4', '5.1', '5.2']);
+
+export function validateGrR001_5(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
+    return schematronResult(rule, true);
+  }
+  const segments = document.id.split('|');
+  const fourthSegment = segments[3];
+  if (!fourthSegment || fourthSegment.trim().length === 0) {
+    return schematronResult(rule, false);
+  }
+  return schematronResult(rule, GREEK_DOCUMENT_TYPES.has(fourthSegment));
+}

package/src/schematron/gr/gr-r-001-6.ts

@@ -0,0 +1,19 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'GR-R-001-6',
+  level: 'fatal',
+  message: 'When Supplier is Greek, the Invoice Id fifth segment must not be empty',
+} as const satisfies SchematronRule;
+
+export function validateGrR001_6(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
+    return schematronResult(rule, true);
+  }
+  const segments = document.id.split('|');
+  return schematronResult(rule, (segments[4]?.length ?? 0) > 0);
+}

package/src/schematron/gr/gr-r-001-7.ts

@@ -0,0 +1,19 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'GR-R-001-7',
+  level: 'fatal',
+  message: 'When Supplier is Greek, the Invoice Id sixth segment must not be empty',
+} as const satisfies SchematronRule;
+
+export function validateGrR001_7(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
+    return schematronResult(rule, true);
+  }
+  const segments = document.id.split('|');
+  return schematronResult(rule, (segments[5]?.length ?? 0) > 0);
+}

package/src/schematron/gr/gr-r-002.ts

@@ -0,0 +1,20 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'GR-R-002',
+  level: 'fatal',
+  message:
+    'Greek Suppliers must provide their full name as they are registered in the Greek Business Registry (G.E.MH.) as a legal entity or in the Tax Registry as a natural person ',
+} as const satisfies SchematronRule;
+
+export function validateGrR002(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
+    return schematronResult(rule, true);
+  }
+  const partyName = document.accountingSupplierParty.partyName?.name;
+  return schematronResult(rule, typeof partyName === 'string' && partyName.length > 0);
+}

package/src/schematron/gr/gr-r-003.ts

@@ -0,0 +1,25 @@
+import type { PeppolDocument } from '#/document';
+import type { SchematronRule } from '#/schematron/helpers';
+import type { SchematronRuleResult } from '#/schematron/types';
+
+import { greekTinVerification } from '#/peppol-validations/greek-tin-verification';
+import { getSupplierCountry, schematronResult } from '#/schematron/helpers';
+
+const rule = {
+  id: 'GR-R-003',
+  level: 'fatal',
+  message: "For the Greek Suppliers, the VAT must start with 'EL' and must be a valid TIN number",
+} as const satisfies SchematronRule;
+
+export function validateGrR003(document: PeppolDocument): SchematronRuleResult {
+  if (getSupplierCountry(document) !== 'GR' && getSupplierCountry(document) !== 'EL') {
+    return schematronResult(rule, true);
+  }
+  const vatCompanyId = document.accountingSupplierParty.partyTaxSchemes?.find(
+    scheme => scheme.taxSchemeId.id.trim().toUpperCase() === 'VAT'
+  )?.companyId;
+  if (!vatCompanyId) {
+    return schematronResult(rule, false);
+  }
+  return schematronResult(rule, vatCompanyId.startsWith('EL') && greekTinVerification(vatCompanyId.slice(2)));
+}