@saasicat/core 1.0.0-rc.0

package/dist/index.cjs

@@ -0,0 +1,957 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AUTH_ERROR_CODES: () => AUTH_ERROR_CODES,
+  BILLING_ERROR_CODES: () => BILLING_ERROR_CODES,
+  CATALOG_ERROR_CODES: () => CATALOG_ERROR_CODES,
+  CONTRACT_ERROR_CODES: () => CONTRACT_ERROR_CODES,
+  ERROR_MESSAGES_DE: () => ERROR_MESSAGES_DE,
+  ERROR_MESSAGES_EN: () => ERROR_MESSAGES_EN,
+  FEATURE_NOT_LICENSED: () => FEATURE_NOT_LICENSED,
+  OTP_RATE_LIMIT_MAX_SENDS: () => OTP_RATE_LIMIT_MAX_SENDS,
+  OTP_RATE_LIMIT_WINDOW_MINUTES: () => OTP_RATE_LIMIT_WINDOW_MINUTES,
+  OTP_TTL_MINUTES: () => OTP_TTL_MINUTES,
+  OTP_VERIFY_MAX_ATTEMPTS: () => OTP_VERIFY_MAX_ATTEMPTS,
+  PASSWORD_RESET_TTL_MINUTES: () => PASSWORD_RESET_TTL_MINUTES,
+  PENDING_CHECKOUT_TTL_DAYS: () => PENDING_CHECKOUT_TTL_DAYS,
+  PENDING_EMAIL_TTL_HOURS: () => PENDING_EMAIL_TTL_HOURS,
+  PENDING_ONBOARDING_TTL_DAYS: () => PENDING_ONBOARDING_TTL_DAYS,
+  PLATFORM_ERROR_CODES: () => PLATFORM_ERROR_CODES,
+  PROMO_ERROR_CODES: () => PROMO_ERROR_CODES,
+  PersistenceCapabilityError: () => PersistenceCapabilityError,
+  PlatformUserExistsError: () => PlatformUserExistsError,
+  REGISTRATION_ERROR_CODES: () => REGISTRATION_ERROR_CODES,
+  REGISTRATION_RESUME_TTL_MINUTES: () => REGISTRATION_RESUME_TTL_MINUTES,
+  REGISTRATION_STEP_BY_STATUS: () => REGISTRATION_STEP_BY_STATUS,
+  SETUP_ERROR_CODES: () => SETUP_ERROR_CODES,
+  applyPromo: () => applyPromo,
+  assertPersistenceCapabilities: () => assertPersistenceCapabilities,
+  buildActivePlanVersionWhere: () => buildActivePlanVersionWhere,
+  buildActiveVersionWhere: () => buildActiveVersionWhere,
+  buildFeatureRequiresIndex: () => buildFeatureRequiresIndex,
+  classifyBundleVersionDiff: () => classifyBundleVersionDiff,
+  classifyPlanDiff: () => classifyPlanDiff,
+  collectUnsatisfiedRequires: () => collectUnsatisfiedRequires,
+  coverageExcludingSelf: () => coverageExcludingSelf,
+  formatErrorMessage: () => formatErrorMessage,
+  isBundleRedundant: () => isBundleRedundant,
+  isPlatformUserExistsError: () => isPlatformUserExistsError,
+  isVersionEditable: () => isVersionEditable,
+  missingRequiresFor: () => missingRequiresFor,
+  pickActivePromo: () => pickActivePromo,
+  promoStatus: () => promoStatus,
+  resolveBundleAvailability: () => resolveBundleAvailability,
+  resolveErrorMessage: () => resolveErrorMessage,
+  selectChargeableBundles: () => selectChargeableBundles,
+  startOfUtcDay: () => startOfUtcDay
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/active-plan-version-query.ts
+function startOfUtcDay(date) {
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+}
+function buildActivePlanVersionWhere(asOf, options = {}) {
+  const asOfDayStart = startOfUtcDay(asOf);
+  const validityWindow = [
+    { OR: [{ validFrom: null }, { validFrom: { lte: asOf } }] },
+    { OR: [{ validUntil: null }, { validUntil: { gte: asOfDayStart } }] }
+  ];
+  if (!options.withEndsAt) {
+    return { publishedAt: { not: null }, AND: validityWindow };
+  }
+  return {
+    publishedAt: { not: null },
+    AND: [...validityWindow, { OR: [{ endsAt: null }, { endsAt: { gt: asOf } }] }]
+  };
+}
+var buildActiveVersionWhere = buildActivePlanVersionWhere;
+
+// src/promotion.types.ts
+function promoStatus(promo, today = /* @__PURE__ */ new Date()) {
+  const from = new Date(promo.validFrom);
+  const to = /* @__PURE__ */ new Date(`${promo.validTo}T23:59:59`);
+  if (today < from) return "scheduled";
+  if (today > to) return "expired";
+  return "active";
+}
+function pickActivePromo(promotions, targetKey, locale, cycle, today = /* @__PURE__ */ new Date(), targetType = "PLAN") {
+  const matches = promotions.filter((p) => (p.targetType ?? "PLAN") === targetType).filter((p) => p.appliesTo.includes(targetKey)).filter((p) => p.billingCycle === "both" || p.billingCycle === cycle).filter((p) => !p.onlyLocales || p.onlyLocales.includes(locale)).filter((p) => !p.requiresCoupon).filter((p) => promoStatus(p, today) === "active").sort((a, b) => (b.priority || 0) - (a.priority || 0));
+  return matches[0] ?? null;
+}
+function applyPromo(promo, basePrice) {
+  if (!promo || basePrice === null || basePrice === void 0) return null;
+  if (promo.type === "percent" && typeof promo.value === "number") {
+    return {
+      kind: "percent",
+      discounted: Math.round(basePrice * (100 - promo.value)) / 100,
+      original: basePrice,
+      pct: promo.value
+    };
+  }
+  if (promo.type === "amount" && typeof promo.value === "number") {
+    return {
+      kind: "amount",
+      discounted: Math.max(0, basePrice - promo.value),
+      original: basePrice,
+      saved: promo.value
+    };
+  }
+  if (promo.type === "intro" && typeof promo.value === "object") {
+    return {
+      kind: "intro",
+      discounted: promo.value.price,
+      original: basePrice,
+      months: promo.value.months
+    };
+  }
+  if (promo.type === "freeMonths" && typeof promo.value === "number") {
+    return { kind: "free", discounted: 0, original: basePrice, months: promo.value };
+  }
+  return null;
+}
+
+// src/version-diff.ts
+function classifyPlanDiff(oldV, newV) {
+  const changes = [];
+  appendFeatureChanges(changes, oldV.features, newV.features);
+  appendNumberChange(changes, "maxUsers", oldV.maxUsers, newV.maxUsers, "higherIsBetter");
+  appendNumberChange(
+    changes,
+    "maxVehicles",
+    oldV.maxVehicles,
+    newV.maxVehicles,
+    "higherIsBetter"
+  );
+  appendNumberChange(
+    changes,
+    "maxStorageGb",
+    oldV.maxStorageGb,
+    newV.maxStorageGb,
+    "higherIsBetter"
+  );
+  appendDecimalChange(changes, "monthlyNet", oldV.monthlyNet, newV.monthlyNet, "lowerIsBetter");
+  appendDecimalChange(changes, "yearlyNet", oldV.yearlyNet, newV.yearlyNet, "lowerIsBetter");
+  return buildResult(changes);
+}
+function classifyBundleVersionDiff(oldV, newV) {
+  const changes = [];
+  appendFeatureChanges(changes, oldV.features, newV.features);
+  appendQuotaChanges(changes, oldV.quotas, newV.quotas);
+  appendNullableDecimalChange(
+    changes,
+    "monthlyNet",
+    oldV.monthlyNet,
+    newV.monthlyNet,
+    "lowerIsBetter"
+  );
+  appendNullableDecimalChange(
+    changes,
+    "yearlyNet",
+    oldV.yearlyNet,
+    newV.yearlyNet,
+    "lowerIsBetter"
+  );
+  return buildResult(changes);
+}
+function appendFeatureChanges(out, oldFeatures, newFeatures) {
+  const oldSet = new Set(oldFeatures);
+  const newSet = new Set(newFeatures);
+  const removed = oldFeatures.filter((f) => !newSet.has(f));
+  const added = newFeatures.filter((f) => !oldSet.has(f));
+  if (removed.length > 0) {
+    out.push({
+      field: "features.removed",
+      oldValue: removed,
+      newValue: [],
+      direction: "REGRESSION"
+    });
+  }
+  if (added.length > 0) {
+    out.push({
+      field: "features.added",
+      oldValue: [],
+      newValue: added,
+      direction: "IMPROVEMENT"
+    });
+  }
+}
+function appendNumberChange(out, field, oldValue, newValue, polarity) {
+  if (oldValue === newValue) return;
+  const direction = directionFromCmp(newValue - oldValue, polarity);
+  out.push({ field, oldValue, newValue, direction });
+}
+function appendDecimalChange(out, field, oldValue, newValue, polarity) {
+  const oldNum = toNumber(oldValue);
+  const newNum = toNumber(newValue);
+  if (oldNum === newNum) return;
+  const direction = directionFromCmp(newNum - oldNum, polarity);
+  out.push({
+    field,
+    oldValue: oldNum.toFixed(2),
+    newValue: newNum.toFixed(2),
+    direction
+  });
+}
+function directionFromCmp(delta, polarity) {
+  if (delta === 0) return "NEUTRAL";
+  const positiveDelta = delta > 0;
+  if (polarity === "higherIsBetter") {
+    return positiveDelta ? "IMPROVEMENT" : "REGRESSION";
+  }
+  return positiveDelta ? "REGRESSION" : "IMPROVEMENT";
+}
+function toNumber(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") return Number(v);
+  return v.toNumber();
+}
+function buildResult(changes) {
+  const nonRegressive = !changes.some((c) => c.direction === "REGRESSION");
+  return { nonRegressive, changes };
+}
+function appendQuotaChanges(out, oldQuotas, newQuotas) {
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(oldQuotas), ...Object.keys(newQuotas)]);
+  for (const key of allKeys) {
+    const oldValue = oldQuotas[key] ?? 0;
+    const newValue = newQuotas[key] ?? 0;
+    if (oldValue === newValue) continue;
+    const direction = directionFromQuotaCmp(oldValue, newValue);
+    out.push({ field: `quotas.${key}`, oldValue, newValue, direction });
+  }
+}
+function directionFromQuotaCmp(oldValue, newValue) {
+  if (oldValue === -1 && newValue !== -1) return "REGRESSION";
+  if (newValue === -1 && oldValue !== -1) return "IMPROVEMENT";
+  return newValue > oldValue ? "IMPROVEMENT" : "REGRESSION";
+}
+function appendNullableDecimalChange(out, field, oldValue, newValue, polarity) {
+  if (oldValue === null && newValue === null) return;
+  if (oldValue === null && newValue !== null) {
+    out.push({
+      field,
+      oldValue: null,
+      newValue: toNumber(newValue).toFixed(2),
+      direction: polarity === "lowerIsBetter" ? "IMPROVEMENT" : "REGRESSION"
+    });
+    return;
+  }
+  if (oldValue !== null && newValue === null) {
+    out.push({
+      field,
+      oldValue: toNumber(oldValue).toFixed(2),
+      newValue: null,
+      direction: polarity === "lowerIsBetter" ? "REGRESSION" : "IMPROVEMENT"
+    });
+    return;
+  }
+  appendDecimalChange(out, field, oldValue, newValue, polarity);
+}
+
+// src/ports/persistence-ports.types.ts
+var PersistenceCapabilityError = class extends Error {
+  constructor(missing, requiredBy) {
+    super(
+      `${requiredBy} requires persistence capabilities the configured adapter does not provide: ${missing.join(", ")}. Use an adapter/database that supports them or disable the feature.`
+    );
+    this.missing = missing;
+    this.requiredBy = requiredBy;
+    this.name = "PersistenceCapabilityError";
+  }
+  missing;
+  requiredBy;
+  code = "PERSISTENCE_CAPABILITY_MISSING";
+};
+function assertPersistenceCapabilities(capabilities, required, requiredBy) {
+  const missing = Object.keys(required).filter(
+    (key) => required[key] && !capabilities[key]
+  );
+  if (missing.length > 0) {
+    throw new PersistenceCapabilityError(missing, requiredBy);
+  }
+}
+
+// src/upsell.types.ts
+var FEATURE_NOT_LICENSED = "FEATURE_NOT_LICENSED";
+
+// src/error-codes.ts
+var SETUP_ERROR_CODES = {
+  /** `SETUP_TOKEN` env not set → setup disabled. */
+  SETUP_DISABLED: "SETUP_DISABLED",
+  /** Provided token does not match. */
+  INVALID_SETUP_TOKEN: "INVALID_SETUP_TOKEN",
+  /** A SUPER_ADMIN already exists — self-disable. */
+  SETUP_ALREADY_DONE: "SETUP_ALREADY_DONE",
+  /** Invalid email in the request. */
+  INVALID_EMAIL: "INVALID_EMAIL",
+  /** Email already taken (mapped from `PlatformUserExistsError`). */
+  EMAIL_EXISTS: "EMAIL_EXISTS"
+};
+var CATALOG_ERROR_CODES = {
+  // ── plan master data ──
+  PLAN_HAS_DRAFTS: "PLAN_HAS_DRAFTS",
+  PLAN_HAS_PUBLISHED_VERSIONS: "PLAN_HAS_PUBLISHED_VERSIONS",
+  PLAN_HARD_DELETE_NOT_IMPLEMENTED: "PLAN_HARD_DELETE_NOT_IMPLEMENTED",
+  // ── plan versions ──
+  PLAN_VERSION_ALREADY_PUBLISHED: "PLAN_VERSION_ALREADY_PUBLISHED",
+  PLAN_VERSION_NOT_EDITABLE: "PLAN_VERSION_NOT_EDITABLE",
+  PLAN_VERSION_REGRESSION: "PLAN_VERSION_REGRESSION",
+  PLAN_VERSION_ZERO_PRICE: "PLAN_VERSION_ZERO_PRICE",
+  PLAN_VERSION_DISCARD_NOT_IMPLEMENTED: "PLAN_VERSION_DISCARD_NOT_IMPLEMENTED",
+  /** Version was never published, so it cannot be terminated. */
+  PLAN_VERSION_NOT_PUBLISHED: "PLAN_VERSION_NOT_PUBLISHED",
+  /** Version was replaced by a successor (`supersededAt` set). */
+  PLAN_VERSION_SUPERSEDED: "PLAN_VERSION_SUPERSEDED",
+  PLAN_VERSION_VALID_FROM_REQUIRED: "PLAN_VERSION_VALID_FROM_REQUIRED",
+  PLAN_VERSION_VALID_FROM_INVALID: "PLAN_VERSION_VALID_FROM_INVALID",
+  PLAN_VERSION_VALID_FROM_NOT_AFTER_PREVIOUS: "PLAN_VERSION_VALID_FROM_NOT_AFTER_PREVIOUS",
+  PLAN_VERSION_VALID_FROM_NOT_GAPLESS: "PLAN_VERSION_VALID_FROM_NOT_GAPLESS",
+  PLAN_VERSION_VALID_UNTIL_INVALID: "PLAN_VERSION_VALID_UNTIL_INVALID",
+  PLAN_VERSION_VALID_UNTIL_BEFORE_FROM: "PLAN_VERSION_VALID_UNTIL_BEFORE_FROM",
+  PLAN_TERMINATE_INVALID_DATE: "PLAN_TERMINATE_INVALID_DATE",
+  PLAN_TERMINATE_DATE_NOT_FUTURE: "PLAN_TERMINATE_DATE_NOT_FUTURE",
+  PLAN_TERMINATE_NOT_IMPLEMENTED: "PLAN_TERMINATE_NOT_IMPLEMENTED",
+  // ── bundle versions ──
+  BUNDLE_VERSION_ALREADY_PUBLISHED: "BUNDLE_VERSION_ALREADY_PUBLISHED",
+  BUNDLE_VERSION_NOT_EDITABLE: "BUNDLE_VERSION_NOT_EDITABLE",
+  BUNDLE_VERSION_NOT_PUBLISHED: "BUNDLE_VERSION_NOT_PUBLISHED",
+  BUNDLE_VERSION_SUPERSEDED: "BUNDLE_VERSION_SUPERSEDED",
+  BUNDLE_VERSION_REGRESSION: "BUNDLE_VERSION_REGRESSION",
+  BUNDLE_VERSION_ZERO_PRICE: "BUNDLE_VERSION_ZERO_PRICE",
+  BUNDLE_VERSION_DISCARD_NOT_IMPLEMENTED: "BUNDLE_VERSION_DISCARD_NOT_IMPLEMENTED",
+  BUNDLE_VERSION_VALID_FROM_REQUIRED: "BUNDLE_VERSION_VALID_FROM_REQUIRED",
+  BUNDLE_VERSION_VALID_FROM_INVALID: "BUNDLE_VERSION_VALID_FROM_INVALID",
+  BUNDLE_VERSION_VALID_FROM_NOT_AFTER_PREVIOUS: "BUNDLE_VERSION_VALID_FROM_NOT_AFTER_PREVIOUS",
+  BUNDLE_VERSION_VALID_FROM_NOT_GAPLESS: "BUNDLE_VERSION_VALID_FROM_NOT_GAPLESS",
+  BUNDLE_VERSION_VALID_FROM_NOT_FUTURE: "BUNDLE_VERSION_VALID_FROM_NOT_FUTURE",
+  BUNDLE_VERSION_VALID_UNTIL_INVALID: "BUNDLE_VERSION_VALID_UNTIL_INVALID",
+  BUNDLE_VERSION_VALID_UNTIL_BEFORE_FROM: "BUNDLE_VERSION_VALID_UNTIL_BEFORE_FROM",
+  /** Publish blocked by strict mode. Carries `warnings[]` with own codes. */
+  STRICT_MODE_VIOLATIONS: "STRICT_MODE_VIOLATIONS",
+  // ── resources not found (stage 3) ──
+  PLAN_NOT_FOUND: "PLAN_NOT_FOUND",
+  PLAN_VERSION_NOT_FOUND: "PLAN_VERSION_NOT_FOUND",
+  BUNDLE_NOT_FOUND: "BUNDLE_NOT_FOUND",
+  BUNDLE_VERSION_NOT_FOUND: "BUNDLE_VERSION_NOT_FOUND",
+  FEATURE_NOT_FOUND: "FEATURE_NOT_FOUND",
+  QUOTA_NOT_FOUND: "QUOTA_NOT_FOUND",
+  PROMOTION_NOT_FOUND: "PROMOTION_NOT_FOUND",
+  MARKETING_PROJECTION_NOT_FOUND: "MARKETING_PROJECTION_NOT_FOUND",
+  // ── already exists ──
+  PLAN_ALREADY_EXISTS: "PLAN_ALREADY_EXISTS",
+  BUNDLE_ALREADY_EXISTS: "BUNDLE_ALREADY_EXISTS",
+  MARKETING_PROJECTION_ALREADY_EXISTS: "MARKETING_PROJECTION_ALREADY_EXISTS",
+  /** A draft already exists — publish or discard it before creating another. */
+  PLAN_DRAFT_ALREADY_EXISTS: "PLAN_DRAFT_ALREADY_EXISTS",
+  BUNDLE_DRAFT_ALREADY_EXISTS: "BUNDLE_DRAFT_ALREADY_EXISTS",
+  // ── discovery ──
+  QUOTA_NOT_IN_DISCOVERY_SNAPSHOT: "QUOTA_NOT_IN_DISCOVERY_SNAPSHOT",
+  DISCOVERY_STATUS_TRANSITION_INVALID: "DISCOVERY_STATUS_TRANSITION_INVALID",
+  DISCOVERY_NOT_INITIALIZED: "DISCOVERY_NOT_INITIALIZED"
+};
+var BILLING_ERROR_CODES = {
+  /**
+   * Feature not covered by the plan. Defined in `upsell.types.ts` because the
+   * upsell body type is built around it; re-exported here so an exhaustive
+   * `PlatformErrorCode` switch covers it.
+   */
+  FEATURE_NOT_LICENSED,
+  BUNDLE_ALREADY_SUBSCRIBED: "BUNDLE_ALREADY_SUBSCRIBED",
+  BUNDLE_INCOMPATIBLE_WITH_PLAN: "BUNDLE_INCOMPATIBLE_WITH_PLAN",
+  BUNDLE_NOT_SELF_SERVICE: "BUNDLE_NOT_SELF_SERVICE",
+  SUBSCRIPTION_BUNDLE_ALREADY_CANCELLED: "SUBSCRIPTION_BUNDLE_ALREADY_CANCELLED",
+  SUBSCRIPTION_BUNDLE_NOT_CANCELLED: "SUBSCRIPTION_BUNDLE_NOT_CANCELLED",
+  SUBSCRIPTION_BUNDLE_CANCELLATION_EFFECTIVE: "SUBSCRIPTION_BUNDLE_CANCELLATION_EFFECTIVE",
+  // ── subscriptions and plan changes (stage 3) ──
+  SUBSCRIPTION_NOT_FOUND: "SUBSCRIPTION_NOT_FOUND",
+  SUBSCRIPTION_TENANT_MISMATCH: "SUBSCRIPTION_TENANT_MISMATCH",
+  SUBSCRIPTION_BUNDLE_NOT_FOUND: "SUBSCRIPTION_BUNDLE_NOT_FOUND",
+  TENANT_NOT_FOUND: "TENANT_NOT_FOUND",
+  /** No plan version is active as of the requested date. */
+  NO_ACTIVE_PLAN_VERSION: "NO_ACTIVE_PLAN_VERSION",
+  /** Plan is unknown to the loaded plan catalogue. */
+  PLAN_NOT_IN_CATALOG: "PLAN_NOT_IN_CATALOG",
+  /** Plan exists but cannot be booked via self-service. */
+  PLAN_NOT_SELF_SERVICE: "PLAN_NOT_SELF_SERVICE",
+  /** Plan change refused. Carries `blockers[]` with their own codes. */
+  PLAN_CHANGE_BLOCKED: "PLAN_CHANGE_BLOCKED",
+  NO_PENDING_PLAN_VERSION: "NO_PENDING_PLAN_VERSION",
+  ONBOARDING_CREATE_FAILED: "ONBOARDING_CREATE_FAILED",
+  BUNDLE_PREVIEW_ARGUMENT_AMBIGUOUS: "BUNDLE_PREVIEW_ARGUMENT_AMBIGUOUS",
+  /**
+   * The adapter returned a `SubscriptionUsageRecord` without `id`. A wiring
+   * error in the consumer, not a missing subscription — hence its own code.
+   */
+  SUBSCRIPTION_PK_MISSING: "SUBSCRIPTION_PK_MISSING",
+  // ── entitlements ──
+  /** Quota exhausted. Carries `dimension`, `used`, `max`. */
+  LIMIT_EXCEEDED: "LIMIT_EXCEEDED",
+  QUOTA_DIMENSION_UNKNOWN: "QUOTA_DIMENSION_UNKNOWN"
+};
+var CONTRACT_ERROR_CODES = {
+  CHECKOUT_OFFER_LINE_ITEMS_REQUIRED: "CHECKOUT_OFFER_LINE_ITEMS_REQUIRED",
+  CHECKOUT_OFFER_PLAN_LINE_ITEM_REQUIRED: "CHECKOUT_OFFER_PLAN_LINE_ITEM_REQUIRED",
+  CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED: "CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED",
+  CHECKOUT_OFFER_BUNDLE_VERSION_NOT_BOOKABLE: "CHECKOUT_OFFER_BUNDLE_VERSION_NOT_BOOKABLE",
+  CHECKOUT_OFFER_FEATURE_DEPENDENCY_UNSATISFIED: "CHECKOUT_OFFER_FEATURE_DEPENDENCY_UNSATISFIED",
+  SUBSCRIPTION_CONTRACT_LINE_ITEMS_REQUIRED: "SUBSCRIPTION_CONTRACT_LINE_ITEMS_REQUIRED",
+  SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED: "SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED",
+  SUBSCRIPTION_CONTRACT_INVALID_DATE: "SUBSCRIPTION_CONTRACT_INVALID_DATE",
+  SUBSCRIPTION_CONTRACT_INVALID_WINDOW: "SUBSCRIPTION_CONTRACT_INVALID_WINDOW",
+  SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START: "SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START",
+  // ── stage 3 ──
+  CHECKOUT_OFFER_NOT_FOUND: "CHECKOUT_OFFER_NOT_FOUND",
+  CHECKOUT_OFFER_EXPIRED: "CHECKOUT_OFFER_EXPIRED",
+  CHECKOUT_OFFER_ALREADY_CONSUMED: "CHECKOUT_OFFER_ALREADY_CONSUMED",
+  CHECKOUT_OFFER_NOT_CONSUMED: "CHECKOUT_OFFER_NOT_CONSUMED",
+  SUBSCRIPTION_CONTRACT_NOT_FOUND: "SUBSCRIPTION_CONTRACT_NOT_FOUND",
+  NO_ACTIVE_SUBSCRIPTION_CONTRACT: "NO_ACTIVE_SUBSCRIPTION_CONTRACT",
+  SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SUBSCRIPTION_CONTRACT_ALREADY_CLOSED"
+};
+var REGISTRATION_ERROR_CODES = {
+  PENDING_REGISTRATION_NOT_FOUND: "PENDING_REGISTRATION_NOT_FOUND",
+  PENDING_REGISTRATION_EXPIRED: "PENDING_REGISTRATION_EXPIRED",
+  INVALID_REGISTRATION_STATE: "INVALID_REGISTRATION_STATE",
+  OTP_INVALID: "OTP_INVALID",
+  OTP_EXPIRED: "OTP_EXPIRED",
+  OTP_LOCKED: "OTP_LOCKED",
+  /** Too many attempts from this origin. Carries `retryAfterSeconds`. */
+  RATE_LIMITED: "RATE_LIMITED",
+  RESUME_TOKEN_INVALID: "RESUME_TOKEN_INVALID",
+  RESUME_NOT_CONFIGURED: "RESUME_NOT_CONFIGURED",
+  CONFIGURATOR_NOT_CONFIGURED: "CONFIGURATOR_NOT_CONFIGURED",
+  CONFIG_NOT_SAVED: "CONFIG_NOT_SAVED",
+  PLAN_NOT_AVAILABLE: "PLAN_NOT_AVAILABLE",
+  PLAN_NOT_SELECTED: "PLAN_NOT_SELECTED",
+  MODEL_NOT_AVAILABLE: "MODEL_NOT_AVAILABLE"
+};
+var AUTH_ERROR_CODES = {
+  /** No authenticated user on the request. */
+  NOT_AUTHENTICATED: "NOT_AUTHENTICATED",
+  /** Authenticated, but the request carries no tenant. */
+  NO_TENANT_ASSIGNED: "NO_TENANT_ASSIGNED",
+  /** Neither `tenantId` nor `userId` could be resolved from the request. */
+  TENANT_CONTEXT_MISSING: "TENANT_CONTEXT_MISSING",
+  TENANT_ADMIN_REQUIRED: "TENANT_ADMIN_REQUIRED",
+  SUPER_ADMIN_REQUIRED: "SUPER_ADMIN_REQUIRED",
+  /** TOTP MFA has never been set up for this user. */
+  MFA_NOT_SET_UP: "MFA_NOT_SET_UP",
+  /** Endpoint is MFA-gated and no `X-Mfa-Code` header was sent. */
+  MFA_REQUIRED: "MFA_REQUIRED",
+  /** The supplied TOTP code did not verify. */
+  MFA_FAILED: "MFA_FAILED",
+  /** Module misconfiguration, not an end-user condition. */
+  AUTH_GUARDS_NOT_CONFIGURED: "AUTH_GUARDS_NOT_CONFIGURED"
+};
+var PROMO_ERROR_CODES = {
+  PROMO_CODE_NOT_FOUND: "PROMO_CODE_NOT_FOUND",
+  PROMO_CODE_ALREADY_EXISTS: "PROMO_CODE_ALREADY_EXISTS",
+  PROMO_CODE_HAS_REDEMPTIONS: "PROMO_CODE_HAS_REDEMPTIONS",
+  /** Not redeemable. Carries `reason` (`PromoPreviewInvalidReason`). */
+  PROMO_CODE_NOT_REDEEMABLE: "PROMO_CODE_NOT_REDEEMABLE",
+  PROMO_CODE_FORMAT_INVALID: "PROMO_CODE_FORMAT_INVALID",
+  PROMO_PERCENT_OUT_OF_RANGE: "PROMO_PERCENT_OUT_OF_RANGE",
+  PROMO_AMOUNT_NOT_POSITIVE: "PROMO_AMOUNT_NOT_POSITIVE",
+  PROMO_ONE_OFF_WITH_DURATION: "PROMO_ONE_OFF_WITH_DURATION",
+  PROMO_DURATION_INVALID: "PROMO_DURATION_INVALID",
+  PROMO_VALIDITY_WINDOW_INVALID: "PROMO_VALIDITY_WINDOW_INVALID",
+  PROMO_PLAN_NOT_DISCOUNTABLE: "PROMO_PLAN_NOT_DISCOUNTABLE",
+  PROMO_MIN_AMOUNT_NOT_POSITIVE: "PROMO_MIN_AMOUNT_NOT_POSITIVE",
+  PROMO_WOULD_PRODUCE_ZERO_INVOICE: "PROMO_WOULD_PRODUCE_ZERO_INVOICE",
+  PROMO_MAX_REDEMPTIONS_LOWERED: "PROMO_MAX_REDEMPTIONS_LOWERED"
+};
+var PLATFORM_ERROR_CODES = {
+  ...SETUP_ERROR_CODES,
+  ...AUTH_ERROR_CODES,
+  ...PROMO_ERROR_CODES,
+  ...CATALOG_ERROR_CODES,
+  ...BILLING_ERROR_CODES,
+  ...CONTRACT_ERROR_CODES,
+  ...REGISTRATION_ERROR_CODES
+};
+
+// src/errors.ts
+var USER_ALREADY_EXISTS = "USER_ALREADY_EXISTS";
+var PlatformUserExistsError = class extends Error {
+  constructor(email, existingRole) {
+    super(`User ${email} already exists (role: ${existingRole}).`);
+    this.email = email;
+    this.existingRole = existingRole;
+    this.name = "PlatformUserExistsError";
+  }
+  email;
+  existingRole;
+  code = USER_ALREADY_EXISTS;
+};
+function isPlatformUserExistsError(err) {
+  return err instanceof Error && err.code === USER_ALREADY_EXISTS;
+}
+
+// src/feature-requires.ts
+function buildFeatureRequiresIndex(features) {
+  const index = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    const requires = (feature.requires ?? []).filter((key) => key !== feature.featureKey);
+    if (requires.length > 0) index.set(feature.featureKey, requires);
+  }
+  return index;
+}
+function collectUnsatisfiedRequires(selected, index) {
+  const own = new Set(selected);
+  const unsatisfied = /* @__PURE__ */ new Set();
+  for (const featureKey of selected) {
+    for (const required of index.get(featureKey) ?? []) {
+      if (!own.has(required)) unsatisfied.add(required);
+    }
+  }
+  return [...unsatisfied].sort((a, b) => a.localeCompare(b));
+}
+function missingRequiresFor(bundle, coveredFeatures) {
+  const missing = (bundle.requiresFeatures ?? []).filter((key) => !coveredFeatures.has(key));
+  return [...new Set(missing)].sort((a, b) => a.localeCompare(b));
+}
+function resolveBundleAvailability(bundle, coveredFeatures) {
+  if (bundle.features.length > 0 && bundle.features.every((f) => coveredFeatures.has(f))) {
+    return "covered";
+  }
+  if (missingRequiresFor(bundle, coveredFeatures).length > 0) return "missing-requires";
+  return "bookable";
+}
+function coverageExcludingSelf(selfVersionId, planFeatures, selectedBundles) {
+  const covered = new Set(planFeatures);
+  for (const bundle of selectedBundles) {
+    if (bundle.bundleVersionId === selfVersionId) continue;
+    for (const feature of bundle.features) covered.add(feature);
+  }
+  return covered;
+}
+function isBundleRedundant(bundle, planFeatures, selectedBundles) {
+  const covered = coverageExcludingSelf(bundle.bundleVersionId, planFeatures, selectedBundles);
+  return resolveBundleAvailability(bundle, covered) === "covered";
+}
+function compareSelectable(a, b) {
+  const orderA = a.sortOrder ?? Number.MAX_SAFE_INTEGER;
+  const orderB = b.sortOrder ?? Number.MAX_SAFE_INTEGER;
+  if (orderA !== orderB) return orderA - orderB;
+  return a.bundleVersionId.localeCompare(b.bundleVersionId);
+}
+function selectChargeableBundles(planFeatures, selectedBundles) {
+  const kept = [...selectedBundles].sort(compareSelectable);
+  for (; ; ) {
+    const redundantIndex = kept.findIndex(
+      (bundle) => isBundleRedundant(bundle, planFeatures, kept)
+    );
+    if (redundantIndex === -1) return kept;
+    kept.splice(redundantIndex, 1);
+  }
+}
+
+// src/registration.types.ts
+var PENDING_EMAIL_TTL_HOURS = 72;
+var PENDING_ONBOARDING_TTL_DAYS = 14;
+var PENDING_CHECKOUT_TTL_DAYS = 30;
+var OTP_TTL_MINUTES = 10;
+var PASSWORD_RESET_TTL_MINUTES = 30;
+var OTP_RATE_LIMIT_MAX_SENDS = 3;
+var OTP_RATE_LIMIT_WINDOW_MINUTES = 15;
+var OTP_VERIFY_MAX_ATTEMPTS = 5;
+var REGISTRATION_STEP_BY_STATUS = {
+  PENDING_EMAIL_VERIFICATION: 2,
+  EMAIL_VERIFIED: 3,
+  PLAN_SELECTED: 4,
+  CHECKOUT_STARTED: 4,
+  EXPIRED: 1,
+  DELETED: 1
+};
+var REGISTRATION_RESUME_TTL_MINUTES = 60;
+
+// src/version-editability.ts
+function isVersionEditable(v, now = /* @__PURE__ */ new Date()) {
+  if (v.publishedAt === null) {
+    return { editable: true, reason: "draft" };
+  }
+  if (v.supersededAt !== null) {
+    return { editable: false, reason: null };
+  }
+  if (v.isLatestInChain !== true) {
+    return { editable: false, reason: null };
+  }
+  if ((v.subscriptionCount ?? 1) > 0) {
+    return { editable: false, reason: null };
+  }
+  if (v.validFrom === null) {
+    return { editable: false, reason: null };
+  }
+  const from = new Date(v.validFrom);
+  if (Number.isNaN(from.getTime())) {
+    return { editable: false, reason: null };
+  }
+  if (from.getTime() <= now.getTime()) {
+    return { editable: false, reason: null };
+  }
+  return { editable: true, reason: "pre-active" };
+}
+
+// src/error-messages.ts
+var ERROR_MESSAGES_EN = {
+  // ── setup ──
+  SETUP_DISABLED: "{envVar} is not set \u2014 setup is disabled.",
+  INVALID_SETUP_TOKEN: "The setup token is not valid.",
+  SETUP_ALREADY_DONE: "Setup has already been completed.",
+  INVALID_EMAIL: "That is not a valid email address.",
+  EMAIL_EXISTS: "An account with this email address already exists.",
+  // ── auth ──
+  NOT_AUTHENTICATED: "Not authenticated",
+  NO_TENANT_ASSIGNED: "No tenant assigned",
+  TENANT_CONTEXT_MISSING: "No tenant ID found on the request",
+  TENANT_ADMIN_REQUIRED: "This action requires the TENANT_ADMIN role.",
+  SUPER_ADMIN_REQUIRED: "Only the SUPER_ADMIN role is allowed",
+  MFA_NOT_SET_UP: "Run the MFA setup via the CLI first.",
+  MFA_REQUIRED: "TOTP code required in the X-Mfa-Code header.",
+  MFA_FAILED: "Invalid TOTP code.",
+  AUTH_GUARDS_NOT_CONFIGURED: "TenantBillingModule.forRoot.authGuards is not configured.",
+  // ── catalog ──
+  PLAN_HAS_DRAFTS: "Plan '{planKey}' still has {draftCount} open draft version(s). Discard them first (DELETE /admin/catalog/plan-versions/:id) or publish them.",
+  PLAN_HAS_PUBLISHED_VERSIONS: "Plan '{planKey}' cannot be {operation} \u2014 it has {publishedCount} published version(s) ({liveCount} live, {supersededCount} superseded). Existing subscriptions reference those versions (contract protection P1), so the plan record must be preserved.",
+  PLAN_HARD_DELETE_NOT_IMPLEMENTED: "Hard delete is not implemented in the current repository. Implement PlanRepository.hardDelete.",
+  PLAN_VERSION_ALREADY_PUBLISHED: "PlanVersion '{versionId}' is already published and cannot be discarded.",
+  PLAN_VERSION_NOT_EDITABLE: "PlanVersion '{versionId}' is not editable. Only drafts and published versions are editable that are latest-in-chain, bind no subscription yet, and whose validFrom lies in the future.",
+  PLAN_VERSION_REGRESSION: "This plan version is regressive (feature removed / quota lowered / price raised). Publishing requires an explicit `forceRegressive: true` (UI confirmation dialog with MFA).",
+  PLAN_VERSION_ZERO_PRICE: "A plan version cannot be published with a price of 0.00 (guard against seed placeholder). For deliberately free special contracts, set allowZeroPrice.",
+  PLAN_VERSION_DISCARD_NOT_IMPLEMENTED: "Discard is not implemented in the current repository. Implement PlanRepository.deletePlanVersionDraft.",
+  PLAN_VERSION_NOT_PUBLISHED: "PlanVersion '{versionId}' is not published and cannot be terminated.",
+  PLAN_VERSION_SUPERSEDED: "PlanVersion '{versionId}' has already been superseded by a newer version and cannot be terminated.",
+  PLAN_VERSION_VALID_FROM_REQUIRED: "validFrom must be set when publishing (on the draft or the publish call)..",
+  PLAN_VERSION_VALID_FROM_INVALID: "validFrom '{validFrom}' is not a valid date",
+  PLAN_VERSION_VALID_FROM_NOT_AFTER_PREVIOUS: "validFrom ({validFrom}) must be strictly after the validFrom of the previous version ({previousValidFrom}).",
+  PLAN_VERSION_VALID_FROM_NOT_GAPLESS: "The predecessor has validUntil={previousValidUntil} \u2014 the successor must start seamlessly on the next day ({requiredValidFrom}). Received: {received}.",
+  PLAN_VERSION_VALID_UNTIL_INVALID: "validUntil '{validUntil}' is not a valid date",
+  PLAN_VERSION_VALID_UNTIL_BEFORE_FROM: "validUntil ({validUntil}) must be strictly after validFrom ({validFrom}).",
+  PLAN_TERMINATE_INVALID_DATE: "endsAt is not a valid date.",
+  PLAN_TERMINATE_DATE_NOT_FUTURE: "endsAt ({endsAt}) must lie strictly in the future.",
+  PLAN_TERMINATE_NOT_IMPLEMENTED: "Terminate is not implemented in the current repository. Implement PlanRepository.terminate.",
+  BUNDLE_VERSION_ALREADY_PUBLISHED: "BundleVersion '{versionId}' is already published and cannot be discarded.",
+  BUNDLE_VERSION_NOT_EDITABLE: "BundleVersion '{versionId}' is not editable. Only drafts and published versions are editable that are latest-in-chain, bind no subscription yet, and whose validFrom lies in the future.",
+  BUNDLE_VERSION_NOT_PUBLISHED: "BundleVersion '{bundleVersionId}' is not published and cannot be booked.",
+  BUNDLE_VERSION_SUPERSEDED: "BundleVersion '{bundleVersionId}' has been superseded by a newer version.",
+  BUNDLE_VERSION_REGRESSION: "This bundle version is regressive (feature removed / quota lowered / price raised). Publishing requires an explicit `forceRegressive: true` (UI confirmation dialog with MFA).",
+  BUNDLE_VERSION_ZERO_PRICE: "A bundle version cannot be published with an explicit price of 0.00 (guard against seed placeholders). For free bundles leave it null, or set allowZeroPrice.",
+  BUNDLE_VERSION_DISCARD_NOT_IMPLEMENTED: "Discard is not implemented in the current repository. Implement BundleRepository.deleteDraft.",
+  BUNDLE_VERSION_VALID_FROM_REQUIRED: "Published bundle versions must keep a validFrom. Set a new future date, or edit the draft before publishing.",
+  BUNDLE_VERSION_VALID_FROM_INVALID: "validFrom '{validFrom}' is not a valid date",
+  BUNDLE_VERSION_VALID_FROM_NOT_AFTER_PREVIOUS: "validFrom ({validFrom}) must be strictly after the validFrom of the previous version ({previousValidFrom}).",
+  BUNDLE_VERSION_VALID_FROM_NOT_GAPLESS: "The predecessor has validUntil={previousValidUntil} \u2014 the successor must start seamlessly on the next day ({requiredValidFrom}). Received: {received}.",
+  BUNDLE_VERSION_VALID_FROM_NOT_FUTURE: "validFrom ({validFrom}) must, for a published-but-future bundle version, still lie in the future.",
+  BUNDLE_VERSION_VALID_UNTIL_INVALID: "validUntil '{validUntil}' is not a valid date",
+  BUNDLE_VERSION_VALID_UNTIL_BEFORE_FROM: "validUntil ({validUntil}) must be strictly after validFrom ({validFrom}).",
+  STRICT_MODE_VIOLATIONS: "The strict-mode check found drift against the discovery snapshot.",
+  PLAN_NOT_FOUND: "Plan '{planId}' not found",
+  PLAN_VERSION_NOT_FOUND: "PlanVersion '{versionId}' not found",
+  BUNDLE_NOT_FOUND: "Bundle '{bundleId}' not found",
+  BUNDLE_VERSION_NOT_FOUND: "BundleVersion '{bundleVersionId}' not found",
+  FEATURE_NOT_FOUND: "Feature '{featureKey}' not found in project '{projectKey}'",
+  QUOTA_NOT_FOUND: "Quota '{quotaKey}' not found in project '{projectKey}'",
+  PROMOTION_NOT_FOUND: "Promotion '{promotionId}' not found",
+  MARKETING_PROJECTION_NOT_FOUND: "MarketingProjection '{projectionId}' not found",
+  PLAN_ALREADY_EXISTS: "Plan '{planKey}' already exists in project '{projectKey}'",
+  BUNDLE_ALREADY_EXISTS: "Bundle '{bundleKey}' already exists in project '{projectKey}'",
+  MARKETING_PROJECTION_ALREADY_EXISTS: "Marketing projection for {targetType}/{targetVersionId}/{locale} already exists \u2014 use PATCH to edit it",
+  PLAN_DRAFT_ALREADY_EXISTS: "Plan '{planKey}' already has a draft version v{draftVersion}; publish or discard it first",
+  BUNDLE_DRAFT_ALREADY_EXISTS: "Bundle '{bundleKey}' already has a draft version v{draftVersion}; publish or discard it first",
+  QUOTA_NOT_IN_DISCOVERY_SNAPSHOT: "Quota '{quotaKey}' is not in the discovery snapshot \u2014 a quota that is not declared in code cannot be approved",
+  DISCOVERY_STATUS_TRANSITION_INVALID: "Transition '{from}' \u2192 '{to}' is not allowed",
+  DISCOVERY_NOT_INITIALIZED: "Approval requires a discovery snapshot \u2014 discovery is not initialised (#25)",
+  // ── billing ──
+  BUNDLE_ALREADY_SUBSCRIBED: "Subscription '{subscriptionId}' has already actively booked this bundle.",
+  BUNDLE_INCOMPATIBLE_WITH_PLAN: "BundleVersion '{bundleVersionId}' is not compatible with plan '{planKey}'. Allowed: [{allowedPlanKeys}].",
+  BUNDLE_NOT_SELF_SERVICE: "Bundle '{bundleKey}' is only activated via a special contract. Please contact the contract manager.",
+  SUBSCRIPTION_BUNDLE_ALREADY_CANCELLED: "SubscriptionBundle '{subscriptionBundleId}' is already cancelled.",
+  SUBSCRIPTION_BUNDLE_NOT_CANCELLED: "SubscriptionBundle '{subscriptionBundleId}' is not cancelled.",
+  SUBSCRIPTION_BUNDLE_CANCELLATION_EFFECTIVE: "Cancellation already in effect \u2014 book the bundle again.",
+  SUBSCRIPTION_NOT_FOUND: "No subscription for tenant {tenantId}",
+  SUBSCRIPTION_TENANT_MISMATCH: "Subscription does not belong to the tenant",
+  SUBSCRIPTION_BUNDLE_NOT_FOUND: "SubscriptionBundle '{subscriptionBundleId}' not found",
+  TENANT_NOT_FOUND: "Tenant {slug} not found",
+  NO_ACTIVE_PLAN_VERSION: "No plan version for {planId} active as of {asOf} \u2014 neither the validFrom window is satisfied nor is a latest-live version available.",
+  PLAN_NOT_IN_CATALOG: 'Plan "{planKey}" is not in the catalog ({projectKey})',
+  PLAN_NOT_SELF_SERVICE: "{planKey} is not activated via self-service.",
+  PLAN_CHANGE_BLOCKED: "Plan change during onboarding is blocked.",
+  NO_PENDING_PLAN_VERSION: "There is no pending plan version awaiting confirmation.",
+  ONBOARDING_CREATE_FAILED: "The account could not be created. Please try again.",
+  BUNDLE_PREVIEW_ARGUMENT_AMBIGUOUS: "Exactly one of bundleVersionId (add preview) or subscriptionBundleId (cancel preview) must be given.",
+  SUBSCRIPTION_PK_MISSING: "The adapter returned a subscription usage record without an id. Pass the subscription primary key through (see SubscriptionUsageRecord.id).",
+  LIMIT_EXCEEDED: "The limit for {dimension} has been reached: {used} of {max}.",
+  QUOTA_DIMENSION_UNKNOWN: 'Unknown quota dimension "{dimension}".',
+  // ── promo ──
+  PROMO_CODE_NOT_FOUND: "Code not found",
+  PROMO_CODE_ALREADY_EXISTS: "The code already exists.",
+  PROMO_CODE_HAS_REDEMPTIONS: "The code already has redemptions \u2014 it cannot be soft-deleted. Pause it instead.",
+  PROMO_CODE_NOT_REDEEMABLE: "Code cannot be redeemed: {reason}",
+  PROMO_CODE_FORMAT_INVALID: 'The code may only contain upper-case letters, digits, "-" and "_" (4\u201332 characters).',
+  PROMO_PERCENT_OUT_OF_RANGE: "The percentage must be between 0 and 100.",
+  PROMO_AMOUNT_NOT_POSITIVE: "The amount must be positive.",
+  PROMO_ONE_OFF_WITH_DURATION: "A one-off discount must not set a duration.",
+  PROMO_DURATION_INVALID: "Invalid duration (at most 24 months or billing periods).",
+  PROMO_VALIDITY_WINDOW_INVALID: "Invalid validity window.",
+  PROMO_PLAN_NOT_DISCOUNTABLE: "{plan}-Plan cannot be discounted.",
+  PROMO_MIN_AMOUNT_NOT_POSITIVE: "The minimum plan gross amount must be positive.",
+  PROMO_WOULD_PRODUCE_ZERO_INVOICE: "For absolute amounts the discount must stay below the lowest applicable plan price, or allowZeroInvoice must be enabled.",
+  PROMO_MAX_REDEMPTIONS_LOWERED: "maxRedemptions cannot be lowered.",
+  // ── contract ──
+  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.",
+  CHECKOUT_OFFER_BUNDLE_VERSION_NOT_BOOKABLE: "At least one bundle version from the checkout offer is no longer bookable.",
+  CHECKOUT_OFFER_FEATURE_DEPENDENCY_UNSATISFIED: "The selected plan does not cover all feature dependencies: [{missingRequires}] are missing from the plan + selected bundles.",
+  SUBSCRIPTION_CONTRACT_LINE_ITEMS_REQUIRED: "A subscription contract requires at least one line item.",
+  SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED: "A subscription contract requires exactly one plan base item.",
+  SUBSCRIPTION_CONTRACT_INVALID_DATE: "{field} must be a valid date.",
+  SUBSCRIPTION_CONTRACT_INVALID_WINDOW: "effectiveUntil must be after effectiveFrom.",
+  SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START: "effectiveUntil must be after the effectiveFrom of the contract.",
+  CHECKOUT_OFFER_NOT_FOUND: "CheckoutOffer '{offerId}' not found",
+  CHECKOUT_OFFER_EXPIRED: "Checkout offer '{offerId}' has expired and cannot be {action}",
+  CHECKOUT_OFFER_ALREADY_CONSUMED: "Checkout offer '{offerId}' has already been consumed and cannot be {action}",
+  CHECKOUT_OFFER_NOT_CONSUMED: "CheckoutOffer '{offerId}' must be consumed before the contract is created",
+  SUBSCRIPTION_CONTRACT_NOT_FOUND: "SubscriptionContract '{contractId}' not found",
+  NO_ACTIVE_SUBSCRIPTION_CONTRACT: "No active subscription contract for tenant {tenantId}",
+  SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SubscriptionContract '{contractId}' is already closed",
+  // ── registration ──
+  PENDING_REGISTRATION_NOT_FOUND: "This registration could not be found. It may have already been completed or discarded.",
+  PENDING_REGISTRATION_EXPIRED: "This registration has expired. Please start again.",
+  INVALID_REGISTRATION_STATE: "This step is not available at the current stage of the registration.",
+  OTP_INVALID: "That code is not correct. Please check it and try again.",
+  OTP_EXPIRED: "That code has expired. Please request a new one.",
+  OTP_LOCKED: "Too many incorrect attempts. Please request a new code.",
+  RATE_LIMITED: "Too many attempts. Please try again in {retryAfterSeconds} seconds.",
+  RESUME_TOKEN_INVALID: "This resume link is no longer valid. Please request a new one.",
+  RESUME_NOT_CONFIGURED: "Resuming a registration is not available.",
+  CONFIGURATOR_NOT_CONFIGURED: "The configurator is not available.",
+  CONFIG_NOT_SAVED: "The configuration could not be saved.",
+  PLAN_NOT_AVAILABLE: "This plan is not available.",
+  PLAN_NOT_SELECTED: "Please select a plan first.",
+  MODEL_NOT_AVAILABLE: "This option is not available.",
+  // ── entitlement (code lives in upsell.types.ts) ──
+  [FEATURE_NOT_LICENSED]: "Feature {featureKeys} is not included in the current plan."
+};
+function formatErrorMessage(template, params = {}) {
+  return template.replace(/\{(\w+)\}/g, (match, name) => {
+    const value = params[name];
+    return value === void 0 || value === null ? match : String(value);
+  });
+}
+function resolveErrorMessage(body, overrides = {}, defaults = ERROR_MESSAGES_EN) {
+  const code = typeof body.code === "string" ? body.code : void 0;
+  const template = (code && (overrides[code] ?? defaults[code])) ?? void 0;
+  if (!template) {
+    return typeof body.message === "string" ? body.message : code ?? "";
+  }
+  const { params, ...rest } = body;
+  return formatErrorMessage(template, { ...rest, ...params });
+}
+
+// src/error-messages-de.ts
+var ERROR_MESSAGES_DE = {
+  // ── setup ──
+  SETUP_DISABLED: "{envVar} ist nicht gesetzt \u2014 das Setup ist deaktiviert.",
+  INVALID_SETUP_TOKEN: "Das Setup-Token ist ung\xFCltig.",
+  SETUP_ALREADY_DONE: "Das Setup wurde bereits abgeschlossen.",
+  INVALID_EMAIL: "Das ist keine g\xFCltige E-Mail-Adresse.",
+  EMAIL_EXISTS: "Mit dieser E-Mail-Adresse gibt es bereits ein Konto.",
+  // ── auth ──
+  NOT_AUTHENTICATED: "Nicht authentifiziert",
+  NO_TENANT_ASSIGNED: "Kein Mandant zugeordnet",
+  TENANT_CONTEXT_MISSING: "Am Request wurde keine Mandanten-ID gefunden",
+  TENANT_ADMIN_REQUIRED: "Diese Aktion erfordert die Rolle TENANT_ADMIN.",
+  SUPER_ADMIN_REQUIRED: "Nur die Rolle SUPER_ADMIN ist zugelassen",
+  MFA_NOT_SET_UP: "Richte MFA zuerst \xFCber die CLI ein.",
+  MFA_REQUIRED: "TOTP-Code im Header X-Mfa-Code erforderlich.",
+  MFA_FAILED: "Ung\xFCltiger TOTP-Code.",
+  AUTH_GUARDS_NOT_CONFIGURED: "TenantBillingModule.forRoot.authGuards ist nicht konfiguriert.",
+  // ── catalog ──
+  PLAN_HAS_DRAFTS: "Plan '{planKey}' hat noch {draftCount} offene Entwurfsversion(en). Verwirf sie zuerst (DELETE /admin/catalog/plan-versions/:id) oder ver\xF6ffentliche sie.",
+  PLAN_HAS_PUBLISHED_VERSIONS: "Plan '{planKey}' kann nicht {operation} werden \u2014 er hat {publishedCount} ver\xF6ffentlichte Version(en) ({liveCount} live, {supersededCount} abgel\xF6st). Bestehende Abonnements verweisen auf diese Versionen (Vertragsschutz P1), deshalb muss der Plan-Datensatz erhalten bleiben.",
+  PLAN_HARD_DELETE_NOT_IMPLEMENTED: "Hard Delete ist im aktuellen Repository nicht implementiert. Implementiere PlanRepository.hardDelete.",
+  PLAN_VERSION_ALREADY_PUBLISHED: "PlanVersion '{versionId}' ist bereits ver\xF6ffentlicht und kann nicht verworfen werden.",
+  PLAN_VERSION_NOT_EDITABLE: "PlanVersion '{versionId}' ist nicht bearbeitbar. Bearbeitbar sind nur Entw\xFCrfe sowie ver\xF6ffentlichte Versionen, die letzte in der Kette sind, noch kein Abonnement binden und deren validFrom in der Zukunft liegt.",
+  PLAN_VERSION_REGRESSION: "Diese Planversion ist regressiv (Feature entfernt / Quota gesenkt / Preis erh\xF6ht). Das Ver\xF6ffentlichen erfordert ein ausdr\xFCckliches `forceRegressive: true` (Best\xE4tigungsdialog in der UI mit MFA).",
+  PLAN_VERSION_ZERO_PRICE: "Eine Planversion l\xE4sst sich nicht mit einem Preis von 0,00 ver\xF6ffentlichen (Schutz vor Seed-Platzhaltern). F\xFCr bewusst kostenlose Sondervertr\xE4ge setze allowZeroPrice.",
+  PLAN_VERSION_DISCARD_NOT_IMPLEMENTED: "Das Verwerfen ist im aktuellen Repository nicht implementiert. Implementiere PlanRepository.deletePlanVersionDraft.",
+  PLAN_VERSION_NOT_PUBLISHED: "Die PlanVersion '{versionId}' ist nicht ver\xF6ffentlicht und kann nicht beendet werden.",
+  PLAN_VERSION_SUPERSEDED: "Die PlanVersion '{versionId}' wurde bereits von einer Nachfolgeversion abgel\xF6st und kann nicht beendet werden.",
+  PLAN_VERSION_VALID_FROM_REQUIRED: "validFrom muss beim Ver\xF6ffentlichen gesetzt sein (am Entwurf oder im Publish-Aufruf)..",
+  PLAN_VERSION_VALID_FROM_INVALID: "validFrom '{validFrom}' ist kein g\xFCltiges Datum",
+  PLAN_VERSION_VALID_FROM_NOT_AFTER_PREVIOUS: "validFrom ({validFrom}) muss strikt nach dem validFrom der Vorg\xE4ngerversion ({previousValidFrom}) liegen.",
+  PLAN_VERSION_VALID_FROM_NOT_GAPLESS: "Der Vorg\xE4nger hat validUntil={previousValidUntil} \u2014 der Nachfolger muss l\xFCckenlos am Folgetag ({requiredValidFrom}) beginnen. Erhalten: {received}.",
+  PLAN_VERSION_VALID_UNTIL_INVALID: "validUntil '{validUntil}' ist kein g\xFCltiges Datum",
+  PLAN_VERSION_VALID_UNTIL_BEFORE_FROM: "validUntil ({validUntil}) muss strikt nach validFrom ({validFrom}) liegen.",
+  PLAN_TERMINATE_INVALID_DATE: "endsAt ist kein g\xFCltiges Datum.",
+  PLAN_TERMINATE_DATE_NOT_FUTURE: "endsAt ({endsAt}) muss strikt in der Zukunft liegen.",
+  PLAN_TERMINATE_NOT_IMPLEMENTED: "Das Beenden ist im aktuellen Repository nicht implementiert. Implementiere PlanRepository.terminate.",
+  BUNDLE_VERSION_ALREADY_PUBLISHED: "BundleVersion '{versionId}' ist bereits ver\xF6ffentlicht und kann nicht verworfen werden.",
+  BUNDLE_VERSION_NOT_EDITABLE: "BundleVersion '{versionId}' ist nicht bearbeitbar. Bearbeitbar sind nur Entw\xFCrfe sowie ver\xF6ffentlichte Versionen, die letzte in der Kette sind, noch kein Abonnement binden und deren validFrom in der Zukunft liegt.",
+  BUNDLE_VERSION_NOT_PUBLISHED: "BundleVersion '{bundleVersionId}' ist nicht ver\xF6ffentlicht und l\xE4sst sich nicht buchen.",
+  BUNDLE_VERSION_SUPERSEDED: "BundleVersion '{bundleVersionId}' wurde durch eine neuere Version abgel\xF6st.",
+  BUNDLE_VERSION_REGRESSION: "Diese Bundle-Version ist regressiv (Feature entfernt / Quota gesenkt / Preis erh\xF6ht). Das Ver\xF6ffentlichen erfordert ein ausdr\xFCckliches `forceRegressive: true` (Best\xE4tigungsdialog in der UI mit MFA).",
+  BUNDLE_VERSION_ZERO_PRICE: "Eine Bundle-Version l\xE4sst sich nicht mit einem ausdr\xFCcklichen Preis von 0,00 ver\xF6ffentlichen (Schutz vor Seed-Platzhaltern). Kostenlose Bundles l\xE4sst du auf null, oder du setzt allowZeroPrice.",
+  BUNDLE_VERSION_DISCARD_NOT_IMPLEMENTED: "Das Verwerfen ist im aktuellen Repository nicht implementiert. Implementiere BundleRepository.deleteDraft.",
+  BUNDLE_VERSION_VALID_FROM_REQUIRED: "Ver\xF6ffentlichte Bundle-Versionen m\xFCssen ein validFrom behalten. Setze ein neues Datum in der Zukunft, oder bearbeite den Entwurf vor dem Ver\xF6ffentlichen.",
+  BUNDLE_VERSION_VALID_FROM_INVALID: "validFrom '{validFrom}' ist kein g\xFCltiges Datum",
+  BUNDLE_VERSION_VALID_FROM_NOT_AFTER_PREVIOUS: "validFrom ({validFrom}) muss strikt nach dem validFrom der Vorg\xE4ngerversion ({previousValidFrom}) liegen.",
+  BUNDLE_VERSION_VALID_FROM_NOT_GAPLESS: "Der Vorg\xE4nger hat validUntil={previousValidUntil} \u2014 der Nachfolger muss l\xFCckenlos am Folgetag ({requiredValidFrom}) beginnen. Erhalten: {received}.",
+  BUNDLE_VERSION_VALID_FROM_NOT_FUTURE: "validFrom ({validFrom}) muss bei einer ver\xF6ffentlichten, aber zuk\xFCnftigen Bundle-Version weiterhin in der Zukunft liegen.",
+  BUNDLE_VERSION_VALID_UNTIL_INVALID: "validUntil '{validUntil}' ist kein g\xFCltiges Datum",
+  BUNDLE_VERSION_VALID_UNTIL_BEFORE_FROM: "validUntil ({validUntil}) muss strikt nach validFrom ({validFrom}) liegen.",
+  STRICT_MODE_VIOLATIONS: "Die Strict-Mode-Pr\xFCfung hat eine Abweichung gegen\xFCber dem Discovery-Snapshot gefunden.",
+  PLAN_NOT_FOUND: "Plan '{planId}' nicht gefunden",
+  PLAN_VERSION_NOT_FOUND: "PlanVersion '{versionId}' nicht gefunden",
+  BUNDLE_NOT_FOUND: "Bundle '{bundleId}' nicht gefunden",
+  BUNDLE_VERSION_NOT_FOUND: "BundleVersion '{bundleVersionId}' nicht gefunden",
+  FEATURE_NOT_FOUND: "Feature '{featureKey}' im Projekt '{projectKey}' nicht gefunden",
+  QUOTA_NOT_FOUND: "Quota '{quotaKey}' im Projekt '{projectKey}' nicht gefunden",
+  PROMOTION_NOT_FOUND: "Promotion '{promotionId}' nicht gefunden",
+  MARKETING_PROJECTION_NOT_FOUND: "MarketingProjection '{projectionId}' nicht gefunden",
+  PLAN_ALREADY_EXISTS: "Plan '{planKey}' gibt es im Projekt '{projectKey}' bereits",
+  BUNDLE_ALREADY_EXISTS: "Bundle '{bundleKey}' gibt es im Projekt '{projectKey}' bereits",
+  MARKETING_PROJECTION_ALREADY_EXISTS: "F\xFCr {targetType}/{targetVersionId}/{locale} gibt es bereits eine Marketing-Projektion \u2014 bearbeite sie per PATCH",
+  PLAN_DRAFT_ALREADY_EXISTS: "Plan '{planKey}' hat bereits die Entwurfsversion v{draftVersion}; ver\xF6ffentliche oder verwirf sie zuerst",
+  BUNDLE_DRAFT_ALREADY_EXISTS: "Bundle '{bundleKey}' hat bereits die Entwurfsversion v{draftVersion}; ver\xF6ffentliche oder verwirf sie zuerst",
+  QUOTA_NOT_IN_DISCOVERY_SNAPSHOT: "Quota '{quotaKey}' steht nicht im Discovery-Snapshot \u2014 eine Quota, die im Code nicht deklariert ist, l\xE4sst sich nicht freigeben",
+  DISCOVERY_STATUS_TRANSITION_INVALID: "Der \xDCbergang '{from}' \u2192 '{to}' ist nicht erlaubt",
+  DISCOVERY_NOT_INITIALIZED: "Die Freigabe braucht einen Discovery-Snapshot \u2014 Discovery ist nicht initialisiert (#25)",
+  // ── billing ──
+  BUNDLE_ALREADY_SUBSCRIBED: "Abonnement '{subscriptionId}' hat dieses Bundle bereits aktiv gebucht.",
+  BUNDLE_INCOMPATIBLE_WITH_PLAN: "BundleVersion '{bundleVersionId}' passt nicht zum Plan '{planKey}'. Erlaubt: [{allowedPlanKeys}].",
+  BUNDLE_NOT_SELF_SERVICE: "Bundle '{bundleKey}' wird nur \xFCber einen Sondervertrag freigeschaltet. Bitte wende dich an die Vertragsverwaltung.",
+  SUBSCRIPTION_BUNDLE_ALREADY_CANCELLED: "SubscriptionBundle '{subscriptionBundleId}' ist bereits gek\xFCndigt.",
+  SUBSCRIPTION_BUNDLE_NOT_CANCELLED: "SubscriptionBundle '{subscriptionBundleId}' ist nicht gek\xFCndigt.",
+  SUBSCRIPTION_BUNDLE_CANCELLATION_EFFECTIVE: "Die K\xFCndigung ist bereits wirksam \u2014 buche das Bundle einfach neu.",
+  SUBSCRIPTION_NOT_FOUND: "Kein Abonnement f\xFCr Mandant {tenantId}",
+  SUBSCRIPTION_TENANT_MISMATCH: "Das Abonnement geh\xF6rt nicht zu diesem Mandanten",
+  SUBSCRIPTION_BUNDLE_NOT_FOUND: "SubscriptionBundle '{subscriptionBundleId}' nicht gefunden",
+  TENANT_NOT_FOUND: "Mandant {slug} nicht gefunden",
+  NO_ACTIVE_PLAN_VERSION: "Zum {asOf} ist keine Planversion f\xFCr {planId} aktiv \u2014 weder ist das validFrom-Fenster erf\xFCllt, noch steht eine j\xFCngste Live-Version bereit.",
+  PLAN_NOT_IN_CATALOG: 'Plan "{planKey}" steht nicht im Katalog ({projectKey})',
+  PLAN_NOT_SELF_SERVICE: "{planKey} wird nicht per Self-Service freigeschaltet.",
+  PLAN_CHANGE_BLOCKED: "W\xE4hrend des Onboardings ist ein Planwechsel gesperrt.",
+  NO_PENDING_PLAN_VERSION: "Es wartet keine Planversion auf eine Best\xE4tigung.",
+  ONBOARDING_CREATE_FAILED: "Das Konto konnte nicht angelegt werden. Bitte versuche es noch einmal.",
+  BUNDLE_PREVIEW_ARGUMENT_AMBIGUOUS: "Genau eines von bundleVersionId (Vorschau f\xFCrs Buchen) oder subscriptionBundleId (Vorschau f\xFCrs K\xFCndigen) muss angegeben sein.",
+  SUBSCRIPTION_PK_MISSING: "Der Adapter hat einen SubscriptionUsageRecord ohne id geliefert. Bitte den Prim\xE4rschl\xFCssel der Subscription durchreichen (siehe SubscriptionUsageRecord.id).",
+  LIMIT_EXCEEDED: "Das Limit f\xFCr {dimension} ist erreicht: {used} von {max}.",
+  QUOTA_DIMENSION_UNKNOWN: 'Unbekannte Quota-Dimension "{dimension}".',
+  // ── promo ──
+  PROMO_CODE_NOT_FOUND: "Code nicht gefunden",
+  PROMO_CODE_ALREADY_EXISTS: "Diesen Code gibt es bereits.",
+  PROMO_CODE_HAS_REDEMPTIONS: "Der Code wurde bereits eingel\xF6st \u2014 er l\xE4sst sich nicht per Soft-Delete entfernen. Pausiere ihn stattdessen.",
+  PROMO_CODE_NOT_REDEEMABLE: "Der Code l\xE4sst sich nicht einl\xF6sen: {reason}",
+  PROMO_CODE_FORMAT_INVALID: 'Der Code darf nur Gro\xDFbuchstaben, Ziffern, "-" und "_" enthalten (4\u201332 Zeichen).',
+  PROMO_PERCENT_OUT_OF_RANGE: "Der Prozentwert muss zwischen 0 und 100 liegen.",
+  PROMO_AMOUNT_NOT_POSITIVE: "Der Betrag muss positiv sein.",
+  PROMO_ONE_OFF_WITH_DURATION: "Ein einmaliger Rabatt darf keine Laufzeit haben.",
+  PROMO_DURATION_INVALID: "Ung\xFCltige Laufzeit (h\xF6chstens 24 Monate oder Abrechnungsperioden).",
+  PROMO_VALIDITY_WINDOW_INVALID: "Ung\xFCltiger G\xFCltigkeitszeitraum.",
+  PROMO_PLAN_NOT_DISCOUNTABLE: "Der {plan}-Plan l\xE4sst sich nicht rabattieren.",
+  PROMO_MIN_AMOUNT_NOT_POSITIVE: "Der Mindest-Bruttobetrag des Plans muss positiv sein.",
+  PROMO_WOULD_PRODUCE_ZERO_INVOICE: "Bei absoluten Betr\xE4gen muss der Rabatt unter dem niedrigsten anwendbaren Planpreis bleiben, oder allowZeroInvoice muss aktiviert sein.",
+  PROMO_MAX_REDEMPTIONS_LOWERED: "maxRedemptions l\xE4sst sich nicht senken.",
+  // ── contract ──
+  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.",
+  CHECKOUT_OFFER_BUNDLE_VERSION_NOT_BOOKABLE: "Mindestens eine Bundle-Version aus dem Checkout-Angebot ist nicht mehr buchbar.",
+  CHECKOUT_OFFER_FEATURE_DEPENDENCY_UNSATISFIED: "Der gew\xE4hlte Plan deckt nicht alle Feature-Abh\xE4ngigkeiten ab: [{missingRequires}] fehlen in Plan und gew\xE4hlten Bundles.",
+  SUBSCRIPTION_CONTRACT_LINE_ITEMS_REQUIRED: "Ein Abo-Vertrag braucht mindestens eine Position.",
+  SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED: "Ein Abo-Vertrag braucht genau eine Plan-Grundposition.",
+  SUBSCRIPTION_CONTRACT_INVALID_DATE: "{field} muss ein g\xFCltiges Datum sein.",
+  SUBSCRIPTION_CONTRACT_INVALID_WINDOW: "effectiveUntil muss nach effectiveFrom liegen.",
+  SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START: "effectiveUntil muss nach dem effectiveFrom des Vertrags liegen.",
+  CHECKOUT_OFFER_NOT_FOUND: "CheckoutOffer '{offerId}' nicht gefunden",
+  CHECKOUT_OFFER_EXPIRED: "Checkout-Angebot '{offerId}' ist abgelaufen \u2014 '{action}' ist nicht mehr m\xF6glich",
+  CHECKOUT_OFFER_ALREADY_CONSUMED: "Checkout-Angebot '{offerId}' wurde bereits eingel\xF6st \u2014 '{action}' ist nicht mehr m\xF6glich",
+  CHECKOUT_OFFER_NOT_CONSUMED: "CheckoutOffer '{offerId}' muss eingel\xF6st sein, bevor der Vertrag entsteht",
+  SUBSCRIPTION_CONTRACT_NOT_FOUND: "SubscriptionContract '{contractId}' nicht gefunden",
+  NO_ACTIVE_SUBSCRIPTION_CONTRACT: "Kein aktiver Abo-Vertrag f\xFCr Mandant {tenantId}",
+  SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SubscriptionContract '{contractId}' ist bereits geschlossen",
+  // ── registration ──
+  PENDING_REGISTRATION_NOT_FOUND: "Diese Registrierung konnten wir nicht finden. Vielleicht ist sie bereits abgeschlossen oder verworfen.",
+  PENDING_REGISTRATION_EXPIRED: "Diese Registrierung ist abgelaufen. Bitte fange noch einmal von vorn an.",
+  INVALID_REGISTRATION_STATE: "Dieser Schritt ist an dieser Stelle der Registrierung nicht verf\xFCgbar.",
+  OTP_INVALID: "Der Code ist nicht korrekt. Bitte pr\xFCfe ihn und versuche es erneut.",
+  OTP_EXPIRED: "Der Code ist abgelaufen. Bitte fordere einen neuen an.",
+  OTP_LOCKED: "Zu viele falsche Versuche. Bitte fordere einen neuen Code an.",
+  RATE_LIMITED: "Zu viele Versuche. Bitte probiere es in {retryAfterSeconds} Sekunden noch einmal.",
+  RESUME_TOKEN_INVALID: "Dieser Link zum Fortsetzen gilt nicht mehr. Bitte fordere einen neuen an.",
+  RESUME_NOT_CONFIGURED: "Eine begonnene Registrierung l\xE4sst sich hier nicht fortsetzen.",
+  CONFIGURATOR_NOT_CONFIGURED: "Der Konfigurator steht nicht zur Verf\xFCgung.",
+  CONFIG_NOT_SAVED: "Die Konfiguration konnte nicht gespeichert werden.",
+  PLAN_NOT_AVAILABLE: "Dieser Plan steht nicht zur Verf\xFCgung.",
+  PLAN_NOT_SELECTED: "Bitte w\xE4hle zuerst einen Plan aus.",
+  MODEL_NOT_AVAILABLE: "Diese Option steht nicht zur Verf\xFCgung.",
+  // ── entitlement (code lives in upsell.types.ts) ──
+  [FEATURE_NOT_LICENSED]: "Das Feature {featureKeys} ist im aktuellen Plan nicht enthalten."
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUTH_ERROR_CODES,
+  BILLING_ERROR_CODES,
+  CATALOG_ERROR_CODES,
+  CONTRACT_ERROR_CODES,
+  ERROR_MESSAGES_DE,
+  ERROR_MESSAGES_EN,
+  FEATURE_NOT_LICENSED,
+  OTP_RATE_LIMIT_MAX_SENDS,
+  OTP_RATE_LIMIT_WINDOW_MINUTES,
+  OTP_TTL_MINUTES,
+  OTP_VERIFY_MAX_ATTEMPTS,
+  PASSWORD_RESET_TTL_MINUTES,
+  PENDING_CHECKOUT_TTL_DAYS,
+  PENDING_EMAIL_TTL_HOURS,
+  PENDING_ONBOARDING_TTL_DAYS,
+  PLATFORM_ERROR_CODES,
+  PROMO_ERROR_CODES,
+  PersistenceCapabilityError,
+  PlatformUserExistsError,
+  REGISTRATION_ERROR_CODES,
+  REGISTRATION_RESUME_TTL_MINUTES,
+  REGISTRATION_STEP_BY_STATUS,
+  SETUP_ERROR_CODES,
+  applyPromo,
+  assertPersistenceCapabilities,
+  buildActivePlanVersionWhere,
+  buildActiveVersionWhere,
+  buildFeatureRequiresIndex,
+  classifyBundleVersionDiff,
+  classifyPlanDiff,
+  collectUnsatisfiedRequires,
+  coverageExcludingSelf,
+  formatErrorMessage,
+  isBundleRedundant,
+  isPlatformUserExistsError,
+  isVersionEditable,
+  missingRequiresFor,
+  pickActivePromo,
+  promoStatus,
+  resolveBundleAvailability,
+  resolveErrorMessage,
+  selectChargeableBundles,
+  startOfUtcDay
+});