@saasicat/adapter-prisma 0.6.0 → 0.7.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { PersistenceInjectionToken, PasswordHasher, SaasicatPersistenceAdapter, TransactionRunner, TransactionContext, MfaPort, AuditPort, AdminActor, AuditQueryPort, AuditQuery, AuditEntry, AuditStatsPort, RlsBypassPort, SubscriptionRepository, SubscriptionRecord, SubscriptionBundleRepository, SubscriptionBundleRecord, CreateSubscriptionBundleData, CancelSubscriptionBundleData, TenantSubscriptionWritePort, ImmediatePlanChangeInput, ScheduledPlanChangeInput, PlanVersionRepository, PlanVersionRecord, PromoCodeRepository, PromoCodeRecord, PromoCodeFilter, CreatePromoCodeData, UpdatePromoCodeData, PromoCodeRedemptionRepository, PromoCodeRedemptionRecord, PromoCodeRedemptionStatus, PromoCodeRedemptionListItem, PromoCodeValidationLogRepository, PromoSubscriptionLookup, BillingCycle, PromoRevenueDeductionAggregator, SuperAdminProvisioningPort, CreateSuperAdminCliInput, PlatformUserDto, PlanCatalogReadSink, PlanCatalogReadSnapshot, PlanCatalogImportSink, UpsertPlanInput, UpsertResult, UpsertPlanVersionInput, UpsertFeatureCatalogEntryInput, PlanRepository, PlanListFilter, PlanRow, CreatePlanData, UpdatePlanData, PlanVersionRow, CreatePlanVersionDraftData, UpdatePlanVersionDraftData, VersionChange, BundleRepository, BundleListFilter, BundleRow, CreateBundleData, UpdateBundleData, BundleVersionRow, CreateBundleVersionDraftData, UpdateBundleVersionDraftData, CatalogEntryRepository, CatalogEntryFilter, CapabilityCatalogEntryRow, FeatureCatalogEntryRow, QuotaCatalogEntryRow, UpsertCapabilityEntryData, UpsertFeatureEntryData, UpsertQuotaEntryData, SetCatalogEntryReviewData, CatalogEntryI18n, UpdateCatalogEntryBaseData, MarketingProjectionRepository, MarketingProjectionFilter, MarketingProjectionRow, CreateMarketingProjectionData, UpdateMarketingProjectionData, MarketingSettingsRepository, MarketingSettingsRow, UpdateMarketingSettingsData, PromotionRepository, PromotionFilter, PromotionRow, CreatePromotionData, UpdatePromotionData, SubscriptionContractRepository, SubscriptionContractFilter, SubscriptionContractRecord, CreateSubscriptionContractData, TerminateSubscriptionContractData } from '@saasicat/types';
+import { PersistenceInjectionToken, PasswordHasher, SaasicatPersistenceAdapter, TransactionRunner, TransactionContext, MfaPort, AuditPort, AdminActor, AuditQueryPort, AuditQuery, AuditEntry, AuditStatsPort, RlsBypassPort, SubscriptionRepository, SubscriptionRecord, SubscriptionBundleRepository, SubscriptionBundleRecord, CreateSubscriptionBundleData, CancelSubscriptionBundleData, TenantSubscriptionWritePort, ApplyOnboardingSelectionInput, RedeemPromoInTransactionCallback, ApplyOnboardingSelectionResult, ImmediatePlanChangeInput, ScheduledPlanChangeInput, PlanVersionRepository, PlanVersionRecord, PromoCodeRepository, PromoCodeRecord, PromoCodeFilter, CreatePromoCodeData, UpdatePromoCodeData, PromoCodeRedemptionRepository, PromoCodeRedemptionRecord, PromoCodeRedemptionStatus, PromoCodeRedemptionListItem, PromoCodeValidationLogRepository, PromoSubscriptionLookup, BillingCycle, PromoRevenueDeductionAggregator, SuperAdminProvisioningPort, CreateSuperAdminCliInput, PlatformUserDto, PlanCatalogReadSink, PlanCatalogReadSnapshot, PlanCatalogImportSink, UpsertPlanInput, UpsertResult, UpsertPlanVersionInput, UpsertFeatureCatalogEntryInput, PlanRepository, PlanListFilter, PlanRow, CreatePlanData, UpdatePlanData, PlanVersionRow, CreatePlanVersionDraftData, UpdatePlanVersionDraftData, VersionChange, BundleRepository, BundleVersionRow, BundleListFilter, BundleRow, CreateBundleData, UpdateBundleData, CreateBundleVersionDraftData, UpdateBundleVersionDraftData, CatalogEntryRepository, CatalogEntryFilter, CapabilityCatalogEntryRow, FeatureCatalogEntryRow, QuotaCatalogEntryRow, UpsertCapabilityEntryData, UpsertFeatureEntryData, UpsertQuotaEntryData, SetCatalogEntryReviewData, CatalogEntryI18n, UpdateCatalogEntryBaseData, MarketingProjectionRepository, MarketingProjectionFilter, MarketingProjectionRow, CreateMarketingProjectionData, UpdateMarketingProjectionData, MarketingSettingsRepository, MarketingSettingsRow, UpdateMarketingSettingsData, PromotionRepository, PromotionFilter, PromotionRow, CreatePromotionData, UpdatePromotionData, SubscriptionContractRepository, SubscriptionContractFilter, SubscriptionContractRecord, CreateSubscriptionContractData, TerminateSubscriptionContractData } from '@saasicat/types';
 
 declare const PRISMA_CLIENT_TOKEN: unique symbol;
 /** Prisma `Decimal` values arrive as objects with `toString()`; tests may use plain values. */
@@ -37,6 +37,9 @@ interface PlanVersionRowLike {
     nonRegressive: boolean;
     createdByUserId: string | null;
     publishedByUserId: string | null;
+    validFrom?: Date | null;
+    validUntil?: Date | null;
+    endsAt?: Date | null;
     createdAt: Date;
     updatedAt: Date;
 }
@@ -578,6 +581,102 @@ interface PrismaModelDelegateLike<Row> {
     count(args?: unknown): Promise<number>;
 }
 
+/**
+ * How `PlanVersion.planId` is persisted.
+ *
+ * - `legacy-plan-key`: SaaSiCat 0.6 behavior. `planId` stores the semantic
+ *   `Plan.planKey` directly and no lookup is performed.
+ * - `normalized-plan-id`: `planId` stores the database `Plan.id` foreign key.
+ *   Adapter ports still accept and return semantic plan keys.
+ */
+type PrismaPlanBindingMode = 'legacy-plan-key' | 'normalized-plan-id';
+type PrismaPlanBindingOptions = {
+    mode?: 'legacy-plan-key';
+    projectKey?: string;
+} | {
+    mode: 'normalized-plan-id';
+    projectKey: string;
+};
+/**
+ * Prisma delegate names used by the two independent plan-version slices.
+ * Both default to `planVersion`, preserving the 0.6 canonical schema.
+ */
+interface PrismaPlanDelegateOptions {
+    catalogPlanVersion?: string;
+    entitlementPlanVersion?: string;
+}
+interface PrismaPlanVersionFieldCapabilities {
+    /** The delegate carries `validFrom` and `validUntil` columns. */
+    validityWindows?: boolean;
+    /** The delegate carries the optional, precise `endsAt` timestamp. */
+    endsAt?: boolean;
+}
+/**
+ * Shared field defaults plus optional per-slice overrides. A consumer with
+ * one plan-version model can set the top-level flags; split schemas can
+ * configure catalog and entitlement independently.
+ */
+interface PrismaPlanVersionFieldOptions extends PrismaPlanVersionFieldCapabilities {
+    catalog?: PrismaPlanVersionFieldCapabilities;
+    entitlement?: PrismaPlanVersionFieldCapabilities;
+}
+interface PrismaTenantSubscriptionOptions {
+    /**
+     * Prisma model delegate used for every Subscription ORM operation.
+     * Locked reads still address the canonical physical `subscriptions`
+     * table, so a differently named model must use `@@map("subscriptions")`.
+     */
+    delegate?: string;
+    /**
+     * Optional SubscriptionBundle delegate used for BundleVersion booking
+     * counts. `false` keeps the capability absent for schemas without the
+     * junction table.
+     */
+    subscriptionBundleDelegate?: string | false;
+    synchronizePlanVersion?: boolean;
+    /** Expose the optional atomic onboarding + promo callback capability. */
+    atomicOnboardingSelection?: boolean;
+    activeVersionSelection?: 'latest-live' | 'validity-window';
+    withEndsAt?: boolean;
+}
+/** Schema differences understood by the plan-related Prisma adapters. */
+interface PrismaSchemaOptions {
+    planBinding?: PrismaPlanBindingOptions;
+    delegates?: PrismaPlanDelegateOptions;
+    planVersionFields?: PrismaPlanVersionFieldOptions;
+    tenantSubscription?: PrismaTenantSubscriptionOptions;
+}
+interface ResolvedPrismaSchemaOptions {
+    planBinding: {
+        mode: PrismaPlanBindingMode;
+        projectKey?: string;
+    };
+    delegates: {
+        catalogPlanVersion: string;
+        entitlementPlanVersion: string;
+    };
+    planVersionFields: {
+        catalog: Required<PrismaPlanVersionFieldCapabilities>;
+        entitlement: Required<PrismaPlanVersionFieldCapabilities>;
+    };
+    tenantSubscription: Required<PrismaTenantSubscriptionOptions>;
+}
+/**
+ * Optional DI token for direct Nest registration of individual adapters.
+ * `prismaPersistence()` passes the options to constructors itself.
+ */
+declare const PRISMA_SCHEMA_OPTIONS_TOKEN: unique symbol;
+interface PrismaPlanBindingResolver {
+    readonly mode: PrismaPlanBindingMode;
+    readonly projectKey?: string;
+    toStoragePlanId(client: unknown, planKey: string, projectKey?: string): Promise<string>;
+    toPlanKey(client: unknown, storedPlanId: string, projectKey?: string): Promise<string>;
+}
+declare function resolvePrismaSchemaOptions(options?: PrismaSchemaOptions): ResolvedPrismaSchemaOptions;
+declare function createPrismaPlanBindingResolver(options?: PrismaPlanBindingOptions): PrismaPlanBindingResolver;
+/** Resolves a configurable Prisma delegate and fails early on misspellings. */
+declare function getPrismaDelegate<Row>(client: unknown, delegateName: string): PrismaModelDelegateLike<Row>;
+
 interface PrismaPersistenceOptions {
     /**
      * The app's Prisma client: either its injection token (typically the
@@ -599,6 +698,12 @@ interface PrismaPersistenceOptions {
      * middleware. Default false.
      */
     rlsIntegration?: boolean;
+    /**
+     * Optional plan-schema adaptations. Omitted means the exact 0.6 layout:
+     * soft `planId === planKey`, one `planVersion` delegate, no validity or
+     * termination columns.
+     */
+    schema?: PrismaSchemaOptions;
 }
 /**
  * Builds the `SaasicatPersistenceAdapter` bundle for Prisma + PostgreSQL on
@@ -629,7 +734,7 @@ declare function prismaPersistence(options: PrismaPersistenceOptions): SaasicatP
  */
 declare class PrismaTransactionRunner implements TransactionRunner {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    constructor(prisma: Record<'$transaction', unknown>);
     run<T>(fn: (tx: TransactionContext) => Promise<T>): Promise<T>;
 }
 
@@ -650,7 +755,7 @@ declare class PrismaTransactionRunner implements TransactionRunner {
  */
 declare class PrismaMfaAdapter implements MfaPort {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    constructor(prisma: Pick<PrismaLike, 'superAdminMfa'>);
     getSecret(userId: string): Promise<string | null>;
     setSecret(userId: string, secret: string | null): Promise<void>;
     isEnabled(userId: string): Promise<boolean>;
@@ -667,7 +772,7 @@ declare function buildActorTag(actor: AdminActor): string;
  */
 declare class PrismaAuditAdapter implements AuditPort {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    constructor(prisma: Pick<PrismaLike, 'auditLog'>);
     write(input: {
         actor: AdminActor;
         entity: string;
@@ -683,14 +788,14 @@ declare class PrismaAuditAdapter implements AuditPort {
  */
 declare class PrismaAuditQueryAdapter implements AuditQueryPort {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    constructor(prisma: Pick<PrismaLike, 'auditLog'>);
     list(filter: AuditQuery): Promise<AuditEntry[]>;
 }
 
 /** `AuditStatsPort` against the canonical `audit_logs` table. */
 declare class PrismaAuditStatsAdapter implements AuditStatsPort {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    constructor(prisma: Pick<PrismaLike, 'auditLog'>);
     countSince(since: Date): Promise<number>;
 }
 
@@ -727,25 +832,44 @@ declare class AsyncLocalRlsBypassAdapter implements RlsBypassPort {
     isBypassActive(): boolean;
 }
 
+/** Root-client fields used directly; subscription and PlanVersion delegates are configurable. */
+interface SubscriptionRepositoryClient {
+    /** Used by normalized semantic-key ↔ UUID binding. */
+    plan: unknown;
+}
 /**
  * `SubscriptionRepository` against the canonical `subscriptions` +
  * `plan_versions` tables.
  *
- * `countByBundleVersionId` is deliberately not implemented (the
- * `subscription_bundles` junction is not part of this adapter's slice);
- * the platform then treats affected bundle versions as frozen (fail-closed).
+ * BundleVersion booking counts are an optional capability. Configure
+ * `tenantSubscription.subscriptionBundleDelegate` for schemas carrying the
+ * `subscription_bundles` junction; without it the platform keeps affected
+ * versions frozen (fail-closed).
  */
 declare class PrismaSubscriptionRepository implements SubscriptionRepository {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    readonly countByBundleVersionId?: (bundleVersionId: string) => Promise<number>;
+    private readonly binding;
+    private readonly planVersionDelegateName;
+    private readonly subscriptionDelegateName;
+    private readonly subscriptionBundleDelegateName;
+    constructor(prisma: SubscriptionRepositoryClient, options?: PrismaSchemaOptions);
+    private db;
     findByTenantId(tenantId: string): Promise<SubscriptionRecord | null>;
     findByTenantIdLocked(tenantId: string, tx: TransactionContext): Promise<SubscriptionRecord | null>;
     countByPlanVersionId(planVersionId: string): Promise<number>;
-    countActiveByPlanKey(_projectKey: string): Promise<Record<string, number>>;
+    countActiveByPlanKey(projectKey: string): Promise<Record<string, number>>;
+    private countActiveBundleBindings;
     private loadByTenantId;
     private toRecord;
+    private planVersions;
+    private subscriptions;
+    private planKeysForProject;
 }
 
+interface SubscriptionBundleClient {
+    subscriptionBundle: unknown;
+}
 /**
  * `SubscriptionBundleRepository` against the canonical `subscription_bundles`
  * junction (SPEC_V2 §11.1 M6 Pack 2e). Dumb persistence: domain constraints
@@ -756,7 +880,7 @@ declare class PrismaSubscriptionRepository implements SubscriptionRepository {
  */
 declare class PrismaSubscriptionBundleRepository implements SubscriptionBundleRepository {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    constructor(prisma: SubscriptionBundleClient);
     private db;
     listBySubscription(subscriptionId: string): Promise<SubscriptionBundleRecord[]>;
     findById(subscriptionBundleId: string): Promise<SubscriptionBundleRecord | null>;
@@ -767,24 +891,42 @@ declare class PrismaSubscriptionBundleRepository implements SubscriptionBundleRe
     countActiveByBundleVersionId(bundleVersionId: string, asOf?: Date): Promise<number>;
 }
 
+/** Structural minimum of the root client; model delegates are configurable. */
+interface TransactionalPrismaClient {
+    $transaction<T>(fn: (tx: unknown) => Promise<T>): Promise<T>;
+}
 /**
- * `TenantSubscriptionWritePort` against the canonical `subscriptions` table.
+ * `TenantSubscriptionWritePort` against a configurable Prisma subscription
+ * delegate.
+ *
+ * The 0.6 default remains deliberately conservative:
+ * `tenantSubscription.synchronizePlanVersion` is false, so
+ * `changePlanImmediate` writes the semantic `plan` and cycle exactly as
+ * before. Opting into synchronization resolves the target plan through the
+ * configured plan binding, selects its live/active PlanVersion, and writes
+ * `plan` + `planVersionId` in one transaction.
+ *
  * Pure persistence: trial carry-over (#17) and contract freeze (#18) are
  * resolved in the platform `changePlan` path and handed down as plain values —
  * this adapter only writes what it receives.
  *
- * The optional `applyOnboardingSelection` is not implemented; the platform
- * service then falls back to sequential `changePlanImmediate` + promo redeem
- * (best-effort, port contract P10.1.1).
+ * `applyOnboardingSelection` is an explicit opt-in capability. When
+ * `tenantSubscription.atomicOnboardingSelection` is true it uses one
+ * interactive transaction for the subscription write and optional promo
+ * callback. In synchronized mode it also binds the concrete PlanVersion and
+ * clears stale pending-version state.
  */
 declare class PrismaTenantSubscriptionWriteAdapter implements TenantSubscriptionWritePort {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
-    private db;
+    readonly applyOnboardingSelection?: (tenantId: string, input: ApplyOnboardingSelectionInput, redeemPromo: RedeemPromoInTransactionCallback | null) => Promise<ApplyOnboardingSelectionResult>;
+    private readonly schema;
+    private readonly planBinding;
+    constructor(prisma: TransactionalPrismaClient, options?: PrismaSchemaOptions);
     changePlanImmediate(tenantId: string, input: ImmediatePlanChangeInput): Promise<{
         plan: string;
         billingCycle: string;
     }>;
+    private changePlanImmediateInClient;
     schedulePlanChange(tenantId: string, input: ScheduledPlanChangeInput): Promise<void>;
     acceptPendingPlanVersion(tenantId: string, userId: string, now: Date): Promise<{
         accepted: boolean;
@@ -792,24 +934,44 @@ declare class PrismaTenantSubscriptionWriteAdapter implements TenantSubscription
         effectiveAt: Date | null;
         alreadyAccepted: boolean;
     }>;
+    private applyOnboardingSelectionAtomic;
     cancelSubscription(tenantId: string, immediate: boolean, now: Date): Promise<{
         canceledAt: Date | null;
         status: string;
     }>;
+    private subscription;
+    private planVersions;
+    private findTargetPlanVersionId;
+    private pendingVersionBelongsToAnotherPlan;
+    private assertConfiguration;
 }
 
+/**
+ * Root-client fields needed outside the configurable PlanVersion delegate.
+ * `plan` is used by normalized semantic-key ↔ UUID binding.
+ */
+interface PlanVersionRepositoryClient {
+    plan: unknown;
+}
 /**
  * `PlanVersionRepository` against the canonical `plan_versions` table.
  *
- * `findActive` is deliberately not implemented: the canonical schema carries
- * no `validFrom`/`validUntil` columns yet, so time-aware resolution is not
- * expressible — consumers fall back to `findLatestLive` (documented port
- * behavior).
+ * `findActive` remains absent with the canonical 0.6 defaults. Extended
+ * schemas enable it through `schema.planVersionFields.entitlement`; its query
+ * then uses the shared day-inclusive validity semantics.
  */
 declare class PrismaPlanVersionRepository implements PlanVersionRepository {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    readonly findActive?: (planId: string, asOf?: Date, tx?: TransactionContext) => Promise<PlanVersionRecord | null>;
+    private readonly binding;
+    private readonly delegateName;
+    private readonly fields;
+    constructor(prisma: PlanVersionRepositoryClient, options?: PrismaSchemaOptions);
+    private db;
     findLatestLive(planId: string, tx?: TransactionContext): Promise<PlanVersionRecord | null>;
+    private findActivePlanVersion;
+    private versions;
+    private toRecord;
 }
 
 /**
@@ -909,58 +1071,82 @@ declare class PrismaSuperAdminBootstrapAdapter implements SuperAdminProvisioning
     createSuperAdmin(input: CreateSuperAdminCliInput): Promise<PlatformUserDto>;
 }
 
+/** Root-client fields used directly; the PlanVersion delegate is configurable. */
+interface PlanCatalogReadClient {
+    plan: unknown;
+    featureCatalogEntry: unknown;
+}
 /**
  * `PlanCatalogReadSink` against the canonical `plans`, `plan_versions` and
  * `feature_catalog_entries` tables — DB hydration of the plan catalog at
  * boot (`PlanCatalogModule.forRoot({ sink })`).
  *
- * `validFrom`/`validUntil` are reported as null: the canonical schema does
- * not persist booking windows yet (see docs/data-model.md, "Known gaps").
+ * The canonical 0.6 defaults report validity fields as null. Extended schemas
+ * can opt into validity/termination fields and can point this sink at a
+ * catalog-specific plan-version delegate.
  */
 declare class PrismaPlanCatalogReadSink implements PlanCatalogReadSink {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    private readonly binding;
+    private readonly delegateName;
+    private readonly fields;
+    constructor(prisma: PlanCatalogReadClient, options?: PrismaSchemaOptions);
+    private db;
     loadSnapshot(projectKey: string): Promise<PlanCatalogReadSnapshot>;
+    private planVersions;
 }
 
+/** Root-client fields used directly; the PlanVersion delegate is configurable. */
+interface PlanCatalogImportClient {
+    plan: unknown;
+    featureCatalogEntry: unknown;
+}
 /**
  * `PlanCatalogImportSink` against the canonical catalog tables — the
  * one-shot `saas.yaml → DB` import at boot.
  *
  * Idempotency per the port contract: existing rows (identity match) are
- * skipped without error; only the created/skipped flags are reported.
+ * skipped without error; only the created/skipped flags are reported. In
+ * normalized mode the semantic `planKey` input is resolved to `Plan.id`.
  */
 declare class PrismaPlanCatalogImportSink implements PlanCatalogImportSink {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    private readonly binding;
+    private readonly delegateName;
+    constructor(prisma: PlanCatalogImportClient, options?: PrismaSchemaOptions);
+    private db;
     upsertPlan(input: UpsertPlanInput): Promise<UpsertResult>;
     upsertPlanVersion(input: UpsertPlanVersionInput): Promise<UpsertResult>;
+    private planVersions;
     upsertFeatureCatalogEntry(input: UpsertFeatureCatalogEntryInput): Promise<UpsertResult>;
 }
 
+/** Root-client fields used directly; the version delegate is configurable. */
+interface PlanRepositoryClient {
+    plan: unknown;
+    $transaction<T>(fn: (tx: unknown) => Promise<T>): Promise<T>;
+}
 /**
  * `PlanRepository` against the canonical `plans` + `plan_versions` tables
  * (SPEC_V2 §11.1 M6). Plan stem CRUD (Pack 1) and PlanVersion lifecycle
- * (Pack 2a) live in one adapter; the soft binding is
- * `PlanVersion.planId === Plan.planKey`, so the lifecycle methods take the
- * **planKey**, not the plan UUID.
+ * (Pack 2a) live in one adapter. Ports always use the semantic **planKey**;
+ * storage defaults to the 0.6 soft binding
+ * `PlanVersion.planId === Plan.planKey`. The opt-in normalized binding resolves
+ * that key to `Plan.id` for every database operation.
  *
- * Schema limitation: the canonical `plan_versions` fragment
- * (03-plan-versions.prisma) intentionally has no validity-window columns
- * (`validFrom`/`validUntil`) and no `endsAt` column — it carries a generic
- * `quotas Json` instead of fixed quota columns. Consequences:
- * - Every `PlanVersionRow.validFrom`/`validUntil` maps to `null`.
- * - `publishPlanVersionDraft` persists only the publish/supersede state; the
- *   `validFrom`/`validUntil` in `publishMeta` cannot be stored, so
- *   auto-succession reduces to setting `supersededAt` on the previous live version.
- * - `findActivePlanVersion` (validity-window read) and `terminate` (endsAt)
- *   throw, because their contract depends on columns this schema does not have.
- *   Consumers that need them provide a custom adapter on an extended schema.
+ * The canonical 0.6 schema has neither validity-window nor `endsAt` columns.
+ * Both capabilities therefore default off for rolling compatibility; apps
+ * that applied the current additive schema opt in through
+ * `schema.planVersionFields.catalog`.
  */
 declare class PrismaPlanRepository implements PlanRepository {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    private readonly binding;
+    private readonly delegateName;
+    private readonly fields;
+    constructor(prisma: PlanRepositoryClient, options?: PrismaSchemaOptions);
     private db;
+    private versions;
     list(filter: PlanListFilter): Promise<PlanRow[]>;
     findById(planId: string): Promise<PlanRow | null>;
     findByKey(projectKey: string, planKey: string): Promise<PlanRow | null>;
@@ -972,7 +1158,7 @@ declare class PrismaPlanRepository implements PlanRepository {
     findVersionById(versionId: string): Promise<PlanVersionRow | null>;
     findCurrentDraft(planKey: string): Promise<PlanVersionRow | null>;
     findLatestLivePlanVersion(planKey: string, tx?: TransactionContext): Promise<PlanVersionRow | null>;
-    findActivePlanVersion(): Promise<PlanVersionRow | null>;
+    findActivePlanVersion(planKey: string, asOf?: Date, tx?: TransactionContext): Promise<PlanVersionRow | null>;
     createPlanVersionDraft(data: CreatePlanVersionDraftData): Promise<PlanVersionRow>;
     updatePlanVersionDraft(versionId: string, data: UpdatePlanVersionDraftData): Promise<PlanVersionRow>;
     publishPlanVersionDraft(versionId: string, publishMeta: {
@@ -983,30 +1169,64 @@ declare class PrismaPlanRepository implements PlanRepository {
         validUntil: Date | null;
     }, tx?: TransactionContext): Promise<PlanVersionRow>;
     deletePlanVersionDraft(versionId: string): Promise<void>;
-    terminate(): Promise<PlanVersionRow>;
+    terminate(versionId: string, endsAt: Date): Promise<PlanVersionRow>;
+    private toPlanVersionRow;
 }
 
+/**
+ * Root-client shape accepted by this repository. Delegates and `$transaction`
+ * stay opaque at the injection boundary because generated Prisma delegates
+ * have schema-specific generic signatures; calls are narrowed locally to the
+ * exact Bundle operations below.
+ */
+interface BundlePrismaClient {
+    bundle: unknown;
+    bundleVersion: unknown;
+    $transaction: unknown;
+}
+/**
+ * Optional DI token for apps that register `PrismaBundleRepository` directly
+ * as a Nest provider. Factory users may pass the same options as the second
+ * constructor argument.
+ */
+declare const PRISMA_BUNDLE_REPOSITORY_OPTIONS: unique symbol;
+interface PrismaBundleRepositoryOptions {
+    /**
+     * Enables reads and writes of `BundleVersion.validFrom`/`validUntil`.
+     *
+     * Default `false` preserves compatibility with databases and Prisma
+     * clients generated from the 0.6 schema, where the columns do not exist.
+     */
+    validityWindows?: boolean;
+}
 /**
  * `BundleRepository` against the canonical `bundles` + `bundle_versions`
  * tables (SPEC_V2 §5 + §11.1 M3). Versioning mirrors `PlanVersion`: at most one
  * draft (`publishedAt IS NULL`) per bundle, monotonically incrementing
  * `version`, `supersededAt` marking the previous live version on publish.
  *
- * Divergence from time-aware consumer schemas: the canonical `bundle_versions`
- * table carries **no** `validFrom`/`validUntil` columns. The `BundleVersionRow`
- * therefore always reports both as `null`, and the `validFrom`/`validUntil`
- * inputs on the Create/Update DTOs and on `publishDraft`'s `publishMeta` are
- * accepted (to satisfy the port signature) but not persisted — consistent with
- * `PrismaPlanVersionRepository`, which documents the same schema gap.
+ * Validity-window support is opt-in via `{ validityWindows: true }`. The
+ * default deliberately does not select, read or write `validFrom`/
+ * `validUntil`, and therefore keeps working with the 0.6 schema. In the
+ * enabled mode the repository expects both nullable columns to exist.
  *
- * Atomicity of `publishDraft` (supersede-previous + publish-draft) is delegated
- * to the caller's `TransactionContext`, following the package convention that
- * repositories never open their own `$transaction`.
+ * In validity-window mode `publishDraft` opens an internal transaction when
+ * the caller did not provide one. This makes superseding the predecessor,
+ * applying its auto-succession end date and publishing the draft atomic.
+ * Legacy mode retains the 0.6 transaction behavior unchanged.
  */
 declare class PrismaBundleRepository implements BundleRepository {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    private readonly validityWindows;
+    /**
+     * Present only when validity-window mode is enabled. This mirrors the
+     * optional port capability and lets 0.6-schema consumers detect that an
+     * active-at-time lookup is unavailable.
+     */
+    readonly findActiveBundleVersion?: (bundleId: string, asOf?: Date, tx?: TransactionContext) => Promise<BundleVersionRow | null>;
+    constructor(prisma: BundlePrismaClient, options?: PrismaBundleRepositoryOptions);
     private db;
+    private transaction;
     list(filter: BundleListFilter): Promise<BundleRow[]>;
     findById(bundleId: string): Promise<BundleRow | null>;
     findByKey(projectKey: string, bundleKey: string): Promise<BundleRow | null>;
@@ -1017,6 +1237,7 @@ declare class PrismaBundleRepository implements BundleRepository {
     findVersionById(versionId: string): Promise<BundleVersionRow | null>;
     findCurrentDraft(bundleId: string): Promise<BundleVersionRow | null>;
     findLatestLive(bundleId: string, tx?: TransactionContext): Promise<BundleVersionRow | null>;
+    private findActiveBundleVersionWithValidity;
     createDraft(data: CreateBundleVersionDraftData): Promise<BundleVersionRow>;
     updateDraft(versionId: string, data: UpdateBundleVersionDraftData): Promise<BundleVersionRow>;
     publishDraft(versionId: string, publishMeta: {
@@ -1026,9 +1247,15 @@ declare class PrismaBundleRepository implements BundleRepository {
         validFrom: Date;
         validUntil: Date | null;
     }, tx?: TransactionContext): Promise<BundleVersionRow>;
+    private publishDraftWithValidity;
     deleteDraft(versionId: string): Promise<void>;
 }
 
+interface CatalogEntryRepositoryClient {
+    capabilityCatalogEntry: unknown;
+    featureCatalogEntry: unknown;
+    quotaCatalogEntry: unknown;
+}
 /**
  * `CatalogEntryRepository` against the canonical `capability_catalog_entries`,
  * `feature_catalog_entries` and `quota_catalog_entries` tables (SPEC_V2 §6.3 —
@@ -1041,7 +1268,7 @@ declare class PrismaBundleRepository implements BundleRepository {
  */
 declare class PrismaCatalogEntryRepository implements CatalogEntryRepository {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    constructor(prisma: CatalogEntryRepositoryClient);
     private get db();
     listCapabilities(filter: CatalogEntryFilter): Promise<CapabilityCatalogEntryRow[]>;
     listFeatures(filter: CatalogEntryFilter): Promise<FeatureCatalogEntryRow[]>;
@@ -1062,6 +1289,9 @@ declare class PrismaCatalogEntryRepository implements CatalogEntryRepository {
     setQuotaBase(projectKey: string, quotaKey: string, data: UpdateCatalogEntryBaseData): Promise<QuotaCatalogEntryRow>;
 }
 
+interface MarketingProjectionRepositoryClient {
+    marketingProjection: unknown;
+}
 /**
  * `MarketingProjectionRepository` against the canonical `marketing_projections`
  * table. Not versioned: per (`targetType`, `targetVersionId`, `locale`) there is
@@ -1070,7 +1300,7 @@ declare class PrismaCatalogEntryRepository implements CatalogEntryRepository {
  */
 declare class PrismaMarketingProjectionRepository implements MarketingProjectionRepository {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    constructor(prisma: MarketingProjectionRepositoryClient);
     private get db();
     list(filter: MarketingProjectionFilter): Promise<MarketingProjectionRow[]>;
     findById(id: string): Promise<MarketingProjectionRow | null>;
@@ -1080,6 +1310,9 @@ declare class PrismaMarketingProjectionRepository implements MarketingProjection
     delete(id: string): Promise<void>;
 }
 
+interface MarketingSettingsRepositoryClient {
+    marketingSettings: unknown;
+}
 /**
  * `MarketingSettingsRepository` against the canonical `marketing_settings`
  * table (one row per project). A missing row means "full locale pool active",
@@ -1087,12 +1320,16 @@ declare class PrismaMarketingProjectionRepository implements MarketingProjection
  */
 declare class PrismaMarketingSettingsRepository implements MarketingSettingsRepository {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    constructor(prisma: MarketingSettingsRepositoryClient);
     private get db();
     get(projectKey: string): Promise<MarketingSettingsRow | null>;
     upsert(projectKey: string, data: UpdateMarketingSettingsData): Promise<MarketingSettingsRow>;
 }
 
+interface PromotionRepositoryClient {
+    promotion: unknown;
+    $executeRaw: unknown;
+}
 /**
  * `PromotionRepository` against the canonical `promotions` table. Not
  * versioned: promotions are edited directly.
@@ -1105,7 +1342,7 @@ declare class PrismaMarketingSettingsRepository implements MarketingSettingsRepo
  */
 declare class PrismaPromotionRepository implements PromotionRepository {
     private readonly prisma;
-    constructor(prisma: PrismaLike);
+    constructor(prisma: PromotionRepositoryClient);
     private get db();
     list(filter: PromotionFilter): Promise<PromotionRow[]>;
     findById(id: string): Promise<PromotionRow | null>;
@@ -1132,4 +1369,4 @@ declare class PrismaSubscriptionContractRepository implements SubscriptionContra
     terminate(contractId: string, data: TerminateSubscriptionContractData): Promise<SubscriptionContractRecord>;
 }
 
-export { AsyncLocalRlsBypassAdapter, type DecimalLike, PASSWORD_HASHER_TOKEN, PRISMA_CLIENT_TOKEN, PrismaAuditAdapter, PrismaAuditQueryAdapter, PrismaAuditStatsAdapter, PrismaBundleRepository, PrismaCatalogEntryRepository, type PrismaLike, PrismaMarketingProjectionRepository, PrismaMarketingSettingsRepository, PrismaMfaAdapter, type PrismaModelDelegateLike, type PrismaPersistenceOptions, PrismaPlanCatalogImportSink, PrismaPlanCatalogReadSink, PrismaPlanRepository, PrismaPlanVersionRepository, PrismaPromoCodeRedemptionRepository, PrismaPromoCodeRepository, PrismaPromoCodeValidationLogRepository, PrismaPromoSubscriptionLookup, PrismaPromotionRepository, PrismaSubscriptionBundleRepository, PrismaSubscriptionContractRepository, PrismaSubscriptionRepository, PrismaSuperAdminBootstrapAdapter, PrismaTenantSubscriptionWriteAdapter, PrismaTransactionRunner, type PrismaTxLike, ZeroPromoRevenueDeductionAggregator, buildActorTag, prismaPersistence };
+export { AsyncLocalRlsBypassAdapter, type DecimalLike, PASSWORD_HASHER_TOKEN, PRISMA_BUNDLE_REPOSITORY_OPTIONS, PRISMA_CLIENT_TOKEN, PRISMA_SCHEMA_OPTIONS_TOKEN, PrismaAuditAdapter, PrismaAuditQueryAdapter, PrismaAuditStatsAdapter, PrismaBundleRepository, type PrismaBundleRepositoryOptions, PrismaCatalogEntryRepository, type PrismaLike, PrismaMarketingProjectionRepository, PrismaMarketingSettingsRepository, PrismaMfaAdapter, type PrismaModelDelegateLike, type PrismaPersistenceOptions, type PrismaPlanBindingMode, type PrismaPlanBindingOptions, type PrismaPlanBindingResolver, PrismaPlanCatalogImportSink, PrismaPlanCatalogReadSink, type PrismaPlanDelegateOptions, PrismaPlanRepository, type PrismaPlanVersionFieldCapabilities, type PrismaPlanVersionFieldOptions, PrismaPlanVersionRepository, PrismaPromoCodeRedemptionRepository, PrismaPromoCodeRepository, PrismaPromoCodeValidationLogRepository, PrismaPromoSubscriptionLookup, PrismaPromotionRepository, type PrismaSchemaOptions, PrismaSubscriptionBundleRepository, PrismaSubscriptionContractRepository, PrismaSubscriptionRepository, PrismaSuperAdminBootstrapAdapter, type PrismaTenantSubscriptionOptions, PrismaTenantSubscriptionWriteAdapter, PrismaTransactionRunner, type PrismaTxLike, type ResolvedPrismaSchemaOptions, ZeroPromoRevenueDeductionAggregator, buildActorTag, createPrismaPlanBindingResolver, getPrismaDelegate, prismaPersistence, resolvePrismaSchemaOptions };