@saasicat/nest 0.2.0

package/dist/catalog/index.d.cts

@@ -0,0 +1,1073 @@
+import { BundleRepository, DiscoverySnapshot, SubscriptionRepository, PlanRepository, CatalogEntryRepository, BundleRow, BundleVersionRow, CreateBundleData, UpdateBundleData, CreateBundleVersionDraftData, BundleVersionMutationResult, UpdateBundleVersionDraftData, PublishBundleVersionData, BusinessTypeRepository, BusinessTypeRow, BusinessTypeVersionRow, CreateBusinessTypeData, UpdateBusinessTypeData, CreateBusinessTypeVersionDraftData, BusinessTypeVersionMutationResult, UpdateBusinessTypeVersionDraftData, PublishBusinessTypeVersionData, MarketingProjectionRepository, MarketingProjectionFilter, MarketingProjectionRow, CreateMarketingProjectionData, UpdateMarketingProjectionData, FeatureUiRegistry, CapabilityCatalogEntryRow, FeatureCatalogEntryRow, QuotaCatalogEntryRow, ReviewCatalogEntryData, CatalogEntryI18n, UpdateCatalogEntryBaseData, SyncDiscoveryResult, PromotionRepository, PromotionRow, CreatePromotionData, UpdatePromotionData, MarketingSettingsRepository, MarketingSettingsRow, UpdateMarketingSettingsData, PublicMarketingCatalogResponse, PlanRow, CreatePlanData, UpdatePlanData, PlanVersionRow, CreatePlanVersionDraftData, PlanVersionMutationResult, UpdatePlanVersionDraftData, PublishPlanVersionData, StrictModeWarningCode, StrictModeWarning, ApprovedCatalogKeys, DiscoveredQuota, DiscoveryStatus, PromotionType, PromotionValue, PromotionTargetType, PromotionBillingCycle, PromotionI18n } from '@saasicat/types';
+import { c as DiscoveryScanner } from '../discovery.scanner-CUYLKlYT.cjs';
+import { OnApplicationBootstrap, Type, CanActivate, DynamicModule, ForwardReference, Provider } from '@nestjs/common';
+import { P as ProviderSpec } from '../di-CcNeq9v-.cjs';
+import '@nestjs/core';
+
+/**
+ * Configuration for the mutating operations.
+ */
+interface CatalogServiceConfig {
+    /** Active mode for the strict-mode check. Default `'blocking'` (#12). */
+    strictModeCheckMode?: 'warn-only' | 'blocking';
+    /**
+     * Discovery→Catalog auto-sync at boot (#12). Default `true` — runs when a
+     * `DiscoverySnapshot` is available. Set to `false` to disable the boot
+     * sync; the manual `POST /admin/catalog/discovery/sync` is unaffected.
+     */
+    autoSyncDiscoveryAtBoot?: boolean;
+    /**
+     * Feature keys the catalog is deliberately allowed to carry WITHOUT them
+     * existing in the discovery snapshot (= in code via @ImplementsCapability) —
+     * marketed non-code features such as support SLAs (e.g. PRIORITY_SUPPORT).
+     * The strict-mode check does NOT report them as BUNDLE_/PLAN_FEATURE_UNKNOWN.
+     * Use sparingly: this is the only legitimate exception to "code is the
+     * source of truth"; not-yet-built features do NOT belong here but should be
+     * removed from the catalog until they are implemented.
+     */
+    marketedOnlyFeatures?: string[];
+}
+declare class BundlesService {
+    private readonly repo;
+    private readonly snapshot;
+    private readonly subscriptions;
+    private readonly planRepo;
+    private readonly scanner;
+    private readonly catalogEntries;
+    private readonly logger;
+    private mode;
+    private readonly marketedOnly;
+    constructor(repo: BundleRepository, snapshot?: DiscoverySnapshot | null, config?: CatalogServiceConfig, subscriptions?: SubscriptionRepository | null, planRepo?: PlanRepository | null, scanner?: DiscoveryScanner | null, catalogEntries?: CatalogEntryRepository | null);
+    listBundles(projectKey: string): Promise<BundleRow[]>;
+    getBundle(bundleId: string): Promise<{
+        bundle: BundleRow;
+        versions: BundleVersionRow[];
+    }>;
+    createBundle(data: CreateBundleData): Promise<BundleRow>;
+    updateBundle(bundleId: string, data: UpdateBundleData): Promise<BundleRow>;
+    softDeleteBundle(bundleId: string): Promise<void>;
+    /**
+     * Hard-deletes a draft BundleVersion (`publishedAt === null`) from the
+     * DB. Published versions stay immutable (contract-protection P1) — the
+     * service throws 422 with code `BUNDLE_VERSION_ALREADY_PUBLISHED`.
+     */
+    discardBundleDraft(versionId: string): Promise<void>;
+    listBundleVersions(bundleId: string): Promise<BundleVersionRow[]>;
+    getBundleVersion(versionId: string): Promise<BundleVersionRow>;
+    /**
+     * Annotates each BundleVersion with `isLatestInChain` (highest version
+     * number in the chain) + `subscriptionCount` so that UI and backend make
+     * the same editability decision. `subscriptionCount` stays `undefined`
+     * when no SubscriptionRepository is registered or the method was not
+     * implemented — `isVersionEditable` interprets that fail-closed
+     * (= frozen).
+     */
+    private annotateEditability;
+    /**
+     * Creates a new draft BundleVersion. Throws when a draft already exists
+     * for the same bundle (repository constraint).
+     *
+     * The strict-mode check runs on the input; in `warn-only` warnings are
+     * returned, in `blocking` the service throws HTTP 422.
+     */
+    createBundleDraft(data: CreateBundleVersionDraftData): Promise<BundleVersionMutationResult>;
+    /**
+     * Updates a draft version or — as a deliberate relaxation of
+     * contract-protection P1 — a published-but-future BundleVersion that is
+     * latest-in-chain and does not yet bind any subscription. Once
+     * `validFrom` is reached or a booking references it, the version freezes
+     * again. The concrete decision is made by the `isVersionEditable` helper,
+     * which is mirrored by the UI.
+     */
+    updateBundleDraft(versionId: string, data: UpdateBundleVersionDraftData): Promise<BundleVersionMutationResult>;
+    /**
+     * Publishes a draft version atomically. Steps:
+     * 1. Strict check on the draft definition (warn-only or blocking)
+     * 2. Enforce validFrom requirement + ordering against the predecessor
+     *    (SPEC_V2 §4.2 + §11.1 M6 Pack 2c, analogous to PlanVersion)
+     * 3. Compute the diff against the predecessor version (latest live) →
+     *    `publishedChanges` + `nonRegressive` via `classifyBundleVersionDiff`
+     * 4. Call Repository.publishDraft with the diff result + validity dates
+     *    (transaction; auto-succession sets the previous validUntil)
+     */
+    publishBundleVersion(versionId: string, publishMeta: PublishBundleVersionData): Promise<BundleVersionMutationResult>;
+    private runStrictCheck;
+    private gateOrPass;
+    private assertBundleVersionWindowUpdate;
+    private findPreviousBundleVersion;
+    private parseOptionalBundleDate;
+    private parseRequiredBundleDate;
+}
+
+declare class BusinessTypesService {
+    private readonly repo;
+    private readonly bundleRepo;
+    private readonly snapshot;
+    private readonly scanner;
+    private readonly catalogEntries;
+    private readonly mode;
+    constructor(repo: BusinessTypeRepository, bundleRepo: BundleRepository, snapshot?: DiscoverySnapshot | null, config?: CatalogServiceConfig, scanner?: DiscoveryScanner | null, catalogEntries?: CatalogEntryRepository | null);
+    listBusinessTypes(projectKey: string): Promise<BusinessTypeRow[]>;
+    getBusinessType(businessTypeId: string): Promise<{
+        businessType: BusinessTypeRow;
+        versions: BusinessTypeVersionRow[];
+    }>;
+    createBusinessType(data: CreateBusinessTypeData): Promise<BusinessTypeRow>;
+    updateBusinessType(businessTypeId: string, data: UpdateBusinessTypeData): Promise<BusinessTypeRow>;
+    softDeleteBusinessType(businessTypeId: string): Promise<void>;
+    listBusinessTypeVersions(businessTypeId: string): Promise<BusinessTypeVersionRow[]>;
+    getBusinessTypeVersion(versionId: string): Promise<BusinessTypeVersionRow>;
+    createBusinessTypeDraft(data: CreateBusinessTypeVersionDraftData): Promise<BusinessTypeVersionMutationResult>;
+    updateBusinessTypeDraft(versionId: string, data: UpdateBusinessTypeVersionDraftData): Promise<BusinessTypeVersionMutationResult>;
+    publishBusinessTypeVersion(versionId: string, publishMeta: PublishBusinessTypeVersionData): Promise<BusinessTypeVersionMutationResult>;
+    /**
+     * Loads the referenced BundleVersions and verifies that all exist
+     * and are published (live or superseded — both allowed, because
+     * BusinessTypeBundle holds the concrete version). Throws NotFound for
+     * missing ones, UnprocessableEntity for non-published ones.
+     */
+    private loadAndAssertBundles;
+    private runStrictCheck;
+    private gateOrPass;
+}
+
+declare class MarketingProjectionsService {
+    private readonly repo;
+    constructor(repo: MarketingProjectionRepository);
+    list(filter: MarketingProjectionFilter): Promise<MarketingProjectionRow[]>;
+    getById(id: string): Promise<MarketingProjectionRow>;
+    create(data: CreateMarketingProjectionData): Promise<MarketingProjectionRow>;
+    update(id: string, data: UpdateMarketingProjectionData): Promise<MarketingProjectionRow>;
+    delete(id: string): Promise<void>;
+}
+
+declare class CatalogEntriesService implements OnApplicationBootstrap {
+    private readonly repo;
+    private readonly snapshot;
+    private readonly scanner;
+    private readonly featureUiRegistry;
+    private readonly logger;
+    private readonly autoSyncAtBoot;
+    constructor(repo: CatalogEntryRepository, snapshot?: DiscoverySnapshot | null, config?: CatalogServiceConfig, scanner?: DiscoveryScanner | null, featureUiRegistry?: FeatureUiRegistry | null);
+    /**
+     * Mirrors the discovery snapshot into the catalog entries at boot
+     * (discovery-as-SSOT, #12). Runs only when a snapshot is available and
+     * the kill switch `autoSyncDiscoveryAtBoot` is not set to `false`. A
+     * sync error deliberately does not abort the boot — the manual endpoint
+     * `POST /admin/catalog/discovery/sync` remains as a fallback.
+     */
+    onApplicationBootstrap(): Promise<void>;
+    listCapabilities(projectKey: string, codeStatus?: string): Promise<CapabilityCatalogEntryRow[]>;
+    listFeatures(projectKey: string, discoveryStatus?: string): Promise<FeatureCatalogEntryRow[]>;
+    listQuotas(projectKey: string, discoveryStatus?: string): Promise<QuotaCatalogEntryRow[]>;
+    /**
+     * Approval transition of a feature (#20). Validates the state machine;
+     * `approved` persists the approval signature from the current
+     * snapshot, `pending` (revoke/reactivate) deletes it, `outdated`/
+     * `obsolete` keep the last approval as history.
+     */
+    reviewFeature(projectKey: string, featureKey: string, data: ReviewCatalogEntryData, reviewedBy: string | null): Promise<FeatureCatalogEntryRow>;
+    /** Approval transition of a quota — same state machine as features (#20). */
+    reviewQuota(projectKey: string, quotaKey: string, data: ReviewCatalogEntryData, reviewedBy: string | null): Promise<QuotaCatalogEntryRow>;
+    private resolveReviewUpdate;
+    setFeatureI18n(projectKey: string, featureKey: string, i18n: CatalogEntryI18n): Promise<FeatureCatalogEntryRow>;
+    setQuotaI18n(projectKey: string, quotaKey: string, i18n: CatalogEntryI18n): Promise<QuotaCatalogEntryRow>;
+    /** Sets the editable default-locale label/description of a feature. */
+    setFeatureBase(projectKey: string, featureKey: string, data: UpdateCatalogEntryBaseData): Promise<FeatureCatalogEntryRow>;
+    /** Sets the editable default-locale label/description of a quota. */
+    setQuotaBase(projectKey: string, quotaKey: string, data: UpdateCatalogEntryBaseData): Promise<QuotaCatalogEntryRow>;
+    /**
+     * Synchronizes the catalog entries from a discovery snapshot.
+     * Idempotent — can run against the same snapshot any number of times.
+     */
+    syncFromSnapshot(snapshot: DiscoverySnapshot): Promise<SyncDiscoveryResult>;
+    /**
+     * `replaced` semantics (#39): if a key disappears from the snapshot AND
+     * another snapshot key claims it via `replaces`, the old entry gets
+     * the successor pointer — `obsolete` (from `retireMissing`)
+     * + `successorKey` instead of a bare `obsolete`. If a key reappears in
+     * the code, an existing pointer is deleted. A missing key
+     * without a claimant remains untouched (deleted without replacement).
+     */
+    private applySuccessorPointers;
+}
+
+declare function buildCatalogEntriesController(guards: Array<Type<CanActivate>>): Type;
+
+declare class PromotionsService {
+    private readonly repo;
+    constructor(repo: PromotionRepository);
+    list(projectKey: string): Promise<PromotionRow[]>;
+    getById(id: string): Promise<PromotionRow>;
+    create(data: CreatePromotionData): Promise<PromotionRow>;
+    update(id: string, data: UpdatePromotionData): Promise<PromotionRow>;
+    delete(id: string): Promise<void>;
+}
+
+declare function buildPromotionsController(guards: Array<Type<CanActivate>>): Type;
+
+declare class MarketingSettingsService {
+    private readonly repo;
+    constructor(repo: MarketingSettingsRepository);
+    /** Returns the stored config or `null` (in which case the full pool applies). */
+    get(projectKey: string): Promise<MarketingSettingsRow | null>;
+    upsert(projectKey: string, data: UpdateMarketingSettingsData): Promise<MarketingSettingsRow>;
+}
+
+declare function buildMarketingSettingsController(guards: Array<Type<CanActivate>>): Type;
+
+declare class PublicMarketingCatalogService {
+    private readonly planRepo;
+    private readonly marketingRepo;
+    private readonly promotionRepo;
+    private readonly catalogEntryRepo;
+    private readonly bundleRepo;
+    constructor(planRepo: PlanRepository, marketingRepo: MarketingProjectionRepository, promotionRepo: PromotionRepository, catalogEntryRepo?: CatalogEntryRepository | null, bundleRepo?: BundleRepository | null);
+    getCatalog(projectKey: string, locale: string, currency: string, vatRate: number, asOf?: Date): Promise<PublicMarketingCatalogResponse>;
+    /**
+     * Loads all published-and-live bundle versions for a project and
+     * filters on `marketed === true`. Without a registered
+     * `BundleRepository` (apps without the SuperAdmin bundle editor) the
+     * list is empty — the public catalog stays plan-only.
+     */
+    private loadMarketedBundles;
+    /**
+     * Maps BundleVersionRow → PublicMarketingBundle. Locale resolution
+     * runs via `MarketingProjectionRepository.findByTarget('BUNDLE',
+     * bundleVersionId, locale)` — on a miss it falls back to
+     * `DEFAULT_LOCALE`. If the fallback is missing too, label/description
+     * come directly from the bundle root (denormalized in `BundleVersionRow`).
+     *
+     * If the marketing projection is `visible === false`, the bundle is
+     * hidden from the public response (preparation phase).
+     */
+    private toPublicBundle;
+    /**
+     * Labels for bundle features ∪ their requires (#48): `comparison.features`
+     * only covers the plan-feature union — bundle-only features would
+     * otherwise get no label in the public payload. Curated keys only;
+     * without a CatalogEntryRepository the map stays empty (frontends fall
+     * back to the key).
+     */
+    private resolveBundleFeatureLabels;
+    /** Loads the translated feature/quota labels (+ sortOrder) for a locale. */
+    private loadLabelMeta;
+    /**
+     * Resolves the displayed label of a top feature: the `label` override
+     * wins; otherwise the translated label of the referenced `key`.
+     */
+    private resolveTopFeature;
+    /** Row definitions of the comparison matrix (feature/quota union + labels). */
+    private buildComparison;
+    private resolvePromo;
+}
+
+declare function buildPublicMarketingCatalogController(guards: Array<Type<CanActivate>>, projectKey: string, currency: string, vatRate: number): Type;
+
+declare class PlansService {
+    private readonly repo;
+    private readonly subscriptions;
+    constructor(repo: PlanRepository, subscriptions?: SubscriptionRepository | null);
+    /**
+     * Platform-wide count of active (ACTIVE/TRIAL) subscriptions per `planKey`,
+     * across versions and across all tenants (RLS-exempt). Plans without a
+     * subscription are absent from the map. Returns `{}` when no
+     * `SubscriptionRepository` is registered or it does not implement
+     * `countActiveByPlanKey`.
+     */
+    getTenantCounts(projectKey: string): Promise<Record<string, number>>;
+    listPlans(projectKey: string, opts?: {
+        onlyPublished?: boolean;
+    }): Promise<PlanRow[]>;
+    getPlan(planId: string): Promise<PlanRow>;
+    createPlan(data: CreatePlanData): Promise<PlanRow>;
+    updatePlan(planId: string, data: UpdatePlanData): Promise<PlanRow>;
+    softDeletePlan(planId: string): Promise<void>;
+    /**
+     * Hard-deletes the plan master record. Only allowed for plans without
+     * `PlanVersion` entries — published versions are immutable under
+     * contract protection P1 (existing subscriptions reference them). The
+     * caller must discard drafts beforehand via `DELETE plan-versions/:id`.
+     *
+     * If the repository does not implement `hardDelete`, the endpoint
+     * responds with 422 `PLAN_HARD_DELETE_NOT_IMPLEMENTED` — consumers can
+     * then fall back to `softDelete`.
+     */
+    hardDeletePlan(planId: string): Promise<void>;
+    /**
+     * Platform invariant (contract protection P1): once a plan has ever had a
+     * published version, its plan master record is retained — regardless of
+     * whether the version has since been superseded. Subscriptions still
+     * reference it via the version, and the audit log must be able to resolve
+     * the plan.
+     */
+    private assertNoPublishedVersions;
+    private assertNoDrafts;
+}
+
+declare class PlanVersionsService {
+    private readonly repo;
+    private readonly snapshot;
+    private readonly subscriptions;
+    private readonly scanner;
+    private readonly catalogEntries;
+    private readonly logger;
+    private mode;
+    private readonly marketedOnly;
+    constructor(repo: PlanRepository, snapshot?: DiscoverySnapshot | null, config?: CatalogServiceConfig, subscriptions?: SubscriptionRepository | null, scanner?: DiscoveryScanner | null, catalogEntries?: CatalogEntryRepository | null);
+    /**
+     * Discards a draft version. Allowed only while the version has not yet
+     * been published — published versions are preserved immutably,
+     * because existing subscriptions reference them (contract protection P1).
+     *
+     * If the repository does not implement the method, the endpoint
+     * responds with 501 Not Implemented (consumers without the editor stack
+     * should not register `PlanVersionsService` anyway).
+     */
+    discardPlanDraft(versionId: string): Promise<void>;
+    /**
+     * @param planUuid UUID of the plan root (Plan.id) — resolved to planKey
+     *   before the repo call (lifecycle methods work with planKey because
+     *   PlanVersion.planId is a string in the schema).
+     */
+    listPlanVersions(planUuid: string): Promise<PlanVersionRow[]>;
+    getPlanVersion(versionId: string): Promise<PlanVersionRow>;
+    /**
+     * Annotates each version with `isLatestInChain` (highest version number
+     * in the root) + `subscriptionCount` so that UI and backend make the same
+     * editability decision. `subscriptionCount` stays
+     * `undefined` when no SubscriptionRepository is registered —
+     * `isVersionEditable` interprets that fail-closed (= frozen).
+     */
+    private annotateEditability;
+    /**
+     * @param data.planId — the plan UUID from the controller. Resolved to
+     *   planKey before the repo call.
+     */
+    createPlanDraft(data: CreatePlanVersionDraftData): Promise<PlanVersionMutationResult>;
+    updatePlanDraft(versionId: string, data: UpdatePlanVersionDraftData): Promise<PlanVersionMutationResult>;
+    publishPlanVersion(versionId: string, publishMeta: PublishPlanVersionData): Promise<PlanVersionMutationResult>;
+    /**
+     * Terminates a **live** PlanVersion by setting `endsAt`.
+     * Unlike auto-succession (validUntil), this is an explicit
+     * user action: the version is not replaced by a successor version
+     * but expires on the chosen date. Existing subscriptions
+     * (P1) stay bound — this only affects new bookings.
+     *
+     * Idempotent — a second call with a different date overwrites.
+     *
+     * Preconditions:
+     *   - Version must be live (`publishedAt != null && supersededAt == null`).
+     *   - `endsAt` must lie in the future (`endsAt > now`).
+     *
+     * If the repository does not implement the method, the endpoint
+     * responds with 422 `PLAN_TERMINATE_NOT_IMPLEMENTED`.
+     */
+    terminatePlanVersion(versionId: string, endsAt: Date): Promise<PlanVersionRow>;
+    private runStrictCheck;
+    private gateOrPass;
+}
+
+/**
+ * Builds the controller class at boot time with the guards configured by the
+ * consumer. Pattern analogous to `buildDiscoveryController`.
+ */
+declare function buildBundlesController(guards: Array<Type<CanActivate>>): Type;
+/**
+ * Second controller with the version-specific endpoints. Deliberately
+ * separate, because they do not go through `bundles/:id/versions/:vid` but
+ * through stable version IDs (`/admin/catalog/bundle-versions/:id`) — this
+ * way the UI can work with a version-ID reference without a bundle lookup.
+ */
+declare function buildBundleVersionsController(guards: Array<Type<CanActivate>>): Type;
+
+declare function buildBusinessTypesController(guards: Array<Type<CanActivate>>): Type;
+declare function buildBusinessTypeVersionsController(guards: Array<Type<CanActivate>>): Type;
+
+declare function buildMarketingProjectionsController(guards: Array<Type<CanActivate>>): Type;
+
+declare function buildPlansController(guards: Array<Type<CanActivate>>): Type;
+/**
+ * Version-specific endpoints. Stable by version ID — the UI does not need
+ * to know the plan master.
+ */
+declare function buildPlanVersionsController(guards: Array<Type<CanActivate>>): Type;
+
+interface CatalogControllerConfig {
+    /**
+     * Class-level guards for `BundlesController` and `BundleVersionsController`.
+     * REQUIRED — otherwise `forRoot()` throws at boot. Pass `[]` explicitly
+     * if the endpoints should intentionally be auth-free.
+     */
+    guards: Array<Type<CanActivate>>;
+}
+interface CatalogModuleOptions {
+    /** Adapter for `bundles` + `bundle_versions` persistence. */
+    bundleRepository: ProviderSpec<BundleRepository>;
+    /**
+     * Adapter for `business_types` + `business_type_versions` +
+     * `business_type_bundles` persistence. Optional — if omitted,
+     * BusinessTypesService + controller are not registered.
+     */
+    businessTypeRepository?: ProviderSpec<BusinessTypeRepository>;
+    /**
+     * Adapter for `marketing_projections` persistence. Optional — if
+     * omitted, MarketingProjectionsService + controller are not
+     * registered.
+     */
+    marketingProjectionRepository?: ProviderSpec<MarketingProjectionRepository>;
+    /**
+     * Adapter for `capability_/feature_/quota_catalog_entries` persistence
+     * (discovery review, SPEC_V2 §6.3). Optional — if omitted,
+     * CatalogEntriesService + controller are not registered.
+     */
+    catalogEntryRepository?: ProviderSpec<CatalogEntryRepository>;
+    /**
+     * Adapter for `promotions` persistence (SPEC_V2 §9a). Optional — if
+     * omitted, PromotionsService + controller are not registered.
+     */
+    promotionRepository?: ProviderSpec<PromotionRepository>;
+    /**
+     * Adapter for `marketing_settings` persistence (SPEC_V2 §6.5 —
+     * `activeLocales`). Optional.
+     */
+    marketingSettingsRepository?: ProviderSpec<MarketingSettingsRepository>;
+    /**
+     * Auth-free pricing-page endpoint `GET /public/marketing-catalog`
+     * (SPEC_V2 §9). Registered only when plan-, marketingProjection-
+     * and promotionRepository are set. `guards` is usually `[]`.
+     */
+    publicMarketingCatalog?: {
+        guards: Array<Type<CanActivate>>;
+        projectKey: string;
+        currency: string;
+        vatRate: number;
+    };
+    /**
+     * SPEC_V2 §11.1 M6 (Pack 1) — adapter for `plans` master-record persistence.
+     * Optional; if omitted, PlansService + controller are not
+     * registered (apps without a need for the plan editor stay unchanged).
+     */
+    planRepository?: ProviderSpec<PlanRepository>;
+    /**
+     * Controller mount for `/admin/catalog/bundles` + `/admin/catalog/bundle-versions`
+     * + (if businessTypeRepository is set) `/admin/catalog/business-types` +
+     * `/admin/catalog/business-type-versions`. If omitted, the
+     * endpoints are not registered — but the services remain usable via DI.
+     */
+    controller?: CatalogControllerConfig;
+    /**
+     * Strict-mode mode. `blocking` (default, #12) throws HTTP 422 on
+     * violations and requires a DiscoverySnapshot; `warn-only` returns them
+     * only as a warning (transition until 100% discovery coverage).
+     */
+    strictModeCheckMode?: 'warn-only' | 'blocking';
+    /**
+     * Discovery→catalog auto-sync at boot (#12). Default `true` — as soon as a
+     * `catalogEntryRepository` is wired and a DiscoverySnapshot is available,
+     * `CatalogEntriesService` mirrors the discovery into the DB at startup. `false`
+     * disables the boot sync; the manual sync endpoint remains usable.
+     */
+    autoSyncDiscoveryAtBoot?: boolean;
+    /**
+     * Feature keys the catalog is deliberately allowed to carry without them
+     * existing in the discovery snapshot (marketed non-code features such as
+     * support SLAs, e.g. `['PRIORITY_SUPPORT']`). The strict-mode check excludes
+     * them from BUNDLE_/PLAN_FEATURE_UNKNOWN. Use sparingly.
+     */
+    marketedOnlyFeatures?: string[];
+    /**
+     * Optional consumer-curated FeatureUiRegistry (label/description/icon
+     * per feature — the same one passed to `PublicCatalogModule.forRoot`). The
+     * discovery auto-sync seeds EMPTY `FeatureCatalogEntry` fields
+     * (label/description/icon) from it at boot; SuperAdmin edits stay untouched. This
+     * makes `FeatureCatalogEntry` the SSOT for UI metadata (SPEC_V2 §6.3 / #12).
+     */
+    featureUiRegistry?: FeatureUiRegistry;
+    /**
+     * Modules whose providers must be visible in the DI scope of this
+     * DynamicModule — typically: `AuthModule`/`PlatformAdminModule`, because the
+     * controller guards come from there.
+     */
+    imports?: Array<Type<unknown> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    /** Additional providers registered in the DynamicModule itself. */
+    extraProviders?: Provider[];
+    /** Register the module globally — default `false`. */
+    global?: boolean;
+}
+declare class CatalogModule {
+    static forRoot(options: CatalogModuleOptions): DynamicModule;
+}
+
+/** Repository for `plans` (SPEC_V2 §11.1 M6 — Plan master CRUD). */
+declare const PLAN_REPOSITORY_TOKEN: unique symbol;
+/** Repository for `bundles` + `bundle_versions`. */
+declare const BUNDLE_REPOSITORY_TOKEN: unique symbol;
+/** Repository for `business_types` + `business_type_versions` + `business_type_bundles`. */
+declare const BUSINESS_TYPE_REPOSITORY_TOKEN: unique symbol;
+/** Repository for `marketing_projections`. */
+declare const MARKETING_PROJECTION_REPOSITORY_TOKEN: unique symbol;
+/**
+ * Repository for `capability_catalog_entries`, `feature_catalog_entries`
+ * and `quota_catalog_entries` (Discovery review, SPEC_V2 §6.3).
+ */
+declare const CATALOG_ENTRY_REPOSITORY_TOKEN: unique symbol;
+/** Repository for `promotions` (time-scheduled price campaigns, SPEC_V2 §9a). */
+declare const PROMOTION_REPOSITORY_TOKEN: unique symbol;
+/** Repository for `marketing_settings` (activeLocales, SPEC_V2 §6.5). */
+declare const MARKETING_SETTINGS_REPOSITORY_TOKEN: unique symbol;
+/**
+ * Service configuration: current app identity, strict mode.
+ * Provided by CatalogModule.forRoot().
+ */
+declare const CATALOG_SERVICE_CONFIG_TOKEN: unique symbol;
+
+/**
+ * Advisory warnings (#35): they inform but never block — not even in
+ * `strictModeCheckMode: 'blocking'`, Seed-Gate, or Preflight. Reason: a
+ * `requires` feature may be satisfied outside the checked draft
+ * (e.g. the Plan covers a Bundle's dependency), which the draft check
+ * cannot know without booking context.
+ */
+declare const ADVISORY_STRICT_MODE_CODES: ReadonlySet<StrictModeWarningCode>;
+/** Returns only the warnings that are allowed to gate in blocking paths. */
+declare function blockingStrictModeWarnings(warnings: StrictModeWarning[]): StrictModeWarning[];
+/**
+ * Validates a Bundle draft definition against the current discovery snapshot.
+ * Returns a (possibly empty) list of warnings.
+ *
+ * Checked:
+ * - **Feature existence** (`BUNDLE_FEATURE_UNKNOWN`): every `features[i]`
+ *   must exist as a `DiscoveredFeature` in the snapshot. Code is the
+ *   source of truth for features (via @ImplementsCapability). Keys in
+ *   `marketedOnlyFeatures` are deliberately exempt — marketed
+ *   non-code features (e.g. support SLAs) that never have a Capability.
+ * - **Quota existence** (`QUOTA_MISSING`): every `quotas` key must exist
+ *   as a `DiscoveredQuota` in the snapshot (provided the app uses quotas
+ *   at all — empty quotas are allowed).
+ * - **Plan key existence** (`BUNDLE_PLAN_KEY_UNKNOWN`, optional via
+ *   `knownPlanKeys`): every `compatibility.planIds[i]` must be an
+ *   existing PlanKey in the current Project. Called by the
+ *   BundlesService once the plan list is available;
+ *   `knownPlanKeys = null` skips the check (e.g. when the PlanRepository
+ *   is not registered).
+ * - **Approved gate** (`BUNDLE_FEATURE_NOT_APPROVED`/`QUOTA_NOT_APPROVED`,
+ *   optional via `approved`, #20 Slice 5): only approved features/quotas
+ *   (`discoveryStatus = 'approved'`) are sellable. `approved = null`
+ *   skips the approval part; marketed-only features are exempt.
+ * - **Feature dependencies** (`BUNDLE_FEATURE_DEPENDENCY_UNSATISFIED`, #35,
+ *   advisory): `requires` features that are not in the Bundle itself.
+ *
+ * **Not** checked (belongs in other validations):
+ * - Pricing (purely business, no discovery relation)
+ * - Compatibility.businessTypeKeys whitelists (BUNDLE_COMPATIBILITY code,
+ *   only checked at BusinessType publish)
+ * - Disjointness (BUNDLE_DISJOINTNESS, also a BusinessType concern)
+ */
+declare function validateBundleDraft(draft: {
+    features: string[];
+    quotas: Record<string, number>;
+    compatibility?: {
+        planIds?: string[];
+        businessTypeKeys?: string[];
+    };
+}, snapshot: DiscoverySnapshot, knownPlanKeys?: Set<string> | null, marketedOnlyFeatures?: ReadonlySet<string>, approved?: ApprovedCatalogKeys | null): StrictModeWarning[];
+/**
+ * Validates a BusinessType draft definition against the discovery snapshot
+ * and the referenced BundleVersions. Three violations:
+ *
+ * - **BUNDLE_DISJOINTNESS** (GESCHAEFTSTYP_SPEC §6.3): two Bundles in
+ *   the composition activate the same feature. Hard block at publish.
+ * - **BUNDLE_COMPATIBILITY** (GESCHAEFTSTYP_SPEC §6.4): a Bundle has set
+ *   a `compatibility.businessTypeKeys` whitelist, but the target
+ *   businessTypeKey is not included. Soft warning (no
+ *   hard block, but an audit marker on override).
+ * - **QUOTA_MISSING**: QuotaOverride keys that do not exist in discovery
+ *   (analogous to the Bundle strict check).
+ *
+ * Bundle existence and published status are checked in the service before
+ * this check (NotFoundException on a missing version, no warning).
+ */
+declare function validateBusinessTypeDraft(draft: {
+    businessTypeKey: string;
+    quotaOverrides: Record<string, number>;
+}, bundles: BundleVersionRow[], snapshot: DiscoverySnapshot, approved?: ApprovedCatalogKeys | null): StrictModeWarning[];
+/**
+ * Validates a PlanVersion draft definition against the discovery snapshot
+ * (SPEC_V2 §8.2 Pack 3a). Returns a (possibly empty) list of
+ * warnings.
+ *
+ * Checked:
+ * - **Feature existence** (`PLAN_FEATURE_UNKNOWN`): every `features[i]`
+ *   must exist as a `DiscoveredFeature` in the snapshot. Code is the
+ *   source of truth for features (via @ImplementsCapability). Keys in
+ *   `marketedOnlyFeatures` are deliberately exempt — marketed
+ *   non-code features (e.g. support SLAs) that never have a Capability.
+ * - **Quota existence** (`QUOTA_MISSING`): every `quotas` key must exist
+ *   as a `DiscoveredQuota` (via `@DefinesQuota`) in the snapshot.
+ * - **Approved gate** (`PLAN_FEATURE_NOT_APPROVED`/`QUOTA_NOT_APPROVED`,
+ *   optional via `approved`, #20 Slice 5): only approved features/quotas
+ *   are sellable. `approved = null` skips the approval part.
+ * - **Feature dependencies** (`PLAN_FEATURE_DEPENDENCY_UNSATISFIED`, #35,
+ *   advisory): `requires` features that are not in the Plan itself —
+ *   may be covered at the Tenant by booked Bundles.
+ *
+ * **Not** checked (belongs in other validations):
+ * - Pricing (purely business)
+ * - Marketing fields (separately in §8.2 item 6)
+ */
+declare function validatePlanDraft(draft: {
+    features: string[];
+    quotas: Record<string, number>;
+}, snapshot: DiscoverySnapshot, marketedOnlyFeatures?: ReadonlySet<string>, approved?: ApprovedCatalogKeys | null): StrictModeWarning[];
+
+/**
+ * Signature of a feature's capability set: `capabilityKey@codeStatus`,
+ * sorted and `|`-separated. `internal` capabilities do not count (they also
+ * do not appear in the catalog).
+ *
+ * `requires`/`replaces` (#35/#39) are only included when they are set —
+ * this keeps existing signatures without that metadata byte-identical;
+ * otherwise the platform upgrade would flip every approved entry to
+ * `outdated` even though nothing in the code changed.
+ */
+declare function featureApprovalSignature(featureKey: string, snapshot: DiscoverySnapshot): string;
+/**
+ * Signature of the code-derived quota facts:
+ * `unit|enforcementMode|usageProvider|featureKey`. `enforcementMode` is the
+ * catalog view of the policy (`hardCap` → `hard`, otherwise `soft`) —
+ * identical to the derivation in the sync. `replaces` (#39) is only appended
+ * when set (same stability rationale as `featureApprovalSignature`).
+ */
+declare function quotaApprovalSignature(quota: DiscoveredQuota): string;
+
+declare function loadApprovedCatalogKeys(repo: CatalogEntryRepository | null, projectKey: string): Promise<ApprovedCatalogKeys | null>;
+
+interface PreflightInput {
+    snapshot: DiscoverySnapshot;
+    /** All live PlanVersions (publishedAt != null AND supersededAt = null). */
+    planVersions: PlanVersionRow[];
+    /** All live BundleVersions. */
+    bundleVersions: BundleVersionRow[];
+    /** All live BusinessTypeVersions. */
+    businessTypeVersions: BusinessTypeVersionRow[];
+    /**
+     * Approved gate (#20 Slice 5): approved feature/quota keys from the
+     * catalog entries (`loadApprovedCatalogKeys`). Omitted/`null` →
+     * existence checks only.
+     */
+    approved?: ApprovedCatalogKeys | null;
+}
+interface PreflightFinding {
+    /** `plan` / `bundle` / `business-type`. */
+    kind: 'plan' | 'bundle' | 'business-type';
+    /** ID of the specific version the violation is attached to. */
+    versionId: string;
+    /** Human-readable key for the UI: `STARTER` or `BANKING` or `SPORT_VEREIN`. */
+    entityKey: string;
+    /** Version number. */
+    version: number;
+    warning: StrictModeWarning;
+}
+interface PreflightReport {
+    /** `'ok'` if no findings; otherwise `'error'`. */
+    overall: 'ok' | 'error';
+    /** Aggregated statistics: how many violations per kind. */
+    counts: {
+        planFindings: number;
+        bundleFindings: number;
+        businessTypeFindings: number;
+        total: number;
+    };
+    findings: PreflightFinding[];
+}
+/**
+ * Runs all three strict checks against the discovery snapshot.
+ * Collects findings by entity type and returns a sorted report
+ * (deterministic for test stability).
+ */
+declare function runPreflight(input: PreflightInput): PreflightReport;
+/**
+ * Formats the report output for CLI stdout. Returns a multi-line string.
+ */
+declare function formatPreflightReport(report: PreflightReport): string;
+/** Exit code for the CLI wrapping: 0 on OK, 4 on violations. */
+declare function preflightExitCode(report: PreflightReport): number;
+
+interface SeedPlanDraft {
+    planKey: string;
+    features: string[];
+    quotas?: Record<string, number>;
+}
+interface SeedBundleDraft {
+    bundleKey: string;
+    features: string[];
+    quotas?: Record<string, number>;
+}
+interface SeedGateInput {
+    snapshot: DiscoverySnapshot;
+    /** Plan drafts to seed (before persisting). */
+    plans?: SeedPlanDraft[];
+    /** Bundle drafts to seed (before persisting). */
+    bundles?: SeedBundleDraft[];
+    /**
+     * Approved gate (#20 Slice 5): approved feature/quota keys from the
+     * catalog entries (`loadApprovedCatalogKeys`). Omitted/`null` →
+     * existence checks only (e.g. first seed, before any catalog entries exist).
+     */
+    approved?: ApprovedCatalogKeys | null;
+}
+interface SeedGateFinding {
+    kind: 'plan' | 'bundle';
+    /** Human-readable key: `STARTER` or `BANKING`. */
+    entityKey: string;
+    warning: StrictModeWarning;
+}
+interface SeedGateReport {
+    /** `'ok'` if no findings; otherwise `'error'`. */
+    overall: 'ok' | 'error';
+    counts: {
+        planFindings: number;
+        bundleFindings: number;
+        total: number;
+    };
+    findings: SeedGateFinding[];
+}
+/**
+ * Validates seeded plan/bundle drafts against the DiscoverySnapshot.
+ * Collects findings and returns a deterministically sorted report.
+ */
+declare function validateSeedAgainstSnapshot(input: SeedGateInput): SeedGateReport;
+/** Formats the report output for CLI/seed stdout. Returns a multi-line string. */
+declare function formatSeedGateReport(report: SeedGateReport): string;
+/** Exit code for CLI/seed wrapping: 0 on OK, 4 on violations (analogous to Preflight). */
+declare function seedGateExitCode(report: SeedGateReport): number;
+
+type SeedGateMode = 'report-only' | 'blocking';
+interface SeedGateRunOptions {
+    /** Path of the snapshot file persisted by the scanner. */
+    snapshotPath: string;
+    plans?: SeedPlanDraft[];
+    bundles?: SeedBundleDraft[];
+    /** Approved gate (#20 Slice 5) — `null`/omitted = existence checks only. */
+    approved?: ApprovedCatalogKeys | null;
+    /** Default `'report-only'`; consumers map their env variable onto this. */
+    mode?: SeedGateMode;
+    /** Log sinks — default `console.log`/`console.warn`/`console.error`. */
+    log?: (line: string) => void;
+    warn?: (line: string) => void;
+    error?: (line: string) => void;
+    /** Exit function in the blocking case — default `process.exit`. Injectable in tests. */
+    exit?: (code: number) => never;
+}
+/**
+ * Loads the snapshot, validates the seed drafts and prints the report.
+ * Returns the report — or `null` if the snapshot is missing and the mode
+ * is report-only (gate skipped). In blocking mode the function does not
+ * return on violations or a missing snapshot (exit 4).
+ */
+declare function runSeedGateFromFile(options: SeedGateRunOptions): SeedGateReport | null;
+
+declare class CreateBundleDto {
+    projectKey: string;
+    bundleKey: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    sortOrder?: number;
+    /** Locale translations { "en": { label, description }, … }. */
+    i18n?: Record<string, {
+        label?: string;
+        description?: string;
+    }>;
+}
+declare class UpdateBundleDto {
+    label?: string;
+    description?: string | null;
+    icon?: string | null;
+    sortOrder?: number;
+    /** Locale translations { "en": { label, description }, … }. */
+    i18n?: Record<string, {
+        label?: string;
+        description?: string;
+    }>;
+}
+declare class CreateBundleVersionDraftDto {
+    features: string[];
+    quotas?: Record<string, number>;
+    compatibility?: {
+        businessTypeKeys?: string[];
+        planIds?: string[];
+    };
+    pricingOverrides?: Array<{
+        businessTypeKey?: string;
+        planId?: string;
+        monthlyNet?: string | null;
+        yearlyNet?: string | null;
+    }>;
+    monthlyNet?: string | null;
+    yearlyNet?: string | null;
+    marketed?: boolean;
+    changeNote?: string;
+    baseVersionId?: string | null;
+    validFrom?: string | null;
+    validUntil?: string | null;
+}
+declare class UpdateBundleVersionDraftDto {
+    features?: string[];
+    quotas?: Record<string, number>;
+    compatibility?: {
+        businessTypeKeys?: string[];
+        planIds?: string[];
+    };
+    pricingOverrides?: Array<{
+        businessTypeKey?: string;
+        planId?: string;
+        monthlyNet?: string | null;
+        yearlyNet?: string | null;
+    }>;
+    monthlyNet?: string | null;
+    yearlyNet?: string | null;
+    marketed?: boolean;
+    changeNote?: string;
+    validFrom?: string | null;
+    validUntil?: string | null;
+}
+declare class PublishBundleVersionDto {
+    forceRegressive?: boolean;
+    /**
+     * Allows a deliberately free bundle (explicit price 0.00) and lifts the
+     * zero-price gate (otherwise 422 BUNDLE_VERSION_ZERO_PRICE). Default: gate
+     * active (protection against seed placeholders).
+     */
+    allowZeroPrice?: boolean;
+    /**
+     * Required on publish if the draft carries no `validFrom`
+     * (SPEC_V2 §4.2 + §11.1 M6 Pack 2c, analogous to PublishPlanVersionDto).
+     * Service strictly checks > `validFrom` of the predecessor version.
+     */
+    validFrom?: string | null;
+    validUntil?: string | null;
+}
+
+declare class CreateBusinessTypeDto {
+    projectKey: string;
+    businessTypeKey: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    sortOrder?: number;
+}
+declare class UpdateBusinessTypeDto {
+    label?: string;
+    description?: string | null;
+    icon?: string | null;
+    sortOrder?: number;
+}
+declare class BusinessTypeBundleInputDto {
+    bundleVersionId: string;
+    sortOrder?: number;
+}
+declare class CreateBusinessTypeVersionDraftDto {
+    bundles: BusinessTypeBundleInputDto[];
+    quotaOverrides?: Record<string, number>;
+    monthlyNet?: string | null;
+    yearlyNet?: string | null;
+    marketed?: boolean;
+    changeNote?: string;
+    baseVersionId?: string | null;
+}
+declare class UpdateBusinessTypeVersionDraftDto {
+    bundles?: BusinessTypeBundleInputDto[];
+    quotaOverrides?: Record<string, number>;
+    monthlyNet?: string | null;
+    yearlyNet?: string | null;
+    marketed?: boolean;
+    changeNote?: string;
+}
+declare class PublishBusinessTypeVersionDto {
+    forceRegressive?: boolean;
+}
+
+declare class MarketingTopFeatureDto {
+    /** Optional feature/quota key reference (auto-translation of the label). */
+    key?: string;
+    /** Free text or override; empty + `key` set = auto label. */
+    label: string;
+    /** Optional bold addendum — may be empty. */
+    strong: string;
+}
+declare class CreateMarketingProjectionDto {
+    projectKey: string;
+    targetType: 'PLAN' | 'BUNDLE' | 'BUSINESS_TYPE';
+    targetVersionId: string;
+    locale?: string;
+    displayLabel: string;
+    description: string;
+    visible?: boolean;
+    badge?: string;
+    topFeatures?: MarketingTopFeatureDto[];
+    trialEnabled?: boolean;
+    trialDays?: number;
+    priceTag?: string | null;
+    ctaLabel?: string | null;
+    priority?: number;
+    highlight?: boolean;
+}
+declare class UpdateMarketingProjectionDto {
+    displayLabel?: string;
+    description?: string;
+    visible?: boolean;
+    badge?: string;
+    topFeatures?: MarketingTopFeatureDto[];
+    trialEnabled?: boolean;
+    trialDays?: number;
+    priceTag?: string | null;
+    ctaLabel?: string | null;
+    priority?: number;
+    highlight?: boolean;
+}
+declare class ListMarketingProjectionsQueryDto {
+    projectKey: string;
+    targetType?: 'PLAN' | 'BUNDLE' | 'BUSINESS_TYPE';
+    targetVersionId?: string;
+    locale?: string;
+}
+
+declare class ListCatalogEntriesQueryDto {
+    projectKey: string;
+    /** Filter for features/quotas (approval lifecycle). */
+    discoveryStatus?: string;
+    /** Filter for capabilities (read-only code facts). */
+    codeStatus?: string;
+}
+/**
+ * Body of `PATCH …/{features,quotas}/:key/review` — target status of the
+ * approval state machine (#20). Allowed transitions are validated by the service.
+ */
+declare class ReviewCatalogEntryDto {
+    discoveryStatus: DiscoveryStatus;
+}
+/** Body of `PATCH …/{features,quotas}/:key/i18n`. */
+declare class UpdateCatalogEntryI18nDto {
+    i18n: CatalogEntryI18n;
+}
+/**
+ * Body of `POST …/discovery/sync` — the discovery snapshot the UI
+ * previously loaded from `GET /admin/discovery`. Validated by the service
+ * against `projectKey`; deep validation is not needed because the
+ * SuperAdmin guard secures the source.
+ */
+declare class SyncDiscoveryDto {
+    snapshot: DiscoverySnapshot;
+}
+
+declare class ListPromotionsQueryDto {
+    projectKey: string;
+}
+declare class CreatePromotionDto {
+    projectKey: string;
+    internalLabel: string;
+    type: PromotionType;
+    /** Type-dependent: number | { price, months }. */
+    value: PromotionValue;
+    appliesTo?: string[];
+    targetType?: PromotionTargetType;
+    billingCycle?: PromotionBillingCycle;
+    validFrom: string;
+    validTo: string;
+    priority?: number;
+    onlyLocales?: string[] | null;
+    requiresCoupon?: boolean;
+    codes?: string[];
+    color?: string;
+    i18n?: PromotionI18n;
+}
+declare class UpdatePromotionDto {
+    internalLabel?: string;
+    type?: PromotionType;
+    value?: PromotionValue;
+    appliesTo?: string[];
+    targetType?: PromotionTargetType;
+    billingCycle?: PromotionBillingCycle;
+    validFrom?: string;
+    validTo?: string;
+    priority?: number;
+    onlyLocales?: string[] | null;
+    requiresCoupon?: boolean;
+    codes?: string[];
+    color?: string;
+    i18n?: PromotionI18n;
+}
+
+declare class ListMarketingSettingsQueryDto {
+    projectKey: string;
+}
+/** Body of `PUT /admin/catalog/marketing-settings`. */
+declare class UpdateMarketingSettingsDto {
+    projectKey: string;
+    activeLocales: string[];
+}
+
+declare class CreatePlanDto {
+    projectKey: string;
+    planKey: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    sortOrder?: number;
+}
+declare class UpdatePlanDto {
+    label?: string;
+    description?: string | null;
+    icon?: string | null;
+    sortOrder?: number;
+}
+
+declare class CreatePlanVersionDraftDto {
+    features: string[];
+    /**
+     * Persisted bundle selection (bundleKeys, SCREAMING_SNAKE_CASE).
+     * Optional + defaults to empty — see `PlanVersionRow.bundles`.
+     */
+    bundles?: string[];
+    quotas: Record<string, number>;
+    monthlyNet: string;
+    yearlyNet: string;
+    marketed?: boolean;
+    changeNote?: string;
+    baseVersionId?: string | null;
+    /** Optional in the draft (required at publish). ISO date string. SPEC_V2 §4.2. */
+    validFrom?: string | null;
+    /** Optional; null = unlimited. ISO date string. */
+    validUntil?: string | null;
+}
+declare class UpdatePlanVersionDraftDto {
+    features?: string[];
+    /** Persisted bundle selection (bundleKeys). See `PlanVersionRow.bundles`. */
+    bundles?: string[];
+    quotas?: Record<string, number>;
+    monthlyNet?: string;
+    yearlyNet?: string;
+    marketed?: boolean;
+    changeNote?: string;
+    validFrom?: string | null;
+    validUntil?: string | null;
+}
+declare class PublishPlanVersionDto {
+    forceRegressive?: boolean;
+    /**
+     * Deliberately allows free special contracts (price 0.00) and thereby lifts
+     * the zero-price gate (otherwise 422 PLAN_VERSION_ZERO_PRICE). Default:
+     * gate active (protection against seed placeholders).
+     */
+    allowZeroPrice?: boolean;
+    /**
+     * Required at publish (on the DTO or draft). The service strictly checks
+     * `validFrom > predecessor.validFrom`. SPEC_V2 §4.2.
+     */
+    validFrom?: string | null;
+    validUntil?: string | null;
+}
+
+export { ADVISORY_STRICT_MODE_CODES, BUNDLE_REPOSITORY_TOKEN, BUSINESS_TYPE_REPOSITORY_TOKEN, BundlesService, BusinessTypeBundleInputDto, BusinessTypesService, CATALOG_ENTRY_REPOSITORY_TOKEN, CATALOG_SERVICE_CONFIG_TOKEN, type CatalogControllerConfig, CatalogEntriesService, CatalogModule, type CatalogModuleOptions, type CatalogServiceConfig, CreateBundleDto, CreateBundleVersionDraftDto, CreateBusinessTypeDto, CreateBusinessTypeVersionDraftDto, CreateMarketingProjectionDto, CreatePlanDto, CreatePlanVersionDraftDto, CreatePromotionDto, ListCatalogEntriesQueryDto, ListMarketingProjectionsQueryDto, ListMarketingSettingsQueryDto, ListPromotionsQueryDto, MARKETING_PROJECTION_REPOSITORY_TOKEN, MARKETING_SETTINGS_REPOSITORY_TOKEN, MarketingProjectionsService, MarketingSettingsService, PLAN_REPOSITORY_TOKEN, PROMOTION_REPOSITORY_TOKEN, PlanVersionsService, PlansService, type PreflightFinding, type PreflightInput, type PreflightReport, PromotionsService, PublicMarketingCatalogService, PublishBundleVersionDto, PublishBusinessTypeVersionDto, PublishPlanVersionDto, ReviewCatalogEntryDto, type SeedBundleDraft, type SeedGateFinding, type SeedGateInput, type SeedGateMode, type SeedGateReport, type SeedGateRunOptions, type SeedPlanDraft, SyncDiscoveryDto, UpdateBundleDto, UpdateBundleVersionDraftDto, UpdateBusinessTypeDto, UpdateBusinessTypeVersionDraftDto, UpdateCatalogEntryI18nDto, UpdateMarketingProjectionDto, UpdateMarketingSettingsDto, UpdatePlanDto, UpdatePlanVersionDraftDto, UpdatePromotionDto, blockingStrictModeWarnings, buildBundleVersionsController, buildBundlesController, buildBusinessTypeVersionsController, buildBusinessTypesController, buildCatalogEntriesController, buildMarketingProjectionsController, buildMarketingSettingsController, buildPlanVersionsController, buildPlansController, buildPromotionsController, buildPublicMarketingCatalogController, featureApprovalSignature, formatPreflightReport, formatSeedGateReport, loadApprovedCatalogKeys, preflightExitCode, quotaApprovalSignature, runPreflight, runSeedGateFromFile, seedGateExitCode, validateBundleDraft, validateBusinessTypeDraft, validatePlanDraft, validateSeedAgainstSnapshot };