@saasicat/nest 0.2.0

package/dist/chunk-Q53N43LQ.js

@@ -0,0 +1,13 @@
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/billing/require-feature.decorator.ts
+import { SetMetadata } from "@nestjs/common";
+var REQUIRE_FEATURE_KEY = "require-feature";
+var RequireFeature = /* @__PURE__ */ __name((...features) => SetMetadata(REQUIRE_FEATURE_KEY, features), "RequireFeature");
+
+export {
+  REQUIRE_FEATURE_KEY,
+  RequireFeature
+};

package/dist/chunk-QJVPRD3R.js

@@ -0,0 +1,573 @@
+import {
+  ADMIN_MANIFEST_CONFIG,
+  AdminManifestModule,
+  AdminModule
+} from "./chunk-P6MYZMXQ.js";
+import {
+  REQUIRE_FEATURE_KEY
+} from "./chunk-Q53N43LQ.js";
+import {
+  DiscoveryModule
+} from "./chunk-AJ3EPELS.js";
+import {
+  EntitlementModule,
+  LimitExceededError
+} from "./chunk-YXGHPILG.js";
+import {
+  PLAN_CATALOG_TOKEN,
+  PlanCatalogModule
+} from "./chunk-MV6LW5UB.js";
+import {
+  asProvider
+} from "./chunk-SABTXESR.js";
+import {
+  ENFORCE_QUOTA_KEY
+} from "./chunk-L4SUWH5B.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/platform/plan-resolver.port.ts
+var PLAN_RESOLVER_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform-nest/PlanResolverPort");
+var StaticPlanResolver = class {
+  static {
+    __name(this, "StaticPlanResolver");
+  }
+  planId;
+  constructor(planId) {
+    this.planId = planId;
+  }
+  async getPlanIdForTenant() {
+    return this.planId;
+  }
+};
+
+// src/platform/static-entitlement.service.ts
+import { Inject, Injectable } 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 StaticEntitlementService = class {
+  static {
+    __name(this, "StaticEntitlementService");
+  }
+  catalog;
+  resolver;
+  constructor(catalog, resolver) {
+    this.catalog = catalog;
+    this.resolver = resolver;
+  }
+  /**
+   * Returns the effective features + quotas of a tenant from the
+   * plan catalog. When the plan is missing: an empty snapshot (no feature,
+   * all quotas at 0).
+   */
+  async snapshot(tenantId) {
+    const planId = await this.resolver.getPlanIdForTenant(tenantId);
+    if (!planId) {
+      return {
+        planId: null,
+        features: [],
+        quotas: {}
+      };
+    }
+    const plan = this.findPlan(planId);
+    if (!plan) {
+      return {
+        planId,
+        features: [],
+        quotas: {}
+      };
+    }
+    return {
+      planId,
+      features: plan.features ?? [],
+      quotas: plan.quotas ?? {}
+    };
+  }
+  /** Convenience helper for tests / synchronous checks in the UI manifest. */
+  async hasFeature(tenantId, featureKey) {
+    const snap = await this.snapshot(tenantId);
+    return snap.features.includes(featureKey);
+  }
+  async quotaLimit(tenantId, quotaKey) {
+    const snap = await this.snapshot(tenantId);
+    const value = snap.quotas[quotaKey];
+    return value === void 0 ? null : value;
+  }
+  findPlan(planId) {
+    return (this.catalog.plans ?? []).find((p) => p.id === planId);
+  }
+};
+StaticEntitlementService = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(PLAN_CATALOG_TOKEN)),
+  _ts_param(1, Inject(PLAN_RESOLVER_PORT_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof PlanCatalog === "undefined" ? Object : PlanCatalog,
+    typeof PlanResolverPort === "undefined" ? Object : PlanResolverPort
+  ])
+], StaticEntitlementService);
+
+// src/platform/static-feature.guard.ts
+import { ForbiddenException, Inject as Inject2, Injectable as Injectable2, Optional } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+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");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var STATIC_FEATURE_GUARD_CONFIG_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform-nest/StaticFeatureGuardConfig");
+var StaticFeatureGuard = class {
+  static {
+    __name(this, "StaticFeatureGuard");
+  }
+  reflector;
+  entitlements;
+  config;
+  constructor(reflector, entitlements, config = null) {
+    this.reflector = reflector;
+    this.entitlements = entitlements;
+    this.config = config;
+  }
+  async canActivate(context) {
+    const required = this.reflector.getAllAndOverride(REQUIRE_FEATURE_KEY, [
+      context.getHandler(),
+      context.getClass()
+    ]);
+    if (!required || required.length === 0) return true;
+    const request = context.switchToHttp().getRequest();
+    const user = request.user;
+    if (!user) throw new ForbiddenException("Nicht authentifiziert");
+    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");
+    const snap = await this.entitlements.snapshot(tenantId);
+    const allowed = required.some((f) => snap.features.includes(f));
+    if (!allowed) {
+      throw new ForbiddenException(`Feature ${required.join(" / ")} nicht im aktuellen Plan enthalten.`);
+    }
+    return true;
+  }
+};
+StaticFeatureGuard = _ts_decorate2([
+  Injectable2(),
+  _ts_param2(0, Inject2(Reflector)),
+  _ts_param2(1, Inject2(StaticEntitlementService)),
+  _ts_param2(2, Optional()),
+  _ts_param2(2, Inject2(STATIC_FEATURE_GUARD_CONFIG_TOKEN)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof Reflector === "undefined" ? Object : Reflector,
+    typeof StaticEntitlementService === "undefined" ? Object : StaticEntitlementService,
+    Object
+  ])
+], StaticFeatureGuard);
+
+// src/platform/enforce-quota.interceptor.ts
+import { Inject as Inject3, Injectable as Injectable3, Optional as Optional2 } from "@nestjs/common";
+import { Reflector as Reflector2 } from "@nestjs/core";
+import { from } from "rxjs";
+import { switchMap } from "rxjs/operators";
+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);
+  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_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var QUOTA_PROVIDERS_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform-nest/QuotaProviders");
+var EnforceQuotaInterceptor = class {
+  static {
+    __name(this, "EnforceQuotaInterceptor");
+  }
+  reflector;
+  entitlements;
+  providers;
+  constructor(reflector, entitlements, providers = null) {
+    this.reflector = reflector;
+    this.entitlements = entitlements;
+    this.providers = providers;
+  }
+  intercept(context, next) {
+    const meta = this.reflector.getAllAndOverride(ENFORCE_QUOTA_KEY, [
+      context.getHandler(),
+      context.getClass()
+    ]);
+    if (!meta?.quotaKey) return next.handle();
+    return from(this.check(context, meta)).pipe(switchMap(() => next.handle()));
+  }
+  async check(context, meta) {
+    const request = context.switchToHttp().getRequest();
+    const user = request.user;
+    if (!user) return;
+    const role = user.role ?? user.platformRole;
+    if (role === "SUPER_ADMIN") return;
+    const tenantId = request.tenantId ?? user.tenantId;
+    if (!tenantId) return;
+    const provider = (this.providers ?? []).find((p) => p.key === meta.quotaKey);
+    if (!provider) {
+      return;
+    }
+    const limit = await this.entitlements.quotaLimit(tenantId, meta.quotaKey);
+    if (limit === null || limit === -1) return;
+    const current = await provider.count(tenantId);
+    const delta = meta.incrementBy ?? 1;
+    if (current + delta > limit) {
+      throw new LimitExceededError(meta.quotaKey, limit, current);
+    }
+  }
+};
+EnforceQuotaInterceptor = _ts_decorate3([
+  Injectable3(),
+  _ts_param3(0, Inject3(Reflector2)),
+  _ts_param3(1, Inject3(StaticEntitlementService)),
+  _ts_param3(2, Optional2()),
+  _ts_param3(2, Inject3(QUOTA_PROVIDERS_TOKEN)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Reflector2 === "undefined" ? Object : Reflector2,
+    typeof StaticEntitlementService === "undefined" ? Object : StaticEntitlementService,
+    Object
+  ])
+], EnforceQuotaInterceptor);
+
+// src/platform/tenant-manifest.service.ts
+import { Injectable as Injectable4 } from "@nestjs/common";
+function _ts_decorate4(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_decorate4, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+var TenantManifestService = class {
+  static {
+    __name(this, "TenantManifestService");
+  }
+  entitlements;
+  navItems = [];
+  constructor(entitlements) {
+    this.entitlements = entitlements;
+  }
+  /**
+   * Call in the app's `OnModuleInit`: registers app navigation for the
+   * Tenant UI. Idempotent: the same `id` overwrites.
+   */
+  registerNavItem(item) {
+    const existing = this.navItems.findIndex((i) => i.id === item.id);
+    if (existing >= 0) this.navItems[existing] = item;
+    else this.navItems.push(item);
+  }
+  /** Bulk variant. */
+  registerNavItems(items) {
+    for (const item of items) this.registerNavItem(item);
+  }
+  /**
+   * Returns the filtered manifest for a Tenant. NavItems with
+   * `requiresFeature` are filtered out server-side as soon as none of the
+   * required features are present in the entitlement snapshot.
+   */
+  async getManifest(tenantId) {
+    const snap = await this.entitlements.snapshot(tenantId);
+    const featureSet = new Set(snap.features);
+    const visible = this.navItems.filter((item) => isVisible(item, featureSet)).map((item) => ({
+      ...item
+    })).sort((a, b) => (a.order ?? 100) - (b.order ?? 100));
+    return {
+      schemaVersion: 1,
+      tenant: {
+        id: tenantId
+      },
+      planId: snap.planId,
+      features: snap.features,
+      quotas: snap.quotas,
+      navigation: visible
+    };
+  }
+};
+TenantManifestService = _ts_decorate4([
+  Injectable4(),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof StaticEntitlementService === "undefined" ? Object : StaticEntitlementService
+  ])
+], TenantManifestService);
+function isVisible(item, features) {
+  if (!item.requiresFeature) return true;
+  const required = Array.isArray(item.requiresFeature) ? item.requiresFeature : [
+    item.requiresFeature
+  ];
+  return required.some((f) => features.has(f));
+}
+__name(isVisible, "isVisible");
+
+// src/platform/tenant-manifest.controller.ts
+import { Controller, Get, Inject as Inject4, Req, UseGuards } from "@nestjs/common";
+function _ts_decorate5(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_decorate5, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+function buildTenantManifestController(options) {
+  const path = options.path ?? "tenant/manifest";
+  let GeneratedTenantManifestController = class GeneratedTenantManifestController {
+    static {
+      __name(this, "GeneratedTenantManifestController");
+    }
+    svc;
+    constructor(svc) {
+      this.svc = svc;
+    }
+    async get(req) {
+      const tenantId = req.user?.tenantId ?? req.tenantId;
+      if (!tenantId) {
+        throw new Error("Kein Mandant im Request \u2014 TenantManifest braucht user.tenantId.");
+      }
+      return this.svc.getManifest(tenantId);
+    }
+  };
+  _ts_decorate5([
+    Get(),
+    _ts_param4(0, Req()),
+    _ts_metadata5("design:type", Function),
+    _ts_metadata5("design:paramtypes", [
+      typeof RequestWithUser === "undefined" ? Object : RequestWithUser
+    ]),
+    _ts_metadata5("design:returntype", Promise)
+  ], GeneratedTenantManifestController.prototype, "get", null);
+  GeneratedTenantManifestController = _ts_decorate5([
+    Controller(path),
+    UseGuards(...options.guards),
+    _ts_param4(0, Inject4(TenantManifestService)),
+    _ts_metadata5("design:type", Function),
+    _ts_metadata5("design:paramtypes", [
+      typeof TenantManifestService === "undefined" ? Object : TenantManifestService
+    ])
+  ], GeneratedTenantManifestController);
+  return GeneratedTenantManifestController;
+}
+__name(buildTenantManifestController, "buildTenantManifestController");
+
+// src/platform/saas-platform.module.ts
+import { Module } from "@nestjs/common";
+import { APP_GUARD, APP_INTERCEPTOR } from "@nestjs/core";
+function _ts_decorate6(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_decorate6, "_ts_decorate");
+function buildMinimalManifestConfig() {
+  return {
+    useFactory: /* @__PURE__ */ __name((catalog) => ({
+      project: {
+        key: catalog.projectKey,
+        displayName: catalog.app?.name ?? catalog.projectKey,
+        label: catalog.app?.label,
+        icon: catalog.app?.icon,
+        logoUrl: catalog.app?.logoUrl,
+        environment: process.env.NODE_ENV === "production" ? "production" : "development",
+        availableLocales: catalog.marketing?.availableLocales,
+        defaultLocale: catalog.marketing?.availableLocales?.[0]
+      },
+      build: {
+        platformPackageVersion: "0.0.0",
+        appVersion: "0.0.0"
+      },
+      planCatalogSnapshot: {
+        source: "saas-platform-module",
+        hash: "sha256-quickstart",
+        currency: catalog.currency,
+        vatRate: catalog.vatRate,
+        plans: catalog.plans ?? [],
+        features: catalog.features ?? []
+      }
+    }), "useFactory"),
+    inject: [
+      PLAN_CATALOG_TOKEN
+    ]
+  };
+}
+__name(buildMinimalManifestConfig, "buildMinimalManifestConfig");
+var SaasPlatformModule = class _SaasPlatformModule {
+  static {
+    __name(this, "SaasPlatformModule");
+  }
+  static forRoot(options) {
+    if (!options.planCatalog && !options.adapters.planCatalogReadSink) {
+      throw new Error("SaasPlatformModule.forRoot: entweder `planCatalog` (Quickstart) oder `adapters.planCatalogReadSink` (DB-Hydration) muss gesetzt sein.");
+    }
+    if (options.entitlement) {
+      const missing = [];
+      if (!options.adapters.subscriptionRepository) missing.push("subscriptionRepository");
+      if (!options.adapters.planVersionRepository) missing.push("planVersionRepository");
+      if (!options.adapters.transactionRunner) missing.push("transactionRunner");
+      if (missing.length) {
+        throw new Error(`SaasPlatformModule.forRoot: entitlement aktiv, aber Adapter fehlen: ${missing.join(", ")}`);
+      }
+    }
+    const planCatalogModule = options.planCatalog ? PlanCatalogModule.forRootWithCatalog(options.planCatalog, {
+      global: true
+    }) : PlanCatalogModule.forRoot({
+      projectKey: "",
+      currency: "",
+      vatRate: 0,
+      sink: options.adapters.planCatalogReadSink,
+      imports: options.imports
+    });
+    const appInfo = options.app ?? {
+      key: options.planCatalog?.projectKey ?? "app",
+      version: options.planCatalog?.app?.version ?? "0.0.0"
+    };
+    const imports = [
+      planCatalogModule,
+      DiscoveryModule.forRoot({
+        app: appInfo,
+        controller: {
+          guards: options.controller.guards
+        },
+        imports: options.imports,
+        snapshotPath: options.discoverySnapshotPath === void 0 ? "var/discovery-snapshot.json" : options.discoverySnapshotPath
+      }),
+      AdminModule.forRoot({
+        mfaPort: options.adapters.mfa,
+        auditPort: options.adapters.audit,
+        rlsBypassPort: options.adapters.rlsBypass,
+        global: true
+      }),
+      AdminManifestModule.forRoot({
+        config: options.adminManifestConfig ?? buildMinimalManifestConfig(),
+        guards: options.controller.guards,
+        reloadGuards: options.reloadGuards
+      })
+    ];
+    if (options.entitlement) {
+      imports.push(EntitlementModule.forRoot({
+        subscriptionRepository: options.adapters.subscriptionRepository,
+        planVersionRepository: options.adapters.planVersionRepository,
+        transactionRunner: options.adapters.transactionRunner,
+        resolutionConfig: options.entitlement.resolutionConfig
+      }));
+    }
+    const lightweightProviders = [];
+    const lightweightExports = [];
+    const hasResolver = !!options.adapters.planResolver;
+    const hasFallback = !!options.defaultPlanId;
+    if (hasResolver || hasFallback) {
+      lightweightProviders.push(hasResolver ? asProvider(PLAN_RESOLVER_PORT_TOKEN, options.adapters.planResolver) : {
+        provide: PLAN_RESOLVER_PORT_TOKEN,
+        useValue: new StaticPlanResolver(options.defaultPlanId)
+      }, StaticEntitlementService, StaticFeatureGuard, EnforceQuotaInterceptor, ...options.quotaProviders ?? [], {
+        provide: QUOTA_PROVIDERS_TOKEN,
+        useFactory: /* @__PURE__ */ __name((...providers) => providers, "useFactory"),
+        inject: options.quotaProviders ?? []
+      }, {
+        provide: APP_GUARD,
+        useExisting: StaticFeatureGuard
+      }, {
+        provide: APP_INTERCEPTOR,
+        useExisting: EnforceQuotaInterceptor
+      });
+      lightweightExports.push(PLAN_RESOLVER_PORT_TOKEN, StaticEntitlementService, StaticFeatureGuard, EnforceQuotaInterceptor, QUOTA_PROVIDERS_TOKEN);
+    }
+    const tenantControllers = [];
+    if (options.tenantManifest) {
+      if (!hasResolver && !hasFallback) {
+        throw new Error("SaasPlatformModule.forRoot: tenantManifest erfordert defaultPlanId oder adapters.planResolver, sonst kann das Manifest keine Features aufl\xF6sen.");
+      }
+      lightweightProviders.push(TenantManifestService);
+      lightweightExports.push(TenantManifestService);
+      tenantControllers.push(buildTenantManifestController(options.tenantManifest));
+    }
+    return {
+      module: _SaasPlatformModule,
+      imports,
+      providers: lightweightProviders,
+      controllers: tenantControllers,
+      exports: [
+        PlanCatalogModule,
+        DiscoveryModule,
+        AdminModule,
+        AdminManifestModule,
+        ...options.entitlement ? [
+          EntitlementModule
+        ] : [],
+        ADMIN_MANIFEST_CONFIG,
+        ...lightweightExports
+      ],
+      global: true
+    };
+  }
+};
+SaasPlatformModule = _ts_decorate6([
+  Module({})
+], SaasPlatformModule);
+
+export {
+  PLAN_RESOLVER_PORT_TOKEN,
+  StaticPlanResolver,
+  StaticEntitlementService,
+  STATIC_FEATURE_GUARD_CONFIG_TOKEN,
+  StaticFeatureGuard,
+  QUOTA_PROVIDERS_TOKEN,
+  EnforceQuotaInterceptor,
+  TenantManifestService,
+  buildTenantManifestController,
+  SaasPlatformModule
+};