@saasicat/adapter-prisma 0.5.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, 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 } 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. */
@@ -16,7 +16,7 @@ interface SubscriptionRowLike {
     pendingPlan: string | null;
     pendingEffectiveAt: Date | null;
     customLimits: unknown;
-    planVersionId: string | null;
+    planVersionId: string;
     pendingPlanVersionId: string | null;
     startedAt: Date | null;
 }
@@ -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;
 }
@@ -547,6 +550,132 @@ interface PrismaTxLike {
 interface PrismaLike extends PrismaTxLike {
     $transaction<T>(fn: (tx: PrismaTxLike) => Promise<T>): Promise<T>;
 }
+/**
+ * Generic structural minimum of a Prisma model delegate. The catalog-plane
+ * repositories (bundle, plan, catalog-entry, marketing,
+ * promotion, contract) declare their own DB-row interfaces and view the
+ * injected client through `{ model: PrismaModelDelegateLike<Row> }` casts —
+ * this keeps each repo self-contained and avoids hard-coding every delegate on
+ * `PrismaTxLike`. Args mirror Prisma's `where`/`data`/`select`/`orderBy` shapes
+ * and are typed `unknown`: the repos build them inline and Prisma validates
+ * them at runtime; only the results are typed, matching the package's
+ * structural-minimum philosophy.
+ */
+interface PrismaModelDelegateLike<Row> {
+    findMany(args?: unknown): Promise<Row[]>;
+    findUnique(args: unknown): Promise<Row | null>;
+    findFirst(args?: unknown): Promise<Row | null>;
+    create(args: unknown): Promise<Row>;
+    update(args: unknown): Promise<Row>;
+    delete(args: unknown): Promise<Row>;
+    upsert(args: unknown): Promise<Row>;
+    updateMany(args: unknown): Promise<{
+        count: number;
+    }>;
+    createMany(args: unknown): Promise<{
+        count: number;
+    }>;
+    deleteMany(args: unknown): Promise<{
+        count: number;
+    }>;
+    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 {
     /**
@@ -569,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
@@ -581,9 +716,14 @@ interface PrismaPersistenceOptions {
  * });
  * ```
  *
- * Slices not shipped by this adapter (contracts, bundles, registration,
- * tenant-billing write ports) stay absent — consumers keep providing custom
- * adapters for those features.
+ * This bundle covers the core/entitlement/promo/plan-catalog slices consumed
+ * by `SaasPlatformModule`. The catalog plane (CatalogModule) and the V3
+ * contract loop take their repositories directly as `forRoot` options — wire
+ * the standalone `PrismaPlanRepository` / `PrismaBundleRepository` /
+ * `PrismaCatalogEntryRepository` /
+ * `PrismaMarketingProjectionRepository` / `PrismaMarketingSettingsRepository` /
+ * `PrismaPromotionRepository` / `PrismaSubscriptionContractRepository` exports
+ * there. The registration and tenant-billing write ports remain app-specific.
  */
 declare function prismaPersistence(options: PrismaPersistenceOptions): SaasicatPersistenceAdapter;
 
@@ -594,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>;
 }
 
@@ -615,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>;
@@ -632,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;
@@ -648,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>;
 }
 
@@ -692,42 +832,146 @@ 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.
  *
- * Limitation: subscriptions that bind ONLY a `businessTypeVersionId` (no
- * `planVersionId`) are not supported by this shipped adapter — the
- * BusinessType composition needs app-specific aggregation. Such rows raise a
- * descriptive error instead of returning wrong entitlements.
- *
- * `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
+ * (plan compatibility, minimum-term default, cancellation-window computation)
+ * live in the platform's `SubscriptionBundlesService`; `add`/`cancel` here only
+ * write what they are handed. "Active" is `canceledAt IS NULL OR
+ * canceledEffectiveAt > asOf`, mirroring the port contract.
+ */
+declare class PrismaSubscriptionBundleRepository implements SubscriptionBundleRepository {
+    private readonly prisma;
+    constructor(prisma: SubscriptionBundleClient);
+    private db;
+    listBySubscription(subscriptionId: string): Promise<SubscriptionBundleRecord[]>;
+    findById(subscriptionBundleId: string): Promise<SubscriptionBundleRecord | null>;
+    listActiveBySubscription(subscriptionId: string, asOf?: Date): Promise<SubscriptionBundleRecord[]>;
+    add(data: CreateSubscriptionBundleData): Promise<SubscriptionBundleRecord>;
+    cancel(subscriptionBundleId: string, data: CancelSubscriptionBundleData): Promise<SubscriptionBundleRecord>;
+    reactivate(subscriptionBundleId: string): Promise<SubscriptionBundleRecord>;
+    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 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.
+ *
+ * `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;
+    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;
+        acceptedAt: Date | null;
+        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;
 }
 
 /**
@@ -827,33 +1071,302 @@ 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>;
 }
 
-export { AsyncLocalRlsBypassAdapter, type DecimalLike, PASSWORD_HASHER_TOKEN, PRISMA_CLIENT_TOKEN, PrismaAuditAdapter, PrismaAuditQueryAdapter, PrismaAuditStatsAdapter, type PrismaLike, PrismaMfaAdapter, type PrismaPersistenceOptions, PrismaPlanCatalogImportSink, PrismaPlanCatalogReadSink, PrismaPlanVersionRepository, PrismaPromoCodeRedemptionRepository, PrismaPromoCodeRepository, PrismaPromoCodeValidationLogRepository, PrismaPromoSubscriptionLookup, PrismaSubscriptionRepository, PrismaSuperAdminBootstrapAdapter, PrismaTransactionRunner, type PrismaTxLike, ZeroPromoRevenueDeductionAggregator, buildActorTag, prismaPersistence };
+/** 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. 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.
+ *
+ * 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;
+    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>;
+    create(data: CreatePlanData): Promise<PlanRow>;
+    update(planId: string, data: UpdatePlanData): Promise<PlanRow>;
+    softDelete(planId: string): Promise<void>;
+    hardDelete(planId: string): Promise<void>;
+    listVersions(planKey: string): Promise<PlanVersionRow[]>;
+    findVersionById(versionId: string): Promise<PlanVersionRow | null>;
+    findCurrentDraft(planKey: string): Promise<PlanVersionRow | null>;
+    findLatestLivePlanVersion(planKey: string, tx?: TransactionContext): 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: {
+        publishedByUserId: string | null;
+        publishedChanges: VersionChange[];
+        nonRegressive: boolean;
+        validFrom: Date;
+        validUntil: Date | null;
+    }, tx?: TransactionContext): Promise<PlanVersionRow>;
+    deletePlanVersionDraft(versionId: string): Promise<void>;
+    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.
+ *
+ * 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.
+ *
+ * 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;
+    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>;
+    create(data: CreateBundleData): Promise<BundleRow>;
+    update(bundleId: string, data: UpdateBundleData): Promise<BundleRow>;
+    softDelete(bundleId: string): Promise<void>;
+    listVersions(bundleId: string): Promise<BundleVersionRow[]>;
+    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: {
+        publishedByUserId: string | null;
+        publishedChanges: VersionChange[];
+        nonRegressive: boolean;
+        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 —
+ * discovery review workflow).
+ *
+ * `upsert*` writes only the code-derived fields + the service-resolved status
+ * and leaves `i18n`, `sortOrder`, `createdAt` and the approval fields untouched
+ * on update (Prisma's `update` payload simply omits them). `retireMissing`
+ * marks entries whose key vanished from the code snapshot.
+ */
+declare class PrismaCatalogEntryRepository implements CatalogEntryRepository {
+    private readonly prisma;
+    constructor(prisma: CatalogEntryRepositoryClient);
+    private get db();
+    listCapabilities(filter: CatalogEntryFilter): Promise<CapabilityCatalogEntryRow[]>;
+    listFeatures(filter: CatalogEntryFilter): Promise<FeatureCatalogEntryRow[]>;
+    listQuotas(filter: CatalogEntryFilter): Promise<QuotaCatalogEntryRow[]>;
+    upsertCapability(data: UpsertCapabilityEntryData): Promise<CapabilityCatalogEntryRow>;
+    upsertFeature(data: UpsertFeatureEntryData): Promise<FeatureCatalogEntryRow>;
+    upsertQuota(data: UpsertQuotaEntryData): Promise<QuotaCatalogEntryRow>;
+    retireMissing(projectKey: string, type: 'capability' | 'feature' | 'quota', presentKeys: string[]): Promise<number>;
+    setFeatureSuccessor(projectKey: string, featureKey: string, successorKey: string | null): Promise<FeatureCatalogEntryRow>;
+    setQuotaSuccessor(projectKey: string, quotaKey: string, successorKey: string | null): Promise<QuotaCatalogEntryRow>;
+    findFeature(projectKey: string, featureKey: string): Promise<FeatureCatalogEntryRow | null>;
+    findQuota(projectKey: string, quotaKey: string): Promise<QuotaCatalogEntryRow | null>;
+    setFeatureReview(projectKey: string, featureKey: string, data: SetCatalogEntryReviewData): Promise<FeatureCatalogEntryRow>;
+    setQuotaReview(projectKey: string, quotaKey: string, data: SetCatalogEntryReviewData): Promise<QuotaCatalogEntryRow>;
+    setFeatureI18n(projectKey: string, featureKey: string, i18n: CatalogEntryI18n): Promise<FeatureCatalogEntryRow>;
+    setQuotaI18n(projectKey: string, quotaKey: string, i18n: CatalogEntryI18n): Promise<QuotaCatalogEntryRow>;
+    setFeatureBase(projectKey: string, featureKey: string, data: UpdateCatalogEntryBaseData): Promise<FeatureCatalogEntryRow>;
+    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
+ * exactly one row (enforced by a unique index), edited directly. `create` on a
+ * duplicate triple therefore raises the DB unique-constraint error.
+ */
+declare class PrismaMarketingProjectionRepository implements MarketingProjectionRepository {
+    private readonly prisma;
+    constructor(prisma: MarketingProjectionRepositoryClient);
+    private get db();
+    list(filter: MarketingProjectionFilter): Promise<MarketingProjectionRow[]>;
+    findById(id: string): Promise<MarketingProjectionRow | null>;
+    findByTarget(targetType: string, targetVersionId: string, locale: string): Promise<MarketingProjectionRow | null>;
+    create(data: CreateMarketingProjectionData): Promise<MarketingProjectionRow>;
+    update(id: string, data: UpdateMarketingProjectionData): Promise<MarketingProjectionRow>;
+    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",
+ * so `get` returns null and the platform falls back to the pool.
+ */
+declare class PrismaMarketingSettingsRepository implements MarketingSettingsRepository {
+    private readonly prisma;
+    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.
+ *
+ * The nullable `onlyLocales` JSON column cannot be set to null through Prisma's
+ * query API without the `Prisma.DbNull` sentinel — which this Prisma-agnostic
+ * package deliberately does not import. On `create` a null restriction is
+ * therefore written by omission (the column defaults to SQL NULL); on `update`
+ * an explicit null clear runs as a raw statement.
+ */
+declare class PrismaPromotionRepository implements PromotionRepository {
+    private readonly prisma;
+    constructor(prisma: PromotionRepositoryClient);
+    private get db();
+    list(filter: PromotionFilter): Promise<PromotionRow[]>;
+    findById(id: string): Promise<PromotionRow | null>;
+    create(data: CreatePromotionData): Promise<PromotionRow>;
+    update(id: string, data: UpdatePromotionData): Promise<PromotionRow>;
+    delete(id: string): Promise<void>;
+}
+
+/**
+ * Append-only `SubscriptionContractRepository` against the canonical
+ * `subscription_contracts` + `contract_line_items` tables. Contracts store full
+ * snapshots and are never rewritten: `create` writes the contract and its line
+ * items atomically via a single nested-create, and `terminate` only closes a
+ * contract (sets `effectiveUntil` + `status`). There is no line-item mutation.
+ */
+declare class PrismaSubscriptionContractRepository implements SubscriptionContractRepository {
+    private readonly prisma;
+    constructor(prisma: PrismaLike);
+    private get db();
+    list(filter: SubscriptionContractFilter): Promise<SubscriptionContractRecord[]>;
+    findById(contractId: string): Promise<SubscriptionContractRecord | null>;
+    findActiveByTenantId(tenantId: string, asOf?: Date): Promise<SubscriptionContractRecord | null>;
+    create(data: CreateSubscriptionContractData): Promise<SubscriptionContractRecord>;
+    terminate(contractId: string, data: TerminateSubscriptionContractData): Promise<SubscriptionContractRecord>;
+}
+
+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 };