@classytic/promo 0.1.0 → 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,128 @@
+# Changelog
+
+Format based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+adhering to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0]
+
+Structural rewrite on top of the 0.1.0 shape. The public API is now a
+smaller, sharper surface organized around two subpath exports (the root
+engine factory and `./schemas`). Legacy barrel files and per-port
+indirection were removed; hosts wire business flows directly against
+the repositories plus the two remaining domain-orchestration services
+(`voucher`, `evaluation`).
+
+### Changed
+
+- **Domain restructure.** Dropped the `src/domain/ports/*` port barrels
+  (`program.port.ts`, `reward.port.ts`, `rule.port.ts`, `voucher.port.ts`,
+  `event-emitter.port.ts`, and the `index.ts` aggregator) in favor of
+  repositories that expose exactly the operations hosts need — program
+  FSM transitions (`activate` / `pause` / `archive`), usage tracking
+  (`incrementUsage` / `incrementCustomerUsage` / `getCustomerUsage`),
+  program lookup (`findActive`), voucher state change (`cancel`),
+  atomic voucher writes (`incrementUsage`, `addLedgerEntry`,
+  `expireByDate`), and voucher lookup (`getByCode`, `hasIdempotencyKey`).
+  The equivalent logic now lives on the repositories where it is
+  naturally atomic.
+- **Services collapsed.** `src/services/program.service.ts` was removed
+  — program FSM transitions + usage counters moved onto
+  `ProgramRepository`. `VoucherService` and `EvaluationService` remain
+  because they coordinate multiple repositories, the `UnitOfWork`
+  transaction boundary, and the resolved config; they are not a service
+  layer wrapping single-repo CRUD.
+- **Events subsystem simplified.** Removed `events/event-bus.ts` +
+  `events/event-types.ts` (both internal indirection the engine did not
+  need). The new `events/dispatch.ts` funnels every emission through a
+  single session-bound outbox-then-transport path; event payloads are
+  declared with Zod in `events/promo-event-catalog.ts` and re-exported
+  from the root.
+- **Repositories updated to mongokit 3.11 + repo-core 0.2 conventions.**
+  Every repo extends `Repository<T>` directly. `VoucherRepository`
+  overrides `create` / `createMany` to inject the tenant field from
+  `ctx` so writes work whether the host opts into the auto-wired
+  `multiTenantPlugin` or scopes at its own framework layer. Atomic
+  state changes go through `$inc` + `$push` on a single document.
+- **Tenant config moved to `@classytic/primitives/tenant`.** `resolveConfig`
+  delegates to `resolveTenantConfig`; the resolved shape
+  (`tenantField` / `fieldType` / `ref` / `contextKey` / `enabled` /
+  `required` / `strategy` / `resolve`) forwards straight into
+  `multiTenantPlugin(...)` without translation.
+- **Peer deps** tightened to `>=` ranges:
+  - `@classytic/mongokit >= 3.11.0`
+  - `@classytic/primitives >= 0.1.0`
+  - `@classytic/repo-core >= 0.2.0`
+  - `mongoose >= 9.4.1`, `zod >= 4.0.0`
+- **DevDeps:** `@classytic/primitives` devDep moved from a `file:` link
+  to `>=0.1.0` (now that primitives ships on npm); all `@classytic/*`
+  dev ranges standardized on `>=`.
+
+### Removed
+
+- `src/services/program.service.ts` — logic folded into
+  `ProgramRepository`.
+- `src/domain/ports/*` — structural types now live with the
+  repositories they describe.
+- `src/domain/enums/index.ts`, `src/domain/entities/index.ts`,
+  `src/domain/errors/index.ts`, `src/domain/index.ts`,
+  `src/events/index.ts`, `src/models/index.ts`,
+  `src/repositories/index.ts`, `src/services/index.ts`,
+  `src/types/index.ts` — internal barrel files deleted; `src/index.ts`
+  is now the only re-export surface.
+- `src/events/event-bus.ts` + `src/events/event-types.ts` — replaced
+  by the typed event catalog + dispatch helper.
+- `src/utils/mongoose.ts`, `src/utils/tenant-guard.ts` — helpers
+  superseded by mongokit + primitives built-ins.
+
+### Added
+
+- Subpath export `@classytic/promo/schemas` — Zod v4 validators for
+  every input (program / rule / reward / voucher generate + redeem /
+  gift card spend + top-up / evaluate + commit) plus the list-filter
+  schemas and every enum constant, depending only on zod.
+- `src/events/promo-event-catalog.ts` — typed event definitions
+  structurally compatible with `@classytic/arc`'s `EventDefinitionOutput`.
+- `src/events/dispatch.ts` — shared session-aware outbox + transport
+  plumbing with per-emission error isolation.
+- `cartHash` field on `EvaluationResult` + optional
+  `CommitOptions { cartHash }` — deterministic SHA-256 of the
+  evaluated cart that hosts can submit at commit time to catch
+  cart-tampering between `evaluate` and `commit`
+  (`CartHashMismatchError`).
+- Gift-card concurrency: `spend` wraps the transaction in a
+  write-conflict detector that maps MongoDB's transient
+  `WriteConflict` (code 112, `TransientTransactionError` label, or
+  `ConflictError` rethrows) into a typed `ConcurrencyConflictError`
+  for retry-or-409 handling at the host.
+- Test restructure — roughly 325 tests across 33 files, split into
+  `unit` and `integration` vitest projects covering full workflows,
+  commerce + vertical scenarios, voucher bulk generation, gift-card
+  concurrent-spend + lifecycle, outbox dispatch, tiered discounts,
+  cart-hash tamper, customer segmentation, program date boundaries,
+  multi-code evaluation, advanced stacking, concurrency edge cases,
+  and input validation.
+
+### Peer compatibility
+
+Anyone on 0.1.0 calling the old `services.program.*` will need to
+migrate to `repositories.program.*`. Signatures are the same — the
+call sites move from `engine.services.program.activate(id, ctx)` to
+`engine.repositories.program.activate(id, ctx)`, and similarly for
+`pause`, `archive`, `incrementUsage`, `getCustomerUsage`,
+`incrementCustomerUsage`, `findActive`. Voucher service and
+evaluation service signatures are unchanged except for the new
+optional `CommitOptions { cartHash }` argument on `commit`.
+
+Hosts reading from the dropped barrel files (`@classytic/promo/domain`,
+`.../ports`, `.../events`, etc.) should switch to the root import —
+every public type is re-exported from `@classytic/promo`, and every
+Zod schema is available from `@classytic/promo/schemas`.
+
+## [0.1.0]
+
+Initial release. Program / rule / reward / voucher engine for MongoDB
+with an evaluation service that resolves active programs against a
+cart, applies stacked or exclusive rewards, and commits usage inside
+a transaction. Multi-tenant via `multiTenantPlugin`, event-emitting
+through an in-process bus, with code generation, gift-card balance
+ledgers, and a port / service / repository layered architecture.

package/README.md

@@ -1,41 +1,245 @@
 # @classytic/promo
 
-Promotions engine for MongoDB — discount codes, vouchers, cashback, BOGO, and rule-based pricing.
-
-Framework-agnostic. Works with Fastify (Arc), Express, NestJS, Next.js, or any Node.js app with a Mongoose connection.
+Production-grade promotion, coupon, and discount engine for MongoDB — programs, rules, rewards, vouchers, gift cards, buy-x-get-y.
 
 ## Install
 
 ```bash
-npm install @classytic/promo
-# Peer deps:
-npm install mongoose@^9 @classytic/mongokit@^3.5
+npm install @classytic/promo \
+  @classytic/mongokit @classytic/primitives @classytic/repo-core \
+  mongoose zod
 ```
 
-## Quick Start
+Peer deps (exactly what `package.json` declares):
 
-```typescript
-import { createPromoEngine } from '@classytic/promo';
+| Peer | Range |
+|---|---|
+| `@classytic/mongokit` | `>=3.11.0` |
+| `@classytic/primitives` | `>=0.1.0` |
+| `@classytic/repo-core` | `>=0.2.0` |
+| `mongoose` | `>=9.4.1` |
+| `zod` | `>=4.0.0` |
+
+Node `>=22`. ESM only.
+
+## Exports
+
+| Subpath | Contents |
+|---|---|
+| `@classytic/promo` | Engine factory (`createPromoEngine`), `resolveConfig`, every repository class (`ProgramRepository`, `RuleRepository`, `RewardRepository`, `VoucherRepository`), domain entity types (`Program`, `Rule`, `Reward`, `Voucher`, `VoucherRedemption`, `BalanceLedgerEntry`), the `PromoEvents` constant + typed event catalog (`ProgramCreated`, `VoucherRedeemed`, `GiftCardSpent`, `EvaluationCompleted`, …), config types (`PromoConfig`, `ResolvedConfig`, `ResolvedTenant`), input DTOs, and result shapes (`EvaluationResult`, `CommitResult`, `GiftCardBalance`, `PaginatedResult`) |
+| `@classytic/promo/schemas` | Zod v4 validators: `programCreateSchema`, `programUpdateSchema`, `programActionSchema`, `ruleCreateSchema`, `rewardCreateSchema`, `voucherGenerateBatchSchema`, `voucherGenerateSingleSchema`, `voucherRedeemSchema`, `giftCardSpendSchema`, `giftCardTopUpSchema`, `evaluateSchema`, `commitEvaluationSchema`, the list-filter schemas, plus enum constants (`PROGRAM_TYPES`, `TRIGGER_MODES`, `STACKING_MODES`, `REWARD_TYPES`, `DISCOUNT_MODES`, `DISCOUNT_SCOPES`, `VOUCHER_STATUSES`) |
+
+The `/schemas` entry depends only on zod — importing it does not pull mongoose, mongokit, or the engine factory into the bundle. Ideal for frontend form validation and SDK codegen.
+
+---
+
+## Quick start
+
+```ts
 import mongoose from 'mongoose';
+import { createPromoEngine } from '@classytic/promo';
+
+await mongoose.connect(process.env.MONGO_URI!);
 
+// 1. Boot the engine against an existing mongoose connection.
 const engine = createPromoEngine({
   mongoose: mongoose.connection,
-  tenant: { field: 'organizationId' }, // multi-tenant (or false for single)
+  // tenant: false                       // disable scoping entirely
+  // tenant: { tenantField: 'branchId' } // custom tenant field
 });
+await engine.syncIndexes();
+
+const ctx = { organizationId: '64b0c0c0c0c0c0c0c0c0c0c0', actorId: 'admin' };
+
+// 2. Create a program + rule + reward.
+const program = await engine.repositories.program.create(
+  {
+    name: 'Summer Sale',
+    programType: 'discount_code',
+    triggerMode: 'code',
+    status: 'active',
+    stackingMode: 'stackable',
+    priority: 10,
+    usedCount: 0,
+    applicableCustomerIds: [],
+    applicableCustomerTags: [],
+  },
+  ctx,
+);
+
+await engine.repositories.rule.create(
+  {
+    programId: program._id,
+    code: 'SUMMER25',
+    minimumAmount: 5_000,
+    minimumQuantity: 0,
+    applicableProductIds: [],
+    applicableCategories: [],
+    applicableSkus: [],
+  },
+  ctx,
+);
+
+await engine.repositories.reward.create(
+  {
+    programId: program._id,
+    rewardType: 'discount',
+    discountMode: 'percentage',
+    discountAmount: 25,
+    discountScope: 'order',
+    applicableProductIds: [],
+    freeQuantity: 0,
+  },
+  ctx,
+);
+
+// 3. Generate a single voucher for that code.
+await engine.services.voucher.generateSingleCode(
+  { programId: program._id, code: 'SUMMER25' },
+  ctx,
+);
+
+// 4. Evaluate a cart, then commit against the order id.
+const result = await engine.services.evaluation.evaluate(
+  {
+    items: [{ productId: 'prod_1', quantity: 2, unitPrice: 3_000 }],
+    subtotal: 6_000,
+    codes: ['SUMMER25'],
+  },
+  ctx,
+);
 
-// Create a discount program
-const program = await engine.services.program.create({
-  name: 'Summer Sale',
-  type: 'discount_code',
-  startsAt: new Date(),
-}, ctx);
-
-// Evaluate cart against active promotions
-const result = await engine.services.evaluation.evaluate({
-  cart: { items, subtotal },
-}, ctx);
+if (result.appliedDiscounts.length > 0) {
+  await engine.services.evaluation.commit(
+    result.evaluationId,
+    'ORD-2026-0001',
+    ctx,
+    { cartHash: result.cartHash }, // tamper guard
+  );
+}
 ```
 
+---
+
+## Concepts
+
+**Program** (`src/domain/entities/program.ts`) — The top-level promotion container. Carries `programType` (`promotion` | `coupon` | `discount_code` | `buy_x_get_y` | `gift_card`), a `triggerMode` (`auto` | `code`), a `status` FSM (`draft → active → paused → expired → archived`), a `stackingMode` (`exclusive` | `stackable`), priority, validity window, and customer-segment filters (`applicableCustomerIds`, `applicableCustomerTags`, `maxUsagePerCustomer`).
+
+**Rule** (`src/domain/entities/rule.ts`) — A qualifier attached to a program. Declares the gates a cart must pass to unlock the program: `minimumAmount`, `minimumQuantity`, `applicableProductIds` / `applicableCategories` / `applicableSkus`, `buyQuantity` (for BXGY), optional `code` (for code-triggered programs), and an own `startsAt` / `endsAt` window. A program may carry multiple rules to express tiers — the engine picks the highest-threshold rule that matches.
+
+**Reward** (`src/domain/entities/reward.ts`) — The payout a qualifying program emits. Either `discount` (with `discountMode`: `percentage` | `fixed`, `discountScope`: `order` | `cheapest` | `specific_products`, optional `maxDiscountAmount` cap) or `free_product` (with `freeProductId` / `freeProductSku` / `freeQuantity`). Optionally scoped to a specific `ruleId` for tiered programs.
+
+**Voucher** (`src/domain/entities/voucher.ts`) — A concrete redeemable code instance of a program. Carries `code`, `status` (`active` | `used` | `expired` | `cancelled`), `usageLimit` / `usedCount`, optional `customerId` binding, optional `expiresAt`, and a `redemptions[]` audit log. For `gift_card` programs it also carries `initialBalance` / `currentBalance` and an append-only `balanceLedger[]`.
+
+**Gift card** — A voucher whose program has `programType: 'gift_card'`. Spend / top-up / balance-check flow through `engine.services.voucher.spend(...)`, `.topUp(...)`, and `.getBalance(...)`, each of which uses a Mongo transaction and an idempotency-key guard. `config.giftCard.allowNegativeBalance` + `config.giftCard.maxBalance` gate the writes.
+
+**Buy-X-Get-Y** — A `programType: 'buy_x_get_y'` program where a rule sets `buyQuantity` (the "X") and a linked reward carries `rewardType: 'free_product'` with a `freeQuantity` (the "Y"). The evaluation engine honors both on a qualifying cart.
+
+---
+
+## Evaluation pipeline
+
+`EvaluationService.evaluate(input, ctx)` (`src/services/evaluation.service.ts`) runs the following steps in order:
+
+1. **Load active programs** via `ProgramRepository.findActive()` — filtered by `status: 'active'`, current date ≥ `startsAt`, and current date ≤ `endsAt` (post-filtered in memory), sorted by `priority` DESC.
+2. **Load rules + rewards** for those programs in parallel, grouped by `programId`.
+3. **Resolve submitted codes to vouchers** — each code is upper-cased and looked up via `VoucherRepository.getByCode()`; only `status: 'active'` vouchers with remaining usage count are kept.
+4. **Per-program evaluation**, stopping on:
+   - `maxUsageTotal` exhausted,
+   - customer-segment mismatch (`applicableCustomerIds` / `applicableCustomerTags`),
+   - `maxUsagePerCustomer` exceeded (reads `ProgramRepository.getCustomerUsage`),
+   - stacking cap (`stackingMode: 'exclusive'` blocks subsequent programs; `maxStackablePromotions` caps the stackable chain).
+5. **Best-rule matching** — for each program, `matchBestRule` picks the highest-threshold rule whose gates all pass (code, date range, minimumAmount, minimumQuantity, product/category/SKU filters, `buyQuantity`). Scoring: `minimumAmount * 1000 + minimumQuantity`.
+6. **Reward computation** — linked rewards run through `computeDiscount` (scope-aware: `order`, `cheapest`, or `specific_products`; `maxDiscountAmount` capped; never exceeds running subtotal) or emit a `FreeProductLine`. The `runningSubtotal` decreases as each discount stacks.
+7. **Cart-hash + evaluation snapshot** — a SHA-256 hash of the normalized items + subtotal + codes + customer identity is computed and returned on the `EvaluationResult`. Non-preview evaluations are persisted via the configured `EvaluationStore` (Mongo by default; hosts can plug Redis / DynamoDB / custom by implementing the port) so `commit()` can replay program + voucher usage writes inside a single transaction. Snapshots survive process restart, horizontal scaling, serverless cold starts, and worker handoff. The default Mongo store applies a TTL index so abandoned snapshots auto-expire (default 30 min).
+8. **Dispatch `EVALUATION_COMPLETED`** via `dispatchPromoEvent` — routed through the configured `events.transport` and optionally persisted via the host `outbox` inside `ctx.session`.
+
+`commit(evaluationId, orderId, ctx, { cartHash })` (same service) consumes the stash: it optionally re-verifies the submitted `cartHash` (throws `CartHashMismatchError` on mismatch), opens a transaction, increments `program.usedCount` + per-customer usage on every applied program, increments voucher usage + appends a redemption record per applied voucher, emits `EVALUATION_COMMITTED`, and returns a `CommitResult`. `rollback(evaluationId, ctx)` drops the stash and emits `EVALUATION_ROLLED_BACK`.
+
+`preview(input, ctx)` runs the same algorithm with `isPreview: true` and skips the stash — safe for read-only quoting.
+
+---
+
+## Repository pattern
+
+All four repositories extend mongokit's `Repository<T>` directly — no wrapper layer. Hosts get the full mongokit surface (pagination, transactions, hooks, soft-delete, tenant plugin) on every repo.
+
+| Repository | Domain verbs (beyond mongokit base CRUD) |
+|---|---|
+| `program` | `activate`, `pause`, `archive` (FSM via `PROGRAM_TRANSITIONS`), `incrementUsage`, `decrementUsage`, `incrementCustomerUsage`, `getCustomerUsage`, `findActive` |
+| `rule` | (inherited only — matching happens in the evaluation service) |
+| `reward` | (inherited only) |
+| `voucher` | `cancel`, `incrementUsage` (atomic `$inc` + `$push`), `addLedgerEntry` (atomic balance delta + ledger push), `expireByDate`, `getByCode`, `hasIdempotencyKey` |
+
+The two services (`engine.services.voucher`, `engine.services.evaluation`) exist because they coordinate multiple repositories + transactions + config: code generation + redemption + gift-card spend/top-up for vouchers, and the multi-program evaluation algorithm + persistent evaluation snapshot store for evaluations.
+
+---
+
+## Multi-tenant scoping
+
+The engine resolves `config.tenant` via `@classytic/primitives/tenant`. By default every write carries an `organizationId: ObjectId` field and `multiTenantPlugin({ tenantField: 'organizationId' })` is wired onto every repository.
+
+```ts
+createPromoEngine({ mongoose: conn });                         // default: objectId, plugin on
+createPromoEngine({ mongoose: conn, tenant: false });          // field present, plugin off
+createPromoEngine({ mongoose: conn, tenant: { tenantField: 'branchId', fieldType: 'string' } });
+```
+
+`tenant: false` still injects the `organizationId` field onto the schema so hosts that scope at their own framework layer (e.g. arc's preset + `BaseController`) get the field written and filtered correctly. This mirrors the `@classytic/order` convention. `VoucherRepository.getByCode` and `ProgramRepository.findActive` inject the tenant filter manually — they work whether the plugin is on or off.
+
+---
+
+## Events
+
+The engine exposes `engine.events` — an `EventTransport` from `@classytic/primitives/events`. Default: in-process fanout. Pass `events: { transport }` into `createPromoEngine()` to drop in any Arc-compatible transport (Memory / Redis / Kafka / outbox-relay). Pass `outbox` alongside for durable at-least-once delivery inside the caller's `ctx.session`.
+
+Every event is typed via the catalog in `src/events/promo-event-catalog.ts`:
+
+```ts
+import { PromoEvents, type PromoEventName } from '@classytic/promo';
+
+engine.events.subscribe?.(PromoEvents.VOUCHER_REDEEMED, async (evt) => {
+  // evt.payload is typed: { voucherId, code, orderId, discountAmount, customerId? }
+});
+```
+
+Representative event names: `promo.program.created` / `.activated` / `.paused` / `.archived`, `promo.rule.added` / `.updated` / `.removed`, `promo.reward.added` / `.updated` / `.removed`, `promo.voucher.generated` / `.redeemed` / `.cancelled` / `.expired`, `promo.gift_card.spent` / `.topped_up` / `.exhausted`, `promo.evaluation.completed` / `.committed` / `.rolled_back`. The full canonical list is exported as `PromoEvents` from the package root.
+
+---
+
+## Design principles
+
+- **No barrel files inside `src/`.** Only `src/index.ts` re-exports. Internal folders import directly from source files.
+- **Peer-dep siblings only.** `@classytic/mongokit`, `@classytic/primitives`, `@classytic/repo-core` are peers, never dependencies. No imports from other `@classytic/*` packages in production code.
+- **Zod v4 at the seams.** Every validator in `@classytic/promo/schemas` is Zod v4. TypeScript DTOs in `src/types/inputs.ts` are hand-written to stay aligned with the schemas.
+- **Multi-tenant via `tenantFieldType` engine config.** Default `'objectId'` with `ref: 'organization'` so `$lookup` / `.populate()` work; pass `'string'` for UUID / slug-based auth systems.
+- **Extend mongokit `Repository<T>` directly.** The two remaining services exist only because they coordinate multiple repositories + `UnitOfWork` transactions + config; they are not a service layer wrapping the repos.
+
+---
+
+## Tests
+
+```bash
+npm test              # unit + integration (mongodb-memory-server)
+npm run test:unit
+npm run test:integration
+```
+
+Current suite: approximately 325 tests across 33 files, split into two vitest projects:
+
+| Project | Directories | Files |
+|---|---|---|
+| `unit` | `tests/unit/` | 6 — code generator, config resolution, constants, domain errors, event bus, event catalog |
+| `integration` | `tests/integration/`, `tests/services/`, `tests/domain/`, `tests/security/` | 27 — full workflows, commerce + vertical scenarios, gift-card concurrent-spend + lifecycle, voucher bulk generation, outbox dispatch, evaluation + voucher service edge cases, concurrency, tiered discounts, customer segmentation, cart-hash tamper guards, input validation |
+
+Integration tests spin up `mongodb-memory-server` one connection per worker (`fileParallelism: false`, single-worker pool); unit tests require no Mongo.
+
+---
+
+## Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md).
+
 ## License
 
-MIT
+MIT. See [LICENSE](./LICENSE).

package/dist/{index-J5BC20DN.d.mts → constants-CrbSSQG5.d.mts}

@@ -7,8 +7,6 @@ declare const REWARD_TYPES: readonly ["discount", "free_product"];
 declare const DISCOUNT_MODES: readonly ["percentage", "fixed"];
 declare const DISCOUNT_SCOPES: readonly ["order", "cheapest", "specific_products"];
 declare const VOUCHER_STATUSES: readonly ["active", "used", "expired", "cancelled"];
-//#endregion
-//#region src/domain/enums/index.d.ts
 type ProgramType = (typeof PROGRAM_TYPES)[number];
 type TriggerMode = (typeof TRIGGER_MODES)[number];
 type ProgramStatus = (typeof PROGRAM_STATUSES)[number];
@@ -18,4 +16,4 @@ type DiscountMode = (typeof DISCOUNT_MODES)[number];
 type DiscountScope = (typeof DISCOUNT_SCOPES)[number];
 type VoucherStatus = (typeof VOUCHER_STATUSES)[number];
 //#endregion
-export { RewardType as a, VoucherStatus as c, PROGRAM_STATUSES as d, PROGRAM_TYPES as f, VOUCHER_STATUSES as g, TRIGGER_MODES as h, ProgramType as i, DISCOUNT_MODES as l, STACKING_MODES as m, DiscountScope as n, StackingMode as o, REWARD_TYPES as p, ProgramStatus as r, TriggerMode as s, DiscountMode as t, DISCOUNT_SCOPES as u };
+export { PROGRAM_STATUSES as a, ProgramType as c, STACKING_MODES as d, StackingMode as f, VoucherStatus as g, VOUCHER_STATUSES as h, DiscountScope as i, REWARD_TYPES as l, TriggerMode as m, DISCOUNT_SCOPES as n, PROGRAM_TYPES as o, TRIGGER_MODES as p, DiscountMode as r, ProgramStatus as s, DISCOUNT_MODES as t, RewardType as u };

package/dist/{constants-BVajdyL3.mjs → constants-D0Rntp2f.mjs}

@@ -28,8 +28,6 @@ const VOUCHER_STATUSES = [
 	"expired",
 	"cancelled"
 ];
-const DEFAULT_TENANT_FIELD = "organizationId";
-const DEFAULT_TENANT_TYPE = "ObjectId";
 const PROGRAM_TRANSITIONS = {
 	draft: ["active", "archived"],
 	active: [
@@ -42,4 +40,4 @@ const PROGRAM_TRANSITIONS = {
 	archived: []
 };
 //#endregion
-export { PROGRAM_STATUSES as a, REWARD_TYPES as c, VOUCHER_STATUSES as d, DISCOUNT_SCOPES as i, STACKING_MODES as l, DEFAULT_TENANT_TYPE as n, PROGRAM_TRANSITIONS as o, DISCOUNT_MODES as r, PROGRAM_TYPES as s, DEFAULT_TENANT_FIELD as t, TRIGGER_MODES as u };
+export { PROGRAM_TYPES as a, TRIGGER_MODES as c, PROGRAM_TRANSITIONS as i, VOUCHER_STATUSES as l, DISCOUNT_SCOPES as n, REWARD_TYPES as o, PROGRAM_STATUSES as r, STACKING_MODES as s, DISCOUNT_MODES as t };