@cosmicdrift/kumiko-bundled-features 0.337.1 → 0.339.0

package/dist/billing-foundation/consumer-protection/termination-request.js

@@ -0,0 +1,231 @@
+// § 312k: the anonymous request handler (public form / API) and the
+// authenticated terminate-contract handler. Both end in the same receipt mail
+// builder and operator notice; the public path never reveals whether the
+// entered email matched a contract.
+import { createSystemUser, declareEscapeHatch, SYSTEM_TENANT_ID, } from "@cosmicdrift/kumiko-framework/engine";
+import { InternalError } from "@cosmicdrift/kumiko-framework/errors";
+import { generateId } from "@cosmicdrift/kumiko-framework/utils";
+import * as z from "zod";
+import { TenantQueries } from "../../tenant/index.js";
+import { UserQueries } from "../../user/index.js";
+import { CONTRACT_TERMINATION_RECEIPT_NOTIFICATION_TYPE, SubscriptionCancelTimings, SubscriptionFoundationHandlers, SubscriptionFoundationQueries, } from "../constants.js";
+import { CONTRACT_TERMINATION_DECLARATION_TYPES, CONTRACT_TERMINATION_KINDS, } from "../events.js";
+import { purchaseRolesOf } from "../plan-catalog.js";
+import { resolveConsentLocale } from "./consent-text.js";
+import { renderTerminationReceipt } from "./termination-mail.js";
+import { notifyOperator, requireNotify } from "./termination-notify.js";
+const TENANT_ADMIN_ROLE = "TenantAdmin";
+const EXTRAORDINARY_REASON_MESSAGE = "reason is required for an extraordinary termination";
+const authUserRowSchema = z.object({
+    id: z.string().min(1),
+    email: z.string().min(1).optional(),
+    isDeleted: z.boolean().optional(),
+});
+const membershipRowsSchema = z.array(z.object({ tenantId: z.string().min(1), roles: z.array(z.string()) }));
+const terminableResultSchema = z.object({ terminable: z.boolean() });
+function hasReasonWhenExtraordinary(value) {
+    return value.terminationKind !== "extraordinary" || (value.reason?.trim().length ?? 0) > 0;
+}
+export const requestContractTerminationSchema = z
+    .object({
+    declarationType: z.enum(CONTRACT_TERMINATION_DECLARATION_TYPES),
+    terminationKind: z.enum(CONTRACT_TERMINATION_KINDS),
+    reason: z.string().max(2000).optional(),
+    name: z.string().min(1).max(200),
+    email: z.email(),
+    customerReference: z.string().max(200).optional(),
+    locale: z.enum(["de", "en"]).optional(),
+})
+    .strict()
+    .refine(hasReasonWhenExtraordinary, { message: EXTRAORDINARY_REASON_MESSAGE, path: ["reason"] });
+export const terminateContractSchema = z
+    .object({
+    declarationType: z.enum(CONTRACT_TERMINATION_DECLARATION_TYPES),
+    terminationKind: z.enum(CONTRACT_TERMINATION_KINDS),
+    reason: z.string().max(2000).optional(),
+})
+    .strict()
+    .refine(hasReasonWhenExtraordinary, { message: EXTRAORDINARY_REASON_MESSAGE, path: ["reason"] });
+function needsOperatorNotice(declaration) {
+    return [
+        ...(declaration.declarationType === "withdrawal" ? ["withdrawal"] : []),
+        ...(declaration.terminationKind === "extraordinary" ? ["extraordinary"] : []),
+    ];
+}
+async function sendTerminationMails(ctx, consumerProtection, plan) {
+    await requireNotify(ctx)(CONTRACT_TERMINATION_RECEIPT_NOTIFICATION_TYPE, {
+        route: { email: plan.declaration.email },
+        data: renderTerminationReceipt({
+            locale: plan.locale,
+            requestId: plan.requestId,
+            receivedAtIso: plan.receivedAtIso,
+            declaration: plan.declaration,
+            operatorEmail: consumerProtection.operatorEmail,
+        }),
+        priority: "critical",
+    });
+    // skip: no operator notice needed for this declaration
+    if (plan.reasons.length === 0)
+        return;
+    await notifyOperator(ctx, consumerProtection, plan);
+}
+// Tenants the entered email can terminate a contract for: tenants where the
+// user is TenantAdmin and the subscription is not terminal. Every identity
+// below comes from the trusted lookups, never from the payload.
+async function findTerminableTenantIds(ctx, requestTenantId, email) {
+    declareEscapeHatch({
+        reason: "anonymous declarant has no session — finds the contract by email via user:find-for-auth and tenant:memberships as a system user; the calling handler declares its own escapeHatch",
+    });
+    const user = authUserRowSchema.safeParse(await ctx.queryAs(createSystemUser(requestTenantId), UserQueries.findForAuth, { email }));
+    if (!user.success || user.data.isDeleted === true)
+        return [];
+    const memberships = membershipRowsSchema.safeParse(await ctx.queryAs(createSystemUser(requestTenantId), TenantQueries.memberships, {
+        userId: user.data.id,
+    }));
+    if (!memberships.success)
+        return [];
+    const adminTenantIds = [
+        ...new Set(memberships.data
+            .filter((membership) => membership.roles.includes(TENANT_ADMIN_ROLE))
+            .map((membership) => membership.tenantId)),
+    ];
+    const terminable = [];
+    for (const tenantId of adminTenantIds) {
+        const probe = terminableResultSchema.safeParse(await ctx.queryAs(createSystemUser(tenantId), SubscriptionFoundationQueries.terminableSubscription, {}));
+        if (probe.success && probe.data.terminable)
+            terminable.push(tenantId);
+    }
+    return terminable;
+}
+export function createRequestContractTerminationHandler(options, consumerProtection) {
+    return {
+        name: "request-contract-termination",
+        description: "Public § 312k declaration: terminates or withdraws from the contract of the account behind the entered email; the answer and the receipt mail never reveal whether the email matched.",
+        schema: requestContractTerminationSchema,
+        access: { roles: ["anonymous"] },
+        rateLimit: { per: "ip+handler", limit: 5, windowSeconds: 600 },
+        ...(consumerProtection.terminationScope === "platform" && { tenantlessAnonymous: true }),
+        escapeHatch: {
+            reason: "Anonymous declarant has no session — finds the contract by email via ctx.queryAs(system, user:find-for-auth) and tenant:memberships; the tenant written to comes only from those lookups.",
+        },
+        handler: async (event, ctx) => {
+            // @cast-boundary engine-payload — dispatcher-zod-validated payload
+            const payload = event.payload;
+            const requestId = generateId();
+            const receivedAtIso = options.now().toString();
+            const { declarationType, terminationKind } = payload;
+            const reasons = [];
+            const locale = resolveConsentLocale(payload.locale);
+            let matchedTenantId;
+            const candidates = await findTerminableTenantIds(ctx, event.user.tenantId, payload.email);
+            const [onlyCandidate] = candidates;
+            if (candidates.length === 1 && onlyCandidate !== undefined) {
+                matchedTenantId = onlyCandidate;
+                const declared = await ctx.writeAs(createSystemUser(onlyCandidate), SubscriptionFoundationHandlers.declareContractTermination, { requestId, declarationType, terminationKind, receivedAtIso, locale });
+                if (!declared.isSuccess)
+                    reasons.push("recording_failed");
+            }
+            else {
+                reasons.push(candidates.length === 0 ? "unmatched" : "ambiguous");
+                const recorded = await ctx.writeAs(createSystemUser(SYSTEM_TENANT_ID), SubscriptionFoundationHandlers.recordUnmatchedContractTermination, {
+                    requestId,
+                    declarationType,
+                    terminationKind,
+                    receivedAtIso,
+                    matchResult: candidates.length === 0 ? "none" : "ambiguous",
+                });
+                if (!recorded.isSuccess)
+                    reasons.push("recording_failed");
+            }
+            reasons.push(...needsOperatorNotice(payload));
+            await sendTerminationMails(ctx, consumerProtection, {
+                locale,
+                requestId,
+                receivedAtIso,
+                channel: "public",
+                declaration: {
+                    declarationType,
+                    terminationKind,
+                    name: payload.name,
+                    email: payload.email,
+                    ...(payload.customerReference !== undefined && {
+                        customerReference: payload.customerReference,
+                    }),
+                    ...(payload.reason !== undefined && { reason: payload.reason }),
+                },
+                reasons,
+                ...(matchedTenantId !== undefined && { tenantId: matchedTenantId }),
+            });
+            return {
+                isSuccess: true,
+                data: { requestId, receivedAtIso },
+            };
+        },
+    };
+}
+export function createTerminateContractHandler(options, consumerProtection) {
+    return {
+        name: "terminate-contract",
+        description: "Terminates the tenant's subscription at the end of the billing period, or withdraws from the contract and cancels it immediately; sends a receipt to the caller's email.",
+        schema: terminateContractSchema,
+        access: { roles: purchaseRolesOf(options.catalog) },
+        escapeHatch: {
+            reason: "reads the calling admin's own email via UserQueries.findForAuth as a system user; the receipt goes only to that address",
+        },
+        handler: async (event, ctx) => {
+            // @cast-boundary engine-payload — dispatcher-zod-validated payload
+            const payload = event.payload;
+            const tenantId = event.user.tenantId;
+            const requestId = generateId();
+            const { declarationType, terminationKind } = payload;
+            const caller = authUserRowSchema.safeParse(await ctx.queryAs(createSystemUser(tenantId), UserQueries.findForAuth, {
+                id: event.user.id,
+            }));
+            if (!caller.success || !caller.data.email || caller.data.isDeleted === true) {
+                throw new InternalError({
+                    message: "billing-foundation:terminate-contract: calling user has no email on record",
+                });
+            }
+            const recorded = await ctx.writeAs(createSystemUser(tenantId), SubscriptionFoundationHandlers.recordContractTermination, {
+                requestId,
+                declarationType,
+                terminationKind,
+                channel: "account",
+                when: declarationType === "withdrawal"
+                    ? SubscriptionCancelTimings.immediately
+                    : SubscriptionCancelTimings.periodEnd,
+            });
+            if (!recorded.isSuccess)
+                return recorded;
+            // @cast-boundary engine-payload — our own record handler's return shape
+            const data = recorded.data;
+            await sendTerminationMails(ctx, consumerProtection, {
+                locale: resolveConsentLocale(ctx.locale),
+                requestId,
+                receivedAtIso: data.receivedAtIso,
+                channel: "account",
+                declaration: {
+                    declarationType,
+                    terminationKind,
+                    email: caller.data.email,
+                    ...(payload.reason !== undefined && { reason: payload.reason }),
+                },
+                reasons: [
+                    ...(data.noticeReason !== null ? [data.noticeReason] : []),
+                    ...needsOperatorNotice(payload),
+                ],
+                tenantId,
+                providerCancel: data.providerCancel,
+            });
+            return {
+                isSuccess: true,
+                data: {
+                    requestId,
+                    receivedAtIso: data.receivedAtIso,
+                    effectiveAtIso: data.effectiveAtIso,
+                    providerCancel: data.providerCancel,
+                },
+            };
+        },
+    };
+}

package/dist/billing-foundation/consumer-protection/termination-texts.d.ts

@@ -0,0 +1,62 @@
+import type { ContractTerminationDeclarationType, ContractTerminationKind } from "../events.js";
+import type { ConsentLocale } from "./consent-text.js";
+export type TerminationTexts = {
+    readonly declarationTypeLabel: Readonly<Record<ContractTerminationDeclarationType, string>>;
+    readonly terminationKindLabel: Readonly<Record<ContractTerminationKind, string>>;
+    readonly declarationType: string;
+    readonly terminationKind: string;
+    readonly receivedAt: string;
+    readonly requestId: string;
+    readonly name: string;
+    readonly email: string;
+    readonly customerReference: string;
+    readonly reasonFieldLabel: string;
+    readonly receiptSubject: Readonly<Record<ContractTerminationDeclarationType, string>>;
+    readonly receiptIntro: string;
+    readonly receiptNextSteps: string;
+    readonly receiptRevoke: (operatorEmail: string) => string;
+    readonly contact: string;
+    readonly operatorSubject: Readonly<Record<ContractTerminationDeclarationType, string>>;
+    readonly operatorIntro: string;
+    readonly operatorReasons: Readonly<Record<OperatorNoticeReason, string>>;
+    readonly noticeReasons: string;
+    readonly channel: string;
+    readonly channelLabel: Readonly<Record<"public" | "account", string>>;
+    readonly tenant: string;
+    readonly providerResult: string;
+    readonly providerResultLabel: Readonly<Record<"period-end" | "immediately" | "none", string>>;
+    readonly page: PageTexts;
+};
+export type PageTexts = {
+    readonly title: string;
+    readonly lead: string;
+    readonly declarationTypeHeading: string;
+    readonly kindHeading: string;
+    readonly reasonHint: string;
+    readonly earliestDate: string;
+    readonly nameLabel: string;
+    readonly emailLabel: string;
+    readonly customerReferenceLabel: string;
+    readonly reasonLabel: string;
+    readonly reviewButton: string;
+    readonly reviewTitle: string;
+    readonly reviewLead: string;
+    readonly confirmButton: Readonly<Record<ContractTerminationDeclarationType, string>>;
+    readonly backButton: string;
+    readonly resultTitle: string;
+    readonly resultLead: string;
+    readonly resultReceivedAt: string;
+    readonly resultRequestId: string;
+    readonly resultMailNote: string;
+    readonly errorsHeading: string;
+    readonly errorName: string;
+    readonly errorEmail: string;
+    readonly errorReason: string;
+    readonly errorChoice: string;
+    readonly errorGeneric: string;
+    readonly rateLimitedTitle: string;
+    readonly rateLimitedBody: string;
+};
+export declare const OPERATOR_NOTICE_REASONS: readonly ["unmatched", "ambiguous", "withdrawal", "extraordinary", "provider_cannot_cancel", "provider_error", "no_active_subscription", "recording_failed"];
+export type OperatorNoticeReason = (typeof OPERATOR_NOTICE_REASONS)[number];
+export declare const TERMINATION_TEXTS: Readonly<Record<ConsentLocale, TerminationTexts>>;

package/dist/billing-foundation/consumer-protection/termination-texts.js

@@ -0,0 +1,168 @@
+export const OPERATOR_NOTICE_REASONS = [
+    "unmatched",
+    "ambiguous",
+    "withdrawal",
+    "extraordinary",
+    "provider_cannot_cancel",
+    "provider_error",
+    "no_active_subscription",
+    "recording_failed",
+];
+export const TERMINATION_TEXTS = {
+    de: {
+        declarationTypeLabel: { termination: "Kündigung", withdrawal: "Widerruf" },
+        terminationKindLabel: {
+            ordinary: "Ordentlich zum nächstmöglichen Zeitpunkt",
+            extraordinary: "Außerordentlich (aus wichtigem Grund)",
+        },
+        declarationType: "Erklärung",
+        terminationKind: "Art der Kündigung",
+        receivedAt: "Eingegangen am",
+        requestId: "Vorgangsnummer",
+        name: "Name",
+        email: "E-Mail",
+        customerReference: "Kundennummer / Referenz",
+        reasonFieldLabel: "Begründung",
+        receiptSubject: {
+            termination: "Eingangsbestätigung deiner Kündigung",
+            withdrawal: "Eingangsbestätigung deines Widerrufs",
+        },
+        receiptIntro: "wir bestätigen den Eingang deiner Erklärung mit folgendem Inhalt. Diese E-Mail ist eine Eingangsbestätigung, keine Bestätigung der Wirksamkeit.",
+        receiptNextSteps: "Wir prüfen deine Erklärung und melden uns, sobald sie bearbeitet ist oder wir Rückfragen haben.",
+        receiptRevoke: (operatorEmail) => `Hast du diese Erklärung nicht abgegeben oder möchtest du sie zurücknehmen? Schreib uns bitte umgehend an ${operatorEmail}.`,
+        contact: "Fragen richtest du bitte an",
+        operatorSubject: {
+            termination: "Kündigung: Bearbeitung nötig",
+            withdrawal: "Widerruf: Bearbeitung nötig",
+        },
+        operatorIntro: "Es ist eine Erklärung eingegangen, die bearbeitet werden muss.",
+        operatorReasons: {
+            unmatched: "Kein passender Vertrag zur angegebenen E-Mail gefunden",
+            ambiguous: "Die angegebene E-Mail passt zu mehreren Verträgen",
+            withdrawal: "Widerruf (nur Erfassung, kein Anbieter-Aufruf über das öffentliche Formular)",
+            extraordinary: "Außerordentliche Kündigung, Begründung prüfen",
+            provider_cannot_cancel: "Der Zahlungsanbieter unterstützt keine Kündigung per Schnittstelle",
+            provider_error: "Die Kündigung beim Zahlungsanbieter ist fehlgeschlagen",
+            no_active_subscription: "Keine laufende Subscription beim Anbieter",
+            recording_failed: "Die Erklärung konnte nicht gespeichert werden",
+        },
+        noticeReasons: "Grund der Benachrichtigung",
+        channel: "Kanal",
+        channelLabel: { public: "Öffentliches Formular", account: "Kundenkonto" },
+        tenant: "Mandant",
+        providerResult: "Kündigung beim Anbieter",
+        providerResultLabel: {
+            "period-end": "zum Ende des Abrechnungszeitraums veranlasst",
+            immediately: "sofort veranlasst",
+            none: "nicht veranlasst",
+        },
+        page: {
+            title: "Vertrag kündigen oder widerrufen",
+            lead: "Mit diesem Formular erklärst du die Kündigung oder den Widerruf deines Vertrags. Du brauchst dafür kein Kundenkonto.",
+            declarationTypeHeading: "Was möchtest du erklären?",
+            kindHeading: "Art der Kündigung",
+            reasonHint: "Pflicht bei außerordentlicher Kündigung.",
+            earliestDate: "Die Kündigung gilt zum nächstmöglichen Zeitpunkt.",
+            nameLabel: "Name",
+            emailLabel: "E-Mail-Adresse des Kontos",
+            customerReferenceLabel: "Kundennummer (optional)",
+            reasonLabel: "Begründung",
+            reviewButton: "Weiter zur Prüfung",
+            reviewTitle: "Bitte prüfe deine Angaben",
+            reviewLead: "Erst mit dem Klick auf den Button unten wird deine Erklärung abgegeben.",
+            confirmButton: { termination: "Jetzt kündigen", withdrawal: "Jetzt widerrufen" },
+            backButton: "Angaben ändern",
+            resultTitle: "Deine Erklärung ist eingegangen",
+            resultLead: "Wir haben deine Erklärung erhalten und senden dir eine Eingangsbestätigung.",
+            resultReceivedAt: "Eingegangen am",
+            resultRequestId: "Vorgangsnummer",
+            resultMailNote: "Die Eingangsbestätigung geht an die von dir angegebene E-Mail-Adresse.",
+            errorsHeading: "Bitte korrigiere deine Angaben",
+            errorName: "Bitte gib deinen Namen an.",
+            errorEmail: "Bitte gib eine gültige E-Mail-Adresse an.",
+            errorReason: "Bei einer außerordentlichen Kündigung ist eine Begründung nötig.",
+            errorChoice: "Bitte wähle eine Erklärung und die Art der Kündigung.",
+            errorGeneric: "Deine Erklärung konnte nicht verarbeitet werden. Bitte versuch es erneut.",
+            rateLimitedTitle: "Zu viele Anfragen",
+            rateLimitedBody: "Von deiner Adresse kamen zu viele Anfragen. Bitte versuch es später erneut.",
+        },
+    },
+    en: {
+        declarationTypeLabel: { termination: "Termination", withdrawal: "Withdrawal" },
+        terminationKindLabel: {
+            ordinary: "Ordinary, at the earliest possible date",
+            extraordinary: "Extraordinary (for good cause)",
+        },
+        declarationType: "Declaration",
+        terminationKind: "Kind of termination",
+        receivedAt: "Received on",
+        requestId: "Reference number",
+        name: "Name",
+        email: "Email",
+        customerReference: "Customer number / reference",
+        reasonFieldLabel: "Reason",
+        receiptSubject: {
+            termination: "Receipt for your termination",
+            withdrawal: "Receipt for your withdrawal",
+        },
+        receiptIntro: "we confirm receipt of your declaration with the following content. This email is a receipt, not a confirmation that the declaration is effective.",
+        receiptNextSteps: "We will review your declaration and get back to you once it is processed or if we have questions.",
+        receiptRevoke: (operatorEmail) => `If you did not make this declaration or want to take it back, please write to ${operatorEmail} right away.`,
+        contact: "Questions go to",
+        operatorSubject: {
+            termination: "Termination: action needed",
+            withdrawal: "Withdrawal: action needed",
+        },
+        operatorIntro: "A declaration arrived that needs your attention.",
+        operatorReasons: {
+            unmatched: "No contract matches the entered email",
+            ambiguous: "The entered email matches several contracts",
+            withdrawal: "Withdrawal (recorded only, no provider call from the public form)",
+            extraordinary: "Extraordinary termination, review the reason",
+            provider_cannot_cancel: "The payment provider does not support cancelling through its API",
+            provider_error: "Cancelling at the payment provider failed",
+            no_active_subscription: "No running subscription at the provider",
+            recording_failed: "The declaration could not be stored",
+        },
+        noticeReasons: "Reason for this notice",
+        channel: "Channel",
+        channelLabel: { public: "Public form", account: "Customer account" },
+        tenant: "Tenant",
+        providerResult: "Cancellation at the provider",
+        providerResultLabel: {
+            "period-end": "requested for the end of the billing period",
+            immediately: "requested immediately",
+            none: "not requested",
+        },
+        page: {
+            title: "Terminate or withdraw from your contract",
+            lead: "Use this form to terminate your contract or withdraw from it. You do not need a customer account.",
+            declarationTypeHeading: "What do you want to declare?",
+            kindHeading: "Kind of termination",
+            reasonHint: "Required for an extraordinary termination.",
+            earliestDate: "The termination takes effect at the earliest possible date.",
+            nameLabel: "Name",
+            emailLabel: "Email address of the account",
+            customerReferenceLabel: "Customer number (optional)",
+            reasonLabel: "Reason",
+            reviewButton: "Continue to review",
+            reviewTitle: "Please check your details",
+            reviewLead: "Your declaration is only submitted when you click the button below.",
+            confirmButton: { termination: "Cancel now", withdrawal: "Withdraw now" },
+            backButton: "Change details",
+            resultTitle: "Your declaration was received",
+            resultLead: "We received your declaration and are sending you a receipt.",
+            resultReceivedAt: "Received on",
+            resultRequestId: "Reference number",
+            resultMailNote: "The receipt goes to the email address you entered.",
+            errorsHeading: "Please correct your details",
+            errorName: "Please enter your name.",
+            errorEmail: "Please enter a valid email address.",
+            errorReason: "An extraordinary termination needs a reason.",
+            errorChoice: "Please choose a declaration and the kind of termination.",
+            errorGeneric: "Your declaration could not be processed. Please try again.",
+            rateLimitedTitle: "Too many requests",
+            rateLimitedBody: "Too many requests came from your address. Please try again later.",
+        },
+    },
+};

package/dist/billing-foundation/events.d.ts

@@ -24,12 +24,12 @@ export declare const subscriptionEventPayloadSchema: z.ZodObject<{
     tier: z.ZodString;
     currentPeriodEndIso: z.ZodString;
     cancelAtIso: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    consentId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type SubscriptionEventPayload = z.infer<typeof subscriptionEventPayloadSchema>;
 export type SubscriptionEventHeaders = {
     readonly providerEventId: string;
     readonly providerName: string;
-    readonly rawPayload: string;
 };
 export declare const PAYMENT_AGGREGATE_TYPE: "payment";
 export declare const PAYMENT_RECEIVED_EVENT_SHORT: "payment-received";
@@ -38,10 +38,113 @@ export declare const paymentEventPayloadSchema: z.ZodObject<{
     providerName: z.ZodString;
     providerCustomerId: z.ZodString;
     priceId: z.ZodString;
+    consentId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type PaymentEventPayload = z.infer<typeof paymentEventPayloadSchema>;
 export type PaymentEventHeaders = {
     readonly providerEventId: string;
     readonly providerName: string;
-    readonly rawPayload: string;
+    readonly providerCheckoutId?: string;
 };
+export declare const CHECKOUT_CONSENT_RECORDED_EVENT_SHORT: "checkout-consent-recorded";
+export declare const CHECKOUT_CONSENT_RECORDED_EVENT_QN: "billing-foundation:event:checkout-consent-recorded";
+export declare const checkoutConsentRecordedPayloadSchema: z.ZodObject<{
+    consentId: z.ZodString;
+    mode: z.ZodEnum<{
+        payment: "payment";
+        subscription: "subscription";
+    }>;
+    tier: z.ZodNullable<z.ZodString>;
+    priceId: z.ZodString;
+    unitAmount: z.ZodNullable<z.ZodNumber>;
+    currency: z.ZodNullable<z.ZodString>;
+    interval: z.ZodNullable<z.ZodString>;
+    intervalCount: z.ZodNullable<z.ZodNumber>;
+    consentTextVersion: z.ZodString;
+    termsHash: z.ZodString;
+    termsTemplateVersion: z.ZodNumber;
+    locale: z.ZodString;
+    actorUserId: z.ZodString;
+}, z.core.$strip>;
+export type CheckoutConsentRecordedPayload = z.infer<typeof checkoutConsentRecordedPayloadSchema>;
+export declare const CONTRACT_CONFIRMATION_ISSUED_EVENT_SHORT: "contract-confirmation-issued";
+export declare const CONTRACT_CONFIRMATION_ISSUED_EVENT_QN: "billing-foundation:event:contract-confirmation-issued";
+export declare const contractConfirmationIssuedPayloadSchema: z.ZodObject<{
+    consentId: z.ZodString;
+    issuedAtIso: z.ZodString;
+    locale: z.ZodString;
+    termsTemplateVersion: z.ZodNumber;
+}, z.core.$strip>;
+export type ContractConfirmationIssuedPayload = z.infer<typeof contractConfirmationIssuedPayloadSchema>;
+export declare const CONTRACT_TERMINATION_DECLARATION_TYPES: readonly ["termination", "withdrawal"];
+export type ContractTerminationDeclarationType = (typeof CONTRACT_TERMINATION_DECLARATION_TYPES)[number];
+export declare const CONTRACT_TERMINATION_KINDS: readonly ["ordinary", "extraordinary"];
+export type ContractTerminationKind = (typeof CONTRACT_TERMINATION_KINDS)[number];
+export declare const CONTRACT_TERMINATION_CHANNELS: readonly ["public", "account"];
+export declare const PROVIDER_CANCEL_OUTCOMES: readonly ["period-end", "immediately", "none"];
+export type ProviderCancelOutcome = (typeof PROVIDER_CANCEL_OUTCOMES)[number];
+export declare const CONTRACT_TERMINATION_REQUESTED_EVENT_SHORT: "contract-termination-requested";
+export declare const CONTRACT_TERMINATION_REQUESTED_EVENT_QN: "billing-foundation:event:contract-termination-requested";
+export declare const contractTerminationRequestedPayloadSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    declarationType: z.ZodEnum<{
+        termination: "termination";
+        withdrawal: "withdrawal";
+    }>;
+    terminationKind: z.ZodEnum<{
+        extraordinary: "extraordinary";
+        ordinary: "ordinary";
+    }>;
+    channel: z.ZodEnum<{
+        account: "account";
+        public: "public";
+    }>;
+    receivedAtIso: z.ZodString;
+    effectiveAtIso: z.ZodNullable<z.ZodString>;
+    providerCancel: z.ZodEnum<{
+        immediately: "immediately";
+        none: "none";
+        "period-end": "period-end";
+    }>;
+}, z.core.$strip>;
+export type ContractTerminationRequestedPayload = z.infer<typeof contractTerminationRequestedPayloadSchema>;
+export declare const CONTRACT_TERMINATION_DECLARED_EVENT_SHORT: "contract-termination-declared";
+export declare const CONTRACT_TERMINATION_DECLARED_EVENT_QN: "billing-foundation:event:contract-termination-declared";
+export declare const contractTerminationDeclaredPayloadSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    declarationType: z.ZodEnum<{
+        termination: "termination";
+        withdrawal: "withdrawal";
+    }>;
+    terminationKind: z.ZodEnum<{
+        extraordinary: "extraordinary";
+        ordinary: "ordinary";
+    }>;
+    receivedAtIso: z.ZodString;
+    locale: z.ZodEnum<{
+        de: "de";
+        en: "en";
+    }>;
+}, z.core.$strip>;
+export type ContractTerminationDeclaredPayload = z.infer<typeof contractTerminationDeclaredPayloadSchema>;
+export declare const CONTRACT_TERMINATION_UNMATCHED_AGGREGATE_TYPE: "contract-termination-unmatched";
+export declare const CONTRACT_TERMINATION_UNMATCHED_EVENT_SHORT: "contract-termination-unmatched";
+export declare const CONTRACT_TERMINATION_UNMATCHED_EVENT_QN: "billing-foundation:event:contract-termination-unmatched";
+export declare const contractTerminationUnmatchedPayloadSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    declarationType: z.ZodEnum<{
+        termination: "termination";
+        withdrawal: "withdrawal";
+    }>;
+    terminationKind: z.ZodEnum<{
+        extraordinary: "extraordinary";
+        ordinary: "ordinary";
+    }>;
+    channel: z.ZodLiteral<"public">;
+    receivedAtIso: z.ZodString;
+    matchResult: z.ZodEnum<{
+        ambiguous: "ambiguous";
+        none: "none";
+    }>;
+}, z.core.$strip>;
+export type ContractTerminationUnmatchedPayload = z.infer<typeof contractTerminationUnmatchedPayloadSchema>;