@saasicat/nest 0.18.0 → 0.19.0

package/dist/{chunk-5KH2O4SF.js → chunk-I77VS3YH.js}

@@ -1,9 +1,9 @@
 import {
   PromoCodesService
-} from "./chunk-E7AJ42AB.js";
+} from "./chunk-QLJHIIOY.js";
 import {
   SubscriptionContractService
-} from "./chunk-32EMXPU2.js";
+} from "./chunk-B7NRY2LV.js";
 import {
   AUDIT_CONTEXT_RESOLVER_TOKEN,
   PENDING_PLAN_QUERY_PORT_TOKEN,
@@ -28,13 +28,13 @@ import {
   SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN,
   isLimitExceededError,
   toEffectiveLimitsSnapshot
-} from "./chunk-EXOLOJFZ.js";
+} from "./chunk-F6DCLVBB.js";
 import {
   PLAN_CATALOG_TOKEN,
   findPlan,
   getMarketedPlans,
   getPlanPriceNet
-} from "./chunk-R2QOSVAA.js";
+} from "./chunk-DQKCK7DX.js";
 import {
   SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN
 } from "./chunk-NYLON2VC.js";
@@ -103,35 +103,35 @@ var PublishValidationError = class extends Error {
 function assertChangeNote(changeNote) {
   const trimmed = (changeNote ?? "").trim();
   if (trimmed.length === 0) {
-    throw new PublishValidationError("CHANGE_NOTE_REQUIRED", "changeNote ist Pflicht beim Ver\xF6ffentlichen einer Version.");
+    throw new PublishValidationError("CHANGE_NOTE_REQUIRED", "changeNote is required when publishing a version.");
   }
   return trimmed;
 }
 __name(assertChangeNote, "assertChangeNote");
 function assertDraftPublishable(draft, draftId) {
   if (!draft) {
-    throw new PublishValidationError("NOT_FOUND", `PlanVersion ${draftId} nicht gefunden`);
+    throw new PublishValidationError("NOT_FOUND", `PlanVersion ${draftId} not found`);
   }
   if (draft.publishedAt !== null) {
-    throw new PublishValidationError("ALREADY_PUBLISHED", `PlanVersion ${draftId} ist bereits ver\xF6ffentlicht.`);
+    throw new PublishValidationError("ALREADY_PUBLISHED", `PlanVersion ${draftId} has already been published.`);
   }
   if (!draft.baseVersionId) {
-    throw new PublishValidationError("NO_BASE_VERSION", `Draft ${draftId} hat keine baseVersion \u2014 wahrscheinlich manuell angelegtes v1, das nur per Migration ver\xF6ffentlicht werden darf.`);
+    throw new PublishValidationError("NO_BASE_VERSION", `Draft ${draftId} has no baseVersion \u2014 probably a manually created v1 that may only be published via a migration.`);
   }
 }
 __name(assertDraftPublishable, "assertDraftPublishable");
 function assertBaseVersionFresh(base, baseId, planContext) {
   if (!base) {
-    throw new PublishValidationError("BASE_NOT_FOUND", `baseVersion ${baseId} nicht mehr vorhanden.`);
+    throw new PublishValidationError("BASE_NOT_FOUND", `baseVersion ${baseId} no longer exists.`);
   }
   if (base.supersededAt !== null) {
-    throw new PublishValidationError("BASE_SUPERSEDED", `Draft basiert auf einer abgel\xF6sten Version (${planContext}). Bitte den Draft gegen die aktuelle Live-Version rebasen oder neu anlegen.`);
+    throw new PublishValidationError("BASE_SUPERSEDED", `The draft is based on a superseded version (${planContext}). Rebase the draft onto the current live version, or create a new one.`);
   }
 }
 __name(assertBaseVersionFresh, "assertBaseVersionFresh");
 function assertOptimisticLockHeld(updateCount, draftId) {
   if (updateCount !== 1) {
-    throw new PublishValidationError("OPTIMISTIC_LOCK_CONFLICT", `Draft ${draftId} wurde zwischenzeitlich von einem anderen Admin ver\xF6ffentlicht.`);
+    throw new PublishValidationError("OPTIMISTIC_LOCK_CONFLICT", `Draft ${draftId} has meanwhile been published by another admin.`);
   }
 }
 __name(assertOptimisticLockHeld, "assertOptimisticLockHeld");
@@ -182,7 +182,7 @@ var FEATURE_GUARD_CONFIG_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/Featu
 // src/billing/feature.guard.ts
 import { ForbiddenException, Inject, Injectable, Logger, Optional } from "@nestjs/common";
 import { Reflector } from "@nestjs/core";
-import { FEATURE_NOT_LICENSED } from "@saasicat/types";
+import { AUTH_ERROR_CODES, FEATURE_NOT_LICENSED } from "@saasicat/types";
 
 // src/billing/upsell.tokens.ts
 var UPSELL_OFFER_RESOLVER_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/UpsellOfferResolver");
@@ -229,11 +229,21 @@ var FeatureGuard = class _FeatureGuard {
     if (!required || required.length === 0) return true;
     const request = context.switchToHttp().getRequest();
     const user = request.user;
-    if (!user) throw new ForbiddenException("Nicht authentifiziert");
+    if (!user) {
+      throw new ForbiddenException({
+        code: AUTH_ERROR_CODES.NOT_AUTHENTICATED,
+        message: "Not authenticated"
+      });
+    }
     const role = this.config?.userRoleResolver ? this.config.userRoleResolver(user) : user.role ?? user.platformRole;
     if (role === "SUPER_ADMIN") return true;
     const tenantId = this.config?.tenantIdResolver ? this.config.tenantIdResolver(request) : request.tenantId ?? user.tenantId;
-    if (!tenantId) throw new ForbiddenException("Kein Mandant zugeordnet");
+    if (!tenantId) {
+      throw new ForbiddenException({
+        code: AUTH_ERROR_CODES.NO_TENANT_ASSIGNED,
+        message: "No tenant assigned"
+      });
+    }
     const compute = /* @__PURE__ */ __name(() => this.entitlements.computeLimits(tenantId), "compute");
     const limits = this.config?.tenantContextRunner ? await this.config.tenantContextRunner(tenantId, compute) : await compute();
     const allowed = required.some((f) => limits.features.has(f));
@@ -245,17 +255,28 @@ var FeatureGuard = class _FeatureGuard {
   /**
    * Upsell response (#36): with a registered `UpsellOfferResolver` the 403
    * becomes machine-readable (`FeatureNotLicensedBody`), so consumer UIs can
-   * render a purchase offer. Without a resolver the previous plain 403
-   * remains — no breaking change.
+   * render a purchase offer. Without a resolver the body carries the same
+   * `code` but no offers.
    *
    * Deliberately 403 + `code` field instead of 402 — rationale in
    * `@saasicat/types` upsell.types.ts (402 is reserved / inconsistently
    * supported; SPA interceptors must not treat the 403 as an auth error, the
    * distinction runs through `code`).
+   *
+   * The message must keep starting with the word `Feature` — consumers
+   * classify the response by that prefix.
    */
   async buildNotLicensedException(required, tenantId) {
-    const message = `Feature ${required.join(" / ")} nicht im aktuellen Paket enthalten.`;
-    if (!this.upsellResolver) return new ForbiddenException(message);
+    const message = `Feature ${required.join(" / ")} is not included in the current plan.`;
+    if (!this.upsellResolver) {
+      return new ForbiddenException({
+        code: FEATURE_NOT_LICENSED,
+        message,
+        params: {
+          featureKeys: required
+        }
+      });
+    }
     const body = {
       code: FEATURE_NOT_LICENSED,
       featureKey: required[0],
@@ -273,7 +294,7 @@ var FeatureGuard = class _FeatureGuard {
     try {
       return await this.upsellResolver.resolveOffers(required, tenantId);
     } catch (error) {
-      this.logger.warn(`UpsellOfferResolver fehlgeschlagen f\xFCr [${required.join(", ")}]: ${String(error)}`);
+      this.logger.warn(`UpsellOfferResolver failed for [${required.join(", ")}]: ${String(error)}`);
       return [];
     }
   }
@@ -426,6 +447,7 @@ __name(compareRankedOffers, "compareRankedOffers");
 // src/billing/limit-exceeded.filter.ts
 import { Catch, HttpStatus, Logger as Logger2 } from "@nestjs/common";
 import { BaseExceptionFilter } from "@nestjs/core";
+import { BILLING_ERROR_CODES } from "@saasicat/types";
 function _ts_decorate3(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -446,11 +468,14 @@ var LimitExceededFilter = class _LimitExceededFilter extends BaseExceptionFilter
     const ctx = host.switchToHttp();
     const response = ctx.getResponse();
     const request = ctx.getRequest();
-    this.logger.warn(`Limit ${exception.dimension} \xFCberschritten: ${exception.used}/${exception.max} bei ${request.method ?? "?"} ${request.url ?? ""}`);
+    this.logger.warn(`Limit ${exception.dimension} exceeded: ${exception.used}/${exception.max} on ${request.method ?? "?"} ${request.url ?? ""}`);
     response.status(HttpStatus.PAYMENT_REQUIRED).send({
       statusCode: HttpStatus.PAYMENT_REQUIRED,
       error: "PaymentRequired",
-      reason: "LIMIT_EXCEEDED",
+      code: BILLING_ERROR_CODES.LIMIT_EXCEEDED,
+      // Deprecated: superseded by `code`, kept until consumers have
+      // migrated. Same value, only under the older field name.
+      reason: BILLING_ERROR_CODES.LIMIT_EXCEEDED,
       dimension: exception.dimension,
       used: exception.used,
       max: exception.max,
@@ -476,8 +501,8 @@ var PlanCatalogValidationError = class extends Error {
   source;
   errors;
   constructor(source, errors) {
-    const messages = errors.map((e) => `${e.instancePath || "/"}: ${e.message ?? "unbekannt"}`).join("\n  ");
-    super(`Plan-Catalog-Validierung fehlgeschlagen f\xFCr ${source}:
+    const messages = errors.map((e) => `${e.instancePath || "/"}: ${e.message ?? "unknown"}`).join("\n  ");
+    super(`Plan catalog validation failed for ${source}:
   ${messages}`), this.source = source, this.errors = errors;
     this.name = "PlanCatalogValidationError";
   }
@@ -494,7 +519,7 @@ __name(loadPlanCatalogFromFile, "loadPlanCatalogFromFile");
 function loadPlanCatalogFromString(yamlContent, opts) {
   const parsed = yaml.load(yamlContent);
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`YAML-Inhalt von ${opts.source} ist kein Objekt`);
+    throw new Error(`The YAML content of ${opts.source} is not an object`);
   }
   const ajv = new Ajv2020({
     strict: false,
@@ -518,19 +543,19 @@ function validateConsistency(catalog, source) {
   const planIds = /* @__PURE__ */ new Set();
   for (const plan of catalog.plans ?? []) {
     if (planIds.has(plan.id)) {
-      errors.push(`plans[].id: Doppelte Plan-ID "${plan.id}"`);
+      errors.push(`plans[].id: duplicate plan id "${plan.id}"`);
     }
     planIds.add(plan.id);
     if (catalog.features) {
       for (const fk of plan.features) {
         if (!declaredFeatureKeys.has(fk)) {
-          errors.push(`plans[id=${plan.id}].features: Unbekannter featureKey "${fk}" \u2014 nicht in catalog.features deklariert`);
+          errors.push(`plans[id=${plan.id}].features: Unknown featureKey "${fk}" \u2014 not declared in catalog.features`);
         }
       }
     }
   }
   if (errors.length > 0) {
-    const err = new Error(`Plan-Catalog-Konsistenz-Fehler in ${source}:
+    const err = new Error(`Plan catalog consistency error in ${source}:
   ${errors.join("\n  ")}`);
     err.name = "PlanCatalogConsistencyError";
     throw err;
@@ -613,7 +638,7 @@ var PlanCatalogImporterService = class {
       if (planResult.created) report.plansCreated++;
       else report.plansSkipped++;
       if (plan.monthlyNet === null || plan.monthlyNet === void 0) {
-        report.warnings.push(`Plan '${plan.id}' hat keinen monthlyNet \u2014 \xFCbersprungen (auf-Anfrage-Plans brauchen manuelle PlanVersion).`);
+        report.warnings.push(`Plan '${plan.id}' has no monthlyNet \u2014 skipped (on-request plans need a manual plan version).`);
         continue;
       }
       const versionResult = await this.sink.upsertPlanVersion({
@@ -1034,6 +1059,7 @@ PublicCatalogModule = _ts_decorate8([
 
 // src/billing/composed-tenant-auth.guard.ts
 import { ForbiddenException as ForbiddenException2, Inject as Inject6, Injectable as Injectable4, Optional as Optional4 } from "@nestjs/common";
+import { AUTH_ERROR_CODES as AUTH_ERROR_CODES2 } from "@saasicat/types";
 function _ts_decorate9(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -1061,7 +1087,10 @@ var ComposedTenantAuthGuard = class {
   }
   async canActivate(context) {
     if (!this.guards || this.guards.length === 0) {
-      throw new ForbiddenException2("TenantBillingModule.forRoot.authGuards ist nicht konfiguriert.");
+      throw new ForbiddenException2({
+        code: AUTH_ERROR_CODES2.AUTH_GUARDS_NOT_CONFIGURED,
+        message: "TenantBillingModule.forRoot.authGuards is not configured."
+      });
     }
     for (const guard of this.guards) {
       const result = await Promise.resolve(guard.canActivate(context));
@@ -1082,6 +1111,7 @@ ComposedTenantAuthGuard = _ts_decorate9([
 
 // src/billing/tenant-admin.guard.ts
 import { ForbiddenException as ForbiddenException3, Injectable as Injectable5 } from "@nestjs/common";
+import { AUTH_ERROR_CODES as AUTH_ERROR_CODES3 } from "@saasicat/types";
 function _ts_decorate10(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -1100,11 +1130,17 @@ var TenantAdminGuard = class {
   canActivate(context) {
     const request = context.switchToHttp().getRequest();
     if (!request.user) {
-      throw new ForbiddenException3("Nicht authentifiziert");
+      throw new ForbiddenException3({
+        code: AUTH_ERROR_CODES3.NOT_AUTHENTICATED,
+        message: "Not authenticated"
+      });
     }
     const role = request.user.platformRole ?? request.user.role;
     if (!role || !ADMIN_ROLES.has(role)) {
-      throw new ForbiddenException3("Diese Aktion erfordert die TENANT_ADMIN-Rolle.");
+      throw new ForbiddenException3({
+        code: AUTH_ERROR_CODES3.TENANT_ADMIN_REQUIRED,
+        message: "This action requires the TENANT_ADMIN role."
+      });
     }
     return true;
   }
@@ -1142,6 +1178,7 @@ __name(round2, "round2");
 
 // src/billing/plan-change-preview.service.ts
 import { Inject as Inject7, Injectable as Injectable6, NotFoundException, Optional as Optional5 } from "@nestjs/common";
+import { BILLING_ERROR_CODES as BILLING_ERROR_CODES2 } from "@saasicat/types";
 function _ts_decorate11(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -1180,11 +1217,24 @@ var PlanChangePreviewService = class {
   async preview(tenantId, targetPlan, targetCycle, now = /* @__PURE__ */ new Date()) {
     const sub = await this.subscriptions.findForTenant(tenantId);
     if (!sub) {
-      throw new NotFoundException(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+      throw new NotFoundException({
+        code: BILLING_ERROR_CODES2.SUBSCRIPTION_NOT_FOUND,
+        message: `No subscription for tenant ${tenantId}`,
+        params: {
+          tenantId
+        }
+      });
     }
     const targetPlanDef = findPlan(this.catalog, targetPlan);
     if (!targetPlanDef) {
-      throw new NotFoundException(`Plan "${targetPlan}" nicht im Catalog (${this.catalog.projectKey})`);
+      throw new NotFoundException({
+        code: BILLING_ERROR_CODES2.PLAN_NOT_IN_CATALOG,
+        message: `Plan "${targetPlan}" is not in the catalog (${this.catalog.projectKey})`,
+        params: {
+          planKey: targetPlan,
+          projectKey: this.catalog.projectKey
+        }
+      });
     }
     const ctx = {
       currentPeriodStart: sub.currentPeriodStart,
@@ -1249,13 +1299,13 @@ var PlanChangePreviewService = class {
     if (blockedTargets.includes(targetPlan)) {
       blockers.push({
         code: `${targetPlan}_NOT_SELF_SERVICE`,
-        message: `${targetSnap.name} wird nur per Sondervertrag aktiviert. Bitte den Vertragsbetreuer kontaktieren.`
+        message: `${targetSnap.name} is only activated via a special contract. Please contact the contract manager.`
       });
     }
     if (blockedSources.includes(sub.plan)) {
       blockers.push({
         code: `${sub.plan}_LOCKED`,
-        message: `Aktiver ${currentSnap.name}-Sondervertrag \u2014 bitte den Vertragsbetreuer f\xFCr Plan-Wechsel kontaktieren.`
+        message: `Active ${currentSnap.name} special contract \u2014 please contact the contract manager to change plans.`
       });
     }
     for (const [key, row] of Object.entries(limitsCheck)) {
@@ -1263,19 +1313,19 @@ var PlanChangePreviewService = class {
       const usedDisplay = isFloatQuota(key) ? row.used.toFixed(1) : row.used.toString();
       blockers.push({
         code: `${key.toUpperCase()}_OVER_TARGET`,
-        message: `Aktueller Verbrauch ${usedDisplay} \xFCberschreitet das Ziel-Limit ${row.targetMax} (${key}) im ${targetSnap.name}-Paket. Bitte Verbrauch reduzieren.`
+        message: `Current usage ${usedDisplay} exceeds the target limit ${row.targetMax} (${key}) in the ${targetSnap.name} plan. Please reduce usage first.`
       });
     }
     if (featuresLost.length > 0) {
       warnings.push({
         code: "FEATURES_LOST",
-        message: `Mit dem Wechsel verlierst du Zugriff auf ${featuresLost.length} Feature${featuresLost.length === 1 ? "" : "s"}. Bestehende Daten bleiben erhalten und werden nicht gel\xF6scht \u2014 du kannst sie wieder freischalten, wenn du erneut upgradest.`
+        message: `Switching means losing access to ${featuresLost.length} feature${featuresLost.length === 1 ? "" : "s"}. Existing data is retained and never deleted \u2014 upgrading again unlocks it.`
       });
     }
     if (changeType === "NOOP") {
       warnings.push({
         code: "NO_CHANGE",
-        message: "Ziel-Paket und Abrechnungszyklus stimmen mit dem aktuellen Stand \xFCberein."
+        message: "Target plan and billing cycle already match the current state."
       });
     }
     const projectedTrialEndsAt = this.trialProjection && sub.status === "TRIAL" ? await this.trialProjection.projectTrialEndsAt({
@@ -1433,13 +1483,13 @@ var PendingPlanMaterializationService = class _PendingPlanMaterializationService
         this.entitlements.invalidateTenant(change.tenantId);
         applied += 1;
       } catch (err) {
-        this.logger.error(`Pending-Plan-Materialisierung fehlgeschlagen (tenant ${change.tenantId}): ${String(err)}`);
+        this.logger.error(`Pending plan materialisation failed (tenant ${change.tenantId}): ${String(err)}`);
         continue;
       }
       await this.tryFreeze(change.tenantId, change.pendingPlan, cycle, now);
     }
     if (applied > 0) {
-      this.logger.log(`Pending-Plan-Materialisierung: ${applied} geplante(r) Plan-Wechsel angewandt.`);
+      this.logger.log(`Pending plan materialisation: applied ${applied} scheduled plan change(s).`);
     }
     return {
       applied
@@ -1450,7 +1500,7 @@ var PendingPlanMaterializationService = class _PendingPlanMaterializationService
     try {
       await this.contractFreeze.freezeOnPlanChange(tenantId, plan, cycle, now);
     } catch (err) {
-      this.logger.error(`Contract-Freeze nach Materialisierung fehlgeschlagen (tenant ${tenantId}): ${String(err)}`);
+      this.logger.error(`Contract freeze after materialisation failed (tenant ${tenantId}): ${String(err)}`);
     }
   }
 };
@@ -1628,14 +1678,14 @@ var PreviewPlanChangeDto = class {
 _ts_decorate14([
   IsString2(),
   Matches(PLAN_OR_CYCLE_PATTERN, {
-    message: "plan muss SCREAMING_SNAKE_CASE sein"
+    message: "plan must be SCREAMING_SNAKE_CASE"
   }),
   _ts_metadata10("design:type", String)
 ], PreviewPlanChangeDto.prototype, "plan", void 0);
 _ts_decorate14([
   IsString2(),
   Matches(PLAN_OR_CYCLE_PATTERN, {
-    message: "billingCycle muss SCREAMING_SNAKE_CASE sein (z. B. MONTHLY, YEARLY)"
+    message: "billingCycle must be SCREAMING_SNAKE_CASE (e.g. MONTHLY, YEARLY)"
   }),
   _ts_metadata10("design:type", String)
 ], PreviewPlanChangeDto.prototype, "billingCycle", void 0);
@@ -1699,14 +1749,14 @@ var CompleteOnboardingSubscriptionDto = class {
 _ts_decorate15([
   IsString3(),
   Matches2(PLAN_OR_CYCLE_PATTERN2, {
-    message: "plan muss SCREAMING_SNAKE_CASE sein"
+    message: "plan must be SCREAMING_SNAKE_CASE"
   }),
   _ts_metadata11("design:type", String)
 ], CompleteOnboardingSubscriptionDto.prototype, "plan", void 0);
 _ts_decorate15([
   IsString3(),
   Matches2(PLAN_OR_CYCLE_PATTERN2, {
-    message: "billingCycle muss SCREAMING_SNAKE_CASE sein (z. B. MONTHLY, YEARLY)"
+    message: "billingCycle must be SCREAMING_SNAKE_CASE (e.g. MONTHLY, YEARLY)"
   }),
   _ts_metadata11("design:type", String)
 ], CompleteOnboardingSubscriptionDto.prototype, "billingCycle", void 0);
@@ -1714,7 +1764,7 @@ _ts_decorate15([
   IsOptional3(),
   IsString3(),
   Matches2(PROMO_CODE_PATTERN, {
-    message: 'promoCode muss aus A\u2013Z, 0\u20139, "-", "_" bestehen (4\u201332 Zeichen)'
+    message: 'promoCode must consist of A\u2013Z, 0\u20139, "-", "_" (4\u201332 characters)'
   }),
   _ts_metadata11("design:type", String)
 ], CompleteOnboardingSubscriptionDto.prototype, "promoCode", void 0);
@@ -1730,9 +1780,11 @@ _ts_decorate15([
 
 // src/billing/tenant-billing.controller.ts
 import { BadRequestException, Body as Body2, Controller as Controller3, ForbiddenException as ForbiddenException4, Get as Get2, HttpCode, HttpStatus as HttpStatus2, Inject as Inject11, Logger as Logger4, NotFoundException as NotFoundException3, Optional as Optional8, Post as Post2, Req, UseGuards as UseGuards2 } from "@nestjs/common";
+import { AUTH_ERROR_CODES as AUTH_ERROR_CODES4, BILLING_ERROR_CODES as BILLING_ERROR_CODES4 } from "@saasicat/types";
 
 // src/billing/subscription-bundles.service.ts
 import { Inject as Inject10, Injectable as Injectable9, NotFoundException as NotFoundException2, Optional as Optional7, UnprocessableEntityException } from "@nestjs/common";
+import { BILLING_ERROR_CODES as BILLING_ERROR_CODES3, CATALOG_ERROR_CODES } from "@saasicat/types";
 function _ts_decorate16(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -1780,38 +1832,61 @@ var SubscriptionBundlesService = class {
   async addBundleToSubscription(input) {
     const bundleVersion = await this.bundles.findVersionById(input.bundleVersionId);
     if (!bundleVersion) {
-      throw new NotFoundException2(`BundleVersion '${input.bundleVersionId}' nicht gefunden`);
+      throw new NotFoundException2({
+        code: CATALOG_ERROR_CODES.BUNDLE_VERSION_NOT_FOUND,
+        message: `BundleVersion '${input.bundleVersionId}' not found`,
+        params: {
+          bundleVersionId: input.bundleVersionId
+        }
+      });
     }
     if (bundleVersion.publishedAt === null) {
       throw new UnprocessableEntityException({
-        code: "BUNDLE_VERSION_NOT_PUBLISHED",
-        message: `BundleVersion '${input.bundleVersionId}' ist nicht published und kann nicht gebucht werden.`
+        code: CATALOG_ERROR_CODES.BUNDLE_VERSION_NOT_PUBLISHED,
+        message: `BundleVersion '${input.bundleVersionId}' is not published and cannot be booked.`,
+        params: {
+          bundleVersionId: input.bundleVersionId
+        }
       });
     }
     if (bundleVersion.supersededAt !== null) {
       throw new UnprocessableEntityException({
-        code: "BUNDLE_VERSION_SUPERSEDED",
-        message: `BundleVersion '${input.bundleVersionId}' wurde durch eine Nachfolge-Version abgel\xF6st.`
+        code: CATALOG_ERROR_CODES.BUNDLE_VERSION_SUPERSEDED,
+        message: `BundleVersion '${input.bundleVersionId}' has been superseded by a newer version.`,
+        params: {
+          bundleVersionId: input.bundleVersionId
+        }
       });
     }
     if (this.blockedBundles?.bundleKeys?.includes(bundleVersion.bundleKey)) {
       throw new UnprocessableEntityException({
-        code: "BUNDLE_NOT_SELF_SERVICE",
-        message: `Bundle '${bundleVersion.bundleKey}' wird nur per Sondervertrag aktiviert. Bitte den Vertragsbetreuer kontaktieren.`
+        code: BILLING_ERROR_CODES3.BUNDLE_NOT_SELF_SERVICE,
+        message: `Bundle '${bundleVersion.bundleKey}' is only activated via a special contract. Please contact the contract manager.`,
+        params: {
+          bundleKey: bundleVersion.bundleKey
+        }
       });
     }
     const planIds = bundleVersion.compatibility?.planIds ?? [];
     if (planIds.length > 0 && !planIds.includes(input.currentPlanKey)) {
       throw new UnprocessableEntityException({
-        code: "BUNDLE_INCOMPATIBLE_WITH_PLAN",
-        message: `BundleVersion '${input.bundleVersionId}' ist nicht mit Plan '${input.currentPlanKey}' kompatibel. Erlaubt: [${planIds.join(", ")}].`
+        code: BILLING_ERROR_CODES3.BUNDLE_INCOMPATIBLE_WITH_PLAN,
+        message: `BundleVersion '${input.bundleVersionId}' is not compatible with plan '${input.currentPlanKey}'. Allowed: [${planIds.join(", ")}].`,
+        params: {
+          bundleVersionId: input.bundleVersionId,
+          planKey: input.currentPlanKey,
+          allowedPlanKeys: planIds
+        }
       });
     }
     const active = await this.repo.listActiveBySubscription(input.subscriptionId);
     if (active.some((b) => b.bundleVersionId === input.bundleVersionId)) {
       throw new UnprocessableEntityException({
-        code: "BUNDLE_ALREADY_SUBSCRIBED",
-        message: `Subscription '${input.subscriptionId}' hat dieses Bundle bereits aktiv gebucht.`
+        code: BILLING_ERROR_CODES3.BUNDLE_ALREADY_SUBSCRIBED,
+        message: `Subscription '${input.subscriptionId}' has already actively booked this bundle.`,
+        params: {
+          subscriptionId: input.subscriptionId
+        }
       });
     }
     const startedAt = input.startedAt ?? /* @__PURE__ */ new Date();
@@ -1827,12 +1902,21 @@ var SubscriptionBundlesService = class {
   async cancelBundleFromSubscription(input) {
     const existing = await this.repo.findById(input.subscriptionBundleId);
     if (!existing) {
-      throw new NotFoundException2(`SubscriptionBundle '${input.subscriptionBundleId}' nicht gefunden`);
+      throw new NotFoundException2({
+        code: BILLING_ERROR_CODES3.SUBSCRIPTION_BUNDLE_NOT_FOUND,
+        message: `SubscriptionBundle '${input.subscriptionBundleId}' not found`,
+        params: {
+          subscriptionBundleId: input.subscriptionBundleId
+        }
+      });
     }
     if (existing.canceledAt !== null) {
       throw new UnprocessableEntityException({
-        code: "SUBSCRIPTION_BUNDLE_ALREADY_CANCELED",
-        message: `SubscriptionBundle '${input.subscriptionBundleId}' ist bereits gek\xFCndigt.`
+        code: BILLING_ERROR_CODES3.SUBSCRIPTION_BUNDLE_ALREADY_CANCELED,
+        message: `SubscriptionBundle '${input.subscriptionBundleId}' is already cancelled.`,
+        params: {
+          subscriptionBundleId: input.subscriptionBundleId
+        }
       });
     }
     const canceledAt = input.canceledAt ?? /* @__PURE__ */ new Date();
@@ -1853,18 +1937,27 @@ var SubscriptionBundlesService = class {
   async reactivateBundle(subscriptionBundleId) {
     const existing = await this.repo.findById(subscriptionBundleId);
     if (!existing) {
-      throw new NotFoundException2(`SubscriptionBundle '${subscriptionBundleId}' nicht gefunden`);
+      throw new NotFoundException2({
+        code: BILLING_ERROR_CODES3.SUBSCRIPTION_BUNDLE_NOT_FOUND,
+        message: `SubscriptionBundle '${subscriptionBundleId}' not found`,
+        params: {
+          subscriptionBundleId
+        }
+      });
     }
     if (existing.canceledAt === null) {
       throw new UnprocessableEntityException({
-        code: "SUBSCRIPTION_BUNDLE_NOT_CANCELED",
-        message: `SubscriptionBundle '${subscriptionBundleId}' ist nicht gek\xFCndigt.`
+        code: BILLING_ERROR_CODES3.SUBSCRIPTION_BUNDLE_NOT_CANCELED,
+        message: `SubscriptionBundle '${subscriptionBundleId}' is not cancelled.`,
+        params: {
+          subscriptionBundleId
+        }
       });
     }
     if (existing.canceledEffectiveAt !== null && existing.canceledEffectiveAt <= /* @__PURE__ */ new Date()) {
       throw new UnprocessableEntityException({
-        code: "SUBSCRIPTION_BUNDLE_CANCELLATION_EFFECTIVE",
-        message: "K\xFCndigung bereits wirksam \u2014 bitte das Bundle neu buchen."
+        code: BILLING_ERROR_CODES3.SUBSCRIPTION_BUNDLE_CANCELLATION_EFFECTIVE,
+        message: "Cancellation already in effect \u2014 book the bundle again."
       });
     }
     return this.repo.reactivate(subscriptionBundleId);
@@ -1970,7 +2063,13 @@ var TenantBillingController = class _TenantBillingController {
       this.usageSnapshot.snapshot(tenantId)
     ]);
     if (!sub) {
-      throw new NotFoundException3(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+      throw new NotFoundException3({
+        code: BILLING_ERROR_CODES4.SUBSCRIPTION_NOT_FOUND,
+        message: `No subscription for tenant ${tenantId}`,
+        params: {
+          tenantId
+        }
+      });
     }
     const usage = {};
     for (const key of /* @__PURE__ */ new Set([
@@ -2019,14 +2118,29 @@ var TenantBillingController = class _TenantBillingController {
     const userId = this.requireUserId(req);
     const blockedTargets = this.blockedPlans?.asTarget ?? [];
     if (blockedTargets.includes(dto.plan)) {
-      throw new ForbiddenException4(`${dto.plan} wird nicht per Self-Service aktiviert.`);
+      throw new ForbiddenException4({
+        code: BILLING_ERROR_CODES4.PLAN_NOT_SELF_SERVICE,
+        message: `${dto.plan} is not activated via self-service.`,
+        params: {
+          planKey: dto.plan
+        }
+      });
     }
     const sub = await this.subscriptionUsage.findForTenant(tenantId);
-    if (!sub) throw new NotFoundException3(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+    if (!sub) {
+      throw new NotFoundException3({
+        code: BILLING_ERROR_CODES4.SUBSCRIPTION_NOT_FOUND,
+        message: `No subscription for tenant ${tenantId}`,
+        params: {
+          tenantId
+        }
+      });
+    }
     const blockers = await this.planPreview.assertChangeAllowed(tenantId, dto.plan, dto.billingCycle);
     if (blockers.length > 0) {
       throw new BadRequestException({
-        message: "Plan-Wechsel blockiert.",
+        code: BILLING_ERROR_CODES4.PLAN_CHANGE_BLOCKED,
+        message: "Plan change is blocked.",
         blockers
       });
     }
@@ -2096,14 +2210,29 @@ var TenantBillingController = class _TenantBillingController {
     const warnings = [];
     const blockedTargets = this.blockedPlans?.asTarget ?? [];
     if (blockedTargets.includes(dto.plan)) {
-      throw new ForbiddenException4(`${dto.plan} wird nicht per Self-Service aktiviert.`);
+      throw new ForbiddenException4({
+        code: BILLING_ERROR_CODES4.PLAN_NOT_SELF_SERVICE,
+        message: `${dto.plan} is not activated via self-service.`,
+        params: {
+          planKey: dto.plan
+        }
+      });
     }
     const sub = await this.subscriptionUsage.findForTenant(tenantId);
-    if (!sub) throw new NotFoundException3(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+    if (!sub) {
+      throw new NotFoundException3({
+        code: BILLING_ERROR_CODES4.SUBSCRIPTION_NOT_FOUND,
+        message: `No subscription for tenant ${tenantId}`,
+        params: {
+          tenantId
+        }
+      });
+    }
     const blockers = await this.planPreview.assertChangeAllowed(tenantId, dto.plan, dto.billingCycle);
     if (blockers.length > 0) {
       throw new BadRequestException({
-        message: "Plan-Wechsel im Onboarding blockiert.",
+        code: BILLING_ERROR_CODES4.PLAN_CHANGE_BLOCKED,
+        message: "Plan change during onboarding is blocked.",
         blockers
       });
     }
@@ -2137,8 +2266,13 @@ var TenantBillingController = class _TenantBillingController {
           warnings.push(...this.collectPromoSkipReasons(dto.promoCode, sub));
         }
       } catch (err) {
+        const reason = err instanceof Error ? err.message : null;
         throw new BadRequestException({
-          message: err instanceof Error ? `Onboarding-Anlage fehlgeschlagen: ${err.message}` : "Onboarding-Anlage fehlgeschlagen"
+          code: BILLING_ERROR_CODES4.ONBOARDING_CREATE_FAILED,
+          message: reason ? `Onboarding creation failed: ${reason}` : "Onboarding creation failed",
+          params: {
+            reason
+          }
         });
       }
     } else {
@@ -2151,9 +2285,9 @@ var TenantBillingController = class _TenantBillingController {
       });
       if (dto.promoCode) {
         if (!this.promoCodes) {
-          warnings.push("Promo-Code wurde gesendet, aber PromoCodesModule ist nicht geladen \u2014 der Code wurde NICHT eingel\xF6st.");
+          warnings.push("A promo code was sent, but PromoCodesModule is not loaded \u2014 the code was NOT redeemed.");
         } else if (!sub.id) {
-          warnings.push("Promo-Code wurde gesendet, aber der Adapter liefert keine SubscriptionUsageRecord.id \u2014 der Code wurde NICHT eingel\xF6st.");
+          warnings.push("A promo code was sent, but the adapter returns no SubscriptionUsageRecord.id \u2014 the code was NOT redeemed.");
         } else {
           try {
             const redemption = await this.promoCodes.redeem({
@@ -2164,8 +2298,8 @@ var TenantBillingController = class _TenantBillingController {
             });
             promoRedemption = this.toResponseRedemption(redemption, dto.promoCode);
           } catch (err) {
-            const message = err instanceof Error ? err.message : "Unbekannter Fehler";
-            warnings.push(`Promo-Code konnte nicht eingel\xF6st werden: ${message}`);
+            const message = err instanceof Error ? err.message : "Unknown error";
+            warnings.push(`The promo code could not be redeemed: ${message}`);
           }
         }
       }
@@ -2191,11 +2325,11 @@ var TenantBillingController = class _TenantBillingController {
           });
           bundlesAdded += 1;
         } catch (err) {
-          warnings.push(`Bundle '${bundleVersionId}' konnte nicht gebucht werden: ` + (err instanceof Error ? err.message : String(err)));
+          warnings.push(`Bundle '${bundleVersionId}' could not be booked: ` + (err instanceof Error ? err.message : String(err)));
         }
       }
     } else if (bundleVersionIds.length > 0 && !this.subscriptionBundles) {
-      warnings.push("Bundle-Buchungen im Onboarding angefordert, aber SubscriptionBundleModule ist nicht im Konsumenten registriert. Bundles wurden nicht angelegt.");
+      warnings.push("Bundle bookings were requested during onboarding, but SubscriptionBundleModule is not registered in the consumer. No bundles were created.");
     }
     return {
       plan: planResult.plan,
@@ -2215,9 +2349,20 @@ var TenantBillingController = class _TenantBillingController {
     const tenantId = this.requireTenantId(req);
     const userId = this.requireUserId(req);
     const sub = await this.subscriptionUsage.findForTenant(tenantId);
-    if (!sub) throw new NotFoundException3(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+    if (!sub) {
+      throw new NotFoundException3({
+        code: BILLING_ERROR_CODES4.SUBSCRIPTION_NOT_FOUND,
+        message: `No subscription for tenant ${tenantId}`,
+        params: {
+          tenantId
+        }
+      });
+    }
     if (!sub.pendingPlanVersion) {
-      throw new BadRequestException("Es liegt aktuell keine Pending-Plan-Version zur Best\xE4tigung vor.");
+      throw new BadRequestException({
+        code: BILLING_ERROR_CODES4.NO_PENDING_PLAN_VERSION,
+        message: "There is no pending plan version awaiting confirmation."
+      });
     }
     const result = await this.subscriptionWrite.acceptPendingPlanVersion(tenantId, userId, /* @__PURE__ */ new Date());
     if (!result.alreadyAccepted) {
@@ -2262,7 +2407,10 @@ var TenantBillingController = class _TenantBillingController {
     const resolver = this.tenantIdResolver ?? ((r) => r.user?.tenantId ?? null);
     const tenantId = resolver(req);
     if (!tenantId) {
-      throw new NotFoundException3("Tenant-ID nicht im Request gefunden");
+      throw new NotFoundException3({
+        code: AUTH_ERROR_CODES4.TENANT_CONTEXT_MISSING,
+        message: "No tenant ID found on the request"
+      });
     }
     return tenantId;
   }
@@ -2270,7 +2418,10 @@ var TenantBillingController = class _TenantBillingController {
     const resolver = this.userIdResolver ?? ((r) => r.user?.sub ?? r.user?.id ?? null);
     const userId = resolver(req);
     if (!userId) {
-      throw new NotFoundException3("User-ID nicht im Request gefunden");
+      throw new NotFoundException3({
+        code: AUTH_ERROR_CODES4.TENANT_CONTEXT_MISSING,
+        message: "No user ID found on the request"
+      });
     }
     return userId;
   }
@@ -2310,10 +2461,10 @@ var TenantBillingController = class _TenantBillingController {
   collectPromoSkipReasons(promoCode, sub) {
     const reasons = [];
     if (!this.promoCodes) {
-      reasons.push(`Promo-Code "${promoCode}" wurde gesendet, aber PromoCodesModule ist nicht geladen \u2014 der Code wurde NICHT eingel\xF6st.`);
+      reasons.push(`Promo-Code "${promoCode}" was sent, but PromoCodesModule is not loaded \u2014 the code was NOT redeemed.`);
     }
     if (!sub.id) {
-      reasons.push(`Promo-Code "${promoCode}" wurde gesendet, aber der Adapter liefert keine SubscriptionUsageRecord.id \u2014 der Code wurde NICHT eingel\xF6st.`);
+      reasons.push(`Promo-Code "${promoCode}" was sent, but the adapter returns no SubscriptionUsageRecord.id \u2014 the code was NOT redeemed.`);
     }
     return reasons;
   }
@@ -2328,7 +2479,7 @@ var TenantBillingController = class _TenantBillingController {
     try {
       await this.contractFreeze.freezeOnPlanChange(tenantId, plan, cycle, /* @__PURE__ */ new Date());
     } catch (err) {
-      this.logger.error(`Contract-Freeze nach Plan-Wechsel fehlgeschlagen (tenant ${tenantId}): ${String(err)}`);
+      this.logger.error(`Contract freeze after plan change failed (tenant ${tenantId}): ${String(err)}`);
     }
   }
   /**
@@ -2639,7 +2790,7 @@ __name(normalizeQuotas, "normalizeQuotas");
 
 // src/billing/subscription-bundle-preview.service.ts
 import { Inject as Inject12, Injectable as Injectable11, NotFoundException as NotFoundException4, Optional as Optional9 } from "@nestjs/common";
-import { buildFeatureRequiresIndex as buildFeatureRequiresIndex3, collectUnsatisfiedRequires as collectUnsatisfiedRequires3 } from "@saasicat/types";
+import { BILLING_ERROR_CODES as BILLING_ERROR_CODES5, CATALOG_ERROR_CODES as CATALOG_ERROR_CODES2, buildFeatureRequiresIndex as buildFeatureRequiresIndex3, collectUnsatisfiedRequires as collectUnsatisfiedRequires3 } from "@saasicat/types";
 function _ts_decorate20(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -2678,7 +2829,13 @@ var SubscriptionBundlePreviewService = class {
   async previewAdd(ctx, input, now = /* @__PURE__ */ new Date()) {
     const bundleVersion = await this.bundles.findVersionById(input.bundleVersionId);
     if (!bundleVersion) {
-      throw new NotFoundException4(`BundleVersion '${input.bundleVersionId}' nicht gefunden`);
+      throw new NotFoundException4({
+        code: CATALOG_ERROR_CODES2.BUNDLE_VERSION_NOT_FOUND,
+        message: `BundleVersion '${input.bundleVersionId}' not found`,
+        params: {
+          bundleVersionId: input.bundleVersionId
+        }
+      });
     }
     const blockers = [];
     const warnings = [];
@@ -2687,7 +2844,7 @@ var SubscriptionBundlePreviewService = class {
     if (activeBundleVersions.some((bv) => bv.id === bundleVersion.id)) {
       blockers.push({
         code: "BUNDLE_ALREADY_SUBSCRIBED",
-        message: "Dieses Bundle ist bereits aktiv gebucht."
+        message: "This bundle is already actively booked."
       });
     }
     const planFeatures = new Set(await this.resolvePlanFeatures(ctx.currentPlanKey, now));
@@ -2695,14 +2852,14 @@ var SubscriptionBundlePreviewService = class {
     if (redundantFeatures.length > 0) {
       warnings.push({
         code: "REDUNDANT_FEATURES",
-        message: `${redundantFeatures.length} Feature${redundantFeatures.length === 1 ? " ist" : "s sind"} bereits im Plan oder einem anderen gebuchten Bundle enthalten \u2014 das Bundle w\xFCrde daf\xFCr doppelt bezahlt.`
+        message: `${redundantFeatures.length} feature${redundantFeatures.length === 1 ? " is" : "s are"} already included in the plan or another booked bundle \u2014 the bundle would be paid for twice.`
       });
     }
     const missingRequires = await this.collectMissingRequires(bundleVersion, planFeatures, activeBundleVersions);
     if (missingRequires.length > 0) {
       blockers.push({
         code: "BUNDLE_FEATURE_DEPENDENCY_UNSATISFIED",
-        message: `Das Bundle ben\xF6tigt [${missingRequires.join(", ")}] \u2014 weder im Plan noch in den aktiven Bundles enthalten.`
+        message: `The bundle requires [${missingRequires.join(", ")}] \u2014 present neither in the plan nor in the active bundles.`
       });
     }
     const priceNet = resolveBundlePriceNet(bundleVersion, ctx.currentPlanKey, ctx.billingCycle);
@@ -2731,18 +2888,30 @@ var SubscriptionBundlePreviewService = class {
   async previewCancel(ctx, input, now = /* @__PURE__ */ new Date()) {
     const existing = await this.subscriptionBundles.findById(input.subscriptionBundleId);
     if (!existing || existing.subscriptionId !== ctx.subscriptionId) {
-      throw new NotFoundException4(`SubscriptionBundle '${input.subscriptionBundleId}' nicht gefunden`);
+      throw new NotFoundException4({
+        code: BILLING_ERROR_CODES5.SUBSCRIPTION_BUNDLE_NOT_FOUND,
+        message: `SubscriptionBundle '${input.subscriptionBundleId}' not found`,
+        params: {
+          subscriptionBundleId: input.subscriptionBundleId
+        }
+      });
     }
     const bundleVersion = await this.bundles.findVersionById(existing.bundleVersionId);
     if (!bundleVersion) {
-      throw new NotFoundException4(`BundleVersion '${existing.bundleVersionId}' nicht gefunden`);
+      throw new NotFoundException4({
+        code: CATALOG_ERROR_CODES2.BUNDLE_VERSION_NOT_FOUND,
+        message: `BundleVersion '${existing.bundleVersionId}' not found`,
+        params: {
+          bundleVersionId: existing.bundleVersionId
+        }
+      });
     }
     const blockers = [];
     const warnings = [];
     if (existing.canceledAt !== null) {
       blockers.push({
         code: "SUBSCRIPTION_BUNDLE_ALREADY_CANCELED",
-        message: "Diese Bundle-Buchung ist bereits gek\xFCndigt."
+        message: "This bundle booking is already cancelled."
       });
     }
     const effectiveAt = resolveBundleCancelEffectiveAt({
@@ -2754,7 +2923,7 @@ var SubscriptionBundlePreviewService = class {
     if (existing.minimumTermEndsAt && existing.minimumTermEndsAt.getTime() > periodEnd.getTime()) {
       warnings.push({
         code: "MINIMUM_TERM_BINDS",
-        message: "Die Mindestlaufzeit bindet \xFCber das Periodenende hinaus \u2014 die K\xFCndigung wirkt erst zum Mindestlaufzeit-Ende."
+        message: "The minimum term extends beyond the end of the period \u2014 the cancellation only takes effect when the minimum term ends."
       });
     }
     return {
@@ -2773,26 +2942,26 @@ var SubscriptionBundlePreviewService = class {
     if (bundleVersion.publishedAt === null) {
       blockers.push({
         code: "BUNDLE_VERSION_NOT_PUBLISHED",
-        message: "Diese BundleVersion ist nicht ver\xF6ffentlicht und nicht buchbar."
+        message: "This bundle version is not published and cannot be booked."
       });
     }
     if (bundleVersion.supersededAt !== null) {
       blockers.push({
         code: "BUNDLE_VERSION_SUPERSEDED",
-        message: "Diese BundleVersion wurde durch eine Nachfolge-Version abgel\xF6st."
+        message: "This bundle version has been superseded by a newer one."
       });
     }
     const planIds = bundleVersion.compatibility?.planIds ?? [];
     if (planIds.length > 0 && !planIds.includes(currentPlanKey)) {
       blockers.push({
         code: "BUNDLE_INCOMPATIBLE_WITH_PLAN",
-        message: `Das Bundle ist nicht mit Plan '${currentPlanKey}' kompatibel. Erlaubt: [${planIds.join(", ")}].`
+        message: `The bundle is not compatible with plan '${currentPlanKey}'. Allowed: [${planIds.join(", ")}].`
       });
     }
     if (this.blockedBundles?.bundleKeys?.includes(bundleVersion.bundleKey)) {
       blockers.push({
         code: "BUNDLE_NOT_SELF_SERVICE",
-        message: `Bundle '${bundleVersion.bundleKey}' wird nur per Sondervertrag aktiviert. Bitte den Vertragsbetreuer kontaktieren.`
+        message: `Bundle '${bundleVersion.bundleKey}' is only activated via a special contract. Please contact the contract manager.`
       });
     }
   }
@@ -2905,6 +3074,7 @@ import { Module as Module4 } from "@nestjs/common";
 
 // src/billing/tenant-subscription-bundles.controller.ts
 import { BadRequestException as BadRequestException2, Body as Body3, Controller as Controller4, Delete, Get as Get3, HttpCode as HttpCode2, HttpStatus as HttpStatus3, Inject as Inject13, Logger as Logger5, NotFoundException as NotFoundException5, Optional as Optional10, Param, ParseUUIDPipe, Post as Post3, Req as Req2, UseGuards as UseGuards3 } from "@nestjs/common";
+import { AUTH_ERROR_CODES as AUTH_ERROR_CODES5, BILLING_ERROR_CODES as BILLING_ERROR_CODES6 } from "@saasicat/types";
 
 // src/billing/dto/subscription-bundles.dto.ts
 import { IsInt, IsOptional as IsOptional4, IsUUID as IsUUID2, Matches as Matches3, Max, Min } from "class-validator";
@@ -2985,7 +3155,7 @@ var CancelSubscriptionBundleDto = class {
 _ts_decorate21([
   IsOptional4(),
   Matches3(ISO_DATE_PATTERN, {
-    message: "canceledAt muss ISO-Datum sein (YYYY-MM-DD)"
+    message: "canceledAt must be an ISO date (YYYY-MM-DD)"
   }),
   _ts_metadata15("design:type", String)
 ], CancelSubscriptionBundleDto.prototype, "canceledAt", void 0);
@@ -3049,7 +3219,10 @@ function buildTenantSubscriptionBundlesController(extraGuards = []) {
       const hasAdd = Boolean(dto.bundleVersionId);
       const hasCancel = Boolean(dto.subscriptionBundleId);
       if (hasAdd === hasCancel) {
-        throw new BadRequestException2("Genau eines von bundleVersionId (Add-Preview) oder subscriptionBundleId (Cancel-Preview) angeben.");
+        throw new BadRequestException2({
+          code: BILLING_ERROR_CODES6.BUNDLE_PREVIEW_ARGUMENT_AMBIGUOUS,
+          message: "Exactly one of bundleVersionId (add preview) or subscriptionBundleId (cancel preview) must be given."
+        });
       }
       const sub = await this.requireSubscription(this.requireTenantId(req));
       const ctx = {
@@ -3089,21 +3262,30 @@ function buildTenantSubscriptionBundlesController(extraGuards = []) {
     }
     requireSubscriptionPk(sub) {
       if (!sub.id) {
-        throw new NotFoundException5("SubscriptionUsageRecord ohne `id` \u2014 Adapter muss die Subscription-PK durchreichen (siehe SubscriptionUsageRecord.id).");
+        throw new NotFoundException5("SubscriptionUsageRecord without `id` \u2014 the adapter must return the subscription primary key (see SubscriptionUsageRecord.id).");
       }
       return sub.id;
     }
     requireTenantId(req) {
       const tenantId = this.tenantIdResolver(req);
       if (!tenantId) {
-        throw new NotFoundException5("Tenant-ID nicht im Request gefunden");
+        throw new NotFoundException5({
+          code: AUTH_ERROR_CODES5.TENANT_CONTEXT_MISSING,
+          message: "No tenant ID found on the request"
+        });
       }
       return tenantId;
     }
     async requireSubscription(tenantId) {
       const sub = await this.subscriptionUsage.findForTenant(tenantId);
       if (!sub) {
-        throw new NotFoundException5(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+        throw new NotFoundException5({
+          code: BILLING_ERROR_CODES6.SUBSCRIPTION_NOT_FOUND,
+          message: `No subscription for tenant ${tenantId}`,
+          params: {
+            tenantId
+          }
+        });
       }
       return sub;
     }
@@ -3122,7 +3304,7 @@ function buildTenantSubscriptionBundlesController(extraGuards = []) {
       try {
         await this.contractFreeze.freezeOnPlanChange(tenantId, sub.planVersion.planId, sub.billingCycle, /* @__PURE__ */ new Date());
       } catch (err) {
-        this.logger.error(`Contract-Freeze nach Bundle-Mutation fehlgeschlagen (tenant ${tenantId}): ${String(err)}`);
+        this.logger.error(`Contract freeze after bundle mutation failed (tenant ${tenantId}): ${String(err)}`);
       }
     }
   };