@cosmicdrift/kumiko-bundled-features 0.337.1 → 0.339.0

package/dist/billing-foundation/checkout-core.d.ts

@@ -88,6 +88,9 @@ export type OpenCheckoutInput = {
     readonly cancelUrl: string;
     readonly providerCustomerId?: string;
     readonly mode?: "subscription" | "payment";
+    readonly consentId?: string;
+    readonly locale?: string;
+    readonly submitMessage?: string;
 };
 /** The one checkout entry-point create-checkout-session and
  *  start-plan-checkout both funnel through. `mode: "payment"` (one-off

package/dist/billing-foundation/checkout-core.js

@@ -282,6 +282,9 @@ export async function openCheckout(ctx, options, input) {
         // pre-hardening wire-contract for callers that never sent `mode`
         // (create-checkout-session's own regression pin).
         ...(input.mode && { mode: input.mode }),
+        ...(input.consentId && { consentId: input.consentId }),
+        ...(input.locale && { locale: input.locale }),
+        ...(input.submitMessage && { submitMessage: input.submitMessage }),
     });
     return { url: result.url, providerName: input.providerName };
 }

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

@@ -2,6 +2,12 @@
 import { Temporal as TemporalPolyfill } from "temporal-polyfill";
 export declare const BILLING_FOUNDATION_FEATURE: "billing-foundation";
 export declare const SUBSCRIPTION_PROVIDER_EXTENSION: "subscriptionProvider";
+/** delivery notification type of the § 312f contract confirmation mail. */
+export declare const CONTRACT_CONFIRMATION_NOTIFICATION_TYPE: "billing-foundation:contract-confirmation";
+/** delivery notification types of the § 312k termination receipt and the
+ *  operator notice. */
+export declare const CONTRACT_TERMINATION_RECEIPT_NOTIFICATION_TYPE: "billing-foundation:contract-termination-receipt";
+export declare const CONTRACT_TERMINATION_OPERATOR_NOTIFICATION_TYPE: "billing-foundation:contract-termination-operator-notice";
 export declare const SubscriptionFoundationHandlers: {
     /** Programmatic entry-point für den webhook-handler. Receives the
      *  parsed SubscriptionEvent (vom Plugin schon verifiziert) + macht
@@ -22,6 +28,26 @@ export declare const SubscriptionFoundationHandlers: {
      *  (payment-aggregate), separate from the subscription-aggregate — a
      *  payment is not a subscription-state transition. */
     readonly processPaymentEvent: "billing-foundation:write:process-payment-event";
+    /** System-only: sends the § 312f contract confirmation mail for a recorded
+     *  checkout consent (consumerProtection only). */
+    readonly issueContractConfirmation: "billing-foundation:write:issue-contract-confirmation";
+    /** System-only: records a termination/withdrawal on the tenant's
+     *  subscription stream and asks the provider to cancel (consumerProtection
+     *  only). */
+    readonly recordContractTermination: "billing-foundation:write:record-contract-termination";
+    /** System-only: records that a public declaration reached a tenant's
+     *  subscription stream; the event triggers the provider cancel job
+     *  (consumerProtection only). */
+    readonly declareContractTermination: "billing-foundation:write:declare-contract-termination";
+    /** System-only: records a public declaration no single tenant could be
+     *  matched to, on a system-tenant stream (consumerProtection only). */
+    readonly recordUnmatchedContractTermination: "billing-foundation:write:record-unmatched-contract-termination";
+    /** Anonymous § 312k cancellation/withdrawal declaration (consumerProtection
+     *  only). */
+    readonly requestContractTermination: "billing-foundation:write:request-contract-termination";
+    /** Tenant-Admin terminates or withdraws from the contract of their own
+     *  tenant (consumerProtection only). */
+    readonly terminateContract: "billing-foundation:write:terminate-contract";
     /** Tenant-Admin/purchase-role picks a plan tier from the catalog with no
      *  existing non-terminal subscription — starts a hosted checkout for the
      *  matching price. Only registered when `createBillingFoundationFeature`
@@ -47,6 +73,9 @@ export declare const SubscriptionFoundationQueries: {
      *  current tier and per-plan action. Only registered when a `catalog` is
      *  configured. */
     readonly billingPlans: "billing-foundation:query:billing-plans";
+    /** System-only probe: does the caller tenant hold a non-terminal
+     *  subscription (consumerProtection only). */
+    readonly terminableSubscription: "billing-foundation:query:terminable-subscription";
 };
 export declare const SubscriptionEventTypes: {
     readonly created: "subscription.created";
@@ -69,6 +98,12 @@ export declare const BillingEventKinds: {
     readonly payment: "payment";
 };
 export type BillingEventKind = (typeof BillingEventKinds)[keyof typeof BillingEventKinds];
+export declare const SubscriptionCancelTimings: {
+    readonly periodEnd: "period-end";
+    readonly immediately: "immediately";
+};
+export type SubscriptionCancelTiming = (typeof SubscriptionCancelTimings)[keyof typeof SubscriptionCancelTimings];
+export declare function parseProviderConsentId(raw: unknown): string | undefined;
 export declare const BILLING_PLANS_SCREEN_ID: "billing-plans";
 export declare const BILLING_PLANS_PANEL_COMPONENT: "BillingPlansPanel";
 export declare const BillingPlanActions: {
@@ -97,3 +132,6 @@ export declare function isSubscriptionBlockingCheckout(sub: {
 export declare const SWITCHABLE_SUBSCRIPTION_STATUSES: ReadonlySet<string>;
 export declare function isSwitchableSubscriptionStatus(status: string): boolean;
 export declare const DEFAULT_PURCHASE_ROLES: readonly ["TenantAdmin", "SystemAdmin"];
+export declare const TERMINATION_SCOPES: readonly ["tenant-host", "platform"];
+export type TerminationScope = (typeof TERMINATION_SCOPES)[number];
+export declare function isTerminationScope(value: unknown): value is TerminationScope;

package/dist/billing-foundation/constants.js

@@ -12,6 +12,12 @@ export const BILLING_FOUNDATION_FEATURE = "billing-foundation";
 // Extension-point name fuer Provider-Plugins (subscription-stripe,
 // subscription-mollie, ...).
 export const SUBSCRIPTION_PROVIDER_EXTENSION = "subscriptionProvider";
+/** delivery notification type of the § 312f contract confirmation mail. */
+export const CONTRACT_CONFIRMATION_NOTIFICATION_TYPE = "billing-foundation:contract-confirmation";
+/** delivery notification types of the § 312k termination receipt and the
+ *  operator notice. */
+export const CONTRACT_TERMINATION_RECEIPT_NOTIFICATION_TYPE = "billing-foundation:contract-termination-receipt";
+export const CONTRACT_TERMINATION_OPERATOR_NOTIFICATION_TYPE = "billing-foundation:contract-termination-operator-notice";
 // Qualified write handler names (QN format: scope:type:name).
 export const SubscriptionFoundationHandlers = {
     /** Programmatic entry-point für den webhook-handler. Receives the
@@ -33,6 +39,26 @@ export const SubscriptionFoundationHandlers = {
      *  (payment-aggregate), separate from the subscription-aggregate — a
      *  payment is not a subscription-state transition. */
     processPaymentEvent: "billing-foundation:write:process-payment-event",
+    /** System-only: sends the § 312f contract confirmation mail for a recorded
+     *  checkout consent (consumerProtection only). */
+    issueContractConfirmation: "billing-foundation:write:issue-contract-confirmation",
+    /** System-only: records a termination/withdrawal on the tenant's
+     *  subscription stream and asks the provider to cancel (consumerProtection
+     *  only). */
+    recordContractTermination: "billing-foundation:write:record-contract-termination",
+    /** System-only: records that a public declaration reached a tenant's
+     *  subscription stream; the event triggers the provider cancel job
+     *  (consumerProtection only). */
+    declareContractTermination: "billing-foundation:write:declare-contract-termination",
+    /** System-only: records a public declaration no single tenant could be
+     *  matched to, on a system-tenant stream (consumerProtection only). */
+    recordUnmatchedContractTermination: "billing-foundation:write:record-unmatched-contract-termination",
+    /** Anonymous § 312k cancellation/withdrawal declaration (consumerProtection
+     *  only). */
+    requestContractTermination: "billing-foundation:write:request-contract-termination",
+    /** Tenant-Admin terminates or withdraws from the contract of their own
+     *  tenant (consumerProtection only). */
+    terminateContract: "billing-foundation:write:terminate-contract",
     /** Tenant-Admin/purchase-role picks a plan tier from the catalog with no
      *  existing non-terminal subscription — starts a hosted checkout for the
      *  matching price. Only registered when `createBillingFoundationFeature`
@@ -59,6 +85,9 @@ export const SubscriptionFoundationQueries = {
      *  current tier and per-plan action. Only registered when a `catalog` is
      *  configured. */
     billingPlans: "billing-foundation:query:billing-plans",
+    /** System-only probe: does the caller tenant hold a non-terminal
+     *  subscription (consumerProtection only). */
+    terminableSubscription: "billing-foundation:query:terminable-subscription",
 };
 // Normalized subscription-event types — provider-agnostic.
 // Alle Provider-Plugins normalisieren ihre eigenen event-types auf einen
@@ -90,6 +119,16 @@ export const BillingEventKinds = {
     subscription: "subscription",
     payment: "payment",
 };
+export const SubscriptionCancelTimings = {
+    periodEnd: "period-end",
+    immediately: "immediately",
+};
+// consentId is echoed back by the provider (checkout metadata), so it is
+// untrusted input: bounded length, id-ish charset only.
+const CONSENT_ID_PATTERN = /^[A-Za-z0-9_-]{1,100}$/;
+export function parseProviderConsentId(raw) {
+    return typeof raw === "string" && CONSENT_ID_PATTERN.test(raw) ? raw : undefined;
+}
 // Billing-plans screen/panel identifiers — the dormant dashboard app-builders
 // mount their own catalog-derived nav entry onto.
 export const BILLING_PLANS_SCREEN_ID = "billing-plans";
@@ -163,3 +202,7 @@ export const DEFAULT_PURCHASE_ROLES = ["TenantAdmin", "SystemAdmin"];
 // Stripe-priceIds vs PayPal-plan-ids vs Apple-product-ids
 // unterschiedliche IDs sind. Jeder Plugin definiert seinen eigenen
 // `<plugin-name>:config:price-to-tier`-Key.
+export const TERMINATION_SCOPES = ["tenant-host", "platform"];
+export function isTerminationScope(value) {
+    return TERMINATION_SCOPES.includes(value);
+}

package/dist/billing-foundation/consumer-protection/confirmation-mail.d.ts

@@ -0,0 +1,21 @@
+import type { CheckoutConsentRecordedPayload } from "../events.js";
+export type ContractConfirmationContent = {
+    readonly subject: string;
+    readonly header: string;
+    readonly sections: readonly {
+        readonly text: string;
+    }[];
+    readonly footer: string;
+};
+export type RenderContractConfirmationArgs = {
+    readonly consent: CheckoutConsentRecordedPayload;
+    readonly consentGivenAtIso: string;
+    readonly contractStartIso: string;
+    readonly currentPeriodEndIso?: string;
+    readonly vatNote: Readonly<Record<string, string>>;
+    readonly operatorEmail: string;
+    readonly termsContent: string;
+};
+/** Structured mail content (header/sections/footer) for the email channel's
+ *  renderer; the renderer owns HTML escaping, this only builds plain text. */
+export declare function renderContractConfirmation(args: RenderContractConfirmationArgs): ContractConfirmationContent;

package/dist/billing-foundation/consumer-protection/confirmation-mail.js

@@ -0,0 +1,125 @@
+import { Temporal } from "temporal-polyfill";
+import { CONSENT_TEXTS, resolveConsentLocale } from "./consent-text.js";
+const LABELS = {
+    de: {
+        subject: "Vertragsbestätigung",
+        intro: "vielen Dank für deine Bestellung. Hiermit bestätigen wir den Vertragsschluss mit folgendem Inhalt.",
+        plan: "Tarif",
+        oneOffPayment: "Einmalzahlung",
+        price: "Preis",
+        oneOff: "einmalig",
+        contractStart: "Vertragsbeginn",
+        currentPeriodEnd: "Aktueller Abrechnungszeitraum bis",
+        consentHeading: "Deine Zustimmungen",
+        consentGivenAt: "Erteilt am",
+        termsHeading: "Allgemeine Geschäftsbedingungen",
+        contact: "Fragen zu deinem Vertrag richtest du bitte an",
+        every: "alle",
+        intervals: {
+            day: { one: "Tag", many: "Tage" },
+            week: { one: "Woche", many: "Wochen" },
+            month: { one: "Monat", many: "Monate" },
+            year: { one: "Jahr", many: "Jahre" },
+        },
+    },
+    en: {
+        subject: "Contract confirmation",
+        intro: "thank you for your order. We hereby confirm the conclusion of the contract with the following content.",
+        plan: "Plan",
+        oneOffPayment: "One-off payment",
+        price: "Price",
+        oneOff: "one-off",
+        contractStart: "Contract start",
+        currentPeriodEnd: "Current billing period ends",
+        consentHeading: "Your consents",
+        consentGivenAt: "Given on",
+        termsHeading: "Terms and conditions",
+        contact: "Questions about your contract go to",
+        every: "every",
+        intervals: {
+            day: { one: "day", many: "days" },
+            week: { one: "week", many: "weeks" },
+            month: { one: "month", many: "months" },
+            year: { one: "year", many: "years" },
+        },
+    },
+};
+function formatPrice(consent, locale) {
+    const labels = LABELS[locale];
+    if (consent.unitAmount === null || consent.currency === null)
+        return "-";
+    let amount;
+    try {
+        const format = new Intl.NumberFormat(locale, { style: "currency", currency: consent.currency });
+        const fractionDigits = format.resolvedOptions().maximumFractionDigits ?? 2;
+        amount = format.format(consent.unitAmount / 10 ** fractionDigits);
+    }
+    catch {
+        // Currency codes come from the provider; an unknown one must not block the mail.
+        amount = `${consent.unitAmount} ${consent.currency.toUpperCase()}`;
+    }
+    if (consent.interval === null)
+        return `${amount} (${labels.oneOff})`;
+    const unit = labels.intervals[consent.interval];
+    const count = consent.intervalCount ?? 1;
+    const intervalText = unit === undefined
+        ? consent.interval
+        : count === 1
+            ? unit.one
+            : `${labels.every} ${count} ${unit.many}`;
+    return count === 1 ? `${amount} / ${intervalText}` : `${amount}, ${intervalText}`;
+}
+function formatDate(iso, locale) {
+    let epochMilliseconds;
+    try {
+        epochMilliseconds = Temporal.Instant.from(iso).epochMilliseconds;
+    }
+    catch {
+        return iso;
+    }
+    return new Intl.DateTimeFormat(locale, {
+        dateStyle: "long",
+        timeStyle: "short",
+        timeZone: "UTC",
+    }).format(epochMilliseconds);
+}
+function paragraphs(text) {
+    return text
+        .split(/\n{2,}/)
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0)
+        .map((part) => ({ text: part }));
+}
+/** Structured mail content (header/sections/footer) for the email channel's
+ *  renderer; the renderer owns HTML escaping, this only builds plain text. */
+export function renderContractConfirmation(args) {
+    const locale = resolveConsentLocale(args.consent.locale);
+    const labels = LABELS[locale];
+    const texts = CONSENT_TEXTS[locale];
+    const { consent } = args;
+    const contractLines = [
+        `${labels.plan}: ${consent.tier ?? labels.oneOffPayment}`,
+        `${labels.price}: ${formatPrice(consent, locale)}`,
+        `${labels.contractStart}: ${formatDate(args.contractStartIso, locale)}`,
+        ...(args.currentPeriodEndIso !== undefined
+            ? [`${labels.currentPeriodEnd}: ${formatDate(args.currentPeriodEndIso, locale)}`]
+            : []),
+    ];
+    const vatNote = args.vatNote[locale] ?? args.vatNote[resolveConsentLocale()];
+    return {
+        subject: labels.subject,
+        header: labels.subject,
+        sections: [
+            { text: labels.intro },
+            ...contractLines.map((text) => ({ text })),
+            ...(vatNote !== undefined ? [{ text: vatNote }] : []),
+            { text: labels.consentHeading },
+            { text: texts.earlyPerformance },
+            { text: texts.withdrawalLoss },
+            { text: `${labels.consentGivenAt}: ${formatDate(args.consentGivenAtIso, locale)}` },
+            { text: labels.termsHeading },
+            ...paragraphs(args.termsContent),
+        ],
+        footer: `${labels.contact} ${args.operatorEmail}`,
+    };
+}

package/dist/billing-foundation/consumer-protection/consent-gate.d.ts

@@ -0,0 +1,32 @@
+import type { HandlerContext } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+import type { ConsumerProtectionOptions, ProviderPrice } from "../types.js";
+export type CheckoutMode = "subscription" | "payment";
+export declare const consentPayloadSchema: z.ZodObject<{
+    earlyPerformanceRequested: z.ZodBoolean;
+    withdrawalLossAcknowledged: z.ZodBoolean;
+    consentTextVersion: z.ZodString;
+    locale: z.ZodString;
+}, z.core.$strict>;
+export type ConsentPayload = z.infer<typeof consentPayloadSchema>;
+export type PreparedConsent = {
+    readonly consentId: string;
+    readonly mode: CheckoutMode;
+    readonly locale: string;
+    readonly submitMessage: string;
+    readonly consentTextVersion: string;
+    readonly termsHash: string;
+    readonly termsTemplateVersion: number;
+};
+export type ConsentPriceDetails = {
+    readonly tier: string | null;
+    readonly priceId: string;
+    readonly price: Pick<ProviderPrice, "unitAmount" | "currency" | "interval" | "intervalCount"> | null;
+};
+export declare function prepareConsent(ctx: HandlerContext, options: ConsumerProtectionOptions, consent: ConsentPayload | undefined, mode: CheckoutMode): Promise<PreparedConsent>;
+export declare function consentCheckoutFields(prepared: PreparedConsent): {
+    readonly consentId: string;
+    readonly locale: string;
+    readonly submitMessage: string;
+};
+export declare function recordConsent(ctx: HandlerContext, prepared: PreparedConsent, details: ConsentPriceDetails): Promise<void>;

package/dist/billing-foundation/consumer-protection/consent-gate.js

@@ -0,0 +1,96 @@
+// Consent gate shared by start-plan-checkout and create-checkout-session:
+// validate + prepare before the provider call, record only after it succeeded.
+import { createHash } from "node:crypto";
+import { UnprocessableError } from "@cosmicdrift/kumiko-framework/errors";
+import { generateId } from "@cosmicdrift/kumiko-framework/utils";
+import * as z from "zod";
+import { requireTemplateResolver, TEXT_BLOCK_KIND, TemplateNotFoundError, } from "../../template-resolver/index.js";
+import { paymentAggregateId, subscriptionAggregateId } from "../aggregate-id.js";
+import { CHECKOUT_CONSENT_RECORDED_EVENT_QN, PAYMENT_AGGREGATE_TYPE, SUBSCRIPTION_AGGREGATE_TYPE, } from "../events.js";
+import { consentTextVersion, resolveConsentLocale, submitMessageFor } from "./consent-text.js";
+// Optional at the schema level so a missing/unchecked consent reaches
+// prepareConsent and fails as 422 consent_required, not as a zod 400.
+export const consentPayloadSchema = z
+    .object({
+    earlyPerformanceRequested: z.boolean(),
+    withdrawalLossAcknowledged: z.boolean(),
+    consentTextVersion: z.string().min(1).max(64),
+    locale: z.string().min(2).max(35),
+})
+    .strict();
+export async function prepareConsent(ctx, options, consent, mode) {
+    if (!consent?.earlyPerformanceRequested || !consent.withdrawalLossAcknowledged) {
+        throw new UnprocessableError("consent_required", {
+            i18nKey: "billing-foundation.errors.consentRequired",
+            message: "billing-foundation: both consent flags must be true to start a checkout",
+        });
+    }
+    const locale = resolveConsentLocale(consent.locale);
+    if (consent.consentTextVersion !== consentTextVersion(locale)) {
+        throw new UnprocessableError("consent_text_outdated", {
+            i18nKey: "billing-foundation.errors.consentTextOutdated",
+            message: `billing-foundation: consent text version "${consent.consentTextVersion}" is not current for locale "${locale}"`,
+        });
+    }
+    const resolver = requireTemplateResolver(ctx, "billing-foundation");
+    let terms;
+    try {
+        terms = await resolver.resolveTemplate({
+            tenantId: ctx.user.tenantId,
+            slug: options.termsTextBlock,
+            kind: TEXT_BLOCK_KIND,
+            locale,
+        });
+    }
+    catch (error) {
+        if (error instanceof TemplateNotFoundError) {
+            throw new UnprocessableError("terms_unavailable", {
+                i18nKey: "billing-foundation.errors.termsUnavailable",
+                message: `billing-foundation: terms text block "${options.termsTextBlock}" could not be resolved`,
+                cause: error,
+            });
+        }
+        throw error;
+    }
+    return {
+        consentId: generateId(),
+        mode,
+        locale,
+        submitMessage: submitMessageFor(locale, mode),
+        consentTextVersion: consent.consentTextVersion,
+        termsHash: createHash("sha256").update(terms.content).digest("hex"),
+        termsTemplateVersion: terms.version,
+    };
+}
+export function consentCheckoutFields(prepared) {
+    return {
+        consentId: prepared.consentId,
+        locale: prepared.locale,
+        submitMessage: prepared.submitMessage,
+    };
+}
+export async function recordConsent(ctx, prepared, details) {
+    const payload = {
+        consentId: prepared.consentId,
+        mode: prepared.mode,
+        tier: details.tier,
+        priceId: details.priceId,
+        unitAmount: details.price?.unitAmount ?? null,
+        currency: details.price?.currency ?? null,
+        interval: details.price?.interval ?? null,
+        intervalCount: details.price?.intervalCount ?? null,
+        consentTextVersion: prepared.consentTextVersion,
+        termsHash: prepared.termsHash,
+        termsTemplateVersion: prepared.termsTemplateVersion,
+        locale: prepared.locale,
+        actorUserId: String(ctx.user.id),
+    };
+    const tenantId = ctx.user.tenantId;
+    const isSubscription = prepared.mode === "subscription";
+    await ctx.unsafeAppendEvent({
+        aggregateId: isSubscription ? subscriptionAggregateId(tenantId) : paymentAggregateId(tenantId),
+        aggregateType: isSubscription ? SUBSCRIPTION_AGGREGATE_TYPE : PAYMENT_AGGREGATE_TYPE,
+        type: CHECKOUT_CONSENT_RECORDED_EVENT_QN,
+        payload,
+    });
+}

package/dist/billing-foundation/consumer-protection/consent-locale.d.ts

@@ -0,0 +1,5 @@
+export declare const CONSENT_LOCALES: readonly ["de", "en"];
+export type ConsentLocale = (typeof CONSENT_LOCALES)[number];
+export declare const FALLBACK_CONSENT_LOCALE: ConsentLocale;
+/** Exact match, else the language part ("de-AT" → "de"), else the fallback. */
+export declare function resolveConsentLocale(input?: string): ConsentLocale;

package/dist/billing-foundation/consumer-protection/consent-locale.js

@@ -0,0 +1,17 @@
+// @runtime client
+// Crypto-free so the browser panel can share the locale rule with the server.
+export const CONSENT_LOCALES = ["de", "en"];
+export const FALLBACK_CONSENT_LOCALE = "de";
+function isConsentLocale(value) {
+    return CONSENT_LOCALES.some((locale) => locale === value);
+}
+/** Exact match, else the language part ("de-AT" → "de"), else the fallback. */
+export function resolveConsentLocale(input) {
+    if (input === undefined)
+        return FALLBACK_CONSENT_LOCALE;
+    const lower = input.toLowerCase();
+    if (isConsentLocale(lower))
+        return lower;
+    const language = lower.split("-")[0] ?? "";
+    return isConsentLocale(language) ? language : FALLBACK_CONSENT_LOCALE;
+}

package/dist/billing-foundation/consumer-protection/consent-text.d.ts

@@ -0,0 +1,11 @@
+import type { ConsentLocale } from "./consent-locale.js";
+export { CONSENT_LOCALES, type ConsentLocale, FALLBACK_CONSENT_LOCALE, resolveConsentLocale, } from "./consent-locale.js";
+export type ConsentTexts = {
+    readonly earlyPerformance: string;
+    readonly withdrawalLoss: string;
+    readonly subscriptionSubmitMessage: string;
+    readonly paymentSubmitMessage: string;
+};
+export declare const CONSENT_TEXTS: Readonly<Record<ConsentLocale, ConsentTexts>>;
+export declare function consentTextVersion(locale: ConsentLocale): string;
+export declare function submitMessageFor(locale: ConsentLocale, mode: "subscription" | "payment"): string;

package/dist/billing-foundation/consumer-protection/consent-text.js

@@ -0,0 +1,28 @@
+import { createHash } from "node:crypto";
+export { CONSENT_LOCALES, FALLBACK_CONSENT_LOCALE, resolveConsentLocale, } from "./consent-locale.js";
+export const CONSENT_TEXTS = {
+    de: {
+        earlyPerformance: "Ich verlange ausdrücklich, dass der Anbieter vor Ablauf der Widerrufsfrist mit der Ausführung des Vertrags beginnt.",
+        withdrawalLoss: "Ich nehme zur Kenntnis, dass ich mein Widerrufsrecht verliere, sobald der Vertrag von dem Anbieter vollständig erfüllt ist, bei digitalen Inhalten sobald die Ausführung begonnen hat, nachdem ich ausdrücklich zugestimmt habe und bestätigt habe, dass ich dadurch mein Widerrufsrecht verliere.",
+        subscriptionSubmitMessage: "Kostenpflichtiges Abonnement: Es verlängert sich zum Ende jedes Abrechnungszeitraums automatisch, bis du es kündigst. Du kannst jederzeit zum Ende des laufenden Zeitraums kündigen.",
+        paymentSubmitMessage: "Kostenpflichtige Einmalzahlung: Mit Klick auf den Button verpflichtest du dich zur Zahlung.",
+    },
+    en: {
+        earlyPerformance: "I expressly request that the provider begins performing the contract before the withdrawal period has expired.",
+        withdrawalLoss: "I acknowledge that I lose my right of withdrawal once the provider has fully performed the contract, and for digital content once performance has begun, after I have expressly consented and confirmed that I lose my right of withdrawal as a result.",
+        subscriptionSubmitMessage: "Paid subscription: it renews automatically at the end of each billing period until you cancel. You can cancel at any time, effective at the end of the current period.",
+        paymentSubmitMessage: "Paid one-off payment: by clicking the button you commit to paying.",
+    },
+};
+const CONSENT_TEXT_VERSION_LENGTH = 16;
+export function consentTextVersion(locale) {
+    const { earlyPerformance, withdrawalLoss } = CONSENT_TEXTS[locale];
+    return createHash("sha256")
+        .update(`${earlyPerformance}\n${withdrawalLoss}`)
+        .digest("hex")
+        .slice(0, CONSENT_TEXT_VERSION_LENGTH);
+}
+export function submitMessageFor(locale, mode) {
+    const texts = CONSENT_TEXTS[locale];
+    return mode === "subscription" ? texts.subscriptionSubmitMessage : texts.paymentSubmitMessage;
+}

package/dist/billing-foundation/consumer-protection/issue-confirmation.d.ts

@@ -0,0 +1,15 @@
+import { type WriteHandlerDef } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+import type { ConsumerProtectionOptions, ResolvedBillingFoundationOptions } from "../types.js";
+export declare const issueContractConfirmationSchema: z.ZodObject<{
+    consentId: z.ZodString;
+    sourceAggregateId: z.ZodUUID;
+    currentPeriodEndIso: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type IssueContractConfirmationResult = {
+    readonly issued: true;
+} | {
+    readonly issued: false;
+    readonly reason: "consent_not_found" | "already_issued" | "recipient_not_found";
+};
+export declare function createIssueContractConfirmationHandler(options: ResolvedBillingFoundationOptions, consumerProtection: ConsumerProtectionOptions): WriteHandlerDef;