@saasicat/nest 0.2.0

package/dist/chunk-YXGHPILG.js

@@ -0,0 +1,614 @@
+import {
+  PLAN_CATALOG_TOKEN,
+  isFeaturePlannedOnly
+} from "./chunk-MV6LW5UB.js";
+import {
+  SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN
+} from "./chunk-NYLON2VC.js";
+import {
+  ENTITLEMENT_RESOLUTION_CONFIG_TOKEN,
+  PLAN_VERSION_REPOSITORY_TOKEN,
+  SUBSCRIPTION_REPOSITORY_TOKEN,
+  TRANSACTION_RUNNER_TOKEN
+} from "./chunk-7MLGHWKO.js";
+import {
+  BUNDLE_REPOSITORY_TOKEN
+} from "./chunk-XCZ3TTFK.js";
+import {
+  asProvider
+} from "./chunk-SABTXESR.js";
+import {
+  DISCOVERY_SNAPSHOT_TOKEN
+} from "./chunk-L4SUWH5B.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/billing/subscription-bundles.tokens.ts
+var SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/SubscriptionBundleRepository");
+var SUBSCRIPTION_BUNDLE_CONFIG_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/SubscriptionBundleConfig");
+
+// src/entitlement/aggregation.ts
+function aggregateBusinessTypeQuotas(snapshot) {
+  const sums = {};
+  for (const bundle of snapshot.bundles) {
+    for (const [key, value] of Object.entries(bundle.quotas)) {
+      if (sums[key] === -1 || value === -1) {
+        sums[key] = -1;
+      } else {
+        sums[key] = (sums[key] ?? 0) + value;
+      }
+    }
+  }
+  for (const [key, value] of Object.entries(snapshot.quotaOverrides)) {
+    if (value !== void 0) {
+      sums[key] = value;
+    }
+  }
+  return sums;
+}
+__name(aggregateBusinessTypeQuotas, "aggregateBusinessTypeQuotas");
+function filterActiveSubscriptionBundles(bundles, now) {
+  return bundles.filter((b) => b.canceledEffectiveAt === null || b.canceledEffectiveAt > now);
+}
+__name(filterActiveSubscriptionBundles, "filterActiveSubscriptionBundles");
+function aggregateSubscriptionBundleQuotas(bundles) {
+  const sums = {};
+  for (const bundle of bundles) {
+    for (const [key, value] of Object.entries(bundle.quotas)) {
+      if (sums[key] === -1 || value === -1) {
+        sums[key] = -1;
+      } else {
+        sums[key] = (sums[key] ?? 0) + value;
+      }
+    }
+  }
+  return sums;
+}
+__name(aggregateSubscriptionBundleQuotas, "aggregateSubscriptionBundleQuotas");
+function collectSubscriptionBundleFeatures(bundles) {
+  const set = /* @__PURE__ */ new Set();
+  for (const bundle of bundles) {
+    for (const f of bundle.features) set.add(f);
+  }
+  return Array.from(set);
+}
+__name(collectSubscriptionBundleFeatures, "collectSubscriptionBundleFeatures");
+function aggregateContractLineItemEntitlements(lineItems, fallbackPlan = "UNKNOWN") {
+  const planItem = lineItems.find((item) => item.kind === "plan");
+  const plan = planItem?.sourceKey ?? fallbackPlan;
+  const quotas = {};
+  const features = /* @__PURE__ */ new Set();
+  for (const item of lineItems) {
+    for (const feature of item.featuresSnapshot) {
+      features.add(feature);
+    }
+    for (const [key, value] of Object.entries(item.quotaEffectsSnapshot)) {
+      if (quotas[key] === -1 || value === -1) {
+        quotas[key] = -1;
+      } else {
+        quotas[key] = (quotas[key] ?? 0) + value;
+      }
+    }
+  }
+  return {
+    plan,
+    quotas,
+    features
+  };
+}
+__name(aggregateContractLineItemEntitlements, "aggregateContractLineItemEntitlements");
+function collectBusinessTypeFeatures(snapshot) {
+  const set = /* @__PURE__ */ new Set();
+  for (const bundle of snapshot.bundles) {
+    for (const f of bundle.features) {
+      set.add(f);
+    }
+  }
+  return Array.from(set);
+}
+__name(collectBusinessTypeFeatures, "collectBusinessTypeFeatures");
+function filterPlannedOnlyFeatures(features, catalog) {
+  const out = /* @__PURE__ */ new Set();
+  for (const f of features) {
+    if (!isFeaturePlannedOnly(catalog, f)) {
+      out.add(f);
+    }
+  }
+  return out;
+}
+__name(filterPlannedOnlyFeatures, "filterPlannedOnlyFeatures");
+function applyCustomLimits(base, custom) {
+  if (!custom) return base;
+  const quotas = {
+    ...base.quotas
+  };
+  if (custom.quotas) {
+    for (const [k, v] of Object.entries(custom.quotas)) {
+      quotas[k] = v;
+    }
+  }
+  const features = new Set(base.features);
+  if (custom.features) {
+    for (const f of custom.features) features.add(f);
+  }
+  return {
+    plan: base.plan,
+    quotas,
+    features
+  };
+}
+__name(applyCustomLimits, "applyCustomLimits");
+function aggregateLimits(input, catalog, now) {
+  const businessTypeQuotas = input.businessTypeVersion ? aggregateBusinessTypeQuotas(input.businessTypeVersion) : {};
+  const businessTypeFeatures = input.businessTypeVersion ? collectBusinessTypeFeatures(input.businessTypeVersion) : [];
+  const activeBundles = filterActiveSubscriptionBundles(input.subscriptionBundles ?? [], now);
+  const subBundleQuotas = aggregateSubscriptionBundleQuotas(activeBundles);
+  const subBundleFeatures = collectSubscriptionBundleFeatures(activeBundles);
+  const quotas = {};
+  for (const [k, v] of Object.entries(input.planVersion.quotas)) {
+    quotas[k] = v;
+  }
+  for (const [k, v] of Object.entries(businessTypeQuotas)) {
+    if (quotas[k] === -1 || v === -1) {
+      quotas[k] = -1;
+    } else {
+      quotas[k] = (quotas[k] ?? 0) + v;
+    }
+  }
+  for (const [k, v] of Object.entries(subBundleQuotas)) {
+    if (quotas[k] === -1 || v === -1) {
+      quotas[k] = -1;
+    } else {
+      quotas[k] = (quotas[k] ?? 0) + v;
+    }
+  }
+  const features = /* @__PURE__ */ new Set([
+    ...input.planVersion.features,
+    ...businessTypeFeatures,
+    ...subBundleFeatures
+  ]);
+  const withCustom = applyCustomLimits({
+    plan: input.plan,
+    quotas,
+    features
+  }, input.customLimits);
+  const filteredFeatures = filterPlannedOnlyFeatures(withCustom.features, catalog);
+  return {
+    plan: withCustom.plan,
+    quotas: withCustom.quotas,
+    features: filteredFeatures
+  };
+}
+__name(aggregateLimits, "aggregateLimits");
+function hasFeature(limits, feature) {
+  return limits.features.has(feature);
+}
+__name(hasFeature, "hasFeature");
+function hasAnyFeature(limits, features) {
+  return features.some((f) => limits.features.has(f));
+}
+__name(hasAnyFeature, "hasAnyFeature");
+function toEffectiveLimitsSnapshot(limits) {
+  return {
+    plan: limits.plan,
+    quotas: {
+      ...limits.quotas
+    },
+    features: Array.from(limits.features).sort()
+  };
+}
+__name(toEffectiveLimitsSnapshot, "toEffectiveLimitsSnapshot");
+
+// src/entitlement/feature-aliases.ts
+function buildReplacedByIndex(features) {
+  const index = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    for (const oldKey of feature.replaces ?? []) {
+      if (oldKey === feature.featureKey) continue;
+      const list = index.get(oldKey) ?? [];
+      list.push(feature.featureKey);
+      index.set(oldKey, list);
+    }
+  }
+  for (const list of index.values()) list.sort((a, b) => a.localeCompare(b));
+  assertNoReplacesCycle(index);
+  return index;
+}
+__name(buildReplacedByIndex, "buildReplacedByIndex");
+function expandReplacedFeatures(granted, index) {
+  const expanded = new Set(granted);
+  const worklist = [
+    ...granted
+  ];
+  while (worklist.length > 0) {
+    const key = worklist.pop();
+    for (const successor of index.get(key) ?? []) {
+      if (expanded.has(successor)) continue;
+      expanded.add(successor);
+      worklist.push(successor);
+    }
+  }
+  return expanded;
+}
+__name(expandReplacedFeatures, "expandReplacedFeatures");
+function assertNoReplacesCycle(index) {
+  const DONE = 2;
+  const IN_PROGRESS = 1;
+  const state = /* @__PURE__ */ new Map();
+  const visit = /* @__PURE__ */ __name((key, path) => {
+    const s = state.get(key);
+    if (s === DONE) return;
+    if (s === IN_PROGRESS) {
+      const cycleStart = path.indexOf(key);
+      const cycle = [
+        ...path.slice(cycleStart),
+        key
+      ].join(" \u2192 ");
+      throw new Error(`replaces-Zyklus in den Discovery-Metadaten: ${cycle}. Feature-Ersetzungen m\xFCssen azyklisch sein \u2014 replaces-Deklarationen im Code korrigieren (#39).`);
+    }
+    state.set(key, IN_PROGRESS);
+    for (const successor of index.get(key) ?? []) {
+      visit(successor, [
+        ...path,
+        key
+      ]);
+    }
+    state.set(key, DONE);
+  }, "visit");
+  for (const key of index.keys()) visit(key, []);
+}
+__name(assertNoReplacesCycle, "assertNoReplacesCycle");
+
+// src/entitlement/limit-exceeded-error.ts
+var LimitExceededError = class extends Error {
+  static {
+    __name(this, "LimitExceededError");
+  }
+  dimension;
+  max;
+  used;
+  constructor(dimension, max, used) {
+    super(`Limit f\xFCr ${dimension} erreicht: ${used}/${max}.`), this.dimension = dimension, this.max = max, this.used = used;
+    this.name = "LimitExceededError";
+  }
+};
+
+// src/entitlement/plan-resolution.ts
+function resolveEntitlementPlan(input, config, now) {
+  if (input.isPilot && config.pilotEntitlementPlan !== void 0) {
+    return config.pilotEntitlementPlan;
+  }
+  if (input.status === "TRIAL") {
+    return input.trialEntitlementPlan ?? config.defaultTrialEntitlementPlan ?? input.plan;
+  }
+  if (input.status === "PENDING_SALES" && config.pendingSalesEntitlementPlan !== void 0) {
+    return config.pendingSalesEntitlementPlan;
+  }
+  if (input.pendingPlan && input.pendingEffectiveAt && input.pendingEffectiveAt <= now) {
+    return input.pendingPlan;
+  }
+  return input.plan;
+}
+__name(resolveEntitlementPlan, "resolveEntitlementPlan");
+
+// src/entitlement/service.ts
+import { Inject, Injectable, NotFoundException, Optional } from "@nestjs/common";
+function _ts_decorate(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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var CACHE_TTL_MS = 6e4;
+var CACHE_MAX_ENTRIES = 1e3;
+var EntitlementService = class {
+  static {
+    __name(this, "EntitlementService");
+  }
+  catalog;
+  subscriptions;
+  planVersions;
+  tx;
+  resolutionConfig;
+  subscriptionBundles;
+  bundles;
+  subscriptionContracts;
+  discoverySnapshot;
+  // Map preserves insert order — on a hit the entry is removed and
+  // re-inserted (LRU). The TTL is a safety net for forgotten
+  // invalidations — 60s is enough, because limits generally only change
+  // through mutations, not through time (a pending plan's effective date
+  // is day-granular).
+  cache = /* @__PURE__ */ new Map();
+  // #39 — replaces alias index, built lazily from the boot-static snapshot;
+  // throws on replaces cycles (a clear error instead of an infinite loop).
+  replacedByIndex = null;
+  constructor(catalog, subscriptions, planVersions, tx, resolutionConfig = null, subscriptionBundles = null, bundles = null, subscriptionContracts = null, discoverySnapshot = null) {
+    this.catalog = catalog;
+    this.subscriptions = subscriptions;
+    this.planVersions = planVersions;
+    this.tx = tx;
+    this.resolutionConfig = resolutionConfig;
+    this.subscriptionBundles = subscriptionBundles;
+    this.bundles = bundles;
+    this.subscriptionContracts = subscriptionContracts;
+    this.discoverySnapshot = discoverySnapshot;
+  }
+  // ---------------------------------------------------------------------
+  // Read path — for FeatureGuard, sidebar hooks, GET /billing/entitlement
+  // ---------------------------------------------------------------------
+  async computeLimits(tenantId, now = /* @__PURE__ */ new Date()) {
+    const cached = this.readCache(tenantId, now.getTime());
+    if (cached) return cached;
+    const sub = await this.subscriptions.findByTenantId(tenantId);
+    if (!sub) {
+      throw new NotFoundException(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+    }
+    const limits = await this.deriveLimits(sub, now);
+    this.writeCache(tenantId, limits, now.getTime());
+    return limits;
+  }
+  /**
+   * Clears a tenant's cache entry. MUST be called as soon as a mutation
+   * changes the subscription, a bundle booking, or a PlanVersion binding —
+   * otherwise FeatureGuard and the sidebar stay on stale state for up to
+   * 60s.
+   */
+  invalidateTenant(tenantId) {
+    this.cache.delete(tenantId);
+  }
+  /** Clears the entire cache. Only for tests / bootstrap. */
+  invalidateAll() {
+    this.cache.clear();
+  }
+  /**
+   * Aggregator path — also callable directly by consumers that already
+   * have a `SubscriptionRecord` (e.g. within a transaction).
+   */
+  async deriveLimits(sub, now, tx) {
+    const contractLimits = await this.deriveLimitsFromContract(sub.tenantId, now);
+    if (contractLimits) return this.withReplacedFeatureAliases(contractLimits);
+    const effectivePlan = resolveEntitlementPlan(sub, this.resolutionConfig ?? {}, now);
+    const planVersion = effectivePlan === sub.plan ? sub.planVersion : await this.findActivePlanVersionOrFallback(effectivePlan, now, tx);
+    const subscriptionBundles = await this.loadSubscriptionBundleSnapshots(sub.id, now);
+    return this.withReplacedFeatureAliases(aggregateLimits({
+      plan: effectivePlan,
+      planVersion,
+      subscriptionBundles,
+      customLimits: sub.customLimits ?? null
+    }, this.catalog, now));
+  }
+  /**
+   * Grandfathering (#39): granted old feature keys transitively grant
+   * their successors from the `replaces` chains of the discovery snapshot.
+   * A no-op without a snapshot or without replaces declarations.
+   */
+  withReplacedFeatureAliases(limits) {
+    if (!this.discoverySnapshot) return limits;
+    if (!this.replacedByIndex) {
+      this.replacedByIndex = buildReplacedByIndex(this.discoverySnapshot.features);
+    }
+    if (this.replacedByIndex.size === 0) return limits;
+    return {
+      ...limits,
+      features: expandReplacedFeatures(limits.features, this.replacedByIndex)
+    };
+  }
+  async deriveLimitsFromContract(tenantId, now) {
+    if (!this.subscriptionContracts) return null;
+    const contract = await this.subscriptionContracts.findActiveByTenantId(tenantId, now);
+    if (!contract) return null;
+    if (contract.entitlementSnapshot) {
+      return {
+        plan: contract.entitlementSnapshot.plan,
+        quotas: {
+          ...contract.entitlementSnapshot.quotas
+        },
+        features: new Set(contract.entitlementSnapshot.features)
+      };
+    }
+    return aggregateContractLineItemEntitlements(contract.lineItems);
+  }
+  /**
+   * Loads a subscription's active bundle bookings and resolves the
+   * `BundleVersion` features/quotas per entry. Without a registered
+   * `SubscriptionBundleRepository` or `BundleRepository` the method
+   * returns an empty list — apps without a bundle schema stay unchanged
+   * (plan-only aggregation).
+   */
+  async loadSubscriptionBundleSnapshots(subscriptionId, now) {
+    if (!this.subscriptionBundles || !this.bundles) return [];
+    const active = await this.subscriptionBundles.listActiveBySubscription(subscriptionId, now);
+    if (active.length === 0) return [];
+    return Promise.all(active.map(async (booking) => {
+      const bv = await this.bundles.findVersionById(booking.bundleVersionId);
+      if (!bv) {
+        throw new Error(`BundleVersion '${booking.bundleVersionId}' aus aktiver SubscriptionBundle nicht gefunden`);
+      }
+      return {
+        bundleKey: bv.bundleKey,
+        features: bv.features,
+        quotas: bv.quotas,
+        canceledEffectiveAt: booking.canceledEffectiveAt
+      };
+    }));
+  }
+  // ---------------------------------------------------------------------
+  // Write/consumption path — row lock + count + insert in the same
+  // transaction. Protects against race conditions on concurrent creations
+  // for the same tenant.
+  // ---------------------------------------------------------------------
+  async enforceLimit(input) {
+    const now = input.now ?? /* @__PURE__ */ new Date();
+    const delta = input.delta ?? 1;
+    return this.tx.run(async (tx) => {
+      const sub = await this.subscriptions.findByTenantIdLocked(input.tenantId, tx);
+      if (!sub) {
+        throw new NotFoundException(`Keine Subscription f\xFCr Tenant ${input.tenantId}`);
+      }
+      const limits = await this.deriveLimits(sub, now, tx);
+      const max = limits.quotas[input.dimension];
+      if (max === void 0) {
+        throw new Error(`Quota-Dimension "${input.dimension}" nicht im PlanCatalog (${this.catalog.projectKey}).`);
+      }
+      const used = await input.currentUsage(tx, input.tenantId);
+      if (max !== -1 && used + delta > max) {
+        throw new LimitExceededError(input.dimension, max, used);
+      }
+      return input.insert(tx);
+    });
+  }
+  // ---------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------
+  /**
+   * Plan fallback for TRIAL/PENDING_SALES: returns the PlanVersion active
+   * as of `asOf` (SPEC_V2 §4.2). If the repo does not implement
+   * `findActive`, we fall back to `findLatestLive` (backward compat for
+   * adapters without `validFrom` columns).
+   */
+  async findActivePlanVersionOrFallback(planId, asOf, tx) {
+    const v = this.planVersions.findActive ? await this.planVersions.findActive(planId, asOf, tx) : await this.planVersions.findLatestLive(planId, tx);
+    if (!v) {
+      throw new NotFoundException(`Keine zu ${asOf.toISOString().slice(0, 10)} aktive PlanVersion f\xFCr ${planId} \u2014 weder validFrom-window erf\xFCllt noch latest-live verf\xFCgbar.`);
+    }
+    return v;
+  }
+  readCache(tenantId, nowMs) {
+    const entry = this.cache.get(tenantId);
+    if (!entry) return null;
+    if (entry.expiresAt < nowMs) {
+      this.cache.delete(tenantId);
+      return null;
+    }
+    this.cache.delete(tenantId);
+    this.cache.set(tenantId, entry);
+    return entry.value;
+  }
+  writeCache(tenantId, value, nowMs) {
+    if (this.cache.has(tenantId)) this.cache.delete(tenantId);
+    this.cache.set(tenantId, {
+      value,
+      expiresAt: nowMs + CACHE_TTL_MS
+    });
+    while (this.cache.size > CACHE_MAX_ENTRIES) {
+      const oldest = this.cache.keys().next().value;
+      if (oldest === void 0) break;
+      this.cache.delete(oldest);
+    }
+  }
+};
+EntitlementService = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(PLAN_CATALOG_TOKEN)),
+  _ts_param(1, Inject(SUBSCRIPTION_REPOSITORY_TOKEN)),
+  _ts_param(2, Inject(PLAN_VERSION_REPOSITORY_TOKEN)),
+  _ts_param(3, Inject(TRANSACTION_RUNNER_TOKEN)),
+  _ts_param(4, Optional()),
+  _ts_param(4, Inject(ENTITLEMENT_RESOLUTION_CONFIG_TOKEN)),
+  _ts_param(5, Optional()),
+  _ts_param(5, Inject(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param(6, Optional()),
+  _ts_param(6, Inject(BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param(7, Optional()),
+  _ts_param(7, Inject(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN)),
+  _ts_param(8, Optional()),
+  _ts_param(8, Inject(DISCOVERY_SNAPSHOT_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof PlanCatalog === "undefined" ? Object : PlanCatalog,
+    typeof SubscriptionRepository === "undefined" ? Object : SubscriptionRepository,
+    typeof PlanVersionRepository === "undefined" ? Object : PlanVersionRepository,
+    typeof TransactionRunner === "undefined" ? Object : TransactionRunner,
+    Object,
+    Object,
+    Object,
+    Object,
+    Object
+  ])
+], EntitlementService);
+
+// src/entitlement/module.ts
+import { Module } from "@nestjs/common";
+function _ts_decorate2(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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var EntitlementModule = class _EntitlementModule {
+  static {
+    __name(this, "EntitlementModule");
+  }
+  static forRoot(options) {
+    const providers = [
+      asProvider(SUBSCRIPTION_REPOSITORY_TOKEN, options.subscriptionRepository),
+      asProvider(PLAN_VERSION_REPOSITORY_TOKEN, options.planVersionRepository),
+      asProvider(TRANSACTION_RUNNER_TOKEN, options.transactionRunner),
+      EntitlementService
+    ];
+    if (options.resolutionConfig) {
+      providers.push({
+        provide: ENTITLEMENT_RESOLUTION_CONFIG_TOKEN,
+        useValue: options.resolutionConfig
+      });
+    }
+    if (options.subscriptionContractRepository) {
+      providers.push(asProvider(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN, options.subscriptionContractRepository));
+    }
+    if (options.subscriptionBundleRepository) {
+      providers.push(asProvider(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN, options.subscriptionBundleRepository));
+    }
+    if (options.bundleRepository) {
+      providers.push(asProvider(BUNDLE_REPOSITORY_TOKEN, options.bundleRepository));
+    }
+    return {
+      module: _EntitlementModule,
+      global: options.global ?? false,
+      providers,
+      exports: [
+        EntitlementService,
+        SUBSCRIPTION_REPOSITORY_TOKEN
+      ]
+    };
+  }
+};
+EntitlementModule = _ts_decorate2([
+  Module({})
+], EntitlementModule);
+
+export {
+  SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN,
+  SUBSCRIPTION_BUNDLE_CONFIG_TOKEN,
+  aggregateBusinessTypeQuotas,
+  filterActiveSubscriptionBundles,
+  aggregateSubscriptionBundleQuotas,
+  collectSubscriptionBundleFeatures,
+  aggregateContractLineItemEntitlements,
+  collectBusinessTypeFeatures,
+  filterPlannedOnlyFeatures,
+  applyCustomLimits,
+  aggregateLimits,
+  hasFeature,
+  hasAnyFeature,
+  toEffectiveLimitsSnapshot,
+  buildReplacedByIndex,
+  expandReplacedFeatures,
+  LimitExceededError,
+  resolveEntitlementPlan,
+  EntitlementService,
+  EntitlementModule
+};