@saasicat/core 1.0.0-rc.26 → 1.0.0-rc.27

package/dist/index.js

@@ -426,7 +426,10 @@ var KINDS = {
   "bundle-version-offered": true,
   "feature-withdrawn": true,
   "feature-withdrawal-lifted": true,
-  "ended-at-once": true
+  "ended-at-once": true,
+  "collection-failed": true,
+  "collection-announced": true,
+  "collection-reversed": true
 };
 function toSubscriptionNoticeRecord(row) {
   return {
@@ -1530,6 +1533,24 @@ var INVOICE_ERROR_CODES = {
    * (`SC-AUD-012`).
    */
   SUBSCRIPTION_INVOICE_PARTIES_UNCONFIRMED: "SUBSCRIPTION_INVOICE_PARTIES_UNCONFIRMED",
+  /**
+   * The subscriber's direct debit names no mandate reference
+   * (`paymentMethodId`), which has to be announced before it is debited
+   * (`SC-PRIC-028`). An invoice collected by it draws no number, and one
+   * planned with it is not announced, until the payment method is replaced.
+   */
+  SUBSCRIPTION_INVOICE_MANDATE_MISSING: "SUBSCRIPTION_INVOICE_MANDATE_MISSING",
+  /**
+   * The subscriber (`subscriberId`) has no payment method in use, so the
+   * invoice is not collected until one is (`SC-PRIC-082`).
+   */
+  SUBSCRIPTION_INVOICE_NO_PAYMENT_METHOD: "SUBSCRIPTION_INVOICE_NO_PAYMENT_METHOD",
+  /**
+   * A direct debit announced again after a failed collection (`attemptKey`)
+   * waits until the subscriber has been told of that failure
+   * (`SC-PRIC-080`).
+   */
+  SUBSCRIPTION_INVOICE_FAILURE_NOT_TOLD: "SUBSCRIPTION_INVOICE_FAILURE_NOT_TOLD",
   /**
    * A file of the invoice's document has another checksum than the one
    * recorded or archived for it (`invoiceId`, `recorded`, `rendered`), and
@@ -1559,7 +1580,26 @@ var INVOICE_ERROR_CODES = {
    * archived invoice cannot be sent (`SC-PRIC-047`); it is sent once one is
    * entered.
    */
-  SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL: "SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL"
+  SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL: "SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL",
+  /** No credit under this id for the tenant's subscriber (`creditId`). */
+  SUBSCRIBER_CREDIT_NOT_FOUND: "SUBSCRIBER_CREDIT_NOT_FOUND",
+  /**
+   * A payout of more than the credit still owes (`creditId`, `open`): nothing
+   * is paid out beyond it (`SC-PRIC-083`), and nothing is recorded.
+   */
+  SUBSCRIBER_PAYOUT_EXCEEDS_CREDIT: "SUBSCRIBER_PAYOUT_EXCEEDS_CREDIT",
+  /**
+   * A payout on a day still to come (`paidOn`, `today` in the installation's
+   * zone): a payout is recorded once it left.
+   */
+  SUBSCRIBER_PAYOUT_NOT_MADE_YET: "SUBSCRIBER_PAYOUT_NOT_MADE_YET",
+  /** No case to reconcile under this id (`caseId`). */
+  SUBSCRIBER_RECONCILIATION_CASE_NOT_FOUND: "SUBSCRIBER_RECONCILIATION_CASE_NOT_FOUND",
+  /**
+   * A case closed before (`caseId`, `closedAt`), by the operator or by
+   * SaaSiCat; its note stands, and nothing is written (`SC-ADM-033`).
+   */
+  SUBSCRIBER_RECONCILIATION_CASE_CLOSED: "SUBSCRIBER_RECONCILIATION_CASE_CLOSED"
 };
 var SUBSCRIBER_ERROR_CODES = {
   /**
@@ -1802,6 +1842,38 @@ var OPTIONAL_CANONICAL_MODELS = {
   SubscriptionInvoiceNumber: ["entitlement.subscriptionInvoiceRepository"],
   SubscriptionInvoiceDocument: ["entitlement.subscriptionInvoiceRepository"],
   SubscriptionInvoiceArchive: ["entitlement.subscriptionInvoiceArchive"],
+  SubscriptionInvoiceCollection: [
+    "entitlement.invoiceCollectionRepository",
+    "entitlement.subscriberPaymentRepository"
+  ],
+  SubscriberPayment: [
+    "entitlement.subscriberPaymentRepository",
+    "entitlement.invoiceCollectionRepository"
+  ],
+  SubscriptionInvoiceSettlement: [
+    "entitlement.subscriberPaymentRepository",
+    "entitlement.invoiceCollectionRepository"
+  ],
+  SubscriberCredit: [
+    "entitlement.subscriberPaymentRepository",
+    "entitlement.invoiceCollectionRepository"
+  ],
+  SubscriberCreditEntry: [
+    "entitlement.subscriberPaymentRepository",
+    "entitlement.invoiceCollectionRepository"
+  ],
+  SubscriberRefund: [
+    "entitlement.subscriberPaymentRepository",
+    "entitlement.invoiceCollectionRepository"
+  ],
+  SubscriberReversal: [
+    "entitlement.subscriberPaymentRepository",
+    "entitlement.invoiceCollectionRepository"
+  ],
+  SubscriberReconciliationCase: [
+    "entitlement.subscriberPaymentRepository",
+    "entitlement.invoiceCollectionRepository"
+  ],
   PromoCodeHold: ["promo.holdRepository"]
 };
 function membersLeftOut(notAdopted = []) {
@@ -2046,12 +2118,20 @@ var ERROR_MESSAGES_EN = {
   SUBSCRIPTION_INVOICE_CHARGE_INVOICED: "Charge '{chargeId}' already stands on an invoice.",
   SUBSCRIPTION_INVOICE_CONTENT_INCOMPLETE: "The invoice lacks what the tax adapter {adapter} requires of it: {missing}. It is issued once that is supplied.",
   SUBSCRIPTION_INVOICE_PARTIES_UNCONFIRMED: "Contract {contractId} names no confirmed issuer and subscriber \u2014 a migration copied its parties, or it names no issuer \u2014 so its charges are not invoiced.",
+  SUBSCRIPTION_INVOICE_MANDATE_MISSING: "The direct debit {paymentMethodId} names no mandate reference, which has to be announced before it is debited. The invoice waits until the payment method is replaced.",
+  SUBSCRIPTION_INVOICE_NO_PAYMENT_METHOD: "The subscriber {subscriberId} has no payment method in use. The invoice is collected once one is.",
+  SUBSCRIPTION_INVOICE_FAILURE_NOT_TOLD: "The direct debit is announced once the subscriber has been told that collection {attemptKey} failed.",
   SUBSCRIPTION_INVOICE_DOCUMENT_CHANGED: "The document of invoice {invoiceId} differs from the one recorded or archived for it ({rendered} instead of {recorded}); the first stays, and the next run settles which one the invoice keeps.",
   SUBSCRIPTION_INVOICE_DOCUMENT_REFUSED: "The tax adapter {adapter} refuses the rendered invoice: {missing}. The invoice keeps its number and waits for a document that passes.",
   SUBSCRIPTION_INVOICE_DOCUMENT_MISMATCH: "The archived document of invoice {invoiceId} does not match the checksum recorded when it was rendered, and is not handed out.",
   SUBSCRIPTION_INVOICE_DOCUMENT_NOT_ARCHIVED: "The document of invoice {invoiceId} is not archived yet.",
   SUBSCRIPTION_INVOICE_NOT_FOUND: "No invoice '{invoiceId}'.",
   SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL: "Subscriber {subscriberId} has no invoice email, so its invoice cannot be sent; it is sent once one is entered.",
+  SUBSCRIBER_CREDIT_NOT_FOUND: "No credit '{creditId}' of this tenant's subscriber.",
+  SUBSCRIBER_PAYOUT_EXCEEDS_CREDIT: "The credit {creditId} still owes {open}; nothing beyond that is paid out, and nothing was recorded.",
+  SUBSCRIBER_PAYOUT_NOT_MADE_YET: "A payout is recorded once it left: {paidOn} is after today, {today}.",
+  SUBSCRIBER_RECONCILIATION_CASE_NOT_FOUND: "No case to reconcile '{caseId}'.",
+  SUBSCRIBER_RECONCILIATION_CASE_CLOSED: "The case {caseId} was closed on {closedAt}; its note stands, and nothing was recorded.",
   CHECKOUT_OFFER_LINE_ITEMS_REQUIRED: "A checkout offer can yield only one contract, and only once its line items are frozen.",
   CHECKOUT_OFFER_PLAN_LINE_ITEM_REQUIRED: "A checkout offer requires a frozen plan line item.",
   CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED: "Every selected bundle version requires a frozen bundle line item.",
@@ -2137,11 +2217,21 @@ var ERROR_MESSAGES_EN = {
   TAX_VAT_ID_CHECK_NOT_COMPLETED: "The VAT identification number could not be checked just now ({reason}). Please try again later.",
   TAX_VAT_ID_CHECK_NOT_AVAILABLE: "This installation names no tax adapter, so no VAT identification number is checked."
 };
+function parameterText(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (value instanceof Date) return String(value);
+  if (!Array.isArray(value)) return null;
+  const items = value.map(parameterText);
+  return items.every((item) => item !== null) ? items.join(",") : null;
+}
 function formatErrorMessage(template, params = {}) {
-  return template.replace(/\{(\w+)\}/g, (match, name) => {
-    const value = params[name];
-    return value === void 0 || value === null ? match : String(value);
-  });
+  return template.replace(
+    /\{(\w+)\}/g,
+    (match, name) => parameterText(params[name]) ?? match
+  );
 }
 function resolveErrorMessage(body, overrides = {}, defaults = ERROR_MESSAGES_EN) {
   const code = typeof body.code === "string" ? body.code : void 0;
@@ -2319,6 +2409,13 @@ function selectChargeableBundles(planFeatures, selectedBundles) {
 }
 
 // src/payment-gateway.types.ts
+var RETRYABLE_FAILURES = /* @__PURE__ */ new Set([
+  "insufficient-funds",
+  "declined"
+]);
+function isRetryableCollectionFailure(reason) {
+  return RETRYABLE_FAILURES.has(reason);
+}
 var PAYMENT_CALLBACK_REJECTED = "PAYMENT_CALLBACK_REJECTED";
 var PaymentCallbackRejectedError = class extends Error {
   code = PAYMENT_CALLBACK_REJECTED;
@@ -2565,6 +2662,87 @@ function formatInvoiceNumber(prefix, year, sequence) {
   return `${prefix}-${year}-${String(sequence).padStart(INVOICE_SEQUENCE_DIGITS, "0")}`;
 }
 
+// src/column-day.ts
+var DAY_LENGTH = "YYYY-MM-DD".length;
+function dayOf2(value, where) {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return value.toISOString().slice(0, DAY_LENGTH);
+  }
+  if (typeof value === "string" && value.length === DAY_LENGTH && !Number.isNaN(Date.parse(value))) {
+    return value;
+  }
+  throw new Error(`${where.table}.${where.column} of ${where.id} is not a day.`);
+}
+
+// src/subscriber-payment-method-mapping.ts
+var PAYMENT_METHOD_TYPES = ["card", "sepa_debit"];
+var STATUSES = ["ACTIVE", "REPLACED"];
+var TABLE4 = "subscriber_payment_methods";
+function toSubscriberPaymentMethodRecord(row) {
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    gatewayAccount: row.gatewayAccount,
+    provider: row.provider,
+    customerRef: row.customerRef,
+    paymentMethodRef: row.paymentMethodRef,
+    type: oneOf(PAYMENT_METHOD_TYPES, row.type, { table: TABLE4, column: "type", id: row.id }),
+    brand: row.brand,
+    last4: row.last4,
+    expiryMonth: row.expiryMonth,
+    expiryYear: row.expiryYear,
+    country: row.country,
+    bankCode: row.bankCode,
+    mandateReference: row.mandateReference,
+    status: oneOf(STATUSES, row.status, { table: TABLE4, column: "status", id: row.id }),
+    confirmedAt: row.confirmedAt,
+    replacedAt: row.replacedAt,
+    createdAt: row.createdAt
+  };
+}
+function subscriberPaymentMethodColumns(data) {
+  return {
+    subscriberId: data.subscriberId,
+    gatewayAccount: data.gatewayAccount,
+    provider: data.provider,
+    customerRef: data.customerRef,
+    paymentMethodRef: data.paymentMethodRef,
+    type: data.type,
+    brand: data.brand,
+    last4: data.last4,
+    expiryMonth: data.expiryMonth,
+    expiryYear: data.expiryYear,
+    country: data.country,
+    bankCode: data.bankCode,
+    mandateReference: data.mandateReference,
+    confirmedAt: data.confirmedAt
+  };
+}
+var FOREIGN_PAYMENT_METHOD_REFERENCE = "FOREIGN_PAYMENT_METHOD_REFERENCE";
+var ForeignPaymentMethodReferenceError = class extends Error {
+  constructor(gatewayAccount, paymentMethodRef) {
+    super(
+      `Payment method '${paymentMethodRef}' of account '${gatewayAccount}' belongs to another subscriber. A reference belongs to exactly one, so it is not handed out.`
+    );
+    this.gatewayAccount = gatewayAccount;
+    this.paymentMethodRef = paymentMethodRef;
+    this.name = "ForeignPaymentMethodReferenceError";
+  }
+  gatewayAccount;
+  paymentMethodRef;
+  code = FOREIGN_PAYMENT_METHOD_REFERENCE;
+};
+function isForeignPaymentMethodReferenceError(error) {
+  return error instanceof Error && error.code === FOREIGN_PAYMENT_METHOD_REFERENCE;
+}
+function refuseForeignPaymentMethodReference(recorded, subscriberId) {
+  if (recorded.subscriberId === subscriberId) return;
+  throw new ForeignPaymentMethodReferenceError(
+    recorded.gatewayAccount,
+    recorded.paymentMethodRef
+  );
+}
+
 // src/subscriber.types.ts
 var SUBSCRIBER_INVOICE_ADDRESS_FIELDS = [
   "addressLine1",
@@ -2706,6 +2884,7 @@ function toSubscriptionInvoiceRecord(row, lines) {
   if (!treatment) {
     throw new Error(`${INVOICES}.taxTreatment of ${row.id} is not a tax treatment.`);
   }
+  const dueDate = dayOf2(row.dueDate, where("dueDate"));
   return {
     id: row.id,
     number: row.number,
@@ -2718,9 +2897,10 @@ function toSubscriptionInvoiceRecord(row, lines) {
     contractId: row.contractId,
     issuedAt: row.issuedAt,
     issueDate: dayOf2(row.issueDate, where("issueDate")),
-    dueDate: dayOf2(row.dueDate, where("dueDate")),
+    dueDate,
     servicePeriodFrom: dayOf2(row.servicePeriodFrom, where("servicePeriodFrom")),
     servicePeriodUntil: dayOf2(row.servicePeriodUntil, where("servicePeriodUntil")),
+    ...collectionOf(row.payment, row.collectionDate, dueDate, where),
     currency: row.currency,
     issuer: issuerOf(row.issuerParty, where("issuerParty")),
     subscriber: subscriberOf(row.subscriberParty, where("subscriberParty")),
@@ -2766,6 +2946,8 @@ function subscriptionInvoiceColumns(invoice, drawn) {
     dueDate: invoice.dueDate,
     servicePeriodFrom: invoice.servicePeriodFrom,
     servicePeriodUntil: invoice.servicePeriodUntil,
+    payment: invoice.payment ? { ...invoice.payment } : null,
+    collectionDate: invoice.collectionDate,
     currency: invoice.currency,
     issuerParty: { ...invoice.issuer },
     subscriberParty: { ...invoice.subscriber },
@@ -2795,15 +2977,58 @@ function subscriptionInvoiceLineColumns(line, invoiceId) {
 function utcMidnightOf(day) {
   return /* @__PURE__ */ new Date(`${day}T00:00:00.000Z`);
 }
-var DAY_LENGTH = "YYYY-MM-DD".length;
-function dayOf2(value, where) {
-  if (value instanceof Date && !Number.isNaN(value.getTime())) {
-    return value.toISOString().slice(0, DAY_LENGTH);
+function collectionOf(payment, collectionDate, dueDate, where) {
+  const paymentAt = where("payment");
+  if (payment === void 0 || collectionDate === void 0) {
+    throw new Error(
+      `${paymentAt.table} row ${paymentAt.id} was read without its payment or its collection date.`
+    );
   }
-  if (typeof value === "string" && value.length === DAY_LENGTH && !Number.isNaN(Date.parse(value))) {
+  if (payment === null) {
+    if (collectionDate !== null) {
+      throw new Error(
+        `${paymentAt.table}.collectionDate of ${paymentAt.id} is set on an invoice that is not collected.`
+      );
+    }
+    return { payment: null, collectionDate: null };
+  }
+  if (typeof payment !== "object" || Array.isArray(payment)) {
+    throw new Error(`${paymentAt.table}.payment of ${paymentAt.id} is not a payment method.`);
+  }
+  const required = (key) => {
+    const value = textOrNull2(payment, key, paymentAt);
+    if (value === null) {
+      throw new Error(`${paymentAt.table}.payment of ${paymentAt.id} names no ${key}.`);
+    }
     return value;
+  };
+  const type = oneOf(PAYMENT_METHOD_TYPES, required("type"), {
+    ...paymentAt,
+    column: "payment.type"
+  });
+  const recorded = {
+    paymentMethodId: required("paymentMethodId"),
+    gatewayAccount: required("gatewayAccount"),
+    type,
+    brand: textOrNull2(payment, "brand", paymentAt),
+    last4: required("last4"),
+    mandateReference: type === "sepa_debit" ? required("mandateReference") : null
+  };
+  if (type !== "sepa_debit") {
+    if (collectionDate !== null) {
+      throw new Error(
+        `${paymentAt.table}.collectionDate of ${paymentAt.id} is set on an invoice paid by ${type}.`
+      );
+    }
+    return { payment: recorded, collectionDate: null };
   }
-  throw new Error(`${where.table}.${where.column} of ${where.id} is not a day.`);
+  const collected = dayOf2(collectionDate, where("collectionDate"));
+  if (collected !== dueDate) {
+    throw new Error(
+      `${paymentAt.table}.dueDate of ${paymentAt.id} is ${dueDate}, and a direct debit falls due on the day it is collected, ${collected}.`
+    );
+  }
+  return { payment: recorded, collectionDate: collected };
 }
 function footerOf(value, where) {
   if (!Array.isArray(value) || !value.every((line) => typeof line === "string")) {
@@ -2827,8 +3052,12 @@ function centsText(amount, field) {
   }
   return amount.toFixed(2);
 }
+function fieldOf(source, key) {
+  const field = Object.getOwnPropertyDescriptor(source, key)?.value;
+  return field;
+}
 function textOrNull2(source, key, where) {
-  const value = source[key];
+  const value = fieldOf(source, key);
   if (value === null || value === void 0) return null;
   if (typeof value !== "string") {
     throw new Error(`${where.table}.${where.column}.${key} of ${where.id} is not text.`);
@@ -2916,11 +3145,34 @@ function invoiceGroupsOf(charges) {
     (a, b) => a.bookedAt.getTime() - b.bookedAt.getTime() || a.contractId.localeCompare(b.contractId)
   );
 }
+var DIRECT_DEBIT_LEAD_DAYS = 14;
+function directDebitLeadDaysOf(invoicing) {
+  return invoicing.directDebitLeadDays ?? DIRECT_DEBIT_LEAD_DAYS;
+}
+function invoicePaymentOf(method) {
+  if (!method) return null;
+  if (method.type === "sepa_debit" && method.mandateReference === null) return null;
+  return {
+    paymentMethodId: method.id,
+    gatewayAccount: method.gatewayAccount,
+    type: method.type,
+    brand: method.brand,
+    last4: method.last4,
+    mandateReference: method.type === "sepa_debit" ? method.mandateReference : null
+  };
+}
 function draftSubscriptionInvoice(input) {
   const { group, treatment, timeZone } = input;
   const lines = linesOf(input);
   const issueDate = dayInZone(input.issuedAt, timeZone);
   const tax = input.tax(lines.map((line) => ({ net: line.amountNet, rate: line.taxRate })));
+  const payment = tax.gross > 0 ? input.payment : null;
+  if (payment?.type === "sepa_debit" && payment.mandateReference === null) {
+    throw new Error(
+      `Payment method ${payment.paymentMethodId} is a direct debit without a mandate reference, which an invoice collected by it has to announce.`
+    );
+  }
+  const collectionDate = payment?.type === "sepa_debit" ? addDaysToDay(issueDate, input.directDebitLeadDays) : null;
   return {
     numberPrefix: input.numberPrefix,
     numberYear: yearOfDay(issueDate),
@@ -2930,7 +3182,9 @@ function draftSubscriptionInvoice(input) {
     contractId: group.contractId,
     issuedAt: input.issuedAt,
     issueDate,
-    dueDate: addDaysToDay(issueDate, input.paymentTermDays),
+    dueDate: collectionDate ?? addDaysToDay(issueDate, input.paymentTermDays),
+    payment: payment ? { ...payment } : null,
+    collectionDate,
     servicePeriodFrom: lines.map((line) => line.periodFrom).sort()[0],
     servicePeriodUntil: lines.map((line) => line.periodUntil).sort().at(-1),
     currency: currencyOf(group),
@@ -3089,6 +3343,802 @@ function invoiceArchiveProtectionProblem(enabledTriggers) {
   return `${ARCHIVE} lacks ${missing.join(" and ")}, which keep an archived invoice document as it was issued: run @saasicat/spec/sql/1.0-an-invoice-document-is-archived.postgres.sql after db push, and enable the triggers where they were disabled.`;
 }
 
+// src/invoice-collection.types.ts
+function sentCollectionOf(attempt) {
+  const { submittedAt, heldAt } = attempt;
+  if (submittedAt === null || heldAt === null) {
+    throw new Error(`Collection attempt ${attempt.attemptKey} has not been sent.`);
+  }
+  return { ...attempt, submittedAt, heldAt };
+}
+var INVOICE_COLLECTION_LEASE_MS = 15 * 6e4;
+var INVOICE_COLLECTION_ASK_EVERY_MS = 60 * 6e4;
+function collectionAttemptKey(invoiceId, attempt) {
+  if (!Number.isInteger(attempt) || attempt < 1) {
+    throw new RangeError(`A collection attempt counts from 1; ${attempt} is not one.`);
+  }
+  return `saasicat:collect:${invoiceId}:${attempt}`;
+}
+function collectionStatusOf(outcome) {
+  if (outcome.status === "succeeded") return "SUCCEEDED";
+  if (outcome.status === "pending") return "PENDING";
+  return "FAILED";
+}
+var COLLECTION_NOT_SENT_PAID = {
+  status: "failed",
+  paymentRef: null,
+  reason: "other",
+  gatewayCode: "saasicat_invoice_paid"
+};
+var COLLECTION_NOT_SENT_REVERSED = {
+  status: "failed",
+  paymentRef: null,
+  reason: "other",
+  gatewayCode: "saasicat_payment_method_reversed"
+};
+
+// src/invoice-collection-mapping.ts
+var TABLE5 = "subscription_invoice_collections";
+var INVOICE_COLLECTION_STATUSES = [
+  "SCHEDULED",
+  "SUBMITTED",
+  "PENDING",
+  "SUCCEEDED",
+  "FAILED",
+  "WITHDRAWN",
+  "REVERSED"
+];
+var UNSETTLED_COLLECTION_STATUSES = [
+  "SUBMITTED",
+  "PENDING"
+];
+var BLOCKING_COLLECTION_STATUSES = [
+  "SCHEDULED",
+  ...UNSETTLED_COLLECTION_STATUSES,
+  "SUCCEEDED"
+];
+var FOLLOWED_UP_COLLECTION_STATUSES = [
+  "FAILED",
+  "REVERSED"
+];
+var REVERSIBLE_COLLECTION_STATUSES = [
+  "SUCCEEDED",
+  "FAILED"
+];
+function lastCollectionOf(earlier) {
+  return earlier.reduce((last, row) => Math.max(last, row.attempt), 0);
+}
+function refusesFirstAttempt(earlier) {
+  return earlier.length > 0;
+}
+function refusesPlannedAttempt(earlier, after) {
+  return earlier.some((row) => BLOCKING.has(row.status)) || lastCollectionOf(earlier) !== after;
+}
+var BLOCKING = new Set(BLOCKING_COLLECTION_STATUSES);
+var NOT_SENT = /* @__PURE__ */ new Set(["SCHEDULED", "WITHDRAWN"]);
+var COLLECTION_FAILURE_REASONS = [
+  "insufficient-funds",
+  "declined",
+  "authentication-required",
+  "payment-method-unusable",
+  "mandate-invalid",
+  "other"
+];
+function toInvoiceCollectionRecord(row) {
+  const where = (column) => ({ table: TABLE5, column, id: row.id });
+  const amount = Number(
+    // oxlint-disable-next-line typescript/no-base-to-string -- Prisma hands a Decimal, whose text is the number; any other object becomes NaN and is refused below
+    row.amount === null || row.amount === void 0 ? NaN : String(row.amount)
+  );
+  if (!Number.isFinite(amount)) {
+    throw new Error(`${TABLE5}.amount of ${row.id} is not an amount.`);
+  }
+  const status = oneOf(INVOICE_COLLECTION_STATUSES, row.status, where("status"));
+  const sent = !NOT_SENT.has(status);
+  if (sent !== (row.submittedAt !== null) || sent !== (row.heldAt !== null)) {
+    throw new Error(
+      `${TABLE5}.submittedAt and heldAt of ${row.id} do not fit its status ${status}: an attempt that left carries both, and one that did not carries neither.`
+    );
+  }
+  const collectOn = row.collectOn === null || row.collectOn === void 0 ? null : dayOf2(row.collectOn, where("collectOn"));
+  if (status === "SCHEDULED" && collectOn === null) {
+    throw new Error(`${TABLE5}.collectOn of ${row.id} is missing from a planned attempt.`);
+  }
+  return {
+    id: row.id,
+    invoiceId: row.invoiceId,
+    attempt: row.attempt,
+    attemptKey: row.attemptKey,
+    gatewayAccount: row.gatewayAccount,
+    paymentMethodId: row.paymentMethodId,
+    paymentMethodType: oneOf(
+      PAYMENT_METHOD_TYPES,
+      row.paymentMethodType,
+      where("paymentMethodType")
+    ),
+    customerRef: row.customerRef,
+    paymentMethodRef: row.paymentMethodRef,
+    invoiceNumber: row.invoiceNumber,
+    amount,
+    currency: row.currency,
+    status,
+    paymentRef: row.paymentRef,
+    failureReason: row.failureReason === null ? null : oneOf(COLLECTION_FAILURE_REASONS, row.failureReason, where("failureReason")),
+    failureCode: row.failureCode,
+    submittedAt: row.submittedAt,
+    heldAt: row.heldAt,
+    resolvedAt: row.resolvedAt,
+    collectOn,
+    announcedAt: row.announcedAt,
+    followedUpAt: row.followedUpAt
+  };
+}
+function invoiceCollectionColumns(attempt, number) {
+  return {
+    invoiceId: attempt.invoiceId,
+    attempt: number,
+    attemptKey: collectionAttemptKey(attempt.invoiceId, number),
+    gatewayAccount: attempt.gatewayAccount,
+    paymentMethodId: attempt.paymentMethodId,
+    paymentMethodType: attempt.paymentMethodType,
+    customerRef: attempt.customerRef,
+    paymentMethodRef: attempt.paymentMethodRef,
+    invoiceNumber: attempt.invoiceNumber,
+    amount: attempt.amount.toFixed(2),
+    currency: attempt.currency,
+    status: "SUBMITTED",
+    submittedAt: attempt.at,
+    heldAt: attempt.at,
+    collectOn: null
+  };
+}
+function plannedCollectionColumns(plan, number) {
+  return {
+    invoiceId: plan.invoiceId,
+    attempt: number,
+    attemptKey: collectionAttemptKey(plan.invoiceId, number),
+    gatewayAccount: plan.gatewayAccount,
+    paymentMethodId: plan.paymentMethodId,
+    paymentMethodType: plan.paymentMethodType,
+    customerRef: plan.customerRef,
+    paymentMethodRef: plan.paymentMethodRef,
+    invoiceNumber: plan.invoiceNumber,
+    amount: plan.amount.toFixed(2),
+    currency: plan.currency,
+    status: "SCHEDULED",
+    submittedAt: null,
+    heldAt: null,
+    collectOn: plan.collectOn
+  };
+}
+function collectionOutcomeColumns(outcome, at) {
+  const failed = outcome.status === "failed" ? outcome : null;
+  return {
+    status: collectionStatusOf(outcome),
+    paymentRef: outcome.paymentRef,
+    failureReason: failed?.reason ?? null,
+    failureCode: failed?.gatewayCode ?? null,
+    resolvedAt: outcome.status === "pending" ? null : at
+  };
+}
+
+// src/invoice-collection-plan.ts
+var COLLECTION_RETRY_AFTER_DAYS = 7;
+function isChargedAgain(failed, attempts) {
+  if (failed.status !== "FAILED" || failed.failureReason === null) return false;
+  if (!isRetryableCollectionFailure(failed.failureReason)) return false;
+  return !attempts.some(
+    (other) => other.id !== failed.id && other.status === "FAILED" && other.paymentMethodId === failed.paymentMethodId
+  );
+}
+function chargedAgainOn(failedOn) {
+  return addDaysToDay(failedOn, COLLECTION_RETRY_AFTER_DAYS);
+}
+function announcedCollectionDay(earliest2, announcedOn, leadDays) {
+  const afterLead = addDaysToDay(announcedOn, leadDays);
+  return afterLead > earliest2 ? afterLead : earliest2;
+}
+
+// src/invoice-collection-notice-mapping.ts
+var TABLE6 = "subscription_notices";
+var NEXT_ACTIONS = [
+  "charged-again",
+  "announced-again",
+  "replace-payment-method"
+];
+var AFTER_REVERSAL_ACTIONS = [
+  "collected-with-payment-method-in-use",
+  "replace-payment-method"
+];
+var NoticeFields = class _NoticeFields {
+  constructor(content, id) {
+    this.content = content;
+    this.id = id;
+  }
+  content;
+  id;
+  where(column) {
+    return { table: TABLE6, column: `content.${column}`, id: this.id };
+  }
+  value(name) {
+    if (this.content === null || typeof this.content !== "object") {
+      throw new Error(`${TABLE6}.content of ${this.id} is not a notice.`);
+    }
+    return Object.getOwnPropertyDescriptor(this.content, name)?.value;
+  }
+  text(name) {
+    const value = this.value(name);
+    if (typeof value !== "string" || value === "") {
+      throw new Error(`${TABLE6}.content.${name} of ${this.id} is not a text.`);
+    }
+    return value;
+  }
+  amount(name) {
+    const value = this.value(name);
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      throw new Error(`${TABLE6}.content.${name} of ${this.id} is not an amount.`);
+    }
+    return value;
+  }
+  day(name) {
+    return dayOf2(this.value(name), this.where(name));
+  }
+  oneOf(allowed, name) {
+    return oneOf(allowed, this.text(name), this.where(name));
+  }
+  nested(name) {
+    return new _NoticeFields(this.value(name), this.id);
+  }
+  invoice() {
+    return {
+      tenantId: this.text("tenantId"),
+      subscriptionId: this.text("subscriptionId"),
+      subscriberId: this.text("subscriberId"),
+      invoiceId: this.text("invoiceId"),
+      invoiceNumber: this.text("invoiceNumber"),
+      amount: this.amount("amount"),
+      currency: this.text("currency")
+    };
+  }
+};
+function toCollectionFailedNotice(content, id) {
+  const fields = new NoticeFields(content, id);
+  const next = fields.nested("next");
+  const action = next.oneOf(NEXT_ACTIONS, "action");
+  return {
+    kind: fields.oneOf(["collection-failed"], "kind"),
+    ...fields.invoice(),
+    paymentMethodType: fields.oneOf(PAYMENT_METHOD_TYPES, "paymentMethodType"),
+    reason: fields.oneOf(COLLECTION_FAILURE_REASONS, "reason"),
+    next: action === "charged-again" ? { action, on: next.day("on") } : { action }
+  };
+}
+function toCollectionAnnouncedNotice(content, id) {
+  const fields = new NoticeFields(content, id);
+  return {
+    kind: fields.oneOf(["collection-announced"], "kind"),
+    ...fields.invoice(),
+    collectOn: fields.day("collectOn"),
+    mandateReference: fields.text("mandateReference"),
+    last4: fields.text("last4")
+  };
+}
+function toCollectionReversedNotice(content, id) {
+  const fields = new NoticeFields(content, id);
+  return {
+    kind: fields.oneOf(["collection-reversed"], "kind"),
+    ...fields.invoice(),
+    paymentMethodType: fields.oneOf(PAYMENT_METHOD_TYPES, "paymentMethodType"),
+    owed: fields.amount("owed"),
+    next: { action: fields.nested("next").oneOf(AFTER_REVERSAL_ACTIONS, "action") }
+  };
+}
+
+// src/subscriber-payment.types.ts
+var SUBSCRIBER_CREDIT_CAPABILITY = "credits.read";
+var SUBSCRIBER_PAYOUT_CAPABILITY = "credits.payout";
+
+// src/column-amount.ts
+function columnAmountOf(value, where) {
+  const amount = Number(value === null || value === void 0 ? NaN : String(value));
+  if (!Number.isFinite(amount)) {
+    throw new Error(`${where.table}.${where.column} of ${where.id} is not an amount.`);
+  }
+  return amount;
+}
+
+// src/subscriber-payment-mapping.ts
+var PAYMENTS = "subscriber_payments";
+var CREDITS = "subscriber_credits";
+var CREDIT_ENTRIES = "subscriber_credit_entries";
+var REFUNDS = "subscriber_refunds";
+var SETTLEMENTS = "subscription_invoice_settlements";
+var REVERSALS = "subscriber_reversals";
+var INVOICE_SETTLEMENT_KINDS = [
+  "PAYMENT",
+  "REVERSAL",
+  "REINSTATEMENT"
+];
+var REOPENING_SETTLEMENT_KINDS = ["REVERSAL"];
+var SUBSCRIBER_CREDIT_ENTRY_KINDS = [
+  "REFUND",
+  "REFUND_FAILED",
+  "PAYOUT",
+  "REVERSAL",
+  "REVERSAL_TAKEN_BACK"
+];
+var REFUND_ENTRY_KINDS = /* @__PURE__ */ new Set([
+  "REFUND",
+  "REFUND_FAILED"
+]);
+var REVERSAL_ENTRY_KINDS = /* @__PURE__ */ new Set([
+  "REVERSAL",
+  "REVERSAL_TAKEN_BACK"
+]);
+var SUBSCRIBER_REFUND_STATUSES = [
+  "PENDING",
+  "SUCCEEDED",
+  "FAILED",
+  "CANCELED"
+];
+var ENDED_REFUND_STATUSES = ["FAILED", "CANCELED"];
+function isEndedRefund(status) {
+  return ENDED_REFUND_STATUSES.includes(status);
+}
+function toSubscriberPaymentRecord(row) {
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    tenantId: row.tenantId,
+    invoiceId: row.invoiceId,
+    collectionId: row.collectionId,
+    gatewayAccount: row.gatewayAccount,
+    provider: row.provider,
+    gatewayRef: row.gatewayRef,
+    amount: columnAmountOf(row.amount, { table: PAYMENTS, column: "amount", id: row.id }),
+    currency: row.currency,
+    recordedAt: row.recordedAt
+  };
+}
+function subscriberPaymentColumns(payment, invoice) {
+  return {
+    subscriberId: invoice.subscriberId,
+    tenantId: invoice.tenantId,
+    invoiceId: payment.invoiceId,
+    collectionId: payment.collectionId,
+    gatewayAccount: payment.gatewayAccount,
+    provider: payment.provider,
+    gatewayRef: payment.gatewayRef,
+    amount: toDecimalString(payment.amount),
+    currency: payment.currency,
+    recordedAt: payment.at
+  };
+}
+function settledAmountOf(row) {
+  const kind = oneOf(INVOICE_SETTLEMENT_KINDS, row.kind, {
+    table: SETTLEMENTS,
+    column: "kind",
+    id: row.id
+  });
+  const amount = columnAmountOf(row.amount, { table: SETTLEMENTS, column: "amount", id: row.id });
+  return REOPENING_SETTLEMENT_KINDS.includes(kind) ? -amount : amount;
+}
+function toSubscriberCreditRecord(row) {
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    tenantId: row.tenantId,
+    amount: columnAmountOf(row.amount, { table: CREDITS, column: "amount", id: row.id }),
+    currency: row.currency,
+    origin: creditOriginOf(row),
+    createdAt: row.createdAt
+  };
+}
+function creditOriginOf(row) {
+  const origins = [];
+  if (row.originPaymentId !== null) {
+    origins.push({ kind: "payment", paymentId: row.originPaymentId });
+  }
+  if (row.originInvoiceId !== null) {
+    origins.push({ kind: "invoice", invoiceId: row.originInvoiceId });
+  }
+  if (row.originReversalId !== null) {
+    origins.push({ kind: "reversal", reversalId: row.originReversalId });
+  }
+  const [origin] = origins;
+  if (origin && origins.length === 1) return origin;
+  throw new Error(
+    `${CREDITS} row '${row.id}' names ${origins.length === 0 ? "none" : String(origins.length)} of a payment, an invoice and a reversal it comes from; a credit comes from exactly one.`
+  );
+}
+function toSubscriberCreditEntryRecord(row) {
+  const where = (column) => ({ table: CREDIT_ENTRIES, column, id: row.id });
+  const kind = oneOf(SUBSCRIBER_CREDIT_ENTRY_KINDS, row.kind, where("kind"));
+  const paidOn = row.paidOn === null || row.paidOn === void 0 ? null : dayOf2(row.paidOn, where("paidOn"));
+  if (REFUND_ENTRY_KINDS.has(kind) !== (row.refundId !== null)) {
+    throw new Error(
+      `${CREDIT_ENTRIES} row '${row.id}' is a ${kind} ${row.refundId === null ? "without" : "with"} a refund; the entries of a refund name it, and no other entry does.`
+    );
+  }
+  if (REVERSAL_ENTRY_KINDS.has(kind) !== (row.reversalId !== null)) {
+    throw new Error(
+      `${CREDIT_ENTRIES} row '${row.id}' is a ${kind} ${row.reversalId === null ? "without" : "with"} a reversal; the entries of a reversal name it, and no other entry does.`
+    );
+  }
+  return {
+    id: row.id,
+    creditId: row.creditId,
+    kind,
+    amount: columnAmountOf(row.amount, where("amount")),
+    refundId: row.refundId,
+    reversalId: row.reversalId,
+    reference: row.reference,
+    paidOn,
+    recordedBy: row.recordedBy,
+    note: row.note,
+    recordedAt: row.recordedAt
+  };
+}
+function refundEntryColumns(creditId, refund, kind, amount, at) {
+  return {
+    creditId,
+    kind,
+    amount: toDecimalString(amount),
+    refundId: refund.id,
+    reversalId: null,
+    reference: refund.gatewayRef,
+    paidOn: null,
+    recordedBy: null,
+    note: null,
+    recordedAt: at
+  };
+}
+function payoutEntryColumns(payout) {
+  return {
+    creditId: payout.creditId,
+    kind: "PAYOUT",
+    amount: toDecimalString(payout.amount),
+    refundId: null,
+    reversalId: null,
+    reference: payout.reference,
+    paidOn: payout.paidOn,
+    recordedBy: payout.recordedBy,
+    note: payout.note,
+    recordedAt: payout.at
+  };
+}
+function toSubscriberRefundRecord(row) {
+  const where = (column) => ({ table: REFUNDS, column, id: row.id });
+  const status = oneOf(SUBSCRIBER_REFUND_STATUSES, row.status, where("status"));
+  if (isEndedRefund(status) !== (row.endedAt !== null)) {
+    throw new Error(
+      `${REFUNDS}.endedAt of ${row.id} does not fit its status ${status}: a refund that failed or was canceled carries when, and one that pays out does not.`
+    );
+  }
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    paymentId: row.paymentId,
+    gatewayAccount: row.gatewayAccount,
+    gatewayRef: row.gatewayRef,
+    amount: columnAmountOf(row.amount, where("amount")),
+    currency: row.currency,
+    status,
+    recordedAt: row.recordedAt,
+    endedAt: row.endedAt
+  };
+}
+function subscriberRefundColumns(refund, payment) {
+  return {
+    subscriberId: payment.subscriberId,
+    paymentId: payment.id,
+    gatewayAccount: refund.gatewayAccount,
+    gatewayRef: refund.gatewayRef,
+    amount: toDecimalString(refund.amount),
+    currency: refund.currency,
+    status: refund.status,
+    recordedAt: refund.at,
+    endedAt: isEndedRefund(refund.status) ? refund.at : null
+  };
+}
+function reversalEntryColumns(creditId, reversal, kind, amount, at) {
+  return {
+    creditId,
+    kind,
+    amount: toDecimalString(amount),
+    refundId: null,
+    reversalId: reversal.id,
+    reference: reversal.gatewayRef,
+    paidOn: null,
+    recordedBy: null,
+    note: null,
+    recordedAt: at
+  };
+}
+function toSubscriberReversalRecord(row) {
+  const where = (column) => ({ table: REVERSALS, column, id: row.id });
+  const amount = columnAmountOf(row.amount, where("amount"));
+  const fromCredit = columnAmountOf(row.fromCredit, where("fromCredit"));
+  const reinstated = columnAmountOf(row.reinstated, where("reinstated"));
+  const within = (part) => part >= 0 && toCents(part) <= toCents(amount);
+  if (!within(fromCredit) || !within(reinstated)) {
+    throw new Error(
+      `${REVERSALS} row '${row.id}' takes ${fromCredit} from the credit and is given back ${reinstated} of the ${amount} it withdrew; each is a part of it.`
+    );
+  }
+  if (reinstated > 0 !== (row.reinstatedAt !== null)) {
+    throw new Error(
+      `${REVERSALS}.reinstatedAt of ${row.id} does not fit what was given back of it: a reversal given something back carries when, and one given nothing does not.`
+    );
+  }
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    tenantId: row.tenantId,
+    paymentId: row.paymentId,
+    gatewayAccount: row.gatewayAccount,
+    gatewayRef: row.gatewayRef,
+    amount,
+    currency: row.currency,
+    fromCredit,
+    reinstated,
+    recordedAt: row.recordedAt,
+    reinstatedAt: row.reinstatedAt
+  };
+}
+function subscriberReversalColumns(reversal, payment) {
+  return {
+    subscriberId: payment.subscriberId,
+    tenantId: payment.tenantId,
+    paymentId: payment.id,
+    gatewayAccount: reversal.gatewayAccount,
+    gatewayRef: reversal.gatewayRef,
+    amount: toDecimalString(0),
+    currency: reversal.currency,
+    fromCredit: toDecimalString(0),
+    reinstated: toDecimalString(0),
+    recordedAt: reversal.at,
+    reinstatedAt: null
+  };
+}
+
+// src/subscriber-payment-rules.ts
+function owedOn(gross, settled) {
+  const paid = settled.reduce((sum2, amount) => sum2 + toCents(amount), 0);
+  return (toCents(gross) - paid) / 100;
+}
+function paymentSettlement(amount, owed) {
+  const brought = toCents(amount);
+  const settles = Math.min(brought, Math.max(0, toCents(owed)));
+  return { settles: settles / 100, credits: (brought - settles) / 100 };
+}
+var GIVING_BACK_CREDIT_ENTRY_KINDS = [
+  "REFUND_FAILED",
+  "REVERSAL_TAKEN_BACK"
+];
+var GIVING_BACK = new Set(GIVING_BACK_CREDIT_ENTRY_KINDS);
+function paidOutBy(entry) {
+  const cents2 = toCents(entry.amount);
+  return GIVING_BACK.has(entry.kind) ? -cents2 : cents2;
+}
+function openOfCredit(amount, entries) {
+  const paidOut = entries.reduce((sum2, entry) => sum2 + paidOutBy(entry), 0);
+  return Math.max(0, toCents(amount) - paidOut) / 100;
+}
+function refundParts(amount, paymentId, credits) {
+  const ownFirst = [...credits].sort(
+    (a, b) => rankFor(a, paymentId) - rankFor(b, paymentId) || a.createdAt.getTime() - b.createdAt.getTime() || a.id.localeCompare(b.id, "en")
+  );
+  let left = toCents(amount);
+  const parts = [];
+  for (const credit of ownFirst) {
+    if (left === 0) break;
+    const taken = Math.min(left, toCents(credit.open));
+    if (taken <= 0) continue;
+    parts.push({ creditId: credit.id, amount: taken / 100 });
+    left -= taken;
+  }
+  return { parts, unmatched: left / 100 };
+}
+function rankFor(credit, paymentId) {
+  return credit.origin.kind === "payment" && credit.origin.paymentId === paymentId ? 0 : 1;
+}
+function withdrawalParts(amount, credit, invoices, covering = []) {
+  let left = toCents(amount);
+  const share = credit ? Math.min(left, Math.max(0, toCents(credit.left))) : 0;
+  const open = credit ? Math.min(share, Math.max(0, toCents(credit.open))) : 0;
+  left -= share;
+  const opening = [];
+  for (const invoice of invoices) {
+    if (left === 0) break;
+    const taken = Math.min(left, Math.max(0, toCents(invoice.left)));
+    if (taken === 0) continue;
+    opening.push({ invoiceId: invoice.invoiceId, cents: taken });
+    left -= taken;
+  }
+  let toCover = opening.reduce((sum2, each) => sum2 + each.cents, 0);
+  const covered = [];
+  for (const other of covering) {
+    if (toCover === 0) break;
+    const taken = Math.min(toCover, Math.max(0, toCents(other.open)));
+    if (taken === 0) continue;
+    covered.push({ creditId: other.creditId, amount: taken / 100 });
+    toCover -= taken;
+  }
+  let coveredCents = opening.reduce((sum2, each) => sum2 + each.cents, 0) - toCover;
+  const opened = [];
+  for (const each of opening) {
+    const kept = Math.min(each.cents, coveredCents);
+    coveredCents -= kept;
+    if (each.cents > kept) {
+      opened.push({ invoiceId: each.invoiceId, amount: (each.cents - kept) / 100 });
+    }
+  }
+  return {
+    fromCredit: share / 100,
+    credit: credit && open > 0 ? { creditId: credit.creditId, amount: open / 100 } : null,
+    covering: covered,
+    invoices: opened,
+    unmatched: (share - open + left) / 100
+  };
+}
+function reinstatementParts(amount, took) {
+  let left = toCents(amount);
+  const covered = Math.min(left, Math.max(0, toCents(took.unmatched)));
+  left -= covered;
+  const credits = [];
+  for (const credit of took.credits) {
+    const given = Math.min(left, Math.max(0, toCents(credit.left)));
+    if (given === 0) continue;
+    credits.push({ creditId: credit.creditId, amount: given / 100 });
+    left -= given;
+  }
+  const invoices = [];
+  let credited = 0;
+  for (const invoice of took.invoices) {
+    const given = Math.min(left, Math.max(0, toCents(invoice.left)));
+    if (given === 0) continue;
+    const settles = Math.min(given, Math.max(0, toCents(invoice.owed)));
+    if (settles > 0) invoices.push({ invoiceId: invoice.invoiceId, amount: settles / 100 });
+    credited += given - settles;
+    left -= given;
+  }
+  return {
+    covered: covered / 100,
+    credits,
+    invoices,
+    credited: credited / 100,
+    beyond: left / 100
+  };
+}
+function netByInvoice(entries) {
+  const net = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    net.set(entry.invoiceId, (net.get(entry.invoiceId) ?? 0) + toCents(entry.amount));
+  }
+  return [...net].map(([invoiceId, cents2]) => ({ invoiceId, amount: cents2 / 100 }));
+}
+function paidOutByCredit(entries) {
+  const paid = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    paid.set(entry.creditId, (paid.get(entry.creditId) ?? 0) + paidOutBy(entry));
+  }
+  return [...paid].map(([creditId, cents2]) => ({ creditId, amount: cents2 / 100 }));
+}
+function coversOf(entries, own) {
+  const taken = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.reversalId === null || own.has(entry.reversalId)) continue;
+    taken.set(entry.reversalId, (taken.get(entry.reversalId) ?? 0) + paidOutBy(entry));
+  }
+  return [...taken].filter(([, cents2]) => cents2 > 0).map(([reversalId, cents2]) => ({ reversalId, amount: cents2 / 100 }));
+}
+function coversLifted(parts, covers) {
+  let reach = toCents(parts.fromCredit) - toCents(parts.credit?.amount ?? 0);
+  const lifted = [];
+  for (const cover of covers) {
+    if (reach <= 0) break;
+    const taken = Math.min(reach, toCents(cover.amount));
+    if (taken <= 0) continue;
+    lifted.push({ reversalId: cover.reversalId, amount: taken / 100 });
+    reach -= taken;
+  }
+  const liftedCents = lifted.reduce((sum2, each) => sum2 + toCents(each.amount), 0);
+  return { lifted, unmatched: (toCents(parts.unmatched) - liftedCents) / 100 };
+}
+function inWithdrawalOrder(parts, credits, paymentId) {
+  const byId = new Map(credits.map((credit) => [credit.id, credit]));
+  const rank = (part) => {
+    const credit = byId.get(part.creditId);
+    if (!credit) return [2, 0, part.creditId];
+    const own = credit.origin.kind === "payment" && credit.origin.paymentId === paymentId;
+    return [own ? 0 : 1, credit.createdAt.getTime(), credit.id];
+  };
+  return [...parts].sort((a, b) => {
+    const [x, y] = [rank(a), rank(b)];
+    return x[0] - y[0] || x[1] - y[1] || x[2].localeCompare(y[2], "en");
+  });
+}
+function casesCovered(cases, covered) {
+  const limit = toCents(covered);
+  let running = 0;
+  const ids = [];
+  for (const each of cases) {
+    running += toCents(each.amount);
+    if (running <= limit) ids.push(each.id);
+  }
+  return ids;
+}
+
+// src/subscriber-reconciliation.types.ts
+var RECONCILIATION_READ_CAPABILITY = "reconciliation.read";
+var RECONCILIATION_CLOSE_CAPABILITY = "reconciliation.close";
+var SUBSCRIBER_PAYMENTS_CAPABILITY = "payments.read";
+var RECONCILIATION_NOTE_MAX_LENGTH = 500;
+
+// src/subscriber-reconciliation-mapping.ts
+var CASES2 = "subscriber_reconciliation_cases";
+var RECONCILIATION_CASE_KINDS = [
+  "REFUND_UNMATCHED",
+  "REVERSAL_UNMATCHED"
+];
+function toSubscriberReconciliationCaseRecord(row) {
+  const where = (column) => ({ table: CASES2, column, id: row.id });
+  const kind = oneOf(RECONCILIATION_CASE_KINDS, row.kind, where("kind"));
+  const aboutRefund = kind === "REFUND_UNMATCHED";
+  if (aboutRefund !== (row.refundId !== null) || aboutRefund === (row.reversalId !== null)) {
+    throw new Error(
+      `${CASES2} row '${row.id}' is a ${kind} naming ${row.refundId === null ? "no" : "a"} refund and ${row.reversalId === null ? "no" : "a"} reversal; a case names what it is about, and nothing else.`
+    );
+  }
+  if (row.closedAt === null !== (row.note === null)) {
+    throw new Error(
+      `${CASES2} row '${row.id}' is ${row.closedAt === null ? "open with" : "closed without"} a note; a case is closed with one, and an open case carries none.`
+    );
+  }
+  if (row.closedAt === null && row.closedBy !== null) {
+    throw new Error(`${CASES2} row '${row.id}' is open and names who closed it.`);
+  }
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    tenantId: row.tenantId,
+    kind,
+    amount: columnAmountOf(row.amount, where("amount")),
+    currency: row.currency,
+    paymentId: row.paymentId,
+    refundId: row.refundId,
+    reversalId: row.reversalId,
+    gatewayAccount: row.gatewayAccount,
+    gatewayRef: row.gatewayRef,
+    recordedAt: row.recordedAt,
+    closedAt: row.closedAt,
+    closedBy: row.closedBy,
+    note: row.note
+  };
+}
+function reconciliationCaseColumns(opened) {
+  const aboutRefund = opened.kind === "REFUND_UNMATCHED";
+  return {
+    subscriberId: opened.payment.subscriberId,
+    tenantId: opened.payment.tenantId,
+    kind: opened.kind,
+    amount: toDecimalString(opened.amount),
+    currency: opened.currency,
+    paymentId: opened.payment.id,
+    refundId: aboutRefund ? opened.about.id : null,
+    reversalId: aboutRefund ? null : opened.about.id,
+    gatewayAccount: opened.about.gatewayAccount,
+    gatewayRef: opened.about.gatewayRef,
+    recordedAt: opened.at,
+    closedAt: null,
+    closedBy: null,
+    note: null
+  };
+}
+var CASE_CLOSED_REFUND_ENDED = "The refund failed or was canceled, and its money came back.";
+var CASE_CLOSED_REVERSAL_GIVEN_BACK = "The gateway gave the reversal back, and with it what matched nothing.";
+
 // src/e-invoice-format.ts
 var CATEGORY = {
   standard: "S",
@@ -3236,75 +4286,6 @@ function toIdentityValues(value) {
   return values;
 }
 
-// src/subscriber-payment-method-mapping.ts
-var PAYMENT_METHOD_TYPES = ["card", "sepa_debit"];
-var STATUSES = ["ACTIVE", "REPLACED"];
-var TABLE4 = "subscriber_payment_methods";
-function toSubscriberPaymentMethodRecord(row) {
-  return {
-    id: row.id,
-    subscriberId: row.subscriberId,
-    gatewayAccount: row.gatewayAccount,
-    provider: row.provider,
-    customerRef: row.customerRef,
-    paymentMethodRef: row.paymentMethodRef,
-    type: oneOf(PAYMENT_METHOD_TYPES, row.type, { table: TABLE4, column: "type", id: row.id }),
-    brand: row.brand,
-    last4: row.last4,
-    expiryMonth: row.expiryMonth,
-    expiryYear: row.expiryYear,
-    country: row.country,
-    bankCode: row.bankCode,
-    mandateReference: row.mandateReference,
-    status: oneOf(STATUSES, row.status, { table: TABLE4, column: "status", id: row.id }),
-    confirmedAt: row.confirmedAt,
-    replacedAt: row.replacedAt,
-    createdAt: row.createdAt
-  };
-}
-function subscriberPaymentMethodColumns(data) {
-  return {
-    subscriberId: data.subscriberId,
-    gatewayAccount: data.gatewayAccount,
-    provider: data.provider,
-    customerRef: data.customerRef,
-    paymentMethodRef: data.paymentMethodRef,
-    type: data.type,
-    brand: data.brand,
-    last4: data.last4,
-    expiryMonth: data.expiryMonth,
-    expiryYear: data.expiryYear,
-    country: data.country,
-    bankCode: data.bankCode,
-    mandateReference: data.mandateReference,
-    confirmedAt: data.confirmedAt
-  };
-}
-var FOREIGN_PAYMENT_METHOD_REFERENCE = "FOREIGN_PAYMENT_METHOD_REFERENCE";
-var ForeignPaymentMethodReferenceError = class extends Error {
-  constructor(gatewayAccount, paymentMethodRef) {
-    super(
-      `Payment method '${paymentMethodRef}' of account '${gatewayAccount}' belongs to another subscriber. A reference belongs to exactly one, so it is not handed out.`
-    );
-    this.gatewayAccount = gatewayAccount;
-    this.paymentMethodRef = paymentMethodRef;
-    this.name = "ForeignPaymentMethodReferenceError";
-  }
-  gatewayAccount;
-  paymentMethodRef;
-  code = FOREIGN_PAYMENT_METHOD_REFERENCE;
-};
-function isForeignPaymentMethodReferenceError(error) {
-  return error instanceof Error && error.code === FOREIGN_PAYMENT_METHOD_REFERENCE;
-}
-function refuseForeignPaymentMethodReference(recorded, subscriberId) {
-  if (recorded.subscriberId === subscriberId) return;
-  throw new ForeignPaymentMethodReferenceError(
-    recorded.gatewayAccount,
-    recorded.paymentMethodRef
-  );
-}
-
 // src/subscription-bundle-mapping.ts
 var BILLING_CYCLES = ["MONTHLY", "YEARLY"];
 function toSubscriptionBundleRecord(row) {
@@ -3716,12 +4697,20 @@ var ERROR_MESSAGES_DE = {
   SUBSCRIPTION_INVOICE_CHARGE_INVOICED: "Die Forderung '{chargeId}' steht bereits auf einer Rechnung.",
   SUBSCRIPTION_INVOICE_CONTENT_INCOMPLETE: "Der Rechnung fehlt, was der Steueradapter {adapter} verlangt: {missing}. Sie wird ausgestellt, sobald es erg\xE4nzt ist.",
   SUBSCRIPTION_INVOICE_PARTIES_UNCONFIRMED: "Der Vertrag {contractId} nennt keinen best\xE4tigten Aussteller und Abonnenten \u2013 eine Migration hat seine Parteien \xFCbernommen, oder er nennt keinen Aussteller \u2013, deshalb werden seine Forderungen nicht in Rechnung gestellt.",
+  SUBSCRIPTION_INVOICE_MANDATE_MISSING: "Die Lastschrift {paymentMethodId} nennt keine Mandatsreferenz, die vor dem Einzug angek\xFCndigt werden muss. Die Rechnung wartet, bis die Zahlungsart ersetzt ist.",
+  SUBSCRIPTION_INVOICE_NO_PAYMENT_METHOD: "Der Abonnent {subscriberId} hat keine Zahlungsart in Gebrauch. Die Rechnung wird eingezogen, sobald er eine hat.",
+  SUBSCRIPTION_INVOICE_FAILURE_NOT_TOLD: "Die Lastschrift wird angek\xFCndigt, sobald dem Abonnenten mitgeteilt ist, dass der Einzug {attemptKey} gescheitert ist.",
   SUBSCRIPTION_INVOICE_DOCUMENT_CHANGED: "Das Dokument der Rechnung {invoiceId} weicht vom festgehaltenen oder archivierten ab ({rendered} statt {recorded}); das erste bleibt, und der n\xE4chste Lauf kl\xE4rt, welches die Rechnung beh\xE4lt.",
   SUBSCRIPTION_INVOICE_DOCUMENT_REFUSED: "Der Steueradapter {adapter} weist die gerenderte Rechnung zur\xFCck: {missing}. Die Rechnung beh\xE4lt ihre Nummer und wartet auf ein Dokument, das die Pr\xFCfung besteht.",
   SUBSCRIPTION_INVOICE_DOCUMENT_MISMATCH: "Das archivierte Dokument der Rechnung {invoiceId} passt nicht zur beim Rendern festgehaltenen Pr\xFCfsumme und wird nicht herausgegeben.",
   SUBSCRIPTION_INVOICE_DOCUMENT_NOT_ARCHIVED: "Das Dokument der Rechnung {invoiceId} ist noch nicht archiviert.",
   SUBSCRIPTION_INVOICE_NOT_FOUND: "Keine Rechnung '{invoiceId}'.",
   SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL: "Der Abonnent {subscriberId} hat keine Rechnungs-E-Mail; seine Rechnung wird versendet, sobald eine eingetragen ist.",
+  SUBSCRIBER_CREDIT_NOT_FOUND: "Kein Guthaben '{creditId}' des Abonnenten dieses Mandanten.",
+  SUBSCRIBER_PAYOUT_EXCEEDS_CREDIT: "Vom Guthaben {creditId} sind noch {open} offen; mehr wird nicht ausgezahlt, und nichts wurde erfasst.",
+  SUBSCRIBER_PAYOUT_NOT_MADE_YET: "Eine Auszahlung wird erfasst, wenn sie erfolgt ist: {paidOn} liegt nach heute, {today}.",
+  SUBSCRIBER_RECONCILIATION_CASE_NOT_FOUND: "Kein abzugleichender Fall '{caseId}'.",
+  SUBSCRIBER_RECONCILIATION_CASE_CLOSED: "Der Fall {caseId} wurde am {closedAt} geschlossen; seine Notiz bleibt, und nichts wurde erfasst.",
   CHECKOUT_OFFER_LINE_ITEMS_REQUIRED: "Aus einem Checkout-Angebot entsteht nur ein einziger Vertrag, und das erst, wenn seine Positionen eingefroren sind.",
   CHECKOUT_OFFER_PLAN_LINE_ITEM_REQUIRED: "Ein Checkout-Angebot braucht eine eingefrorene Plan-Position.",
   CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED: "Jede gew\xE4hlte Bundle-Version braucht eine eingefrorene Bundle-Position.",
@@ -3811,22 +4800,37 @@ export {
   ACTIVE_SUBSCRIPTION_CONTRACT_STATUSES,
   AUTH_ERROR_CODES,
   BILLING_ERROR_CODES,
+  BLOCKING_COLLECTION_STATUSES,
   BUNDLE_PRICE_LOOKUP_LIMIT,
   BUNDLE_VERSION_RETIREMENT_CAPABILITY,
+  CASE_CLOSED_REFUND_ENDED,
+  CASE_CLOSED_REVERSAL_GIVEN_BACK,
   CATALOGUE_KEYS,
   CATALOG_ERROR_CODES,
+  COLLECTION_FAILURE_REASONS,
+  COLLECTION_NOT_SENT_PAID,
+  COLLECTION_NOT_SENT_REVERSED,
+  COLLECTION_RETRY_AFTER_DAYS,
   CONTRACT_ERROR_CODES,
   CUSTOM_LIMITS_KEYS,
+  DIRECT_DEBIT_LEAD_DAYS,
+  ENDED_REFUND_STATUSES,
   ERROR_MESSAGES_DE,
   ERROR_MESSAGES_EN,
   FEATURE_NOT_LICENSED,
   FEATURE_WITHDRAWAL_CAPABILITY,
   FEATURE_WITHDRAWAL_REASON_MAX_LENGTH,
+  FOLLOWED_UP_COLLECTION_STATUSES,
   ForeignPaymentMethodReferenceError,
+  GIVING_BACK_CREDIT_ENTRY_KINDS,
   INVOICE_ARCHIVE_TRIGGERS,
+  INVOICE_COLLECTION_ASK_EVERY_MS,
+  INVOICE_COLLECTION_LEASE_MS,
+  INVOICE_COLLECTION_STATUSES,
   INVOICE_DOCUMENT_CAPABILITY,
   INVOICE_ERROR_CODES,
   INVOICE_SEQUENCE_DIGITS,
+  INVOICE_SETTLEMENT_KINDS,
   LEGAL_IDENTITY_FIELDS,
   MAINTENANCE_CAPABILITY,
   MAINTENANCE_ERROR_CODES,
@@ -3852,10 +4856,16 @@ export {
   PersistenceCapabilityError,
   PersistenceRefusal,
   PlatformUserExistsError,
+  RECONCILIATION_CASE_KINDS,
+  RECONCILIATION_CLOSE_CAPABILITY,
+  RECONCILIATION_NOTE_MAX_LENGTH,
+  RECONCILIATION_READ_CAPABILITY,
   REGISTRATION_ERROR_CODES,
   REGISTRATION_RESUME_TTL_MINUTES,
   REGISTRATION_STEP_BY_STATUS,
+  REOPENING_SETTLEMENT_KINDS,
   RETIREMENT_REMINDER_LEAD_DAYS,
+  REVERSIBLE_COLLECTION_STATUSES,
   SETTINGS_ERROR_CODES,
   SETUP_ERROR_CODES,
   SUBSCRIBER_ACCOUNT_CAPABILITY,
@@ -3864,14 +4874,21 @@ export {
   SUBSCRIBER_CHARGE_ORIGINS,
   SUBSCRIBER_CHARGE_SOURCES,
   SUBSCRIBER_CORRECTION_CAPABILITY,
+  SUBSCRIBER_CREDIT_CAPABILITY,
+  SUBSCRIBER_CREDIT_ENTRY_KINDS,
   SUBSCRIBER_ERROR_CODES,
   SUBSCRIBER_INVOICE_ADDRESS_FIELDS,
+  SUBSCRIBER_PAYMENTS_CAPABILITY,
+  SUBSCRIBER_PAYOUT_CAPABILITY,
+  SUBSCRIBER_REFUND_STATUSES,
   SUBSCRIBER_STANDING_CAPABILITY,
   SUBSCRIBER_TAX_ORIGIN_FIELDS,
   TAX_ERROR_CODES,
   TAX_TREATMENT_KINDS,
+  UNSETTLED_COLLECTION_STATUSES,
   VERSION_RETIREMENT_CAPABILITY,
   addDaysToDay,
+  announcedCollectionDay,
   applyPromo,
   asXmlReadsIt,
   assertPersistenceCapabilities,
@@ -3883,23 +4900,32 @@ export {
   bundleStemDefaults,
   canonicalJson,
   canonicalVatId,
+  casesCovered,
   catalogDraftExists,
   catalogVersionAlreadyPublished,
   catalogVersionGone,
+  chargedAgainOn,
   classifyBundleVersionDiff,
   classifyIssuerChange,
   classifyPlanDiff,
   classifyVersionOffer,
   collectUnsatisfiedRequires,
+  collectionAttemptKey,
+  collectionOutcomeColumns,
+  collectionStatusOf,
+  columnAmountOf,
   computeIncludedVat,
   concurrencyGate,
   concurrencyGateOf,
   contractPartiesOf,
   coverageExcludingSelf,
+  coversLifted,
+  coversOf,
   customLimitsReader,
   dayInZone,
   definedFields,
   diffSettings,
+  directDebitLeadDaysOf,
   draftSubscriptionInvoice,
   endedAtOnceSubjectOf,
   featureWithdrawalRowOf,
@@ -3910,12 +4936,17 @@ export {
   grossFromNet,
   holdsOnlyXmlCharacters,
   identityCorrectionDelta,
+  inWithdrawalOrder,
   invoiceArchiveProtectionProblem,
+  invoiceCollectionColumns,
   invoiceContentDraftOf,
   invoiceFooterOf,
   invoiceGroupsOf,
   invoiceIssuerOf,
+  invoicePaymentOf,
   isBundleRedundant,
+  isChargedAgain,
+  isEndedRefund,
   isFeatureWithdrawnAt,
   isForeignPaymentMethodReferenceError,
   isInvoiceDocumentChecksum,
@@ -3924,11 +4955,13 @@ export {
   isPaymentCallbackRejectedError,
   isPersistenceRefusal,
   isPlatformUserExistsError,
+  isRetryableCollectionFailure,
   isVersionActiveAt,
   isVersionEditable,
   issuerIdentityOf,
   keepOneRecommended,
   keepsVatIdCheck,
+  lastCollectionOf,
   lastDayInZone,
   maintenanceRetryAfterSeconds,
   maintenanceStatusOf,
@@ -3938,15 +4971,22 @@ export {
   membersLeftOut,
   missingRequiresFor,
   movedIdentityFields,
+  netByInvoice,
   netFromGross,
   nextWithdrawalChange,
   noActivePlanVersion,
+  openOfCredit,
+  owedOn,
+  paidOutByCredit,
   parseZonedInstant,
+  paymentSettlement,
+  payoutEntryColumns,
   percentOf,
   pickActivePromo,
   planCatalogSettingsOf,
   planKeyTaken,
   planNotInCatalog,
+  plannedCollectionColumns,
   previousUtcDay,
   promoCodeTaken,
   promoStatus,
@@ -3955,23 +4995,35 @@ export {
   readCustomLimits,
   readQuotaRecord,
   readQuotaValue,
+  reconciliationCaseColumns,
   recordedIssuerIdentity,
+  refundEntryColumns,
+  refundParts,
   refuseForeignPaymentMethodReference,
+  refusesFirstAttempt,
+  refusesPlannedAttempt,
+  reinstatementParts,
   resolveBundleAvailability,
   resolveErrorMessage,
   retirementCostsTheSubscription,
   retirementReminderDueAt,
   retirementReminderIsDue,
   retirementSwitchTerms,
+  reversalEntryColumns,
   roundToCents,
   sameLegalIdentity,
   scheduledChangeAfterWrite,
   selectChargeableBundles,
+  sentCollectionOf,
   settingsSubtreeOf,
+  settledAmountOf,
   startOfUtcDay,
   subscriberChargeColumns,
   subscriberFromRegistration,
+  subscriberPaymentColumns,
   subscriberPaymentMethodColumns,
+  subscriberRefundColumns,
+  subscriberReversalColumns,
   subscriptionBundleAlreadyCancelled,
   subscriptionBundleGone,
   subscriptionContractGone,
@@ -3989,17 +5041,27 @@ export {
   toBundleStemRow,
   toBundleVersionRetirementRecord,
   toCents,
+  toCollectionAnnouncedNotice,
+  toCollectionFailedNotice,
+  toCollectionReversedNotice,
   toContractLineItemRecord,
   toDecimalString,
   toFeatureWithdrawalRecord,
+  toInvoiceCollectionRecord,
   toMaintenanceWindowRecord,
   toPlanRow,
   toPlanVersionRow,
   toRunningContractIssuer,
   toSubscriberChargeRecord,
   toSubscriberCorrectionRecord,
+  toSubscriberCreditEntryRecord,
+  toSubscriberCreditRecord,
   toSubscriberPaymentMethodRecord,
+  toSubscriberPaymentRecord,
+  toSubscriberReconciliationCaseRecord,
   toSubscriberRecord,
+  toSubscriberRefundRecord,
+  toSubscriberReversalRecord,
   toSubscriberTaxOriginChangeRecord,
   toSubscriberVatIdCheckRecord,
   toSubscriptionBundleRecord,
@@ -4016,6 +5078,7 @@ export {
   versionOnSale,
   versionOnSaleOrNext,
   versionSale,
+  withdrawalParts,
   withdrawnFeaturesOf,
   yearOfDay
 };