@saasicat/nest 0.8.0 → 0.10.0

package/dist/registration/index.js

@@ -36,7 +36,7 @@ import {
   resolveModel,
   slugify,
   verifyOtpCode
-} from "../chunk-CK54YKVK.js";
+} from "../chunk-75JABGZK.js";
 import "../chunk-SABTXESR.js";
 import "../chunk-SHUYVCID.js";
 export {

package/dist/setup.service-BPwJ7My_.d.cts

@@ -0,0 +1,45 @@
+import { DynamicModule } from '@nestjs/common';
+import { SuperAdminProvisioningPort, SetupStatusResponse, SetupRequest, SetupResult, SetupConfirmMfaRequest, SetupConfirmMfaResponse } from '@saasicat/types';
+import { P as ProviderSpec } from './di-CcNeq9v-.cjs';
+import { j as MfaService } from './admin-stats.module-v4SVvWzj.cjs';
+
+interface SetupModuleOptions {
+    /**
+     * App adapter for the existence check + creation of the first SUPER_ADMIN. A
+     * full `UserManagementPort` adapter (CLI) satisfies this contract as well, so
+     * it can be reused.
+     */
+    provisioningPort: ProviderSpec<SuperAdminProvisioningPort>;
+    /** Env-var name of the setup token. Default `SETUP_TOKEN`. */
+    setupTokenEnvVar?: string;
+    /** Authenticator issuer for MFA enrollment. Default `SuperAdmin`. */
+    mfaIssuer?: string;
+    /** Register the module globally — default `false`. */
+    global?: boolean;
+}
+declare class SetupModule {
+    static forRoot(options: SetupModuleOptions): DynamicModule;
+}
+
+declare const SETUP_PROVISIONING_PORT_TOKEN: unique symbol;
+declare const SETUP_CONFIG_TOKEN: unique symbol;
+interface SetupConfig {
+    /** Env-var name of the setup token. Without the var set, setup is disabled. */
+    setupTokenEnvVar: string;
+    /** Authenticator issuer for the MFA enrollment in the wizard. */
+    mfaIssuer: string;
+}
+
+declare class SetupService {
+    private readonly users;
+    private readonly config;
+    private readonly mfa;
+    constructor(users: SuperAdminProvisioningPort, config: SetupConfig, mfa: MfaService);
+    status(): Promise<SetupStatusResponse>;
+    setup(req: SetupRequest): Promise<SetupResult>;
+    confirmMfa(req: SetupConfirmMfaRequest): Promise<SetupConfirmMfaResponse>;
+    private assertToken;
+    private assertNoSuperAdmin;
+}
+
+export { SetupService as S, SETUP_CONFIG_TOKEN as a, SETUP_PROVISIONING_PORT_TOKEN as b, type SetupConfig as c, SetupModule as d, type SetupModuleOptions as e };

package/dist/setup.service-D2mrdDDB.d.ts

@@ -0,0 +1,45 @@
+import { DynamicModule } from '@nestjs/common';
+import { SuperAdminProvisioningPort, SetupStatusResponse, SetupRequest, SetupResult, SetupConfirmMfaRequest, SetupConfirmMfaResponse } from '@saasicat/types';
+import { P as ProviderSpec } from './di-CcNeq9v-.js';
+import { j as MfaService } from './admin-stats.module-15ac5KY3.js';
+
+interface SetupModuleOptions {
+    /**
+     * App adapter for the existence check + creation of the first SUPER_ADMIN. A
+     * full `UserManagementPort` adapter (CLI) satisfies this contract as well, so
+     * it can be reused.
+     */
+    provisioningPort: ProviderSpec<SuperAdminProvisioningPort>;
+    /** Env-var name of the setup token. Default `SETUP_TOKEN`. */
+    setupTokenEnvVar?: string;
+    /** Authenticator issuer for MFA enrollment. Default `SuperAdmin`. */
+    mfaIssuer?: string;
+    /** Register the module globally — default `false`. */
+    global?: boolean;
+}
+declare class SetupModule {
+    static forRoot(options: SetupModuleOptions): DynamicModule;
+}
+
+declare const SETUP_PROVISIONING_PORT_TOKEN: unique symbol;
+declare const SETUP_CONFIG_TOKEN: unique symbol;
+interface SetupConfig {
+    /** Env-var name of the setup token. Without the var set, setup is disabled. */
+    setupTokenEnvVar: string;
+    /** Authenticator issuer for the MFA enrollment in the wizard. */
+    mfaIssuer: string;
+}
+
+declare class SetupService {
+    private readonly users;
+    private readonly config;
+    private readonly mfa;
+    constructor(users: SuperAdminProvisioningPort, config: SetupConfig, mfa: MfaService);
+    status(): Promise<SetupStatusResponse>;
+    setup(req: SetupRequest): Promise<SetupResult>;
+    confirmMfa(req: SetupConfirmMfaRequest): Promise<SetupConfirmMfaResponse>;
+    private assertToken;
+    private assertNoSuperAdmin;
+}
+
+export { SetupService as S, SETUP_CONFIG_TOKEN as a, SETUP_PROVISIONING_PORT_TOKEN as b, type SetupConfig as c, SetupModule as d, type SetupModuleOptions as e };

package/dist/subscription-bundle-preview.service-BkJXHAeP.d.cts

@@ -0,0 +1,438 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { b as AuthGuardList, m as SelfServiceBlockedPlans, w as TrialProjectionPort, h as PendingPlanQueryPort, f as ContractFreezePort, l as SelfServiceBlockedBundles, u as TenantIdResolver, B as UserIdResolver, z as UserEmailResolver, a as AuditContextResolver } from './subscription-bundles.module-DCpV-Pb5.cjs';
+import { PlanCatalog, SubscriptionUsagePort, UsageSnapshotPort, TenantSubscriptionWritePort, SubscriptionBundleRepository, BundleRepository, SubscriptionBundleView, SubscriptionBundleRecord, SubscriptionUsageRecord, OnboardingSelectionResponse, PlanRepository, CatalogEntryRepository, BundleVersionRow } from '@saasicat/types';
+import { c as EntitlementService, a as EffectiveLimitsSnapshot, t as toEffectiveLimitsSnapshot } from './aggregation-CfI0bOsQ.cjs';
+import { f as PromoCodesService } from './service-DX8KbGXl.cjs';
+import { A as AdminAuditService } from './admin-audit.service-9IqXMlZm.cjs';
+
+declare class ComposedTenantAuthGuard implements CanActivate {
+    private readonly guards;
+    constructor(guards?: AuthGuardList | null);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}
+
+declare class TenantAdminGuard implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}
+
+interface ProrationDto {
+    daysRemainingInPeriod: number;
+    daysInPeriod: number;
+    periodStart: Date;
+    periodEnd: Date;
+    currentPriceNet: number;
+    targetPriceNet: number;
+    /** Prorated surcharge/credit until end of period. Negative = credit. */
+    prorataDeltaNet: number;
+}
+interface ProrationInput {
+    periodStart: Date;
+    periodEnd: Date;
+    now: Date;
+    /** Previous period price (bundle add: 0 — something is only added). */
+    currentPriceNet: number;
+    targetPriceNet: number;
+}
+declare function computeProration(input: ProrationInput): ProrationDto;
+
+type PlanChangeType = 'UPGRADE' | 'DOWNGRADE' | 'CYCLE_CHANGE' | 'NOOP';
+interface PlanSnapshotDto {
+    id: string;
+    name: string;
+    monthlyNet: number | null;
+    yearlyNet: number | null;
+    quotas: Record<string, number>;
+    features: string[];
+}
+interface LimitsCheckRow {
+    used: number;
+    currentMax: number;
+    targetMax: number;
+    exceeded: boolean;
+}
+interface PlanChangePreviewIssue {
+    code: string;
+    message: string;
+}
+interface PlanChangePreviewDto {
+    changeType: PlanChangeType;
+    current: {
+        plan: PlanSnapshotDto;
+        billingCycle: string;
+    };
+    target: {
+        plan: PlanSnapshotDto;
+        billingCycle: string;
+    };
+    /** For upgrade/NOOP: immediately (null). Otherwise period end. */
+    effectiveAt: Date | null;
+    isImmediate: boolean;
+    /**
+     * Projected new trial end after the change (app trial logic, e.g.
+     * carry-over of the remaining time). `null` if no TrialProjectionPort is
+     * configured, the subscription is not in a trial, or nothing changes.
+     * The wizard uses this to show "regulär ab Ende der Testphase".
+     */
+    projectedTrialEndsAt: Date | null;
+    proration: ProrationDto | null;
+    /** Map quotaKey → LimitsCheckRow across all quota dimensions from the current limit, target plan and usage. */
+    limitsCheck: Record<string, LimitsCheckRow>;
+    featuresLost: string[];
+    featuresGained: string[];
+    /** Hard prevention reasons — e.g. usage > target limit. */
+    blockers: PlanChangePreviewIssue[];
+    /** Non-blocking hints — e.g. feature loss. */
+    warnings: PlanChangePreviewIssue[];
+}
+interface PlanChangeContext {
+    /** Current period start time from the subscription, if present. */
+    currentPeriodStart: Date | null;
+    /** Current period end from the subscription, if present. */
+    currentPeriodEnd: Date | null;
+    /** TRIAL end, if status === 'TRIAL'. */
+    trialEndsAt: Date | null;
+    /** Subscription status (TRIAL/ACTIVE/...). */
+    status: string;
+    /** Current cycle of the subscription (for cycle-change classification). */
+    currentBillingCycle: string;
+    /** Current plan of the subscription. */
+    currentPlan: string;
+    /** Subscription start, if present (for the periodEndAfter fallback). */
+    startedAt: Date | null;
+}
+declare class PlanChangePreviewService {
+    private readonly catalog;
+    private readonly entitlements;
+    private readonly subscriptions;
+    private readonly usageSnapshot;
+    private readonly blockedPlans;
+    private readonly trialProjection;
+    constructor(catalog: PlanCatalog, entitlements: EntitlementService, subscriptions: SubscriptionUsagePort, usageSnapshot: UsageSnapshotPort, blockedPlans?: SelfServiceBlockedPlans | null, trialProjection?: TrialProjectionPort | null);
+    preview(tenantId: string, targetPlan: string, targetCycle: string, now?: Date): Promise<PlanChangePreviewDto>;
+    /** Like `preview`, but only the blocker list — for a server-side
+     * pre-check before the `changePlan` mutation (defense-in-depth). */
+    assertChangeAllowed(tenantId: string, targetPlan: string, targetCycle: string, now?: Date): Promise<PlanChangePreviewIssue[]>;
+    private classify;
+    /** Catalog order = rank. Non-marketed plans go to the end. */
+    private planRank;
+    private resolveEffectiveAt;
+    private computeProration;
+}
+
+declare class PendingPlanMaterializationService {
+    private readonly query;
+    private readonly subscriptionWrite;
+    private readonly entitlements;
+    private readonly contractFreeze;
+    private readonly logger;
+    constructor(query: PendingPlanQueryPort, subscriptionWrite: TenantSubscriptionWritePort, entitlements: EntitlementService, contractFreeze?: ContractFreezePort | null);
+    materializeDuePlanChanges(now?: Date): Promise<{
+        applied: number;
+    }>;
+    private tryFreeze;
+}
+
+declare class PreviewPlanChangeDto {
+    plan: string;
+    billingCycle: string;
+}
+declare class ChangePlanDto extends PreviewPlanChangeDto {
+    /** Immediate change (true) vs. change at period end (false/undefined). */
+    effectiveImmediately?: boolean;
+}
+declare class CancelSubscriptionDto {
+    /** true = cancel immediately (status CANCELED). false/undefined = at period end. */
+    immediately?: boolean;
+}
+
+declare class CompleteOnboardingSubscriptionDto {
+    plan: string;
+    billingCycle: string;
+    promoCode?: string;
+    /**
+     * Optional — UUIDs of the BundleVersions that should be booked
+     * together with the plan (P11.7.3). Per bundle, the platform
+     * default minimum term (12 months) is set. Bundles are added
+     * best-effort **after** the plan change — an error on an individual
+     * bundle (e.g. incompatible with the chosen plan) lands as a
+     * warning in the response, without rolling back the plan change.
+     */
+    bundleVersionIds?: string[];
+}
+
+interface SubscriptionBundleConfig {
+    /** Default minimum term in months on `add`. Default = 12. */
+    defaultMinimumTermMonths?: number;
+}
+interface AddBundleToSubscriptionInput {
+    subscriptionId: string;
+    bundleVersionId: string;
+    /** PlanKey of the current subscription for the plan-compatibility check. */
+    currentPlanKey: string;
+    /** Default = now (service time). */
+    startedAt?: Date;
+    /**
+     * Override for the minimum term (months). Default = config or
+     * 12. `0` explicitly means "no minimum term"
+     * (`minimumTermEndsAt = null`).
+     */
+    minimumTermMonths?: number;
+}
+interface CancelBundleFromSubscriptionInput {
+    subscriptionBundleId: string;
+    /** Default = now. */
+    canceledAt?: Date;
+    /**
+     * Period end of the subscription from which the cancellation could take effect.
+     * Effective date = `max(currentPeriodEnd, minimumTermEndsAt)`.
+     * If not set, `canceledAt` is interpreted as the period end
+     * (= immediate effect, provided the minimum term has already expired).
+     */
+    currentPeriodEnd?: Date;
+}
+declare class SubscriptionBundlesService {
+    private readonly repo;
+    private readonly bundles;
+    private readonly blockedBundles;
+    private readonly defaultMinTermMonths;
+    constructor(repo: SubscriptionBundleRepository, bundles: BundleRepository, config?: SubscriptionBundleConfig, blockedBundles?: SelfServiceBlockedBundles | null);
+    /** All bundle bookings of a subscription (for the "My Bundles" page). */
+    listForSubscription(subscriptionId: string): Promise<SubscriptionBundleView[]>;
+    addBundleToSubscription(input: AddBundleToSubscriptionInput): Promise<SubscriptionBundleRecord>;
+    cancelBundleFromSubscription(input: CancelBundleFromSubscriptionInput): Promise<SubscriptionBundleRecord>;
+    /**
+     * "Undo cancellation" — only as long as the cancellation is not yet effective
+     * (the bundle runs until `canceledEffectiveAt`). After that, re-booking is the way.
+     */
+    reactivateBundle(subscriptionBundleId: string): Promise<SubscriptionBundleRecord>;
+}
+/**
+ * Effective date of a bundle cancellation:
+ * `max(currentPeriodEnd, minimumTermEndsAt)` — missing values fall back to
+ * `canceledAt` (= immediate effect). Shared between the
+ * cancellation mutation and the preview (#37).
+ */
+declare function resolveBundleCancelEffectiveAt(input: {
+    canceledAt: Date;
+    currentPeriodEnd: Date | null;
+    minimumTermEndsAt: Date | null;
+}): Date;
+/**
+ * Adds `months` to `date` and keeps the UTC day. Edge case
+ * 31.01 + 1 month → 28/29.02 (JS Date does this automatically by
+ * setMonth normalizing the day).
+ */
+declare function addMonths(date: Date, months: number): Date;
+
+interface RequestLike {
+    user?: {
+        tenantId?: string;
+        sub?: string;
+        id?: string;
+    };
+}
+interface UsageResponse {
+    plan: string;
+    effectivePlan: string;
+    billingCycle: string;
+    status: string;
+    isPilot: boolean;
+    pilotEndsAt: Date | null;
+    trialEndsAt: Date | null;
+    startedAt: Date | null;
+    currentPeriodStart: Date | null;
+    currentPeriodEnd: Date | null;
+    pendingPlan: string | null;
+    pendingBillingCycle: string | null;
+    pendingEffectiveAt: Date | null;
+    planVersion: SubscriptionUsageRecord['planVersion'];
+    pendingPlanVersion: SubscriptionUsageRecord['pendingPlanVersion'];
+    pendingPlanVersionEffectiveAt: Date | null;
+    pendingPlanVersionAccepted: boolean;
+    pendingPlanVersionAcceptedAt: Date | null;
+    limits: ReturnType<typeof toEffectiveLimitsSnapshot>;
+    usage: Record<string, number>;
+    /**
+     * P11.4 (METAMODELL §17a): Frozen package snapshot from the
+     * `CheckoutOffer` that was activated during onboarding. Read-only
+     * for the tenant self-service UI. `null` for subscriptions without
+     * a CheckoutOffer origin.
+     */
+    packageSnapshot: unknown | null;
+    /** P11.4: Optional reference to the originating CheckoutOffer. */
+    checkoutOfferId: string | null;
+}
+declare class TenantBillingController {
+    private readonly entitlements;
+    private readonly planPreview;
+    private readonly subscriptionUsage;
+    private readonly usageSnapshot;
+    private readonly subscriptionWrite;
+    private readonly tenantIdResolver;
+    private readonly userIdResolver;
+    private readonly blockedPlans;
+    private readonly promoCodes;
+    private readonly auditService;
+    private readonly userEmailResolver;
+    private readonly auditContextResolver;
+    private readonly subscriptionBundles;
+    private readonly contractFreeze;
+    private readonly trialProjection;
+    constructor(entitlements: EntitlementService, planPreview: PlanChangePreviewService, subscriptionUsage: SubscriptionUsagePort, usageSnapshot: UsageSnapshotPort, subscriptionWrite: TenantSubscriptionWritePort, tenantIdResolver?: TenantIdResolver | null, userIdResolver?: UserIdResolver | null, blockedPlans?: SelfServiceBlockedPlans | null, promoCodes?: PromoCodesService | null, auditService?: AdminAuditService | null, userEmailResolver?: UserEmailResolver | null, auditContextResolver?: AuditContextResolver | null, subscriptionBundles?: SubscriptionBundlesService | null, contractFreeze?: ContractFreezePort | null, trialProjection?: TrialProjectionPort | null);
+    private readonly logger;
+    getEntitlement(req: RequestLike): Promise<EffectiveLimitsSnapshot>;
+    getUsage(req: RequestLike): Promise<UsageResponse>;
+    previewPlanChange(req: RequestLike, dto: PreviewPlanChangeDto): Promise<PlanChangePreviewDto>;
+    changePlan(req: RequestLike, dto: ChangePlanDto): Promise<{
+        plan: string;
+        billingCycle: string;
+        immediate: boolean;
+        pendingPlan?: undefined;
+        pendingBillingCycle?: undefined;
+        pendingEffectiveAt?: undefined;
+    } | {
+        plan: string;
+        billingCycle: string;
+        pendingPlan: string;
+        pendingBillingCycle: string;
+        pendingEffectiveAt: Date;
+        immediate: boolean;
+    }>;
+    completeOnboardingSubscription(req: RequestLike, dto: CompleteOnboardingSubscriptionDto): Promise<OnboardingSelectionResponse>;
+    acceptPendingPlanVersion(req: RequestLike): Promise<{
+        accepted: boolean;
+        acceptedAt: Date | null;
+        effectiveAt: Date | null;
+        idempotent: boolean;
+    }>;
+    cancelSubscription(req: RequestLike, dto: CancelSubscriptionDto): Promise<{
+        canceledAt: Date | null;
+        status: string;
+        immediate: boolean;
+    }>;
+    private requireTenantId;
+    private requireUserId;
+    private buildActor;
+    private resolveUserEmail;
+    private toResponseRedemption;
+    private collectPromoSkipReasons;
+    /**
+     * #18: contract freeze after the plan change — non-fatal, only outside of
+     * the trial (during a trial the trial entitlements apply, not the booked plan;
+     * the freeze happens on the transition to ACTIVE, i.e. on materialization).
+     * Without a configured `contractFreeze` hook the call is a no-op.
+     */
+    private tryFreezeOnPlanChange;
+    /**
+     * Audit-log helper — writes best-effort, does not block the response path.
+     * If `AdminAuditService` is not injected (e.g. a minimal deploy without
+     * AdminModule), the call is silently discarded.
+     */
+    private auditLog;
+}
+
+interface SubscriptionBundlePreviewIssue {
+    code: string;
+    message: string;
+}
+/** Subscription context — the controller reads it from the SubscriptionUsagePort. */
+interface SubscriptionBundlePreviewContext {
+    subscriptionId: string;
+    /** PlanKey of the current subscription (plan compatibility + redundancy source). */
+    currentPlanKey: string;
+    /** 'MONTHLY' | 'YEARLY' (port convention). */
+    billingCycle: string;
+    /** Subscription status (TRIAL/ACTIVE/...). No proration during TRIAL. */
+    status: string;
+    startedAt: Date | null;
+    currentPeriodStart: Date | null;
+    currentPeriodEnd: Date | null;
+}
+interface BundlePreviewSnapshot {
+    bundleKey: string;
+    label: string;
+    bundleVersionId: string;
+    features: string[];
+    quotas: Record<string, number>;
+}
+/** AK-13: feature is already paid for elsewhere — double-payment hint. */
+interface RedundantFeatureHint {
+    featureKey: string;
+    coveredBy: 'PLAN' | 'BUNDLE';
+    /** planKey or bundleKey of the covering source. */
+    coveredByKey: string;
+}
+interface SubscriptionBundleAddPreviewDto {
+    action: 'add';
+    bundle: BundlePreviewSnapshot;
+    billingCycle: string;
+    /**
+     * Prorated amount until period end. `null` during TRIAL (no paid
+     * period yet) or without a list price for the cycle.
+     */
+    proration: ProrationDto | null;
+    /** List price per follow-up period in the current cycle; null = no price maintained. */
+    nextPeriodPriceNet: number | null;
+    minimumTermMonths: number;
+    /** Projected minimum-term end from `now`; null = no minimum term. */
+    minimumTermEndsAt: Date | null;
+    redundantFeatures: RedundantFeatureHint[];
+    /**
+     * requires-features (#35) that neither the plan nor active bundles nor the
+     * bundle itself cover. Non-empty ⇒ blocker
+     * BUNDLE_FEATURE_DEPENDENCY_UNSATISFIED.
+     */
+    missingRequires: string[];
+    blockers: SubscriptionBundlePreviewIssue[];
+    warnings: SubscriptionBundlePreviewIssue[];
+}
+interface SubscriptionBundleCancelPreviewDto {
+    action: 'cancel';
+    subscriptionBundleId: string;
+    bundle: BundlePreviewSnapshot;
+    billingCycle: string;
+    /** Effective date = max(currentPeriodEnd, minimumTermEndsAt). */
+    effectiveAt: Date;
+    /** Savings per period from the effective date; null = no price maintained. */
+    nextPeriodSavingsNet: number | null;
+    blockers: SubscriptionBundlePreviewIssue[];
+    warnings: SubscriptionBundlePreviewIssue[];
+}
+declare class SubscriptionBundlePreviewService {
+    private readonly subscriptionBundles;
+    private readonly bundles;
+    private readonly plans;
+    private readonly catalogEntries;
+    private readonly blockedBundles;
+    private readonly defaultMinTermMonths;
+    constructor(subscriptionBundles: SubscriptionBundleRepository, bundles: BundleRepository, plans?: PlanRepository | null, catalogEntries?: CatalogEntryRepository | null, blockedBundles?: SelfServiceBlockedBundles | null, config?: SubscriptionBundleConfig);
+    previewAdd(ctx: SubscriptionBundlePreviewContext, input: {
+        bundleVersionId: string;
+        minimumTermMonths?: number;
+    }, now?: Date): Promise<SubscriptionBundleAddPreviewDto>;
+    previewCancel(ctx: SubscriptionBundlePreviewContext, input: {
+        subscriptionBundleId: string;
+    }, now?: Date): Promise<SubscriptionBundleCancelPreviewDto>;
+    /** Bookability checks — same codes as `addBundleToSubscription` (422 path). */
+    private collectBookabilityBlockers;
+    /** Versions of the active bundle bookings (for redundancy + requires coverage). */
+    private loadActiveBundleVersions;
+    /** Features of the currently live PlanVersion state; empty without PlanRepository. */
+    private resolvePlanFeatures;
+    private collectRedundantFeatures;
+    /**
+     * requires of the new bundle that neither the bundle itself nor plan ∪
+     * active bundles cover (#35). Empty without CatalogEntryRepository.
+     */
+    private collectMissingRequires;
+    /** `projectKey` lives on the bundle stem, not on the version. */
+    private resolveProjectKey;
+}
+/**
+ * List price (net) for the billing cycle including plan-specific
+ * pricing override (BundlePricingOverride with `planId`). null = no price
+ * maintained for the cycle.
+ */
+declare function resolveBundlePriceNet(bundleVersion: BundleVersionRow, planKey: string, billingCycle: string): number | null;
+
+export { type AddBundleToSubscriptionInput as A, type BundlePreviewSnapshot as B, type CancelBundleFromSubscriptionInput as C, type LimitsCheckRow as L, PendingPlanMaterializationService as P, type RedundantFeatureHint as R, type SubscriptionBundleAddPreviewDto as S, TenantAdminGuard as T, type UsageResponse as U, CancelSubscriptionDto as a, ChangePlanDto as b, CompleteOnboardingSubscriptionDto as c, ComposedTenantAuthGuard as d, type PlanChangeContext as e, type PlanChangePreviewDto as f, type PlanChangePreviewIssue as g, PlanChangePreviewService as h, type PlanChangeType as i, type PlanSnapshotDto as j, PreviewPlanChangeDto as k, type ProrationDto as l, type ProrationInput as m, type SubscriptionBundleCancelPreviewDto as n, type SubscriptionBundleConfig as o, type SubscriptionBundlePreviewContext as p, type SubscriptionBundlePreviewIssue as q, SubscriptionBundlePreviewService as r, SubscriptionBundlesService as s, TenantBillingController as t, addMonths as u, computeProration as v, resolveBundleCancelEffectiveAt as w, resolveBundlePriceNet as x };