@saasicat/nest 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/payment-callback.service-CR84Xw1Z.d.cts

@@ -0,0 +1,125 @@
+import { PlanCatalogSettings, PaymentGateway, PaymentMethodType, PaymentEventLog, TransactionRunner, PaymentMethodSetupSubject, PaymentGatewayEvent, TransactionContext, PaymentGatewayCallback } from '@saasicat/core';
+
+/** A configured account with the adapter bound for it. */
+interface PaymentGatewayAccount {
+    name: string;
+    provider: string;
+    gateway: PaymentGateway;
+}
+/** The account new payment methods are taken at, with what its form offers. */
+interface NewPaymentMethodAccount extends PaymentGatewayAccount {
+    methods: readonly PaymentMethodType[];
+}
+/**
+ * The gateway accounts `config/saas.yaml#payments` names, each with the adapter
+ * the application bound for it.
+ *
+ * Refuses to be built when the two disagree: a callback for an account nobody
+ * bound would be answered with an error until the gateway gave up, and a
+ * payment method taken at the wrong provider could not be charged.
+ */
+declare class PaymentGatewayRegistry {
+    private readonly settings;
+    private readonly accounts;
+    private readonly takesNew;
+    constructor(settings: PlanCatalogSettings, gateways: Readonly<Record<string, PaymentGateway>>);
+    /** The account a callback names, or `null` when none is configured under it. */
+    account(name: string): PaymentGatewayAccount | null;
+    /** The accounts among `held` that are not configured, each once — references nothing can reach any more. */
+    unconfigured(held: readonly string[]): string[];
+    /** The origins a gateway's form may send a person back to. */
+    returnUrlOrigins(): readonly string[];
+    /** The account a new payment method is taken at, or `null` when none takes new ones. */
+    forNewPaymentMethods(): NewPaymentMethodAccount | null;
+}
+
+/** A confirmation of a payment method, as its handler receives it. */
+type PaymentMethodConfirmedEvent = Extract<PaymentGatewayEvent, {
+    kind: 'payment-method-confirmed';
+}>;
+/** A setup the gateway reports as failed. */
+type PaymentMethodSetupFailedEvent = Extract<PaymentGatewayEvent, {
+    kind: 'payment-method-setup-failed';
+}>;
+/** Where an event is handled: on the transaction its claim is written on. */
+interface PaymentEventContext {
+    tx: TransactionContext;
+    gatewayAccount: string;
+    provider: string;
+    /**
+     * Runs `step` once the transaction committed — for what must not happen
+     * when it rolls back, such as a notice or deleting a record kept outside
+     * it. A step that fails is logged; the event stays handled.
+     */
+    afterCommit(step: () => Promise<void>): void;
+}
+/**
+ * What a handler did about a confirmation.
+ *
+ * `nothing-to-do` gives the session back: the confirmation named a setup
+ * nobody opened, or one that is complete, so a later event about that session
+ * has to be handled rather than answered as a duplicate.
+ */
+type PaymentEventEffect = 'took-effect' | 'nothing-to-do';
+/** What a sign-up or a subscriber does with the events about its setup. */
+interface PaymentSetupEventHandler {
+    confirmed(event: PaymentMethodConfirmedEvent, context: PaymentEventContext): Promise<PaymentEventEffect>;
+    failed(event: PaymentMethodSetupFailedEvent, context: PaymentEventContext): Promise<void>;
+}
+/** How a callback ended. A duplicate and an event nobody acts on are both answered as received. */
+type PaymentCallbackOutcome = 'handled' | 'duplicate' | 'unhandled';
+/**
+ * Takes a gateway callback from the wire to its effect.
+ *
+ * The adapter verifies it first, so nothing unverified is read. The event is
+ * then claimed and handled on ONE transaction: a handler that fails rolls the
+ * claim back with its own writes, and the gateway's retry is handled instead of
+ * being discarded as a duplicate; a handler that succeeded leaves a claim that
+ * turns every later delivery into a duplicate.
+ */
+declare class PaymentCallbackService {
+    private readonly registry;
+    private readonly log;
+    private readonly transactions;
+    private readonly logger;
+    private readonly handlers;
+    constructor(registry: PaymentGatewayRegistry, log: PaymentEventLog, transactions: TransactionRunner);
+    /**
+     * Names who handles the setups of one kind of subject. Each kind has one
+     * handler; a second is a wiring error, not a replacement.
+     */
+    handleSetupsOf(kind: PaymentMethodSetupSubject['kind'], handler: PaymentSetupEventHandler): void;
+    handle(account: string, callback: PaymentGatewayCallback): Promise<PaymentCallbackOutcome>;
+    /**
+     * Hands the confirmation to its handler, and names the one refusal that
+     * will never come out differently.
+     *
+     * A reference belongs to one subscriber for good (`SC-SEC-014`), so a
+     * confirmation refused for that reason is refused on every delivery. It
+     * still leaves by throwing, which rolls this transaction back: by the time
+     * it is raised a handler has written something that must not stand on its
+     * own — the setup marked complete on the tenant's path, the whole
+     * activation on the sign-up's. Answering the gateway anything else would
+     * commit one of those without the payment method that justifies it.
+     *
+     * The gateway therefore retries until it gives up, and the claim rolls back
+     * with everything else, so nothing durable is left to say why. This line is
+     * what says it.
+     *
+     * There is no terminal state for it, and that is worth knowing before an
+     * operator waits for one: the webhook route has no filter for this, so every
+     * redelivery is answered `500`, for as long as the provider keeps trying. A
+     * provider that disables an endpoint after sustained failures would take the
+     * account's other callbacks with it. Giving the event an end would mean
+     * keeping the claim while undoing what the handler wrote, which needs a
+     * savepoint the port does not have — so it is named here rather than
+     * implied. It names the account, the reference and the subject the
+     * event was about — never the subscriber the reference belongs to, which is
+     * on the other side of the boundary being refused.
+     */
+    private confirm;
+    private read;
+    private handlerFor;
+}
+
+export { type NewPaymentMethodAccount as N, PaymentGatewayRegistry as P, PaymentCallbackService as a, type PaymentCallbackOutcome as b, type PaymentEventContext as c, type PaymentGatewayAccount as d, type PaymentMethodConfirmedEvent as e, type PaymentMethodSetupFailedEvent as f, type PaymentSetupEventHandler as g };

package/dist/payment-callback.service-CR84Xw1Z.d.ts

@@ -0,0 +1,125 @@
+import { PlanCatalogSettings, PaymentGateway, PaymentMethodType, PaymentEventLog, TransactionRunner, PaymentMethodSetupSubject, PaymentGatewayEvent, TransactionContext, PaymentGatewayCallback } from '@saasicat/core';
+
+/** A configured account with the adapter bound for it. */
+interface PaymentGatewayAccount {
+    name: string;
+    provider: string;
+    gateway: PaymentGateway;
+}
+/** The account new payment methods are taken at, with what its form offers. */
+interface NewPaymentMethodAccount extends PaymentGatewayAccount {
+    methods: readonly PaymentMethodType[];
+}
+/**
+ * The gateway accounts `config/saas.yaml#payments` names, each with the adapter
+ * the application bound for it.
+ *
+ * Refuses to be built when the two disagree: a callback for an account nobody
+ * bound would be answered with an error until the gateway gave up, and a
+ * payment method taken at the wrong provider could not be charged.
+ */
+declare class PaymentGatewayRegistry {
+    private readonly settings;
+    private readonly accounts;
+    private readonly takesNew;
+    constructor(settings: PlanCatalogSettings, gateways: Readonly<Record<string, PaymentGateway>>);
+    /** The account a callback names, or `null` when none is configured under it. */
+    account(name: string): PaymentGatewayAccount | null;
+    /** The accounts among `held` that are not configured, each once — references nothing can reach any more. */
+    unconfigured(held: readonly string[]): string[];
+    /** The origins a gateway's form may send a person back to. */
+    returnUrlOrigins(): readonly string[];
+    /** The account a new payment method is taken at, or `null` when none takes new ones. */
+    forNewPaymentMethods(): NewPaymentMethodAccount | null;
+}
+
+/** A confirmation of a payment method, as its handler receives it. */
+type PaymentMethodConfirmedEvent = Extract<PaymentGatewayEvent, {
+    kind: 'payment-method-confirmed';
+}>;
+/** A setup the gateway reports as failed. */
+type PaymentMethodSetupFailedEvent = Extract<PaymentGatewayEvent, {
+    kind: 'payment-method-setup-failed';
+}>;
+/** Where an event is handled: on the transaction its claim is written on. */
+interface PaymentEventContext {
+    tx: TransactionContext;
+    gatewayAccount: string;
+    provider: string;
+    /**
+     * Runs `step` once the transaction committed — for what must not happen
+     * when it rolls back, such as a notice or deleting a record kept outside
+     * it. A step that fails is logged; the event stays handled.
+     */
+    afterCommit(step: () => Promise<void>): void;
+}
+/**
+ * What a handler did about a confirmation.
+ *
+ * `nothing-to-do` gives the session back: the confirmation named a setup
+ * nobody opened, or one that is complete, so a later event about that session
+ * has to be handled rather than answered as a duplicate.
+ */
+type PaymentEventEffect = 'took-effect' | 'nothing-to-do';
+/** What a sign-up or a subscriber does with the events about its setup. */
+interface PaymentSetupEventHandler {
+    confirmed(event: PaymentMethodConfirmedEvent, context: PaymentEventContext): Promise<PaymentEventEffect>;
+    failed(event: PaymentMethodSetupFailedEvent, context: PaymentEventContext): Promise<void>;
+}
+/** How a callback ended. A duplicate and an event nobody acts on are both answered as received. */
+type PaymentCallbackOutcome = 'handled' | 'duplicate' | 'unhandled';
+/**
+ * Takes a gateway callback from the wire to its effect.
+ *
+ * The adapter verifies it first, so nothing unverified is read. The event is
+ * then claimed and handled on ONE transaction: a handler that fails rolls the
+ * claim back with its own writes, and the gateway's retry is handled instead of
+ * being discarded as a duplicate; a handler that succeeded leaves a claim that
+ * turns every later delivery into a duplicate.
+ */
+declare class PaymentCallbackService {
+    private readonly registry;
+    private readonly log;
+    private readonly transactions;
+    private readonly logger;
+    private readonly handlers;
+    constructor(registry: PaymentGatewayRegistry, log: PaymentEventLog, transactions: TransactionRunner);
+    /**
+     * Names who handles the setups of one kind of subject. Each kind has one
+     * handler; a second is a wiring error, not a replacement.
+     */
+    handleSetupsOf(kind: PaymentMethodSetupSubject['kind'], handler: PaymentSetupEventHandler): void;
+    handle(account: string, callback: PaymentGatewayCallback): Promise<PaymentCallbackOutcome>;
+    /**
+     * Hands the confirmation to its handler, and names the one refusal that
+     * will never come out differently.
+     *
+     * A reference belongs to one subscriber for good (`SC-SEC-014`), so a
+     * confirmation refused for that reason is refused on every delivery. It
+     * still leaves by throwing, which rolls this transaction back: by the time
+     * it is raised a handler has written something that must not stand on its
+     * own — the setup marked complete on the tenant's path, the whole
+     * activation on the sign-up's. Answering the gateway anything else would
+     * commit one of those without the payment method that justifies it.
+     *
+     * The gateway therefore retries until it gives up, and the claim rolls back
+     * with everything else, so nothing durable is left to say why. This line is
+     * what says it.
+     *
+     * There is no terminal state for it, and that is worth knowing before an
+     * operator waits for one: the webhook route has no filter for this, so every
+     * redelivery is answered `500`, for as long as the provider keeps trying. A
+     * provider that disables an endpoint after sustained failures would take the
+     * account's other callbacks with it. Giving the event an end would mean
+     * keeping the claim while undoing what the handler wrote, which needs a
+     * savepoint the port does not have — so it is named here rather than
+     * implied. It names the account, the reference and the subject the
+     * event was about — never the subscriber the reference belongs to, which is
+     * on the other side of the boundary being refused.
+     */
+    private confirm;
+    private read;
+    private handlerFor;
+}
+
+export { type NewPaymentMethodAccount as N, PaymentGatewayRegistry as P, PaymentCallbackService as a, type PaymentCallbackOutcome as b, type PaymentEventContext as c, type PaymentGatewayAccount as d, type PaymentMethodConfirmedEvent as e, type PaymentMethodSetupFailedEvent as f, type PaymentSetupEventHandler as g };

package/dist/payments/index.cjs

@@ -0,0 +1,4 @@
+'use strict';
+// Generated by scripts/build-cjs-stubs.mjs — do not edit.
+// Thin re-export so every entry shares one set of class objects.
+module.exports = require('../_entries.cjs').paymentsNs;

package/dist/payments/index.d.cts

@@ -0,0 +1,187 @@
+export { b as PaymentsModule, P as PaymentsModuleOptions, a as PaymentsTenantRoutesOptions } from '../payments.module-BdUq9ot_.cjs';
+import { P as PaymentGatewayRegistry, a as PaymentCallbackService } from '../payment-callback.service-CR84Xw1Z.cjs';
+export { N as NewPaymentMethodAccount, b as PaymentCallbackOutcome, c as PaymentEventContext, d as PaymentGatewayAccount, e as PaymentMethodConfirmedEvent, f as PaymentMethodSetupFailedEvent, g as PaymentSetupEventHandler } from '../payment-callback.service-CR84Xw1Z.cjs';
+import { OnModuleInit, RawBodyRequest } from '@nestjs/common';
+import { SubscriberPaymentMethodRepository, SubscriberPaymentMethodRecord, PaymentMethodType, PaymentGateway, StartPaymentMethodSetupInput, PaymentMethodSetupSession, PaymentGatewayCallback, PaymentGatewayEvent } from '@saasicat/core';
+import { S as SubscriberService } from '../subscriber.service-5W6Gi-1B.cjs';
+import { T as TenantIdResolver, U as UserEmailResolver } from '../tenant-billing.tokens-G-1xOlMr.cjs';
+import '../di-CcNeq9v-.cjs';
+
+interface StartPaymentMethodChange {
+    successUrl: string;
+    cancelUrl: string;
+    /** Where the gateway writes when the subscriber's record holds no invoice email: the requesting user's. */
+    fallbackEmail: string | null;
+}
+/**
+ * A subscriber's payment method: the one in use, and replacing it through the
+ * gateway's form.
+ *
+ * Nothing changes when the form is opened. The gateway confirms through its
+ * callback, and the confirmation is what records the new payment method —
+ * on the transaction that claims the callback.
+ */
+declare class SubscriberPaymentMethodService implements OnModuleInit {
+    private readonly methods;
+    private readonly subscribers;
+    private readonly registry;
+    private readonly callbacks;
+    private readonly logger;
+    constructor(methods: SubscriberPaymentMethodRepository, subscribers: SubscriberService, registry: PaymentGatewayRegistry, callbacks: PaymentCallbackService);
+    onModuleInit(): void;
+    /** The payment method in use for the tenant's subscriber, or `null` when it has none. */
+    current(tenantId: string): Promise<SubscriberPaymentMethodRecord | null>;
+    /**
+     * Opens the gateway's form for a new payment method for the tenant's
+     * subscriber, and returns where to send the person.
+     *
+     * The customer the subscriber has at that account is reused, so the new
+     * payment method sits beside the ones the gateway already holds for it.
+     */
+    startChange(tenantId: string, input: StartPaymentMethodChange): Promise<{
+        redirectUrl: string;
+    }>;
+    private recordConfirmed;
+}
+
+/** Where the gateway's form sends the person — `POST /billing/payment-method/setup`. */
+declare class StartPaymentMethodSetupDto {
+    successUrl: string;
+    cancelUrl: string;
+}
+
+/** How a payment method in use is shown: what tells it apart, and nothing that reaches it at the gateway. */
+interface TenantPaymentMethodView {
+    type: PaymentMethodType;
+    brand: string | null;
+    last4: string;
+    expiryMonth: number | null;
+    expiryYear: number | null;
+    country: string | null;
+    mandateReference: string | null;
+    confirmedAt: string;
+}
+/**
+ * `GET /billing/payment-method` and `POST /billing/payment-method/setup` — the
+ * tenant's view of what its subscriber pays with, behind the billing
+ * permission for reading and changing alike.
+ */
+declare class TenantPaymentMethodController {
+    private readonly paymentMethods;
+    private readonly tenantIdResolver;
+    private readonly userEmailResolver;
+    constructor(paymentMethods: SubscriberPaymentMethodService, tenantIdResolver: TenantIdResolver, userEmailResolver?: UserEmailResolver | null);
+    current(request: unknown): Promise<{
+        paymentMethod: TenantPaymentMethodView | null;
+    }>;
+    startSetup(request: unknown, body: StartPaymentMethodSetupDto): Promise<{
+        redirectUrl: string;
+    }>;
+    private tenantOf;
+    private emailOf;
+}
+
+/**
+ * A change of the subscriber's contact details — `PATCH /billing/details`. A
+ * field left out keeps its value.
+ *
+ * The legal name and the tax identifiers are declared so that they reach the
+ * service rather than being stripped by the application's `ValidationPipe`:
+ * a tenant that sends a new legal name is told it cannot change it there,
+ * instead of being told it succeeded.
+ */
+declare class ChangeBillingDetailsDto {
+    addressLine1?: string | null;
+    addressLine2?: string | null;
+    postalCode?: string | null;
+    city?: string | null;
+    /** ISO 3166-1 alpha-2, e.g. `DE`; its form is checked where every detail is settled. */
+    country?: string | null;
+    invoiceEmail?: string | null;
+    legalName?: unknown;
+    vatId?: unknown;
+    taxNumber?: unknown;
+}
+
+/** The subscriber as its tenant sees it in its billing area. */
+interface TenantBillingDetailsView {
+    customerNumber: string;
+    legalName: string;
+    vatId: string | null;
+    taxNumber: string | null;
+    addressLine1: string | null;
+    addressLine2: string | null;
+    postalCode: string | null;
+    city: string | null;
+    country: string | null;
+    invoiceEmail: string | null;
+}
+/**
+ * `GET /billing/details` and `PATCH /billing/details` — whom the tenant's
+ * subscription is billed to, behind the billing permission for reading and
+ * changing alike. The contact details change here; the legal name and the tax
+ * identifiers are shown and corrected by the operator (`SC-SUB-017`).
+ */
+declare class TenantBillingDetailsController {
+    private readonly subscribers;
+    private readonly tenantIdResolver;
+    constructor(subscribers: SubscriberService, tenantIdResolver: TenantIdResolver);
+    current(request: unknown): Promise<{
+        details: TenantBillingDetailsView;
+    }>;
+    change(request: unknown, body: ChangeBillingDetailsDto): Promise<{
+        details: TenantBillingDetailsView;
+    }>;
+    private tenantOf;
+}
+
+interface CallbackRequest {
+    headers: Record<string, string | string[] | undefined>;
+}
+/**
+ * `POST /webhooks/payment/:account` — where a gateway account sends its
+ * callbacks, one route per account in `config/saas.yaml#payments.accounts`.
+ *
+ * Public, because the gateway has no session: what makes a callback genuine is
+ * its signature over the exact bytes it sent, which the account's adapter
+ * verifies before anything is read. That needs the body as it arrived, so the
+ * application is created with `rawBody: true`.
+ */
+declare class PaymentWebhookController {
+    private readonly callbacks;
+    constructor(callbacks: PaymentCallbackService);
+    receive(account: string, request: RawBodyRequest<CallbackRequest>): Promise<{
+        received: true;
+    }>;
+}
+
+/** The provider name `config/saas.yaml` gives an account bound to this gateway. */
+declare const DEV_PAYMENT_PROVIDER = "dev";
+/**
+ * A payment gateway for development and tests, with no provider behind it.
+ *
+ * It opens no form: starting a setup confirms the first payment method the
+ * account offers straight away, as a callback signed with a key it holds in
+ * memory, which the platform handles like any other — verified, claimed and
+ * recorded on one transaction. The person is sent to the success URL.
+ *
+ * It takes no means of payment and charges nothing, which is why it refuses to
+ * be constructed with `NODE_ENV=production`.
+ */
+declare class DevPaymentGateway implements PaymentGateway {
+    readonly provider = "dev";
+    private readonly key;
+    constructor();
+    startPaymentMethodSetup(input: StartPaymentMethodSetupInput): Promise<PaymentMethodSetupSession>;
+    readCallback(callback: PaymentGatewayCallback): Promise<PaymentGatewayEvent>;
+    private sign;
+    private verify;
+}
+
+/** The bound gateway adapters, by the account name `config/saas.yaml#payments.accounts` gives each. */
+declare const PAYMENT_GATEWAYS_TOKEN: unique symbol;
+declare const PAYMENT_EVENT_LOG_TOKEN: unique symbol;
+declare const SUBSCRIBER_PAYMENT_METHOD_REPOSITORY_TOKEN: unique symbol;
+declare const PAYMENT_TRANSACTION_RUNNER_TOKEN: unique symbol;
+
+export { ChangeBillingDetailsDto, DEV_PAYMENT_PROVIDER, DevPaymentGateway, PAYMENT_EVENT_LOG_TOKEN, PAYMENT_GATEWAYS_TOKEN, PAYMENT_TRANSACTION_RUNNER_TOKEN, PaymentCallbackService, PaymentGatewayRegistry, PaymentWebhookController, SUBSCRIBER_PAYMENT_METHOD_REPOSITORY_TOKEN, type StartPaymentMethodChange, StartPaymentMethodSetupDto, SubscriberPaymentMethodService, TenantBillingDetailsController, type TenantBillingDetailsView, TenantPaymentMethodController, type TenantPaymentMethodView };

package/dist/payments/index.d.ts

@@ -0,0 +1,187 @@
+export { b as PaymentsModule, P as PaymentsModuleOptions, a as PaymentsTenantRoutesOptions } from '../payments.module-CQGv_VG7.js';
+import { P as PaymentGatewayRegistry, a as PaymentCallbackService } from '../payment-callback.service-CR84Xw1Z.js';
+export { N as NewPaymentMethodAccount, b as PaymentCallbackOutcome, c as PaymentEventContext, d as PaymentGatewayAccount, e as PaymentMethodConfirmedEvent, f as PaymentMethodSetupFailedEvent, g as PaymentSetupEventHandler } from '../payment-callback.service-CR84Xw1Z.js';
+import { OnModuleInit, RawBodyRequest } from '@nestjs/common';
+import { SubscriberPaymentMethodRepository, SubscriberPaymentMethodRecord, PaymentMethodType, PaymentGateway, StartPaymentMethodSetupInput, PaymentMethodSetupSession, PaymentGatewayCallback, PaymentGatewayEvent } from '@saasicat/core';
+import { S as SubscriberService } from '../subscriber.service-5W6Gi-1B.js';
+import { T as TenantIdResolver, U as UserEmailResolver } from '../tenant-billing.tokens-G-1xOlMr.js';
+import '../di-CcNeq9v-.js';
+
+interface StartPaymentMethodChange {
+    successUrl: string;
+    cancelUrl: string;
+    /** Where the gateway writes when the subscriber's record holds no invoice email: the requesting user's. */
+    fallbackEmail: string | null;
+}
+/**
+ * A subscriber's payment method: the one in use, and replacing it through the
+ * gateway's form.
+ *
+ * Nothing changes when the form is opened. The gateway confirms through its
+ * callback, and the confirmation is what records the new payment method —
+ * on the transaction that claims the callback.
+ */
+declare class SubscriberPaymentMethodService implements OnModuleInit {
+    private readonly methods;
+    private readonly subscribers;
+    private readonly registry;
+    private readonly callbacks;
+    private readonly logger;
+    constructor(methods: SubscriberPaymentMethodRepository, subscribers: SubscriberService, registry: PaymentGatewayRegistry, callbacks: PaymentCallbackService);
+    onModuleInit(): void;
+    /** The payment method in use for the tenant's subscriber, or `null` when it has none. */
+    current(tenantId: string): Promise<SubscriberPaymentMethodRecord | null>;
+    /**
+     * Opens the gateway's form for a new payment method for the tenant's
+     * subscriber, and returns where to send the person.
+     *
+     * The customer the subscriber has at that account is reused, so the new
+     * payment method sits beside the ones the gateway already holds for it.
+     */
+    startChange(tenantId: string, input: StartPaymentMethodChange): Promise<{
+        redirectUrl: string;
+    }>;
+    private recordConfirmed;
+}
+
+/** Where the gateway's form sends the person — `POST /billing/payment-method/setup`. */
+declare class StartPaymentMethodSetupDto {
+    successUrl: string;
+    cancelUrl: string;
+}
+
+/** How a payment method in use is shown: what tells it apart, and nothing that reaches it at the gateway. */
+interface TenantPaymentMethodView {
+    type: PaymentMethodType;
+    brand: string | null;
+    last4: string;
+    expiryMonth: number | null;
+    expiryYear: number | null;
+    country: string | null;
+    mandateReference: string | null;
+    confirmedAt: string;
+}
+/**
+ * `GET /billing/payment-method` and `POST /billing/payment-method/setup` — the
+ * tenant's view of what its subscriber pays with, behind the billing
+ * permission for reading and changing alike.
+ */
+declare class TenantPaymentMethodController {
+    private readonly paymentMethods;
+    private readonly tenantIdResolver;
+    private readonly userEmailResolver;
+    constructor(paymentMethods: SubscriberPaymentMethodService, tenantIdResolver: TenantIdResolver, userEmailResolver?: UserEmailResolver | null);
+    current(request: unknown): Promise<{
+        paymentMethod: TenantPaymentMethodView | null;
+    }>;
+    startSetup(request: unknown, body: StartPaymentMethodSetupDto): Promise<{
+        redirectUrl: string;
+    }>;
+    private tenantOf;
+    private emailOf;
+}
+
+/**
+ * A change of the subscriber's contact details — `PATCH /billing/details`. A
+ * field left out keeps its value.
+ *
+ * The legal name and the tax identifiers are declared so that they reach the
+ * service rather than being stripped by the application's `ValidationPipe`:
+ * a tenant that sends a new legal name is told it cannot change it there,
+ * instead of being told it succeeded.
+ */
+declare class ChangeBillingDetailsDto {
+    addressLine1?: string | null;
+    addressLine2?: string | null;
+    postalCode?: string | null;
+    city?: string | null;
+    /** ISO 3166-1 alpha-2, e.g. `DE`; its form is checked where every detail is settled. */
+    country?: string | null;
+    invoiceEmail?: string | null;
+    legalName?: unknown;
+    vatId?: unknown;
+    taxNumber?: unknown;
+}
+
+/** The subscriber as its tenant sees it in its billing area. */
+interface TenantBillingDetailsView {
+    customerNumber: string;
+    legalName: string;
+    vatId: string | null;
+    taxNumber: string | null;
+    addressLine1: string | null;
+    addressLine2: string | null;
+    postalCode: string | null;
+    city: string | null;
+    country: string | null;
+    invoiceEmail: string | null;
+}
+/**
+ * `GET /billing/details` and `PATCH /billing/details` — whom the tenant's
+ * subscription is billed to, behind the billing permission for reading and
+ * changing alike. The contact details change here; the legal name and the tax
+ * identifiers are shown and corrected by the operator (`SC-SUB-017`).
+ */
+declare class TenantBillingDetailsController {
+    private readonly subscribers;
+    private readonly tenantIdResolver;
+    constructor(subscribers: SubscriberService, tenantIdResolver: TenantIdResolver);
+    current(request: unknown): Promise<{
+        details: TenantBillingDetailsView;
+    }>;
+    change(request: unknown, body: ChangeBillingDetailsDto): Promise<{
+        details: TenantBillingDetailsView;
+    }>;
+    private tenantOf;
+}
+
+interface CallbackRequest {
+    headers: Record<string, string | string[] | undefined>;
+}
+/**
+ * `POST /webhooks/payment/:account` — where a gateway account sends its
+ * callbacks, one route per account in `config/saas.yaml#payments.accounts`.
+ *
+ * Public, because the gateway has no session: what makes a callback genuine is
+ * its signature over the exact bytes it sent, which the account's adapter
+ * verifies before anything is read. That needs the body as it arrived, so the
+ * application is created with `rawBody: true`.
+ */
+declare class PaymentWebhookController {
+    private readonly callbacks;
+    constructor(callbacks: PaymentCallbackService);
+    receive(account: string, request: RawBodyRequest<CallbackRequest>): Promise<{
+        received: true;
+    }>;
+}
+
+/** The provider name `config/saas.yaml` gives an account bound to this gateway. */
+declare const DEV_PAYMENT_PROVIDER = "dev";
+/**
+ * A payment gateway for development and tests, with no provider behind it.
+ *
+ * It opens no form: starting a setup confirms the first payment method the
+ * account offers straight away, as a callback signed with a key it holds in
+ * memory, which the platform handles like any other — verified, claimed and
+ * recorded on one transaction. The person is sent to the success URL.
+ *
+ * It takes no means of payment and charges nothing, which is why it refuses to
+ * be constructed with `NODE_ENV=production`.
+ */
+declare class DevPaymentGateway implements PaymentGateway {
+    readonly provider = "dev";
+    private readonly key;
+    constructor();
+    startPaymentMethodSetup(input: StartPaymentMethodSetupInput): Promise<PaymentMethodSetupSession>;
+    readCallback(callback: PaymentGatewayCallback): Promise<PaymentGatewayEvent>;
+    private sign;
+    private verify;
+}
+
+/** The bound gateway adapters, by the account name `config/saas.yaml#payments.accounts` gives each. */
+declare const PAYMENT_GATEWAYS_TOKEN: unique symbol;
+declare const PAYMENT_EVENT_LOG_TOKEN: unique symbol;
+declare const SUBSCRIBER_PAYMENT_METHOD_REPOSITORY_TOKEN: unique symbol;
+declare const PAYMENT_TRANSACTION_RUNNER_TOKEN: unique symbol;
+
+export { ChangeBillingDetailsDto, DEV_PAYMENT_PROVIDER, DevPaymentGateway, PAYMENT_EVENT_LOG_TOKEN, PAYMENT_GATEWAYS_TOKEN, PAYMENT_TRANSACTION_RUNNER_TOKEN, PaymentCallbackService, PaymentGatewayRegistry, PaymentWebhookController, SUBSCRIBER_PAYMENT_METHOD_REPOSITORY_TOKEN, type StartPaymentMethodChange, StartPaymentMethodSetupDto, SubscriberPaymentMethodService, TenantBillingDetailsController, type TenantBillingDetailsView, TenantPaymentMethodController, type TenantPaymentMethodView };