@classytic/promo 0.1.0 → 0.2.1

package/dist/index.d.mts

@@ -1,20 +1,1311 @@
-import { a as BalanceLedgerEntry, c as Rule, l as Reward, o as Voucher, s as VoucherRedemption, u as Program } from "./voucher.port-yxfb3MHJ.mjs";
-import { t as EventEmitterPort } from "./event-emitter.port-DaodlJSG.mjs";
-import { o as PromoEvents } from "./index-C52zSBkI.mjs";
-import { i as PromoConfig, o as ResolvedConfig, s as ResolvedTenant } from "./config-iZjn_8pp.mjs";
-import { t as PromoModels } from "./index-B7lLH19a.mjs";
-import { t as PromoRepositories } from "./index-l09KqnlE.mjs";
-import { C as UpdateRuleInput, S as UpdateRewardInput, _ as GiftCardTopUpInput, a as GiftCardBalance, b as RedeemVoucherInput, c as VoucherValidation, d as CreateRewardInput, f as CreateRuleInput, g as GiftCardSpendInput, h as GenerateSingleCodeInput, i as FreeProductLine, l as CartItem, m as GenerateCodesInput, n as DiscountLine, o as PaginatedResult, p as EvaluateInput, r as EvaluationResult, s as RejectedCode, t as CommitResult, u as CreateProgramInput, v as ListQuery, x as UpdateProgramInput, y as PromoContext } from "./results-Ca5ZCNbN.mjs";
-import { i as FullProgram, t as PromoServices } from "./index-Cu9iwy4v.mjs";
+import { c as ProgramType, f as StackingMode, g as VoucherStatus, i as DiscountScope, m as TriggerMode, r as DiscountMode, s as ProgramStatus, u as RewardType } from "./constants-CrbSSQG5.mjs";
+import { PluginType as PluginType$1, Repository } from "@classytic/mongokit";
+import { ResolvedTenantConfig, TenantConfig, TenantFieldType } from "@classytic/primitives/tenant";
+import { DomainEvent, DomainEvent as DomainEvent$1, EventHandler, EventTransport, EventTransport as EventTransport$1 } from "@classytic/primitives/events";
+import { ClientSession, Connection, Model } from "mongoose";
+import { z } from "zod";
+import { OutboxStore } from "@classytic/primitives/outbox";
+import { OperationContext } from "@classytic/primitives/context";
 
+//#region src/types/inputs.d.ts
+/**
+ * Extends `@classytic/primitives`' {@link OperationContext}. The
+ * `[key: string]: unknown` fall-through lets hosts pass dynamic tenant keys
+ * when they've configured a custom `contextKey` on `TenantConfig`.
+ */
+interface PromoContext extends OperationContext {
+  /** Narrowed from primitives' `IdLike` to string. */
+  actorId?: string;
+  /** Narrowed from primitives' `IdLike` to string. */
+  organizationId?: string;
+  /** Narrows primitives' `session: unknown` to the concrete Mongoose type so
+   *  this context flows directly into mongokit repository calls. */
+  session?: ClientSession;
+  [key: string]: unknown;
+}
+interface CreateProgramInput {
+  name: string;
+  description?: string;
+  programType: ProgramType;
+  triggerMode: TriggerMode;
+  stackingMode?: StackingMode;
+  priority?: number;
+  startsAt?: Date;
+  endsAt?: Date;
+  maxUsageTotal?: number;
+  maxUsagePerCustomer?: number;
+  applicableCustomerIds?: string[];
+  applicableCustomerTags?: string[];
+  metadata?: Record<string, unknown>;
+}
+interface UpdateProgramInput {
+  name?: string;
+  description?: string;
+  stackingMode?: StackingMode;
+  priority?: number;
+  startsAt?: Date;
+  endsAt?: Date;
+  maxUsageTotal?: number;
+  maxUsagePerCustomer?: number;
+  applicableCustomerIds?: string[];
+  applicableCustomerTags?: string[];
+  metadata?: Record<string, unknown>;
+}
+interface CreateRuleInput {
+  name?: string;
+  minimumAmount?: number;
+  minimumQuantity?: number;
+  applicableProductIds?: string[];
+  applicableCategories?: string[];
+  applicableSkus?: string[];
+  buyQuantity?: number;
+  code?: string;
+  startsAt?: Date;
+  endsAt?: Date;
+  metadata?: Record<string, unknown>;
+}
+interface UpdateRuleInput {
+  name?: string;
+  minimumAmount?: number;
+  minimumQuantity?: number;
+  applicableProductIds?: string[];
+  applicableCategories?: string[];
+  applicableSkus?: string[];
+  buyQuantity?: number;
+  code?: string;
+  startsAt?: Date;
+  endsAt?: Date;
+  metadata?: Record<string, unknown>;
+}
+interface CreateRewardInput {
+  ruleId?: string;
+  rewardType: RewardType;
+  discountMode?: DiscountMode;
+  discountAmount?: number;
+  maxDiscountAmount?: number;
+  discountScope?: DiscountScope;
+  applicableProductIds?: string[];
+  freeProductId?: string;
+  freeProductSku?: string;
+  freeQuantity?: number;
+  giftCardAmount?: number;
+  metadata?: Record<string, unknown>;
+}
+interface UpdateRewardInput {
+  discountMode?: DiscountMode;
+  discountAmount?: number;
+  maxDiscountAmount?: number;
+  discountScope?: DiscountScope;
+  applicableProductIds?: string[];
+  freeProductId?: string;
+  freeProductSku?: string;
+  freeQuantity?: number;
+  giftCardAmount?: number;
+  metadata?: Record<string, unknown>;
+}
+interface GenerateCodesInput {
+  programId: string;
+  count: number;
+  customerId?: string;
+  expiresAt?: Date;
+  metadata?: Record<string, unknown>;
+}
+interface GenerateSingleCodeInput {
+  programId: string;
+  code?: string;
+  customerId?: string;
+  expiresAt?: Date;
+  initialBalance?: number;
+  metadata?: Record<string, unknown>;
+}
+interface RedeemVoucherInput {
+  code: string;
+  orderId: string;
+  customerId?: string;
+  discountAmount: number;
+  idempotencyKey?: string;
+}
+interface GiftCardSpendInput {
+  code: string;
+  amount: number;
+  orderId: string;
+  description?: string;
+  idempotencyKey?: string;
+}
+interface GiftCardTopUpInput {
+  code: string;
+  amount: number;
+  description?: string;
+  idempotencyKey?: string;
+}
+interface CartItem {
+  productId: string;
+  sku?: string;
+  categoryId?: string;
+  quantity: number;
+  unitPrice: number;
+  lineTotal?: number;
+}
+interface EvaluateInput {
+  items: CartItem[];
+  subtotal: number;
+  codes?: string[];
+  customerId?: string;
+  customerTags?: string[];
+}
+interface ListQuery {
+  page?: number;
+  limit?: number;
+  sort?: string;
+  filters?: Record<string, unknown>;
+}
+//#endregion
+//#region src/types/results.d.ts
+interface DiscountLine {
+  programId: string;
+  programName: string;
+  rewardId: string;
+  type: 'percentage' | 'fixed';
+  scope: 'order' | 'cheapest' | 'specific_products';
+  amount: number;
+  description: string;
+  voucherCode?: string;
+}
+interface FreeProductLine {
+  programId: string;
+  programName: string;
+  rewardId: string;
+  productId?: string;
+  productSku?: string;
+  quantity: number;
+  description: string;
+}
+interface RejectedCode {
+  code: string;
+  reason: string;
+}
+interface EvaluationResult {
+  evaluationId: string;
+  /**
+   * Deterministic hash of the evaluated cart (items + subtotal + codes +
+   * customerId). Hosts that want tamper-proof commits pass this hash back
+   * to `EvaluationService.commit(evaluationId, orderId, ctx, { cartHash })`;
+   * the engine throws `CartHashMismatchError` when the caller's hash does
+   * not match what was evaluated. Omitting the hash at commit keeps the
+   * legacy "trusted host" behaviour.
+   */
+  cartHash: string;
+  appliedDiscounts: DiscountLine[];
+  freeProducts: FreeProductLine[];
+  totalDiscount: number;
+  subtotalAfterDiscount: number;
+  appliedCodes: string[];
+  rejectedCodes: RejectedCode[];
+  warnings: string[];
+  isPreview: boolean;
+  programsApplied: string[];
+}
+interface CommitResult {
+  evaluationId: string;
+  orderId: string;
+  totalDiscount: number;
+  programsCommitted: number;
+  vouchersUsed: number;
+}
+interface VoucherValidation {
+  valid: boolean;
+  voucher?: {
+    code: string;
+    programId: string;
+    programType: string;
+    status: string;
+    remainingUses: number;
+    currentBalance?: number;
+    expiresAt?: Date;
+  };
+  error?: string;
+}
+interface GiftCardBalance {
+  code: string;
+  initialBalance: number;
+  currentBalance: number;
+  spent: number;
+  voucherId: string;
+}
+interface PaginatedResult<T> {
+  docs: T[];
+  page: number;
+  limit: number;
+  total: number;
+  pages: number;
+  hasNext: boolean;
+  hasPrev: boolean;
+}
+//#endregion
+//#region src/domain/ports/evaluation-store.port.d.ts
+/**
+ * Snapshot the engine writes after `evaluate` and reads back at `commit`
+ * or `rollback`. Carries the materialised discount + the per-program /
+ * per-voucher usages the commit step must increment atomically.
+ *
+ * Mirrors the in-memory `StoredEvaluation` shape but moved out of the
+ * service file so storage adapters (Mongo, Redis, host-supplied) share
+ * one definition.
+ */
+interface StoredEvaluationSnapshot {
+  readonly result: EvaluationResult;
+  readonly ctx: PromoContext;
+  readonly customerId?: string;
+  readonly programUsages: ReadonlyArray<{
+    programId: string;
+  }>;
+  readonly voucherUsages: ReadonlyArray<{
+    voucherId: string;
+    code: string;
+    discountAmount: number;
+  }>;
+  readonly cartHash: string;
+  readonly createdAt: Date;
+}
+/**
+ * Per-call context for store operations. Carries:
+ *   - `tenantValue` — the tenant scope value (e.g. an org id, branch id,
+ *     workspace id). The store maps this onto whatever field name the
+ *     engine's resolved TenantConfig declared (`organizationId`,
+ *     `branchId`, `tenantId`, etc.). Storage adapters that don't tenant-
+ *     scope simply ignore this.
+ *   - `session` — Mongoose `ClientSession`. When set, the store
+ *     operation joins the caller's transaction so failures roll back
+ *     the read-and-delete atomically (the snapshot stays in the store
+ *     and the caller can retry).
+ *
+ * The shape is intentionally tenant-agnostic — it carries the VALUE
+ * but not the FIELD NAME, so hosts on `branchId`/`tenantId`/etc. don't
+ * have to translate between context shapes at the call site.
+ */
+interface EvaluationStoreContext {
+  readonly tenantValue?: string;
+  readonly session?: unknown;
+}
+/**
+ * Pluggable backing store for pending evaluation snapshots.
+ *
+ * **Why a port, not a hard-coded Map:** the previous implementation kept
+ * pending evaluations in a process-local `Map<string, StoredEvaluation>`.
+ * That works for a single long-lived dev server but breaks every real
+ * production topology:
+ *   - **Process restart** — every in-flight checkout's pending snapshot
+ *     vanishes; subsequent commit() calls throw `EvaluationNotFoundError`.
+ *   - **Horizontal scaling** — pod A's evaluate() snapshot is invisible
+ *     to pod B's commit(); load-balanced traffic randomly fails.
+ *   - **Serverless** — every cold start drops the Map; fits the worst
+ *     pattern of the topology.
+ *   - **Background worker handoff** — main pod evaluates, worker pod
+ *     commits asynchronously: never works.
+ *   - **Test isolation** — Map persists across vitest cases sharing the
+ *     same engine singleton, polluting tests that should be independent.
+ *
+ * The port lets the package ship a default Mongo-backed store (works
+ * everywhere mongokit already runs) while letting hosts plug in Redis,
+ * DynamoDB, or in-memory implementations as their topology demands.
+ *
+ * Contract notes:
+ *   - `take()` is **read-and-delete atomically**. This is the storage
+ *     defence for "no double-commit on the same evaluationId" — even if
+ *     the cap-CAS in the program repo were bypassed somehow, two
+ *     concurrent commit() calls cannot both observe the same snapshot.
+ *   - `take()` MUST honour `ctx.session` when provided. The service
+ *     calls `take` INSIDE its transaction so a transient transaction
+ *     failure rolls back the delete, leaving the snapshot for retry.
+ *     Without session-awareness, a transient DB error would consume
+ *     the snapshot permanently and force callers to re-evaluate.
+ *   - `delete()` exists for explicit `rollback()`, where we want to drop
+ *     the snapshot without consuming it.
+ *   - `put()` carries a TTL. The store SHOULD honour it (Mongo TTL index,
+ *     Redis EXPIRE, etc.) but the engine never relies on TTL alone for
+ *     correctness — it always checks `take()` returned a fresh snapshot.
+ *   - All methods take an optional `ctx` for tenant scoping. The store
+ *     applies the configured tenant field to its read/write filters so
+ *     pod A's snapshot in tenant X cannot be taken by a request in
+ *     tenant Y.
+ */
+interface EvaluationStore {
+  /**
+   * Persist a fresh evaluation snapshot. The store is expected to expire
+   * the entry after `ttlSeconds` so abandoned evaluations don't grow
+   * unbounded. Implementations MUST allow re-puts on the same id (a host
+   * that re-evaluates the same cart should see the latest snapshot).
+   */
+  put(id: string, snapshot: StoredEvaluationSnapshot, ttlSeconds: number, ctx?: EvaluationStoreContext): Promise<void>;
+  /**
+   * Atomically read AND delete the snapshot in a single operation. Used by
+   * `commit()` so two concurrent commits on the same evaluationId can
+   * never both succeed at the storage layer (one wins, the other gets
+   * `null` and surfaces as `EvaluationNotFoundError`).
+   *
+   * Honours `ctx.session` to participate in the caller's transaction —
+   * essential for transient-failure recovery (the delete rolls back if
+   * the transaction aborts, leaving the snapshot intact for retry).
+   */
+  take(id: string, ctx?: EvaluationStoreContext): Promise<StoredEvaluationSnapshot | null>;
+  /**
+   * Drop the snapshot without consuming it. Used by `rollback()`.
+   * Idempotent: if the entry doesn't exist, return without error.
+   */
+  delete(id: string, ctx?: EvaluationStoreContext): Promise<void>;
+}
+//#endregion
+//#region src/types/config.d.ts
+type TenantConfig$1 = false | TenantConfig;
+interface IndexDefinition {
+  fields: Record<string, 1 | -1>;
+  options?: Record<string, unknown> | undefined;
+}
+type ModelName = 'program' | 'rule' | 'reward' | 'voucher';
+type PluginType = PluginType$1;
+interface RepositoryPlugins {
+  program?: PluginType$1[] | undefined;
+  rule?: PluginType$1[] | undefined;
+  reward?: PluginType$1[] | undefined;
+  voucher?: PluginType$1[] | undefined;
+}
+interface PromoConfig {
+  mongoose: Connection;
+  tenant?: TenantConfig$1 | undefined;
+  evaluation?: {
+    maxStackablePromotions?: number | undefined;
+    allowExclusiveAndStackable?: boolean | undefined;
+  } | undefined;
+  voucher?: {
+    codeLength?: number | undefined;
+    codePrefix?: string | undefined;
+    defaultExpiryDays?: number | undefined;
+  } | undefined;
+  giftCard?: {
+    allowNegativeBalance?: boolean | undefined;
+    maxBalance?: number | undefined;
+  } | undefined;
+  indexes?: Partial<Record<ModelName, IndexDefinition[]>> | undefined;
+  autoIndex?: boolean | Partial<Record<ModelName, boolean>> | undefined;
+  events?: {
+    transport?: EventTransport$1 | undefined;
+  } | undefined;
+  /**
+   * Host-provided outbox store (PACKAGE_RULES §5.5 + §P8). When wired, every
+   * domain event is persisted to the outbox inside the caller's `ctx.session`
+   * BEFORE being published to the transport — giving at-least-once delivery
+   * via the host-side relay. Absent → transport-only best-effort.
+   *
+   * Explicit `| undefined` per `exactOptionalPropertyTypes` convention.
+   */
+  outbox?: OutboxStore | undefined;
+  /**
+   * Optional logger for dispatch-layer errors. Used by the shared
+   * `dispatch()` helper to surface outbox/transport failures without
+   * aborting the domain mutation. Defaults to `console`.
+   */
+  logger?: {
+    error(message: string, ...args: unknown[]): void;
+  } | undefined;
+  plugins?: RepositoryPlugins | undefined;
+  /**
+   * Override the pending-evaluation backing store. Defaults to a
+   * Mongo-backed implementation over the engine's own
+   * `pendingEvaluation` repository — works on every topology mongokit
+   * already runs on (single process, horizontal scaling, serverless,
+   * worker handoff).
+   *
+   * Hosts on Redis, DynamoDB, an existing cache layer, or any custom
+   * backend implement `EvaluationStore` and pass it here. The package
+   * never assumes one backend; the port is stable, the default is
+   * convenient.
+   */
+  evaluationStore?: EvaluationStore | undefined;
+}
+type ResolvedTenant = ResolvedTenantConfig;
+interface ResolvedConfig {
+  evaluation: {
+    maxStackablePromotions: number;
+    allowExclusiveAndStackable: boolean;
+  };
+  voucher: {
+    codeLength: number;
+    codePrefix: string;
+    defaultExpiryDays: number | null;
+  };
+  giftCard: {
+    allowNegativeBalance: boolean;
+    maxBalance: number | null;
+  };
+  tenant: ResolvedTenant;
+}
+//#endregion
+//#region src/models/create-models.d.ts
+interface PromoModels {
+  Program: Model<unknown>;
+  Rule: Model<unknown>;
+  Reward: Model<unknown>;
+  Voucher: Model<unknown>;
+  PendingEvaluation: Model<unknown>;
+}
+//#endregion
+//#region src/events/dispatch.d.ts
+interface DispatchLogger {
+  error(message: string, ...args: unknown[]): void;
+}
+interface DispatchDeps {
+  events?: EventTransport$1 | undefined;
+  outbox?: OutboxStore | undefined;
+  logger?: DispatchLogger | undefined;
+}
+//#endregion
+//#region src/repositories/pending-evaluation.repository.d.ts
+/**
+ * Persistence-layer document shape — flat blob of the snapshot fields
+ * the schema declares. The service layer maps to/from
+ * `StoredEvaluationSnapshot` so the storage shape stays decoupled from
+ * the domain shape.
+ */
+interface PendingEvaluationDocument {
+  _id: string;
+  evaluationId: string;
+  result: Record<string, unknown>;
+  ctx: Record<string, unknown>;
+  customerId: string | null;
+  programUsages: Array<Record<string, unknown>>;
+  voucherUsages: Array<Record<string, unknown>>;
+  cartHash: string;
+  expiresAt: Date;
+  createdAt: Date;
+  updatedAt: Date;
+}
+/**
+ * Pending-evaluation repository. Extends mongokit's `Repository<TDoc>`
+ * directly per package rules (no service wrapper, no aliased verbs).
+ * Adds one custom domain method: `takeByEvaluationId` — atomic
+ * read-and-delete via raw `Model.findOneAndDelete`.
+ *
+ * **Why raw `findOneAndDelete` (escape from mongokit's `delete()`)**:
+ * mongokit's `Repository.delete()` returns `{success, message}` only —
+ * it doesn't surface the deleted document. `take` semantics require
+ * "atomically remove AND return", which is the canonical defence
+ * against double-commit on the same evaluationId at the storage layer
+ * (one caller wins the document, the other gets `null`). This is the
+ * narrow exception PACKAGE_RULES.md / order/CLAUDE.md sanction:
+ * *"Raw findOneAndUpdate/findOneAndDelete is allowed ONLY for atomic
+ * state-machine transitions — flag each one with a comment."*
+ */
+declare class PendingEvaluationRepository extends Repository<PendingEvaluationDocument> {
+  /**
+   * The repository owns its tenant config so its raw-driver methods
+   * (`findOneAndDelete`, `deleteOne`) can apply the SAME scoping rule
+   * the mongokit hook pipeline would apply on standard methods —
+   * specifically using `tenant.tenantField` (host-configurable as
+   * `organizationId`, `branchId`, `tenantId`, etc.) NOT a hardcoded
+   * `organizationId`. Without this, deployments that configure custom
+   * tenant fields would silently lose isolation on the cache layer.
+   */
+  private readonly tenant;
+  constructor(model: Model<PendingEvaluationDocument>, plugins?: PluginType$1[], tenant?: ResolvedTenant);
+  /** The host-configured tenant field name (or `undefined` if single-tenant). */
+  get tenantField(): string | undefined;
+  /**
+   * Atomic read-and-delete by evaluationId. Two concurrent commit calls
+   * on the same id race here at the database layer — the winner gets
+   * the document, the loser gets `null` and the calling service throws
+   * `EvaluationNotFoundError`. No way both succeed.
+   *
+   * Honours `ctx.session` so the operation joins the caller's
+   * transaction. If the transaction aborts (transient DB error, cap
+   * exceeded, etc.) the delete rolls back and the snapshot stays in
+   * the store — letting the caller retry without re-evaluation.
+   *
+   * Tenant scoping uses the configured `tenant.tenantField` (NOT a
+   * hardcoded `organizationId`) so hosts on `branchId`/`tenantId`/etc.
+   * keep cross-tenant isolation on the cache layer too.
+   */
+  takeByEvaluationId(evaluationId: string, ctx?: {
+    tenantValue?: string;
+    session?: ClientSession;
+  }): Promise<PendingEvaluationDocument | null>;
+  /**
+   * Idempotent delete. Returns whether anything was actually removed,
+   * so callers can distinguish "we cleaned it" from "already gone".
+   */
+  deleteByEvaluationId(evaluationId: string, ctx?: {
+    tenantValue?: string;
+    session?: ClientSession;
+  }): Promise<boolean>;
+  /**
+   * Build a query filter with the configured tenant scope appended,
+   * mirroring what mongokit's `multiTenantPlugin` injects on standard
+   * Repository methods. We re-implement here because raw driver calls
+   * (`findOneAndDelete`, `deleteOne`) bypass the plugin pipeline.
+   */
+  private scopedFilter;
+}
+//#endregion
+//#region src/domain/entities/program.d.ts
+interface Program {
+  _id: string;
+  name: string;
+  description?: string;
+  programType: ProgramType;
+  triggerMode: TriggerMode;
+  status: ProgramStatus;
+  stackingMode: StackingMode;
+  priority: number;
+  startsAt?: Date;
+  endsAt?: Date;
+  maxUsageTotal?: number;
+  usedCount: number;
+  maxUsagePerCustomer?: number;
+  applicableCustomerIds: string[];
+  applicableCustomerTags: string[];
+  customerUsageCounts?: Record<string, number>;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+//#endregion
+//#region src/repositories/program.repository.d.ts
+declare class ProgramRepository extends Repository<Program> {
+  private dispatchDeps;
+  constructor(model: Model<Program>, plugins?: PluginType$1[], dispatchDeps?: DispatchDeps);
+  activate(id: string, ctx: PromoContext): Promise<Program>;
+  pause(id: string, ctx: PromoContext): Promise<Program>;
+  archive(id: string, ctx: PromoContext): Promise<Program>;
+  private _transition;
+  incrementUsage(id: string, ctx?: Record<string, unknown>): Promise<Program>;
+  /**
+   * Atomic compare-and-set increment: succeeds only if the program either
+   * has no cap (`maxUsageTotal == null`) OR `usedCount < maxUsageTotal`.
+   * If the cap is already saturated, returns `null` so the caller can
+   * decide whether to throw (commit-time enforcement) or skip silently
+   * (best-effort eligibility check).
+   *
+   * Industry-standard primitive for "promo with finite supply" — without
+   * this, two evaluations both see the program as available and both
+   * commit, leading to oversell. The atomic filter on the same write
+   * eliminates the race entirely; concurrent losers see a `null` return
+   * and can downgrade their commit (apply order without the discount,
+   * surface "promo no longer available" to the user, etc.).
+   *
+   * Routes through mongokit's `update` so tenant scoping + hooks fire.
+   */
+  tryIncrementUsage(id: string, ctx?: Record<string, unknown>): Promise<Program | null>;
+  decrementUsage(id: string, ctx?: Record<string, unknown>): Promise<Program>;
+  getCustomerUsage(id: string, customerId: string, ctx?: Record<string, unknown>): Promise<number>;
+  incrementCustomerUsage(id: string, customerId: string, ctx?: Record<string, unknown>): Promise<Program>;
+  findActive(now?: Date, ctx?: Record<string, unknown>): Promise<Program[]>;
+}
+//#endregion
+//#region src/domain/entities/reward.d.ts
+interface Reward {
+  _id: string;
+  programId: string;
+  ruleId?: string;
+  rewardType: RewardType;
+  discountMode?: DiscountMode;
+  discountAmount?: number;
+  maxDiscountAmount?: number;
+  discountScope: DiscountScope;
+  applicableProductIds: string[];
+  freeProductId?: string;
+  freeProductSku?: string;
+  freeQuantity: number;
+  giftCardAmount?: number;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+//#endregion
+//#region src/repositories/reward.repository.d.ts
+declare class RewardRepository extends Repository<Reward> {
+  constructor(model: Model<Reward>, plugins?: PluginType$1[]);
+}
+//#endregion
+//#region src/domain/entities/rule.d.ts
+interface Rule {
+  _id: string;
+  programId: string;
+  name?: string;
+  minimumAmount: number;
+  minimumQuantity: number;
+  applicableProductIds: string[];
+  applicableCategories: string[];
+  applicableSkus: string[];
+  buyQuantity?: number;
+  code?: string;
+  startsAt?: Date;
+  endsAt?: Date;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+//#endregion
+//#region src/repositories/rule.repository.d.ts
+declare class RuleRepository extends Repository<Rule> {
+  constructor(model: Model<Rule>, plugins?: PluginType$1[]);
+}
+//#endregion
+//#region src/domain/entities/voucher.d.ts
+interface BalanceLedgerEntry {
+  amount: number;
+  orderId?: string;
+  description?: string;
+  createdAt: Date;
+  idempotencyKey?: string;
+  /** Branch / store / location where the spend or top-up was performed.
+   *  Stamped from `ctx.organizationId` at write time. Vouchers themselves
+   *  remain company-wide (`tenant: false` deployments included) — this
+   *  field is purely for analytics ("redemptions per branch") and audit
+   *  ("which staff branch credited this card?") without joining orders. */
+  organizationId?: string;
+}
+interface VoucherRedemption {
+  orderId: string;
+  customerId?: string;
+  discountAmount: number;
+  redeemedAt: Date;
+  idempotencyKey?: string;
+  /** Branch / store / location where the redemption happened. Stamped
+   *  from `ctx.organizationId` at write time. See `BalanceLedgerEntry`. */
+  organizationId?: string;
+}
+interface Voucher {
+  _id: string;
+  programId: string;
+  code: string;
+  status: VoucherStatus;
+  customerId?: string;
+  usageLimit: number;
+  usedCount: number;
+  initialBalance?: number;
+  currentBalance?: number;
+  balanceLedger: BalanceLedgerEntry[];
+  expiresAt?: Date;
+  redemptions: VoucherRedemption[];
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+//#endregion
+//#region src/repositories/voucher.repository.d.ts
+declare class VoucherRepository extends Repository<Voucher> {
+  private dispatchDeps;
+  private tenantField;
+  private tenantEnabled;
+  constructor(model: Model<Voucher>, plugins?: PluginType$1[], dispatchDeps?: DispatchDeps, tenantField?: string, tenantEnabled?: boolean);
+  /**
+   * Copy the tenant id from `ctx` onto the write payload so the doc persists
+   * with the correct `organizationId` even when the host has opted OUT of the
+   * auto-wired `multiTenantPlugin` but still scopes at its framework layer
+   * (e.g. arc's preset + `BaseController` — see `@classytic/order` CLAUDE.md:
+   * "Child repos set `organizationId` explicitly on the doc").
+   *
+   * Skipped entirely when the engine was configured with `tenant: false` —
+   * the host's intent is company-wide rows (no `organizationId` on disk),
+   * and injecting it from `ctx` would silently re-scope writes per branch
+   * while reads still look at the unscoped collection.
+   */
+  private _injectTenant;
+  create(data: Parameters<Repository<Voucher>['create']>[0], options?: Parameters<Repository<Voucher>['create']>[1]): Promise<Voucher>;
+  createMany(docs: Parameters<Repository<Voucher>['createMany']>[0], options?: Parameters<Repository<Voucher>['createMany']>[1]): Promise<Voucher[]>;
+  /** Domain verb: cancel a voucher (status transition + event). */
+  cancel(id: string, ctx: PromoContext): Promise<Voucher>;
+  /** Atomic usage increment + push redemption record. */
+  incrementUsage(id: string, redemption: Record<string, unknown>, ctx?: Record<string, unknown>): Promise<Voucher>;
+  /** Atomic balance delta + push ledger entry. */
+  addLedgerEntry(id: string, entry: Record<string, unknown>, balanceDelta: number, ctx?: Record<string, unknown>): Promise<Voucher>;
+  /**
+   * Batch expire by date.
+   *
+   * Routes through `findAll` + per-doc `update` instead of a raw
+   * `this.Model.updateMany`. Rationale:
+   *  1. `findAll` casts the filter through the schema (so an ObjectId
+   *     tenant field on a write-time String context doesn't silently
+   *     return 0 rows the way a raw `$match` would).
+   *  2. `update` fires the full hook pipeline (multi-tenant, audit,
+   *     soft-delete) on every expiration — a bulk `updateMany` at the
+   *     Model layer bypasses all of them.
+   * Volume is bounded per tenant (active + past-expiry vouchers), so an
+   * N+1 loop is acceptable for correctness.
+   */
+  expireByDate(before: Date, ctx?: Record<string, unknown>): Promise<number>;
+  /**
+   * Lookup voucher by unique code, scoped to the tenant in `ctx` when
+   * tenant scoping is configured.
+   *
+   * Manual tenant injection mirrors `expireByDate` and `ProgramRepository.findActive`
+   * — it makes the method work whether the host opts into the auto-wired
+   * `multiTenantPlugin` or enforces scoping at its own framework layer
+   * (e.g. arc's preset + `BaseController`). Without this, a host that
+   * runs the plugin off would leak vouchers across branches at
+   * validate/redeem/spend/topUp call sites.
+   *
+   * When the engine is configured with `tenant: false`, the filter is
+   * code-only — vouchers are company-wide and the docs carry no
+   * `organizationId`, so injecting one would always miss.
+   */
+  getByCode(code: string, ctx?: Record<string, unknown>): Promise<Voucher | null>;
+  /**
+   * Idempotency check on nested arrays. Routes through mongokit's `count`
+   * so `multiTenantPlugin` injects the configured tenant field from
+   * `ctx` — a non-tenant-scoped check would cross organization boundaries.
+   */
+  hasIdempotencyKey(id: string, key: string, ctx?: Record<string, unknown>): Promise<boolean>;
+}
+//#endregion
+//#region src/repositories/create-repositories.d.ts
+interface PromoRepositories {
+  program: ProgramRepository;
+  rule: RuleRepository;
+  reward: RewardRepository;
+  voucher: VoucherRepository;
+  pendingEvaluation: PendingEvaluationRepository;
+}
+interface RepositoryPluginsMap {
+  program?: PluginType$1[];
+  rule?: PluginType$1[];
+  reward?: PluginType$1[];
+  voucher?: PluginType$1[];
+  pendingEvaluation?: PluginType$1[];
+}
+interface RepositoryDispatchDeps {
+  events?: EventTransport$1 | undefined;
+  outbox?: OutboxStore | undefined;
+  logger?: DispatchLogger | undefined;
+}
+//#endregion
+//#region src/domain/ports/unit-of-work.port.d.ts
+type TransactionSession = ClientSession;
+interface UnitOfWork {
+  withTransaction<T>(cb: (session: TransactionSession) => Promise<T>): Promise<T>;
+}
+//#endregion
+//#region src/services/evaluation.service.d.ts
+interface CommitOptions {
+  /**
+   * The `cartHash` returned from `evaluate`. When provided, the engine
+   * verifies it matches the hash computed at evaluation time and throws
+   * `CartHashMismatchError` on mismatch. Guards against cart-tampering
+   * between evaluate and commit (e.g. user previews a big discount on a
+   * heavy cart, swaps the cart for a cheaper one, then commits the stale
+   * discount). Hosts that trust their own commit pipeline end-to-end may
+   * omit it for the legacy behaviour.
+   */
+  cartHash?: string;
+}
+declare class EvaluationService {
+  private programRepo;
+  private ruleRepo;
+  private rewardRepo;
+  private voucherRepo;
+  private unitOfWork;
+  private dispatchDeps;
+  private config;
+  private store;
+  constructor(programRepo: ProgramRepository, ruleRepo: RuleRepository, rewardRepo: RewardRepository, voucherRepo: VoucherRepository, unitOfWork: UnitOfWork, dispatchDeps: DispatchDeps, config: ResolvedConfig, store: EvaluationStore);
+  evaluate(input: EvaluateInput, ctx: PromoContext): Promise<EvaluationResult>;
+  preview(input: EvaluateInput, ctx: PromoContext): Promise<EvaluationResult>;
+  commit(evaluationId: string, orderId: string, ctx: PromoContext, options?: CommitOptions): Promise<CommitResult>;
+  private commitInTransaction;
+  rollback(evaluationId: string, ctx: PromoContext): Promise<void>;
+  private doEvaluate;
+  private isCustomerEligible;
+  private matchBestRule;
+  private matchSingleRule;
+  private filterRewardsByRule;
+  private computeDiscount;
+  private getEligibleItems;
+  private describeDiscount;
+}
+//#endregion
+//#region src/services/voucher.service.d.ts
+/**
+ * VoucherService — multi-repo domain orchestration only.
+ *
+ * Code generation, redemption (transactional + idempotency), gift card
+ * spend/topUp, and validation live here because they need programRepo +
+ * voucherRepo + config + transactions.
+ *
+ * Simple lookups (getById, getByCode, getAll) and the cancel domain verb
+ * live on VoucherRepository directly — callers use the repo. §2/§3.
+ */
+declare class VoucherService {
+  private voucherRepo;
+  private programRepo;
+  private unitOfWork;
+  private dispatchDeps;
+  private config;
+  constructor(voucherRepo: VoucherRepository, programRepo: ProgramRepository, unitOfWork: UnitOfWork, dispatchDeps: DispatchDeps, config: ResolvedConfig);
+  generateCodes(input: GenerateCodesInput, ctx: PromoContext): Promise<Voucher[]>;
+  generateSingleCode(input: GenerateSingleCodeInput, ctx: PromoContext): Promise<Voucher>;
+  validateCode(code: string, ctx: PromoContext): Promise<VoucherValidation>;
+  redeem(input: RedeemVoucherInput, ctx: PromoContext): Promise<Voucher>;
+  getBalance(code: string, ctx: PromoContext): Promise<GiftCardBalance>;
+  spend(input: GiftCardSpendInput, ctx: PromoContext): Promise<GiftCardBalance>;
+  private spendInTransaction;
+  topUp(input: GiftCardTopUpInput, ctx: PromoContext): Promise<GiftCardBalance>;
+  private topUpInTransaction;
+  private assertVoucherUsable;
+}
+//#endregion
+//#region src/services/create-services.d.ts
+interface PromoServices {
+  voucher: VoucherService;
+  evaluation: EvaluationService;
+}
+//#endregion
+//#region src/adapters/mongo-evaluation-store.d.ts
+/**
+ * Default Mongo-backed implementation of {@link EvaluationStore}. Translates
+ * between the domain snapshot shape and the persistence document shape,
+ * forwards atomic `take`/`delete` semantics to the repository, and
+ * applies the engine's configured tenant field on writes (the repo
+ * applies it on reads).
+ *
+ * Hosts that prefer a different backend (Redis, DynamoDB, in-memory for
+ * tests) can implement `EvaluationStore` directly and pass it via engine
+ * config — this class isn't load-bearing.
+ */
+declare class MongoEvaluationStore implements EvaluationStore {
+  private readonly repo;
+  constructor(repo: PendingEvaluationRepository);
+  put(id: string, snapshot: StoredEvaluationSnapshot, ttlSeconds: number, ctx?: EvaluationStoreContext): Promise<void>;
+  take(id: string, ctx?: EvaluationStoreContext): Promise<StoredEvaluationSnapshot | null>;
+  delete(id: string, ctx?: EvaluationStoreContext): Promise<void>;
+}
+/**
+ * In-memory fallback. Useful for unit tests, single-process dev servers,
+ * and hosts that consciously opt out of persistence (knowing they lose
+ * pending evaluations on restart). NOT recommended for production
+ * topologies — see EvaluationStore docblock for why.
+ *
+ * Tenant scoping uses `ctx.tenantValue` as part of the in-memory key
+ * (the field-name layer doesn't matter here — we just namespace by
+ * value). No transaction semantics (in-memory has nothing to roll
+ * back), no TTL refinement beyond initial expiry check.
+ */
+declare class InMemoryEvaluationStore implements EvaluationStore {
+  private readonly map;
+  put(id: string, snapshot: StoredEvaluationSnapshot, ttlSeconds: number, ctx?: EvaluationStoreContext): Promise<void>;
+  take(id: string, ctx?: EvaluationStoreContext): Promise<StoredEvaluationSnapshot | null>;
+  delete(id: string, ctx?: EvaluationStoreContext): Promise<void>;
+  private key;
+}
+//#endregion
+//#region src/domain/errors/base.d.ts
+declare abstract class PromoError extends Error {
+  abstract readonly code: string;
+  constructor(message: string);
+}
+//#endregion
+//#region src/domain/errors/domain-errors.d.ts
+declare class ValidationError extends PromoError {
+  readonly code = "VALIDATION_ERROR";
+}
+declare class ProgramNotFoundError extends PromoError {
+  readonly code = "PROGRAM_NOT_FOUND";
+  constructor(id?: string);
+}
+/**
+ * Raised when a commit-time atomic CAS on `usedCount < maxUsageTotal`
+ * fails — i.e. the program's cap was exhausted by another concurrent
+ * commit between this caller's evaluate and its commit. The host should
+ * surface this as a "promo no longer available" failure to the user; the
+ * order itself can still proceed without the discount if the host wishes.
+ */
+declare class ProgramUsageCapExceededError extends PromoError {
+  readonly programId: string;
+  readonly maxUsageTotal: number;
+  readonly code = "PROGRAM_USAGE_CAP_EXCEEDED";
+  constructor(programId: string, maxUsageTotal: number);
+}
+declare class RuleNotFoundError extends PromoError {
+  readonly code = "RULE_NOT_FOUND";
+  constructor(id?: string);
+}
+declare class RewardNotFoundError extends PromoError {
+  readonly code = "REWARD_NOT_FOUND";
+  constructor(id?: string);
+}
+declare class VoucherNotFoundError extends PromoError {
+  readonly code = "VOUCHER_NOT_FOUND";
+  constructor(codeOrId?: string);
+}
+declare class InvalidTransitionError extends PromoError {
+  readonly code = "INVALID_TRANSITION";
+  constructor(from: string, to: string);
+}
+declare class VoucherExpiredError extends PromoError {
+  readonly code = "VOUCHER_EXPIRED";
+  constructor(code: string);
+}
+declare class VoucherExhaustedError extends PromoError {
+  readonly code = "VOUCHER_EXHAUSTED";
+  constructor(code: string);
+}
+/**
+ * Thrown when a gift card's balance has been fully spent and its status
+ * flipped to `'used'`. Distinct from `VoucherExhaustedError` (usage-limit
+ * exhaustion on a discount voucher) so hosts can show "top up" vs "retry
+ * later" messaging.
+ */
+declare class GiftCardExhaustedError extends PromoError {
+  readonly code = "GIFT_CARD_EXHAUSTED";
+  constructor(code: string);
+}
+/**
+ * Thrown when a MongoDB WriteConflict surfaces under voucher-spend
+ * contention. Losers see a stable domain shape rather than the raw
+ * `"Write conflict during plan execution"` string. Hosts can translate
+ * this to HTTP 409 + retry.
+ */
+declare class ConcurrencyConflictError extends PromoError {
+  readonly resource: 'voucher' | 'program' | 'rule' | 'reward';
+  readonly resourceId: string;
+  readonly cause?: unknown | undefined;
+  readonly code = "CONCURRENCY_CONFLICT";
+  readonly status = 409;
+  constructor(resource: 'voucher' | 'program' | 'rule' | 'reward', resourceId: string, cause?: unknown | undefined);
+}
+declare class InsufficientBalanceError extends PromoError {
+  readonly code = "INSUFFICIENT_BALANCE";
+  constructor(code: string, available: number, requested: number);
+}
+declare class TenantIsolationError extends PromoError {
+  readonly code = "TENANT_ISOLATION";
+  constructor();
+}
+declare class DuplicateRedemptionError extends PromoError {
+  readonly code = "DUPLICATE_REDEMPTION";
+  constructor(key: string);
+}
+declare class EvaluationNotFoundError extends PromoError {
+  readonly code = "EVALUATION_NOT_FOUND";
+  constructor(id: string);
+}
+/**
+ * Thrown by `EvaluationService.commit` when the cart hash provided by the
+ * caller does not match the cart hash computed at evaluation time. Guards
+ * against cart-tampering attacks where a user previews a large discount on
+ * a heavy cart, mutates the cart to something cheaper before committing, and
+ * tries to apply the stale discount to the altered order.
+ */
+declare class CartHashMismatchError extends PromoError {
+  readonly code = "CART_HASH_MISMATCH";
+  constructor(evaluationId: string);
+}
+//#endregion
+//#region src/events/event-constants.d.ts
+declare const PromoEvents: {
+  readonly PROGRAM_CREATED: "promo.program.created";
+  readonly PROGRAM_ACTIVATED: "promo.program.activated";
+  readonly PROGRAM_PAUSED: "promo.program.paused";
+  readonly PROGRAM_ARCHIVED: "promo.program.archived";
+  readonly RULE_ADDED: "promo.rule.added";
+  readonly RULE_UPDATED: "promo.rule.updated";
+  readonly RULE_REMOVED: "promo.rule.removed";
+  readonly REWARD_ADDED: "promo.reward.added";
+  readonly REWARD_UPDATED: "promo.reward.updated";
+  readonly REWARD_REMOVED: "promo.reward.removed";
+  readonly VOUCHER_GENERATED: "promo.voucher.generated";
+  readonly VOUCHER_REDEEMED: "promo.voucher.redeemed";
+  readonly VOUCHER_CANCELLED: "promo.voucher.cancelled";
+  readonly VOUCHER_EXPIRED: "promo.voucher.expired";
+  readonly GIFT_CARD_SPENT: "promo.gift_card.spent";
+  readonly GIFT_CARD_TOPPED_UP: "promo.gift_card.topped_up";
+  readonly GIFT_CARD_EXHAUSTED: "promo.gift_card.exhausted";
+  readonly EVALUATION_COMPLETED: "promo.evaluation.completed";
+  readonly EVALUATION_COMMITTED: "promo.evaluation.committed";
+  readonly EVALUATION_ROLLED_BACK: "promo.evaluation.rolled_back";
+};
+type PromoEventName = (typeof PromoEvents)[keyof typeof PromoEvents];
+//#endregion
+//#region src/events/in-process-bus.d.ts
+interface InProcessPromoBusOptions {
+  logger?: {
+    error(message: string, ...args: unknown[]): void;
+  };
+}
+//#endregion
+//#region src/events/promo-event-catalog.d.ts
+interface PromoEventSchema {
+  type: 'object';
+  properties?: Record<string, {
+    type?: string;
+    format?: string;
+    [key: string]: unknown;
+  }>;
+  required?: string[];
+  [key: string]: unknown;
+}
+interface PromoEventDefinition<TSchema extends z.ZodType = z.ZodType> {
+  readonly name: string;
+  readonly version: number;
+  readonly description?: string;
+  readonly schema: PromoEventSchema;
+  readonly zodSchema: TSchema;
+  create(payload: z.infer<TSchema>, meta?: Partial<DomainEvent$1['meta']>): DomainEvent$1<z.infer<TSchema>>;
+  readonly __payload?: z.infer<TSchema>;
+}
+type PromoEventPayloadOf<D> = D extends PromoEventDefinition<infer S> ? z.infer<S> : never;
+/** Mirrors `ProgramLifecyclePayload`. */
+declare const programLifecycleSchema: z.ZodObject<{
+  programId: z.ZodString;
+  programType: z.ZodString;
+  status: z.ZodString;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Mirrors `RulePayload`. */
+declare const ruleSchema: z.ZodObject<{
+  programId: z.ZodString;
+  ruleId: z.ZodString;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Mirrors `RewardPayload`. */
+declare const rewardSchema: z.ZodObject<{
+  programId: z.ZodString;
+  rewardId: z.ZodString;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Mirrors `VoucherGeneratedPayload`. */
+declare const voucherGeneratedSchema: z.ZodObject<{
+  programId: z.ZodString;
+  voucherIds: z.ZodArray<z.ZodString>;
+  codes: z.ZodArray<z.ZodString>;
+  count: z.ZodNumber;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Mirrors `VoucherRedeemedPayload`. */
+declare const voucherRedeemedSchema: z.ZodObject<{
+  voucherId: z.ZodString;
+  code: z.ZodString;
+  orderId: z.ZodString;
+  discountAmount: z.ZodNumber;
+  customerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Mirrors `VoucherLifecyclePayload` — shared by VOUCHER_CANCELLED,
+ * VOUCHER_EXPIRED, and GIFT_CARD_EXHAUSTED (repo emits `status: 'cancelled'`
+ * / `'used'` / host-supplied terminal value).
+ */
+declare const voucherLifecycleSchema: z.ZodObject<{
+  voucherId: z.ZodString;
+  code: z.ZodString;
+  status: z.ZodString;
+}, z.core.$strip>;
+/** Mirrors `GiftCardSpentPayload`. */
+declare const giftCardSpentSchema: z.ZodObject<{
+  voucherId: z.ZodString;
+  code: z.ZodString;
+  amount: z.ZodNumber;
+  remainingBalance: z.ZodNumber;
+  orderId: z.ZodString;
+}, z.core.$strip>;
+/** Mirrors `GiftCardToppedUpPayload`. */
+declare const giftCardToppedUpSchema: z.ZodObject<{
+  voucherId: z.ZodString;
+  code: z.ZodString;
+  amount: z.ZodNumber;
+  newBalance: z.ZodNumber;
+}, z.core.$strip>;
+/** Mirrors `EvaluationCompletedPayload`. */
+declare const evaluationCompletedSchema: z.ZodObject<{
+  evaluationId: z.ZodString;
+  totalDiscount: z.ZodNumber;
+  programsApplied: z.ZodNumber;
+  codesUsed: z.ZodArray<z.ZodString>;
+  isPreview: z.ZodBoolean;
+}, z.core.$strip>;
+/** Mirrors `EvaluationCommittedPayload`. */
+declare const evaluationCommittedSchema: z.ZodObject<{
+  evaluationId: z.ZodString;
+  orderId: z.ZodString;
+  totalDiscount: z.ZodNumber;
+}, z.core.$strip>;
+/** Single-field rollback payload — emitted by `evaluation.service.ts`. */
+declare const evaluationRolledBackSchema: z.ZodObject<{
+  evaluationId: z.ZodString;
+}, z.core.$strip>;
+type ProgramLifecyclePayloadSchema = z.infer<typeof programLifecycleSchema>;
+type RulePayloadSchema = z.infer<typeof ruleSchema>;
+type RewardPayloadSchema = z.infer<typeof rewardSchema>;
+type VoucherGeneratedPayloadSchema = z.infer<typeof voucherGeneratedSchema>;
+type VoucherRedeemedPayloadSchema = z.infer<typeof voucherRedeemedSchema>;
+type VoucherLifecyclePayloadSchema = z.infer<typeof voucherLifecycleSchema>;
+type GiftCardSpentPayloadSchema = z.infer<typeof giftCardSpentSchema>;
+type GiftCardToppedUpPayloadSchema = z.infer<typeof giftCardToppedUpSchema>;
+type EvaluationCompletedPayloadSchema = z.infer<typeof evaluationCompletedSchema>;
+type EvaluationCommittedPayloadSchema = z.infer<typeof evaluationCommittedSchema>;
+type EvaluationRolledBackPayloadSchema = z.infer<typeof evaluationRolledBackSchema>;
+declare const ProgramCreated: PromoEventDefinition<z.ZodObject<{
+  programId: z.ZodString;
+  programType: z.ZodString;
+  status: z.ZodString;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const ProgramActivated: PromoEventDefinition<z.ZodObject<{
+  programId: z.ZodString;
+  programType: z.ZodString;
+  status: z.ZodString;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const ProgramPaused: PromoEventDefinition<z.ZodObject<{
+  programId: z.ZodString;
+  programType: z.ZodString;
+  status: z.ZodString;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const ProgramArchived: PromoEventDefinition<z.ZodObject<{
+  programId: z.ZodString;
+  programType: z.ZodString;
+  status: z.ZodString;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const RuleAdded: PromoEventDefinition<z.ZodObject<{
+  programId: z.ZodString;
+  ruleId: z.ZodString;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const RuleUpdated: PromoEventDefinition<z.ZodObject<{
+  programId: z.ZodString;
+  ruleId: z.ZodString;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const RuleRemoved: PromoEventDefinition<z.ZodObject<{
+  programId: z.ZodString;
+  ruleId: z.ZodString;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const RewardAdded: PromoEventDefinition<z.ZodObject<{
+  programId: z.ZodString;
+  rewardId: z.ZodString;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const RewardUpdated: PromoEventDefinition<z.ZodObject<{
+  programId: z.ZodString;
+  rewardId: z.ZodString;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const RewardRemoved: PromoEventDefinition<z.ZodObject<{
+  programId: z.ZodString;
+  rewardId: z.ZodString;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const VoucherGenerated: PromoEventDefinition<z.ZodObject<{
+  programId: z.ZodString;
+  voucherIds: z.ZodArray<z.ZodString>;
+  codes: z.ZodArray<z.ZodString>;
+  count: z.ZodNumber;
+  actorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const VoucherRedeemed: PromoEventDefinition<z.ZodObject<{
+  voucherId: z.ZodString;
+  code: z.ZodString;
+  orderId: z.ZodString;
+  discountAmount: z.ZodNumber;
+  customerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const VoucherCancelled: PromoEventDefinition<z.ZodObject<{
+  voucherId: z.ZodString;
+  code: z.ZodString;
+  status: z.ZodString;
+}, z.core.$strip>>;
+declare const VoucherExpired: PromoEventDefinition<z.ZodObject<{
+  voucherId: z.ZodString;
+  code: z.ZodString;
+  status: z.ZodString;
+}, z.core.$strip>>;
+declare const GiftCardSpent: PromoEventDefinition<z.ZodObject<{
+  voucherId: z.ZodString;
+  code: z.ZodString;
+  amount: z.ZodNumber;
+  remainingBalance: z.ZodNumber;
+  orderId: z.ZodString;
+}, z.core.$strip>>;
+declare const GiftCardToppedUp: PromoEventDefinition<z.ZodObject<{
+  voucherId: z.ZodString;
+  code: z.ZodString;
+  amount: z.ZodNumber;
+  newBalance: z.ZodNumber;
+}, z.core.$strip>>;
+declare const GiftCardExhausted: PromoEventDefinition<z.ZodObject<{
+  voucherId: z.ZodString;
+  code: z.ZodString;
+  status: z.ZodString;
+}, z.core.$strip>>;
+declare const EvaluationCompleted: PromoEventDefinition<z.ZodObject<{
+  evaluationId: z.ZodString;
+  totalDiscount: z.ZodNumber;
+  programsApplied: z.ZodNumber;
+  codesUsed: z.ZodArray<z.ZodString>;
+  isPreview: z.ZodBoolean;
+}, z.core.$strip>>;
+declare const EvaluationCommitted: PromoEventDefinition<z.ZodObject<{
+  evaluationId: z.ZodString;
+  orderId: z.ZodString;
+  totalDiscount: z.ZodNumber;
+}, z.core.$strip>>;
+declare const EvaluationRolledBack: PromoEventDefinition<z.ZodObject<{
+  evaluationId: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * Every promo event defined in the package — pass to Arc's
+ * `EventRegistry`. Hosts wire ONE array; the whole `promo.*` namespace
+ * becomes introspectable via OpenAPI and auto-validated at publish time
+ * when `eventPlugin({ validateMode: 'reject' })` is set.
+ */
+declare const promoEventDefinitions: ReadonlyArray<PromoEventDefinition>;
+//#endregion
 //#region src/index.d.ts
 declare function resolveConfig(config: PromoConfig): ResolvedConfig;
 interface PromoEngine {
   models: PromoModels;
   repositories: PromoRepositories;
   services: PromoServices;
-  events: EventEmitterPort;
+  events: EventTransport$1;
+  syncIndexes(): Promise<void>;
 }
+/**
+ * Build the promo engine for a host application.
+ *
+ * **Index management — important for boot performance:**
+ *
+ * `createPromoEngine` itself is non-blocking. It registers Mongoose models
+ * and returns immediately. Index creation is delegated to Mongoose's
+ * standard lazy-init: with `autoIndex: true` (default in dev) Mongoose
+ * builds indexes in the background after the first query touches each
+ * model; with `autoIndex: false` (recommended for production) hosts
+ * control index creation explicitly.
+ *
+ * The returned `engine.syncIndexes()` helper is opt-in and **MUST NOT be
+ * `await`ed during Fastify plugin registration / boot** — Atlas index
+ * creation can take 10s+ on fresh collections, longer than typical
+ * plugin timeouts. Three safe patterns:
+ *
+ *   1. **Migration script** (recommended for production):
+ *      ```ts
+ *      // scripts/sync-indexes.ts
+ *      await engine.syncIndexes();
+ *      ```
+ *      Run before deploying / serving traffic.
+ *
+ *   2. **Background fire-and-log** during boot:
+ *      ```ts
+ *      engine.syncIndexes().catch((err) => log.warn({ err }, 'index sync'));
+ *      ```
+ *      App accepts traffic immediately; first queries may wait briefly
+ *      on still-building indexes.
+ *
+ *   3. **Lazy init** (`autoIndex: true` in dev): just don't call
+ *      `syncIndexes()` at all. Mongoose schedules creation on first
+ *      query per model.
+ *
+ * Production hosts should set `autoIndex: false` and use option (1).
+ */
 declare function createPromoEngine(config: PromoConfig): PromoEngine;
 //#endregion
-export { type BalanceLedgerEntry, type CartItem, type CommitResult, type CreateProgramInput, type CreateRewardInput, type CreateRuleInput, type DiscountLine, type EvaluateInput, type EvaluationResult, type EventEmitterPort, type FreeProductLine, type FullProgram, type GenerateCodesInput, type GenerateSingleCodeInput, type GiftCardBalance, type GiftCardSpendInput, type GiftCardTopUpInput, type ListQuery, type PaginatedResult, type Program, type PromoConfig, type PromoContext, PromoEngine, PromoEvents, type PromoModels, type PromoRepositories, type PromoServices, type RedeemVoucherInput, type RejectedCode, type ResolvedConfig, type ResolvedTenant, type Reward, type Rule, type UpdateProgramInput, type UpdateRewardInput, type UpdateRuleInput, type Voucher, type VoucherRedemption, type VoucherValidation, createPromoEngine, resolveConfig };
+export { type BalanceLedgerEntry, CartHashMismatchError, type CartItem, type CommitOptions, type CommitResult, ConcurrencyConflictError, type CreateProgramInput, type CreateRewardInput, type CreateRuleInput, type DiscountLine, type DomainEvent, DuplicateRedemptionError, type EvaluateInput, EvaluationCommitted, type EvaluationCommittedPayloadSchema, EvaluationCompleted, type EvaluationCompletedPayloadSchema, EvaluationNotFoundError, type EvaluationResult, EvaluationRolledBack, type EvaluationRolledBackPayloadSchema, type EvaluationStore, type EvaluationStoreContext, type EventHandler, type EventTransport, type FreeProductLine, type GenerateCodesInput, type GenerateSingleCodeInput, type GiftCardBalance, GiftCardExhausted, GiftCardExhaustedError, type GiftCardSpendInput, GiftCardSpent, type GiftCardSpentPayloadSchema, type GiftCardTopUpInput, GiftCardToppedUp, type GiftCardToppedUpPayloadSchema, InMemoryEvaluationStore, type InProcessPromoBusOptions, InsufficientBalanceError, InvalidTransitionError, type ListQuery, MongoEvaluationStore, type PaginatedResult, type PendingEvaluationDocument, PendingEvaluationRepository, type PluginType, type Program, ProgramActivated, ProgramArchived, ProgramCreated, type ProgramLifecyclePayloadSchema, ProgramNotFoundError, ProgramPaused, ProgramRepository, ProgramUsageCapExceededError, type PromoConfig, type PromoContext, PromoEngine, PromoError, type PromoEventDefinition, type PromoEventName, type PromoEventPayloadOf, type PromoEventSchema, PromoEvents, type PromoModels, type PromoRepositories, type PromoServices, type RedeemVoucherInput, type RejectedCode, type RepositoryDispatchDeps, type RepositoryPluginsMap, type ResolvedConfig, type ResolvedTenant, type Reward, RewardAdded, RewardNotFoundError, type RewardPayloadSchema, RewardRemoved, RewardRepository, RewardUpdated, type Rule, RuleAdded, RuleNotFoundError, type RulePayloadSchema, RuleRemoved, RuleRepository, RuleUpdated, type StoredEvaluationSnapshot, type TenantFieldType, TenantIsolationError, type UpdateProgramInput, type UpdateRewardInput, type UpdateRuleInput, ValidationError, type Voucher, VoucherCancelled, VoucherExhaustedError, VoucherExpired, VoucherExpiredError, VoucherGenerated, type VoucherGeneratedPayloadSchema, type VoucherLifecyclePayloadSchema, VoucherNotFoundError, VoucherRedeemed, type VoucherRedeemedPayloadSchema, type VoucherRedemption, VoucherRepository, type VoucherValidation, createPromoEngine, promoEventDefinitions, resolveConfig };