@classytic/loyalty 0.1.0

package/dist/index-BcoGeDco.d.mts

@@ -0,0 +1,127 @@
+import { a as PointTransaction, n as TierDefinition, o as Member, u as EarningRule } from "./tier-definition-Djf72UPa.mjs";
+import { a as MemberPort, i as PointTransactionPort, l as Referral, n as ReferralPort, o as EarningRulePort, r as RedemptionPort, t as TierDefinitionPort, u as Redemption } from "./tier-definition.port-BzrHYBRo.mjs";
+import { a as RepositoryPlugins } from "./config-aNigy4ec.mjs";
+import { t as LoyaltyModels } from "./index-B6ZstxSP.mjs";
+import { Model } from "mongoose";
+import { PluginType } from "@classytic/mongokit";
+
+//#region src/repositories/earning-rule.repository.d.ts
+declare class EarningRuleRepository implements EarningRulePort {
+  private repo;
+  private tenantField;
+  constructor(model: Model<any>, plugins?: PluginType[], tenantField?: string);
+  create(data: Record<string, unknown>, session?: unknown): Promise<EarningRule>;
+  getById(id: string, tenantId?: string): Promise<EarningRule | null>;
+  update(id: string, data: Record<string, unknown>, tenantId?: string, session?: unknown): Promise<EarningRule>;
+  findActive(tenantId?: string, programId?: string): Promise<EarningRule[]>;
+  paginate(query: Record<string, unknown>, options: {
+    page?: number;
+    limit?: number;
+    sort?: Record<string, number>;
+  }): Promise<{
+    docs: EarningRule[];
+    total: number;
+    page: number;
+    pages: number;
+  }>;
+}
+//#endregion
+//#region src/repositories/member.repository.d.ts
+declare class MemberRepository implements MemberPort {
+  private repo;
+  private tenantField;
+  constructor(model: Model<any>, plugins?: PluginType[], tenantField?: string);
+  create(data: Record<string, unknown>, session?: unknown): Promise<Member>;
+  getById(id: string, tenantId?: string): Promise<Member | null>;
+  getByExternalId(externalId: string, externalType: string, tenantId?: string): Promise<Member | null>;
+  getByCardId(cardId: string, tenantId?: string): Promise<Member | null>;
+  getByReferralCode(code: string, tenantId?: string): Promise<Member | null>;
+  update(id: string, data: Record<string, unknown>, tenantId?: string, session?: unknown): Promise<Member>;
+  updateBalance(id: string, balanceUpdate: Record<string, number>, tenantId?: string, session?: unknown): Promise<Member>;
+  findMany(query: Record<string, unknown>, options?: Record<string, unknown>): Promise<Member[]>;
+}
+//#endregion
+//#region src/repositories/point-transaction.repository.d.ts
+declare class PointTransactionRepository implements PointTransactionPort {
+  private repo;
+  private tenantField;
+  constructor(model: Model<any>, plugins?: PluginType[], tenantField?: string);
+  create(data: Record<string, unknown>, session?: unknown): Promise<PointTransaction>;
+  getById(id: string, tenantId?: string): Promise<PointTransaction | null>;
+  getByIdempotencyKey(key: string, tenantId?: string): Promise<PointTransaction | null>;
+  update(id: string, data: Record<string, unknown>, session?: unknown): Promise<PointTransaction>;
+  findMany(query: Record<string, unknown>, options?: Record<string, unknown>): Promise<PointTransaction[]>;
+  paginate(query: Record<string, unknown>, options: {
+    page?: number;
+    limit?: number;
+    sort?: Record<string, number>;
+  }): Promise<{
+    docs: PointTransaction[];
+    total: number;
+    page: number;
+    pages: number;
+  }>;
+  findExpired(now: Date, tenantId?: string, limit?: number): Promise<PointTransaction[]>;
+}
+//#endregion
+//#region src/repositories/redemption.repository.d.ts
+declare class RedemptionRepository implements RedemptionPort {
+  private repo;
+  private tenantField;
+  constructor(model: Model<any>, plugins?: PluginType[], tenantField?: string);
+  create(data: Record<string, unknown>, session?: unknown): Promise<Redemption>;
+  getById(id: string, tenantId?: string): Promise<Redemption | null>;
+  getByOwner(ownerType: string, ownerId: string, tenantId?: string): Promise<Redemption | null>;
+  update(id: string, data: Record<string, unknown>, tenantId?: string, session?: unknown): Promise<Redemption>;
+  atomicStatusTransition(id: string, expectedStatus: string, data: Record<string, unknown>, tenantId?: string, session?: unknown): Promise<Redemption | null>;
+  findExpired(now: Date, tenantId?: string): Promise<Redemption[]>;
+}
+//#endregion
+//#region src/repositories/referral.repository.d.ts
+declare class ReferralRepository implements ReferralPort {
+  private repo;
+  private tenantField;
+  constructor(model: Model<any>, plugins?: PluginType[], tenantField?: string);
+  create(data: Record<string, unknown>, session?: unknown): Promise<Referral>;
+  getById(id: string, tenantId?: string): Promise<Referral | null>;
+  getByReferee(refereeId: string, tenantId?: string): Promise<Referral | null>;
+  update(id: string, data: Record<string, unknown>, tenantId?: string, session?: unknown): Promise<Referral>;
+  atomicStatusTransition(id: string, expectedStatus: string, data: Record<string, unknown>, tenantId?: string, session?: unknown): Promise<Referral | null>;
+  countByReferrerInPeriod(referrerId: string, since: Date, tenantId?: string): Promise<number>;
+  findByReferrer(referrerId: string, options: {
+    page?: number;
+    limit?: number;
+  }, tenantId?: string): Promise<{
+    docs: Referral[];
+    total: number;
+    page: number;
+    pages: number;
+  }>;
+  findExpired(now: Date, tenantId?: string): Promise<Referral[]>;
+}
+//#endregion
+//#region src/repositories/tier-definition.repository.d.ts
+declare class TierDefinitionRepository implements TierDefinitionPort {
+  private repo;
+  private tenantField;
+  constructor(model: Model<any>, plugins?: PluginType[], tenantField?: string);
+  create(data: Record<string, unknown>, session?: unknown): Promise<TierDefinition>;
+  getById(id: string, tenantId?: string): Promise<TierDefinition | null>;
+  getByName(name: string, tenantId?: string, programId?: string): Promise<TierDefinition | null>;
+  update(id: string, data: Record<string, unknown>, tenantId?: string, session?: unknown): Promise<TierDefinition>;
+  delete(id: string, tenantId?: string): Promise<void>;
+  findAll(tenantId?: string, programId?: string): Promise<TierDefinition[]>;
+}
+//#endregion
+//#region src/repositories/index.d.ts
+interface LoyaltyRepositories {
+  member: MemberPort;
+  pointTransaction: PointTransactionPort;
+  earningRule: EarningRulePort;
+  tierDefinition: TierDefinitionPort;
+  redemption: RedemptionPort;
+  referral: ReferralPort;
+}
+declare function createRepositories(models: LoyaltyModels, plugins?: RepositoryPlugins, tenantField?: string): LoyaltyRepositories;
+//#endregion
+export { RedemptionRepository as a, EarningRuleRepository as c, ReferralRepository as i, createRepositories as n, PointTransactionRepository as o, TierDefinitionRepository as r, MemberRepository as s, LoyaltyRepositories as t };

package/dist/index-CaH4GhSF.d.mts

@@ -0,0 +1,19 @@
+//#region src/constants.d.ts
+declare const TRANSACTION_TYPES: readonly ["earn", "redeem", "adjust", "expire", "transfer", "referral_bonus"];
+declare const MEMBER_STATUSES: readonly ["active", "inactive", "suspended"];
+declare const RULE_TYPES: readonly ["order", "action", "category", "tier_bonus"];
+declare const RULE_STATUSES: readonly ["active", "paused", "expired"];
+declare const REFERRAL_STATUSES: readonly ["pending", "approved", "rejected", "expired"];
+declare const REDEMPTION_STATUSES: readonly ["reserved", "confirmed", "released", "expired"];
+declare const EARNING_ACTIONS: readonly ["signup", "referral", "birthday", "review", "profile_complete"];
+//#endregion
+//#region src/domain/enums/index.d.ts
+type TransactionType = (typeof TRANSACTION_TYPES)[number];
+type MemberStatus = (typeof MEMBER_STATUSES)[number];
+type RuleType = (typeof RULE_TYPES)[number];
+type RuleStatus = (typeof RULE_STATUSES)[number];
+type ReferralStatus = (typeof REFERRAL_STATUSES)[number];
+type RedemptionStatus = (typeof REDEMPTION_STATUSES)[number];
+type EarningAction = (typeof EARNING_ACTIONS)[number];
+//#endregion
+export { RuleStatus as a, EARNING_ACTIONS as c, REFERRAL_STATUSES as d, RULE_STATUSES as f, ReferralStatus as i, MEMBER_STATUSES as l, TRANSACTION_TYPES as m, MemberStatus as n, RuleType as o, RULE_TYPES as p, RedemptionStatus as r, TransactionType as s, EarningAction as t, REDEMPTION_STATUSES as u };

package/dist/index-DqzTjeEB.d.mts

@@ -0,0 +1,148 @@
+import { a as PointTransaction, c as EarningConditions, i as TierQualification, l as EarningReward, r as TierDowngrade, s as MemberBalance, t as TierBenefits } from "./tier-definition-Djf72UPa.mjs";
+//#region src/types/results.d.ts
+interface BalanceSummary extends MemberBalance {
+  tier: string | null;
+  tierOverride: string | null;
+}
+interface EarningBreakdown {
+  ruleId: string;
+  ruleName: string;
+  points: number;
+}
+interface EarningResult {
+  totalPoints: number;
+  breakdown: EarningBreakdown[];
+  transactions: PointTransaction[];
+}
+interface TierEvaluation {
+  memberId: string;
+  previousTier: string | null;
+  newTier: string | null;
+  action: 'upgraded' | 'downgraded' | 'grace_period' | 'unchanged';
+  graceExpiresAt?: Date;
+}
+interface TierEvaluationBatch {
+  upgraded: number;
+  downgraded: number;
+  unchanged: number;
+}
+interface RedemptionValidation {
+  valid: boolean;
+  error?: string;
+  pointsToRedeem: number;
+  discountAmount: number;
+  maxAllowedPoints: number;
+}
+interface ExpirationResult {
+  membersAffected: number;
+  pointsExpired: number;
+  transactionCount: number;
+}
+interface PaginatedResult<T> {
+  docs: T[];
+  total: number;
+  page: number;
+  pages: number;
+  hasNext: boolean;
+  hasPrev: boolean;
+}
+interface ListQuery {
+  page?: number;
+  limit?: number;
+  sort?: Record<string, 1 | -1>;
+}
+//#endregion
+//#region src/types/index.d.ts
+/**
+ * Context passed to every loyalty operation.
+ *
+ * The tenant key is dynamic — if you configured `tenant: { field: 'companyId', contextKey: 'companyId' }`,
+ * pass `{ companyId: '...' }` in the context. The `[key: string]: unknown` index allows this.
+ *
+ * For the default config (`tenant: true` or `tenant: undefined`), pass `organizationId`.
+ * For `tenant: false`, the tenant key is ignored.
+ */
+interface LoyaltyContext {
+  /** Required: who is performing this operation */
+  actorId: string;
+  /** Default tenant key (used when tenant config uses default 'organizationId' field) */
+  organizationId?: string;
+  /** Override program ID for multi-program setups */
+  programId?: string;
+  /** Deduplication key for earn/adjust operations */
+  idempotencyKey?: string;
+  /** Dynamic tenant key support — e.g. `{ companyId: '...' }` */
+  [key: string]: unknown;
+}
+interface EnrollInput {
+  externalId: string;
+  externalType: string;
+  programId?: string;
+  tier?: string;
+  cardId?: string;
+  metadata?: Record<string, unknown>;
+}
+interface EarnPointsInput {
+  memberId: string;
+  points: number;
+  description: string;
+  referenceType?: string;
+  referenceId?: string;
+  earningRuleId?: string;
+  expiresAt?: Date;
+  idempotencyKey?: string;
+  metadata?: Record<string, unknown>;
+}
+interface AdjustPointsInput {
+  memberId: string;
+  points: number;
+  description: string;
+  reason: string;
+  referenceType?: string;
+  referenceId?: string;
+  idempotencyKey?: string;
+  metadata?: Record<string, unknown>;
+}
+interface CreateEarningRuleInput {
+  name: string;
+  type: 'order' | 'action' | 'category' | 'tier_bonus';
+  priority?: number;
+  description?: string;
+  conditions?: EarningConditions;
+  reward: EarningReward;
+  startsAt?: Date | string;
+  endsAt?: Date | string;
+  programId?: string;
+  metadata?: Record<string, unknown>;
+}
+interface UpdateEarningRuleInput {
+  name?: string;
+  priority?: number;
+  description?: string;
+  conditions?: EarningConditions;
+  reward?: EarningReward;
+  startsAt?: Date | string;
+  endsAt?: Date | string;
+  metadata?: Record<string, unknown>;
+}
+interface CreateTierInput {
+  name: string;
+  rank: number;
+  qualificationCriteria?: TierQualification;
+  benefits?: TierBenefits;
+  downgrade?: TierDowngrade;
+  color?: string;
+  programId?: string;
+  metadata?: Record<string, unknown>;
+}
+interface UpdateTierInput {
+  name?: string;
+  rank?: number;
+  qualificationCriteria?: TierQualification;
+  benefits?: TierBenefits;
+  downgrade?: TierDowngrade;
+  color?: string;
+  metadata?: Record<string, unknown>;
+}
+//#endregion
+export { TierEvaluationBatch as _, EnrollInput as a, UpdateTierInput as c, EarningResult as d, ExpirationResult as f, TierEvaluation as g, RedemptionValidation as h, EarnPointsInput as i, BalanceSummary as l, PaginatedResult as m, CreateEarningRuleInput as n, LoyaltyContext as o, ListQuery as p, CreateTierInput as r, UpdateEarningRuleInput as s, AdjustPointsInput as t, EarningBreakdown as u };

package/dist/index-O7TL4R2P.d.mts

@@ -0,0 +1,86 @@
+import { t as EventEmitterPort } from "./event-emitter.port-CLYPoMni.mjs";
+
+//#region src/events/event-bus.d.ts
+type Handler = (payload: unknown) => void | Promise<void>;
+declare class InProcessEventBus implements EventEmitterPort {
+  private handlers;
+  emit(event: string, payload: unknown): void;
+  on(event: string, handler: Handler): void;
+  off(event: string, handler: Handler): void;
+}
+//#endregion
+//#region src/events/event-types.d.ts
+declare const LoyaltyEvents: {
+  readonly MEMBER_ENROLLED: "loyalty.member.enrolled";
+  readonly MEMBER_DEACTIVATED: "loyalty.member.deactivated";
+  readonly MEMBER_REACTIVATED: "loyalty.member.reactivated";
+  readonly MEMBER_SUSPENDED: "loyalty.member.suspended";
+  readonly POINTS_EARNED: "loyalty.points.earned";
+  readonly POINTS_REDEEMED: "loyalty.points.redeemed";
+  readonly POINTS_ADJUSTED: "loyalty.points.adjusted";
+  readonly POINTS_EXPIRED: "loyalty.points.expired";
+  readonly POINTS_EXPIRING_SOON: "loyalty.points.expiring_soon";
+  readonly TIER_UPGRADED: "loyalty.tier.upgraded";
+  readonly TIER_DOWNGRADED: "loyalty.tier.downgraded";
+  readonly TIER_GRACE_STARTED: "loyalty.tier.grace_started";
+  readonly REDEMPTION_RESERVED: "loyalty.redemption.reserved";
+  readonly REDEMPTION_CONFIRMED: "loyalty.redemption.confirmed";
+  readonly REDEMPTION_RELEASED: "loyalty.redemption.released";
+  readonly REFERRAL_RECORDED: "loyalty.referral.recorded";
+  readonly REFERRAL_APPROVED: "loyalty.referral.approved";
+  readonly REFERRAL_REJECTED: "loyalty.referral.rejected";
+  readonly REFERRAL_REWARDED: "loyalty.referral.rewarded";
+};
+type LoyaltyEvent = (typeof LoyaltyEvents)[keyof typeof LoyaltyEvents];
+interface PointsEarnedPayload {
+  memberId: string;
+  externalId: string;
+  externalType: string;
+  points: number;
+  balanceAfter: number;
+  transactionId: string;
+  earningRuleName?: string;
+  referenceType?: string;
+  referenceId?: string;
+}
+interface PointsAdjustedPayload {
+  memberId: string;
+  externalId: string;
+  points: number;
+  balanceAfter: number;
+  transactionId: string;
+  description: string;
+}
+interface TierChangedPayload {
+  memberId: string;
+  externalId: string;
+  previousTier: string | null;
+  newTier: string | null;
+  lifetimePoints: number;
+}
+interface MemberLifecyclePayload {
+  memberId: string;
+  externalId: string;
+  externalType: string;
+  status: string;
+}
+interface RedemptionPayload {
+  memberId: string;
+  externalId: string;
+  redemptionId: string;
+  points: number;
+  discountAmount: number;
+  ownerType: string;
+  ownerId: string;
+}
+interface ReferralPayload {
+  referralId: string;
+  referrerId: string;
+  refereeId: string;
+  referralCode: string;
+  status: string;
+  referrerRewardPoints?: number;
+  refereeRewardPoints?: number;
+}
+//#endregion
+export { PointsEarnedPayload as a, TierChangedPayload as c, PointsAdjustedPayload as i, InProcessEventBus as l, LoyaltyEvents as n, RedemptionPayload as o, MemberLifecyclePayload as r, ReferralPayload as s, LoyaltyEvent as t };

package/dist/index-_pg4J11t.d.mts

@@ -0,0 +1,191 @@
+import { a as PointTransaction, n as TierDefinition, o as Member, u as EarningRule } from "./tier-definition-Djf72UPa.mjs";
+import { a as MemberPort, c as UnitOfWork, i as PointTransactionPort, l as Referral, n as ReferralPort, o as EarningRulePort, r as RedemptionPort, t as TierDefinitionPort, u as Redemption } from "./tier-definition.port-BzrHYBRo.mjs";
+import { t as EventEmitterPort } from "./event-emitter.port-CLYPoMni.mjs";
+import { t as NotificationAdapter } from "./notification.port-BzUsH0It.mjs";
+import { o as ResolvedConfig } from "./config-aNigy4ec.mjs";
+import { t as LoyaltyRepositories } from "./index-BcoGeDco.mjs";
+import { _ as TierEvaluationBatch, c as UpdateTierInput, d as EarningResult, f as ExpirationResult, g as TierEvaluation, h as RedemptionValidation, l as BalanceSummary, m as PaginatedResult, n as CreateEarningRuleInput, o as LoyaltyContext, p as ListQuery, r as CreateTierInput, s as UpdateEarningRuleInput } from "./index-DqzTjeEB.mjs";
+
+//#region src/services/ledger.service.d.ts
+declare class LedgerService {
+  private txPort;
+  private memberPort;
+  private events;
+  private notifications;
+  private unitOfWork;
+  private config;
+  constructor(txPort: PointTransactionPort, memberPort: MemberPort, events: EventEmitterPort, notifications: NotificationAdapter | null, unitOfWork: UnitOfWork, config: ResolvedConfig);
+  earnPoints(input: {
+    memberId: string;
+    points: number;
+    description: string;
+    referenceType?: string;
+    referenceId?: string;
+    earningRuleId?: string;
+    expiresAt?: Date;
+    idempotencyKey?: string;
+    metadata?: Record<string, unknown>;
+  }, ctx: LoyaltyContext): Promise<PointTransaction>;
+  adjustPoints(input: {
+    memberId: string;
+    points: number;
+    description: string;
+    reason: string;
+    referenceType?: string;
+    referenceId?: string;
+    idempotencyKey?: string;
+    metadata?: Record<string, unknown>;
+  }, ctx: LoyaltyContext): Promise<PointTransaction>;
+  getHistory(memberId: string, query: ListQuery, ctx: LoyaltyContext): Promise<PaginatedResult<PointTransaction>>;
+  getBalance(memberId: string, ctx: LoyaltyContext): Promise<number>;
+  processExpirations(ctx: LoyaltyContext): Promise<ExpirationResult>;
+}
+//#endregion
+//#region src/services/earning.service.d.ts
+declare class EarningService {
+  private rulePort;
+  private ledger;
+  private memberPort;
+  private config;
+  constructor(rulePort: EarningRulePort, ledger: LedgerService, memberPort: MemberPort, config: ResolvedConfig);
+  evaluateOrder(input: {
+    memberId: string;
+    orderId: string;
+    orderTotal: number;
+    items?: Array<{
+      categoryId?: string;
+      amount: number;
+      quantity: number;
+    }>;
+  }, ctx: LoyaltyContext): Promise<EarningResult>;
+  evaluateAction(input: {
+    memberId: string;
+    action: string;
+    referenceId?: string;
+  }, ctx: LoyaltyContext): Promise<EarningResult>;
+  createRule(input: CreateEarningRuleInput, ctx: LoyaltyContext): Promise<EarningRule>;
+  updateRule(ruleId: string, input: UpdateEarningRuleInput, ctx: LoyaltyContext): Promise<EarningRule>;
+  deactivateRule(ruleId: string, ctx: LoyaltyContext): Promise<EarningRule>;
+  listRules(query: ListQuery, ctx: LoyaltyContext): Promise<PaginatedResult<EarningRule>>;
+  private matchesConditions;
+  private calculateOrderPoints;
+  private calculateCategoryPoints;
+  private applyRounding;
+}
+//#endregion
+//#region src/services/member.service.d.ts
+declare class MemberService {
+  private memberPort;
+  private events;
+  private notifications;
+  private unitOfWork;
+  private config;
+  constructor(memberPort: MemberPort, events: EventEmitterPort, notifications: NotificationAdapter | null, unitOfWork: UnitOfWork, config: ResolvedConfig);
+  enroll(input: {
+    externalId: string;
+    externalType: string;
+    programId?: string;
+    tier?: string; /** Public loyalty card identifier (set by integration layer, e.g. MBR-DHK-00004821-8) */
+    cardId?: string;
+    metadata?: Record<string, unknown>;
+  }, ctx: LoyaltyContext): Promise<Member>;
+  deactivate(memberId: string, ctx: LoyaltyContext): Promise<Member>;
+  reactivate(memberId: string, ctx: LoyaltyContext): Promise<Member>;
+  suspend(memberId: string, reason: string, ctx: LoyaltyContext): Promise<Member>;
+  getById(memberId: string, ctx: LoyaltyContext): Promise<Member>;
+  getByExternalId(externalId: string, externalType: string, ctx: LoyaltyContext): Promise<Member | null>;
+  getByCardId(cardId: string, ctx: LoyaltyContext): Promise<Member | null>;
+  getBalance(memberId: string, ctx: LoyaltyContext): Promise<BalanceSummary>;
+}
+//#endregion
+//#region src/services/redemption.service.d.ts
+declare class RedemptionService {
+  private redemptionPort;
+  private memberPort;
+  private txPort;
+  private events;
+  private notifications;
+  private unitOfWork;
+  private config;
+  constructor(redemptionPort: RedemptionPort, memberPort: MemberPort, txPort: PointTransactionPort, events: EventEmitterPort, notifications: NotificationAdapter | null, unitOfWork: UnitOfWork, config: ResolvedConfig);
+  validate(input: {
+    memberId: string;
+    pointsToRedeem: number;
+    orderTotal: number;
+  }, ctx: LoyaltyContext): Promise<RedemptionValidation>;
+  reserve(input: {
+    memberId: string;
+    pointsToRedeem: number;
+    orderTotal: number;
+    ownerType: string;
+    ownerId: string;
+    expiresAt?: Date;
+  }, ctx: LoyaltyContext): Promise<Redemption>;
+  confirm(redemptionId: string, ctx: LoyaltyContext): Promise<Redemption>;
+  release(redemptionId: string, ctx: LoyaltyContext): Promise<Redemption>;
+  cleanupExpired(ctx: LoyaltyContext): Promise<number>;
+}
+//#endregion
+//#region src/services/referral.service.d.ts
+declare class ReferralService {
+  private referralPort;
+  private memberPort;
+  private ledger;
+  private events;
+  private notifications;
+  private config;
+  constructor(referralPort: ReferralPort, memberPort: MemberPort, ledger: LedgerService, events: EventEmitterPort, notifications: NotificationAdapter | null, config: ResolvedConfig);
+  generateCode(memberId: string, ctx: LoyaltyContext): Promise<string>;
+  lookupByCode(code: string, ctx: LoyaltyContext): Promise<Member | null>;
+  recordReferral(input: {
+    referralCode: string;
+    refereeExternalId: string;
+    refereeExternalType: string;
+  }, ctx: LoyaltyContext): Promise<Referral>;
+  approve(referralId: string, ctx: LoyaltyContext): Promise<Referral>;
+  reject(referralId: string, reason: string, ctx: LoyaltyContext): Promise<Referral>;
+  getReferralsByReferrer(memberId: string, query: ListQuery, ctx: LoyaltyContext): Promise<PaginatedResult<Referral>>;
+  cleanupExpired(ctx: LoyaltyContext): Promise<number>;
+  private rewardBothSides;
+  private requireReferral;
+}
+//#endregion
+//#region src/services/tier.service.d.ts
+declare class TierService {
+  private tierPort;
+  private memberPort;
+  private events;
+  private notifications;
+  private config;
+  constructor(tierPort: TierDefinitionPort, memberPort: MemberPort, events: EventEmitterPort, notifications: NotificationAdapter | null, config: ResolvedConfig);
+  evaluateMember(memberId: string, ctx: LoyaltyContext): Promise<TierEvaluation>;
+  evaluateAll(ctx: LoyaltyContext): Promise<TierEvaluationBatch>;
+  setOverride(memberId: string, tierName: string, reason: string, ctx: LoyaltyContext): Promise<Member>;
+  clearOverride(memberId: string, ctx: LoyaltyContext): Promise<TierEvaluation>;
+  createTier(input: CreateTierInput, ctx: LoyaltyContext): Promise<TierDefinition>;
+  updateTier(tierId: string, input: UpdateTierInput, ctx: LoyaltyContext): Promise<TierDefinition>;
+  deleteTier(tierId: string, ctx: LoyaltyContext): Promise<void>;
+  listTiers(ctx: LoyaltyContext): Promise<TierDefinition[]>;
+  private applyUpgrade;
+  private applyDowngrade;
+}
+//#endregion
+//#region src/services/index.d.ts
+interface LoyaltyServices {
+  member: MemberService;
+  ledger: LedgerService;
+  earning: EarningService;
+  tier: TierService;
+  redemption: RedemptionService;
+  referral: ReferralService;
+}
+interface CreateServicesInput {
+  repositories: LoyaltyRepositories;
+  unitOfWork: UnitOfWork;
+  events: EventEmitterPort;
+  notifications: NotificationAdapter | null;
+  config: ResolvedConfig;
+}
+declare function createServices(input: CreateServicesInput): LoyaltyServices;
+//#endregion
+export { ReferralService as a, EarningService as c, TierService as i, LedgerService as l, LoyaltyServices as n, RedemptionService as o, createServices as r, MemberService as s, CreateServicesInput as t };

package/dist/index.d.mts

@@ -0,0 +1,21 @@
+import { a as PointTransaction, n as TierDefinition, o as Member, s as MemberBalance, u as EarningRule } from "./tier-definition-Djf72UPa.mjs";
+import { l as Referral, u as Redemption } from "./tier-definition.port-BzrHYBRo.mjs";
+import { t as EventEmitterPort } from "./event-emitter.port-CLYPoMni.mjs";
+import { n as LoyaltyEvents } from "./index-O7TL4R2P.mjs";
+import { n as LoyaltyConfig, o as ResolvedConfig, s as ResolvedTenant } from "./config-aNigy4ec.mjs";
+import { t as LoyaltyModels } from "./index-B6ZstxSP.mjs";
+import { t as LoyaltyRepositories } from "./index-BcoGeDco.mjs";
+import { a as EnrollInput, c as UpdateTierInput, d as EarningResult, g as TierEvaluation, h as RedemptionValidation, i as EarnPointsInput, l as BalanceSummary, n as CreateEarningRuleInput, o as LoyaltyContext, r as CreateTierInput, s as UpdateEarningRuleInput, t as AdjustPointsInput } from "./index-DqzTjeEB.mjs";
+import { n as LoyaltyServices } from "./index-_pg4J11t.mjs";
+
+//#region src/index.d.ts
+declare function resolveConfig(config: LoyaltyConfig): ResolvedConfig;
+interface LoyaltyEngine {
+  models: LoyaltyModels;
+  repositories: LoyaltyRepositories;
+  services: LoyaltyServices;
+  events: EventEmitterPort;
+}
+declare function createLoyaltyEngine(config: LoyaltyConfig): LoyaltyEngine;
+//#endregion
+export { type AdjustPointsInput, type BalanceSummary, type CreateEarningRuleInput, type CreateTierInput, type EarnPointsInput, type EarningResult, type EarningRule, type EnrollInput, type EventEmitterPort, type LoyaltyConfig, type LoyaltyContext, LoyaltyEngine, LoyaltyEvents, type LoyaltyModels, type LoyaltyRepositories, type LoyaltyServices, type Member, type MemberBalance, type PointTransaction, type Redemption, type RedemptionValidation, type Referral, type ResolvedConfig, type ResolvedTenant, type TierDefinition, type TierEvaluation, type UpdateEarningRuleInput, type UpdateTierInput, createLoyaltyEngine, resolveConfig };