@classytic/revenue 0.2.4 → 1.0.1

package/dist/index.js

@@ -0,0 +1,4362 @@
+import { nanoid } from 'nanoid';
+import * as z from 'zod';
+export { z };
+import { Schema } from 'mongoose';
+
+// @classytic/revenue - Enterprise Revenue Management System
+
+
+// src/core/container.ts
+var Container = class _Container {
+  _services;
+  _singletons;
+  constructor() {
+    this._services = /* @__PURE__ */ new Map();
+    this._singletons = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a service
+   * @param name - Service name
+   * @param implementation - Service implementation or factory
+   * @param options - Registration options
+   */
+  register(name, implementation, options = {}) {
+    this._services.set(name, {
+      implementation,
+      singleton: options.singleton !== false,
+      // Default to singleton
+      factory: options.factory ?? false
+    });
+    return this;
+  }
+  /**
+   * Register a singleton service
+   * @param name - Service name
+   * @param implementation - Service implementation
+   */
+  singleton(name, implementation) {
+    return this.register(name, implementation, { singleton: true });
+  }
+  /**
+   * Register a transient service (new instance each time)
+   * @param name - Service name
+   * @param factory - Factory function
+   */
+  transient(name, factory) {
+    return this.register(name, factory, { singleton: false, factory: true });
+  }
+  /**
+   * Get a service from the container
+   * @param name - Service name
+   * @returns Service instance
+   */
+  get(name) {
+    if (this._singletons.has(name)) {
+      return this._singletons.get(name);
+    }
+    const service = this._services.get(name);
+    if (!service) {
+      throw new Error(`Service "${name}" not registered in container`);
+    }
+    if (service.factory) {
+      const factory = service.implementation;
+      const instance2 = factory(this);
+      if (service.singleton) {
+        this._singletons.set(name, instance2);
+      }
+      return instance2;
+    }
+    const instance = service.implementation;
+    if (service.singleton) {
+      this._singletons.set(name, instance);
+    }
+    return instance;
+  }
+  /**
+   * Check if service is registered
+   * @param name - Service name
+   */
+  has(name) {
+    return this._services.has(name);
+  }
+  /**
+   * Get all registered service names
+   */
+  keys() {
+    return Array.from(this._services.keys());
+  }
+  /**
+   * Clear all services (useful for testing)
+   */
+  clear() {
+    this._services.clear();
+    this._singletons.clear();
+  }
+  /**
+   * Create a child container (for scoped dependencies)
+   */
+  createScope() {
+    const scope = new _Container();
+    this._services.forEach((value, key) => {
+      scope._services.set(key, value);
+    });
+    return scope;
+  }
+};
+
+// src/core/events.ts
+var EventBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  onceHandlers = /* @__PURE__ */ new Map();
+  /**
+   * Subscribe to an event
+   */
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(event).add(handler);
+    return () => this.off(event, handler);
+  }
+  /**
+   * Subscribe to an event once
+   */
+  once(event, handler) {
+    if (!this.onceHandlers.has(event)) {
+      this.onceHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.onceHandlers.get(event).add(handler);
+    return () => this.onceHandlers.get(event)?.delete(handler);
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  off(event, handler) {
+    this.handlers.get(event)?.delete(handler);
+    this.onceHandlers.get(event)?.delete(handler);
+  }
+  /**
+   * Emit an event (fire and forget, non-blocking)
+   */
+  emit(event, payload) {
+    const fullPayload = {
+      ...payload,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    const handlers = this.handlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        Promise.resolve(handler(fullPayload)).catch((err2) => {
+          console.error(`[Revenue] Event handler error for "${event}":`, err2);
+        });
+      }
+    }
+    const onceHandlers = this.onceHandlers.get(event);
+    if (onceHandlers) {
+      for (const handler of onceHandlers) {
+        Promise.resolve(handler(fullPayload)).catch((err2) => {
+          console.error(`[Revenue] Once handler error for "${event}":`, err2);
+        });
+      }
+      this.onceHandlers.delete(event);
+    }
+    if (event !== "*") {
+      const wildcardHandlers = this.handlers.get("*");
+      if (wildcardHandlers) {
+        for (const handler of wildcardHandlers) {
+          Promise.resolve(handler(fullPayload)).catch((err2) => {
+            console.error(`[Revenue] Wildcard handler error:`, err2);
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Emit and wait for all handlers to complete
+   */
+  async emitAsync(event, payload) {
+    const fullPayload = {
+      ...payload,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    const promises = [];
+    const handlers = this.handlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        promises.push(Promise.resolve(handler(fullPayload)));
+      }
+    }
+    const onceHandlers = this.onceHandlers.get(event);
+    if (onceHandlers) {
+      for (const handler of onceHandlers) {
+        promises.push(Promise.resolve(handler(fullPayload)));
+      }
+      this.onceHandlers.delete(event);
+    }
+    if (event !== "*") {
+      const wildcardHandlers = this.handlers.get("*");
+      if (wildcardHandlers) {
+        for (const handler of wildcardHandlers) {
+          promises.push(Promise.resolve(handler(fullPayload)));
+        }
+      }
+    }
+    await Promise.all(promises);
+  }
+  /**
+   * Remove all handlers
+   */
+  clear() {
+    this.handlers.clear();
+    this.onceHandlers.clear();
+  }
+  /**
+   * Get handler count for an event
+   */
+  listenerCount(event) {
+    return (this.handlers.get(event)?.size ?? 0) + (this.onceHandlers.get(event)?.size ?? 0);
+  }
+};
+function createEventBus() {
+  return new EventBus();
+}
+
+// src/core/plugin.ts
+var PluginManager = class {
+  plugins = /* @__PURE__ */ new Map();
+  hooks = /* @__PURE__ */ new Map();
+  initialized = false;
+  /**
+   * Register a plugin
+   */
+  register(plugin) {
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Plugin "${plugin.name}" is already registered`);
+    }
+    if (plugin.dependencies) {
+      for (const dep of plugin.dependencies) {
+        if (!this.plugins.has(dep)) {
+          throw new Error(
+            `Plugin "${plugin.name}" requires "${dep}" to be registered first`
+          );
+        }
+      }
+    }
+    this.plugins.set(plugin.name, plugin);
+    if (plugin.hooks) {
+      for (const [hookName, hookFn] of Object.entries(plugin.hooks)) {
+        if (!this.hooks.has(hookName)) {
+          this.hooks.set(hookName, []);
+        }
+        this.hooks.get(hookName).push(hookFn);
+      }
+    }
+    return this;
+  }
+  /**
+   * Initialize all plugins
+   */
+  async init(ctx) {
+    if (this.initialized) return;
+    for (const plugin of this.plugins.values()) {
+      if (plugin.init) {
+        await plugin.init(ctx);
+      }
+      if (plugin.events) {
+        for (const [event, handler] of Object.entries(plugin.events)) {
+          ctx.events.on(event, handler);
+        }
+      }
+    }
+    this.initialized = true;
+  }
+  /**
+   * Execute a hook chain
+   */
+  async executeHook(hookName, ctx, input, execute) {
+    const hooks = this.hooks.get(hookName) ?? [];
+    if (hooks.length === 0) {
+      return execute();
+    }
+    let index = 0;
+    const next = async () => {
+      if (index >= hooks.length) {
+        return execute();
+      }
+      const hook = hooks[index++];
+      return hook(ctx, input, next);
+    };
+    return next();
+  }
+  /**
+   * Check if plugin is registered
+   */
+  has(name) {
+    return this.plugins.has(name);
+  }
+  /**
+   * Get a plugin by name
+   */
+  get(name) {
+    return this.plugins.get(name);
+  }
+  /**
+   * Get all registered plugins
+   */
+  list() {
+    return Array.from(this.plugins.values());
+  }
+  /**
+   * Destroy all plugins
+   */
+  async destroy() {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.destroy) {
+        await plugin.destroy();
+      }
+    }
+    this.plugins.clear();
+    this.hooks.clear();
+    this.initialized = false;
+  }
+};
+function loggingPlugin(options = {}) {
+  const level = options.level ?? "info";
+  return {
+    name: "logging",
+    version: "1.0.0",
+    description: "Logs all revenue operations",
+    hooks: {
+      "payment.create.before": async (ctx, input, next) => {
+        ctx.logger[level]("Creating payment", { amount: input.amount, currency: input.currency });
+        const result = await next();
+        ctx.logger[level]("Payment created", { transactionId: result?.transactionId });
+        return result;
+      },
+      "payment.verify.before": async (ctx, input, next) => {
+        ctx.logger[level]("Verifying payment", { id: input.id });
+        const result = await next();
+        ctx.logger[level]("Payment verified", { verified: result?.verified });
+        return result;
+      },
+      "payment.refund.before": async (ctx, input, next) => {
+        ctx.logger[level]("Processing refund", { transactionId: input.transactionId, amount: input.amount });
+        const result = await next();
+        ctx.logger[level]("Refund processed", { refundId: result?.refundId });
+        return result;
+      }
+    }
+  };
+}
+function auditPlugin(options = {}) {
+  const store = options.store ?? (async (entry) => {
+  });
+  return {
+    name: "audit",
+    version: "1.0.0",
+    description: "Audit trail for all operations",
+    hooks: {
+      "payment.create.after": async (ctx, input, next) => {
+        const result = await next();
+        await store({
+          action: "payment.create",
+          requestId: ctx.meta.requestId,
+          timestamp: ctx.meta.timestamp,
+          input: sanitizeInput(input),
+          output: sanitizeOutput(result),
+          idempotencyKey: ctx.meta.idempotencyKey
+        });
+        return result;
+      },
+      "payment.refund.after": async (ctx, input, next) => {
+        const result = await next();
+        await store({
+          action: "payment.refund",
+          requestId: ctx.meta.requestId,
+          timestamp: ctx.meta.timestamp,
+          input: sanitizeInput(input),
+          output: sanitizeOutput(result),
+          idempotencyKey: ctx.meta.idempotencyKey
+        });
+        return result;
+      }
+    }
+  };
+}
+function sanitizeInput(input) {
+  if (typeof input !== "object" || !input) return {};
+  const sanitized = { ...input };
+  delete sanitized.apiKey;
+  delete sanitized.secretKey;
+  delete sanitized.password;
+  return sanitized;
+}
+function sanitizeOutput(output) {
+  if (typeof output !== "object" || !output) return {};
+  return { ...output };
+}
+function metricsPlugin(options = {}) {
+  const record2 = options.onMetric ?? ((metric) => {
+  });
+  return {
+    name: "metrics",
+    version: "1.0.0",
+    description: "Collects operation metrics",
+    hooks: {
+      "payment.create.before": async (_ctx, input, next) => {
+        const start = Date.now();
+        try {
+          const result = await next();
+          record2({
+            name: "payment.create",
+            duration: Date.now() - start,
+            success: true,
+            amount: input.amount,
+            currency: input.currency
+          });
+          return result;
+        } catch (error) {
+          record2({
+            name: "payment.create",
+            duration: Date.now() - start,
+            success: false,
+            error: error.message
+          });
+          throw error;
+        }
+      }
+    }
+  };
+}
+function definePlugin(plugin) {
+  return plugin;
+}
+
+// src/core/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok === true;
+}
+function isErr(result) {
+  return result.ok === false;
+}
+function unwrap(result) {
+  if (result.ok) return result.value;
+  throw result.error;
+}
+function unwrapOr(result, defaultValue) {
+  return result.ok ? result.value : defaultValue;
+}
+function map(result, fn) {
+  return result.ok ? ok(fn(result.value)) : result;
+}
+function mapErr(result, fn) {
+  return result.ok ? result : err(fn(result.error));
+}
+function flatMap(result, fn) {
+  return result.ok ? fn(result.value) : result;
+}
+async function tryCatch(fn, mapError) {
+  try {
+    const value = await fn();
+    return ok(value);
+  } catch (e) {
+    const error = mapError ? mapError(e) : e;
+    return err(error);
+  }
+}
+function tryCatchSync(fn, mapError) {
+  try {
+    const value = fn();
+    return ok(value);
+  } catch (e) {
+    const error = mapError ? mapError(e) : e;
+    return err(error);
+  }
+}
+function all(results) {
+  const values = [];
+  for (const result of results) {
+    if (!result.ok) return result;
+    values.push(result.value);
+  }
+  return ok(values);
+}
+function match(result, handlers) {
+  return result.ok ? handlers.ok(result.value) : handlers.err(result.error);
+}
+var Result = {
+  ok,
+  err,
+  isOk,
+  isErr,
+  unwrap,
+  unwrapOr,
+  map,
+  mapErr,
+  flatMap,
+  tryCatch,
+  tryCatchSync,
+  all,
+  match
+};
+var MemoryIdempotencyStore = class {
+  records = /* @__PURE__ */ new Map();
+  cleanupInterval = null;
+  constructor(cleanupIntervalMs = 6e4) {
+    this.cleanupInterval = setInterval(() => {
+      this.cleanup();
+    }, cleanupIntervalMs);
+  }
+  async get(key) {
+    const record2 = this.records.get(key);
+    if (!record2) return null;
+    if (record2.expiresAt < /* @__PURE__ */ new Date()) {
+      this.records.delete(key);
+      return null;
+    }
+    return record2;
+  }
+  async set(key, record2) {
+    this.records.set(key, record2);
+  }
+  async delete(key) {
+    this.records.delete(key);
+  }
+  async exists(key) {
+    const record2 = await this.get(key);
+    return record2 !== null;
+  }
+  cleanup() {
+    const now = /* @__PURE__ */ new Date();
+    for (const [key, record2] of this.records) {
+      if (record2.expiresAt < now) {
+        this.records.delete(key);
+      }
+    }
+  }
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.records.clear();
+  }
+};
+var IdempotencyError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "IdempotencyError";
+  }
+};
+var IdempotencyManager = class {
+  store;
+  ttl;
+  prefix;
+  constructor(config = {}) {
+    this.store = config.store ?? new MemoryIdempotencyStore();
+    this.ttl = config.ttl ?? 24 * 60 * 60 * 1e3;
+    this.prefix = config.prefix ?? "idem:";
+  }
+  /**
+   * Generate a unique idempotency key
+   */
+  generateKey() {
+    return `${this.prefix}${nanoid(21)}`;
+  }
+  /**
+   * Hash request parameters for validation
+   */
+  hashRequest(params) {
+    const json = JSON.stringify(params, Object.keys(params).sort());
+    let hash = 0;
+    for (let i = 0; i < json.length; i++) {
+      const char = json.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return hash.toString(36);
+  }
+  /**
+   * Execute operation with idempotency protection
+   */
+  async execute(key, params, operation) {
+    const fullKey = key.startsWith(this.prefix) ? key : `${this.prefix}${key}`;
+    const requestHash = this.hashRequest(params);
+    const existing = await this.store.get(fullKey);
+    if (existing) {
+      if (existing.requestHash !== requestHash) {
+        return err(new IdempotencyError(
+          "Idempotency key used with different request parameters",
+          "REQUEST_MISMATCH"
+        ));
+      }
+      if (existing.status === "completed" && existing.result !== void 0) {
+        return ok(existing.result);
+      }
+      if (existing.status === "pending") {
+        return err(new IdempotencyError(
+          "Request with this idempotency key is already in progress",
+          "REQUEST_IN_PROGRESS"
+        ));
+      }
+      if (existing.status === "failed") {
+        await this.store.delete(fullKey);
+      }
+    }
+    const record2 = {
+      key: fullKey,
+      status: "pending",
+      createdAt: /* @__PURE__ */ new Date(),
+      requestHash,
+      expiresAt: new Date(Date.now() + this.ttl)
+    };
+    await this.store.set(fullKey, record2);
+    try {
+      const result = await operation();
+      record2.status = "completed";
+      record2.result = result;
+      record2.completedAt = /* @__PURE__ */ new Date();
+      await this.store.set(fullKey, record2);
+      return ok(result);
+    } catch (error) {
+      record2.status = "failed";
+      await this.store.set(fullKey, record2);
+      throw error;
+    }
+  }
+  /**
+   * Check if operation with key was already completed
+   */
+  async wasCompleted(key) {
+    const fullKey = key.startsWith(this.prefix) ? key : `${this.prefix}${key}`;
+    const record2 = await this.store.get(fullKey);
+    return record2?.status === "completed";
+  }
+  /**
+   * Get cached result for key
+   */
+  async getCached(key) {
+    const fullKey = key.startsWith(this.prefix) ? key : `${this.prefix}${key}`;
+    const record2 = await this.store.get(fullKey);
+    return record2?.status === "completed" ? record2.result ?? null : null;
+  }
+  /**
+   * Invalidate a key (force re-execution on next call)
+   */
+  async invalidate(key) {
+    const fullKey = key.startsWith(this.prefix) ? key : `${this.prefix}${key}`;
+    await this.store.delete(fullKey);
+  }
+};
+function createIdempotencyManager(config) {
+  return new IdempotencyManager(config);
+}
+
+// src/utils/retry.ts
+var DEFAULT_CONFIG = {
+  maxAttempts: 3,
+  baseDelay: 1e3,
+  maxDelay: 3e4,
+  backoffMultiplier: 2,
+  jitter: 0.1,
+  retryIf: isRetryableError
+};
+function calculateDelay(attempt, config) {
+  const exponentialDelay = config.baseDelay * Math.pow(config.backoffMultiplier, attempt);
+  const cappedDelay = Math.min(exponentialDelay, config.maxDelay);
+  const jitterRange = cappedDelay * config.jitter;
+  const jitter = Math.random() * jitterRange * 2 - jitterRange;
+  return Math.round(Math.max(0, cappedDelay + jitter));
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryableError(error) {
+  if (!(error instanceof Error)) return false;
+  if (error.message.includes("ECONNREFUSED")) return true;
+  if (error.message.includes("ETIMEDOUT")) return true;
+  if (error.message.includes("ENOTFOUND")) return true;
+  if (error.message.includes("network")) return true;
+  if (error.message.includes("timeout")) return true;
+  if (error.message.includes("429")) return true;
+  if (error.message.includes("rate limit")) return true;
+  if (error.message.includes("500")) return true;
+  if (error.message.includes("502")) return true;
+  if (error.message.includes("503")) return true;
+  if (error.message.includes("504")) return true;
+  if ("retryable" in error && error.retryable === true) return true;
+  return false;
+}
+async function retry(operation, config = {}) {
+  const fullConfig = { ...DEFAULT_CONFIG, ...config };
+  const state = {
+    attempt: 0,
+    totalDelay: 0,
+    errors: []
+  };
+  while (state.attempt < fullConfig.maxAttempts) {
+    try {
+      return await operation();
+    } catch (error) {
+      state.errors.push(error instanceof Error ? error : new Error(String(error)));
+      state.attempt++;
+      const shouldRetry = fullConfig.retryIf?.(error) ?? isRetryableError(error);
+      if (!shouldRetry || state.attempt >= fullConfig.maxAttempts) {
+        throw new RetryExhaustedError(
+          `Operation failed after ${state.attempt} attempts`,
+          state.errors
+        );
+      }
+      const delay = calculateDelay(state.attempt - 1, fullConfig);
+      state.totalDelay += delay;
+      fullConfig.onRetry?.(error, state.attempt, delay);
+      await sleep(delay);
+    }
+  }
+  throw new RetryExhaustedError(
+    `Operation failed after ${state.attempt} attempts`,
+    state.errors
+  );
+}
+async function retryWithResult(operation, config = {}) {
+  try {
+    const result = await retry(operation, config);
+    return ok(result);
+  } catch (error) {
+    if (error instanceof RetryExhaustedError) {
+      return err(error);
+    }
+    return err(new RetryExhaustedError("Operation failed", [
+      error instanceof Error ? error : new Error(String(error))
+    ]));
+  }
+}
+var RetryExhaustedError = class extends Error {
+  attempts;
+  errors;
+  constructor(message, errors) {
+    super(message);
+    this.name = "RetryExhaustedError";
+    this.attempts = errors.length;
+    this.errors = errors;
+  }
+  /**
+   * Get the last error
+   */
+  get lastError() {
+    return this.errors[this.errors.length - 1];
+  }
+  /**
+   * Get the first error
+   */
+  get firstError() {
+    return this.errors[0];
+  }
+};
+var DEFAULT_CIRCUIT_CONFIG = {
+  failureThreshold: 5,
+  resetTimeout: 3e4,
+  successThreshold: 3,
+  monitorWindow: 6e4
+};
+var CircuitBreaker = class {
+  state = "closed";
+  failures = [];
+  successes = 0;
+  lastFailure;
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CIRCUIT_CONFIG, ...config };
+  }
+  /**
+   * Execute operation through circuit breaker
+   */
+  async execute(operation) {
+    if (this.state === "open") {
+      if (this.shouldAttemptReset()) {
+        this.state = "half-open";
+      } else {
+        throw new CircuitOpenError("Circuit is open, request rejected");
+      }
+    }
+    try {
+      const result = await operation();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      throw error;
+    }
+  }
+  /**
+   * Execute with Result type
+   */
+  async executeWithResult(operation) {
+    try {
+      const result = await this.execute(operation);
+      return ok(result);
+    } catch (error) {
+      return err(error);
+    }
+  }
+  onSuccess() {
+    if (this.state === "half-open") {
+      this.successes++;
+      if (this.successes >= this.config.successThreshold) {
+        this.reset();
+      }
+    }
+    this.cleanOldFailures();
+  }
+  onFailure() {
+    this.failures.push(/* @__PURE__ */ new Date());
+    this.lastFailure = /* @__PURE__ */ new Date();
+    this.successes = 0;
+    this.cleanOldFailures();
+    if (this.failures.length >= this.config.failureThreshold) {
+      this.state = "open";
+    }
+  }
+  shouldAttemptReset() {
+    if (!this.lastFailure) return true;
+    return Date.now() - this.lastFailure.getTime() >= this.config.resetTimeout;
+  }
+  cleanOldFailures() {
+    const cutoff = Date.now() - this.config.monitorWindow;
+    this.failures = this.failures.filter((f) => f.getTime() > cutoff);
+  }
+  reset() {
+    this.state = "closed";
+    this.failures = [];
+    this.successes = 0;
+  }
+  /**
+   * Get current circuit state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Manually reset circuit
+   */
+  forceReset() {
+    this.reset();
+  }
+  /**
+   * Get circuit statistics
+   */
+  getStats() {
+    return {
+      state: this.state,
+      failures: this.failures.length,
+      successes: this.successes,
+      lastFailure: this.lastFailure
+    };
+  }
+};
+var CircuitOpenError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CircuitOpenError";
+  }
+};
+function createCircuitBreaker(config) {
+  return new CircuitBreaker(config);
+}
+async function resilientExecute(operation, options = {}) {
+  const { retry: retryConfig, circuitBreaker } = options;
+  const wrappedOperation = async () => {
+    if (circuitBreaker) {
+      return circuitBreaker.execute(operation);
+    }
+    return operation();
+  };
+  if (retryConfig) {
+    return retry(wrappedOperation, retryConfig);
+  }
+  return wrappedOperation();
+}
+
+// src/core/errors.ts
+var RevenueError = class extends Error {
+  code;
+  retryable;
+  metadata;
+  constructor(message, code, options = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.retryable = options.retryable ?? false;
+    this.metadata = options.metadata ?? {};
+    Error.captureStackTrace(this, this.constructor);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      retryable: this.retryable,
+      metadata: this.metadata
+    };
+  }
+};
+var ConfigurationError = class extends RevenueError {
+  constructor(message, metadata = {}) {
+    super(message, "CONFIGURATION_ERROR", { retryable: false, metadata });
+  }
+};
+var ModelNotRegisteredError = class extends ConfigurationError {
+  constructor(modelName) {
+    super(
+      `Model "${modelName}" is not registered. Register it via createRevenue({ models: { ${modelName}: ... } })`,
+      { modelName }
+    );
+  }
+};
+var ProviderError = class extends RevenueError {
+  constructor(message, code, options = {}) {
+    super(message, code, options);
+  }
+};
+var ProviderNotFoundError = class extends ProviderError {
+  constructor(providerName, availableProviders = []) {
+    super(
+      `Payment provider "${providerName}" not found. Available: ${availableProviders.join(", ")}`,
+      "PROVIDER_NOT_FOUND",
+      { retryable: false, metadata: { providerName, availableProviders } }
+    );
+  }
+};
+var ProviderCapabilityError = class extends ProviderError {
+  constructor(providerName, capability) {
+    super(
+      `Provider "${providerName}" does not support ${capability}`,
+      "PROVIDER_CAPABILITY_NOT_SUPPORTED",
+      { retryable: false, metadata: { providerName, capability } }
+    );
+  }
+};
+var PaymentIntentCreationError = class extends ProviderError {
+  constructor(providerName, originalError) {
+    super(
+      `Failed to create payment intent with provider "${providerName}": ${originalError.message}`,
+      "PAYMENT_INTENT_CREATION_FAILED",
+      { retryable: true, metadata: { providerName, originalError: originalError.message } }
+    );
+  }
+};
+var PaymentVerificationError = class extends ProviderError {
+  constructor(paymentIntentId, reason) {
+    super(
+      `Payment verification failed for intent "${paymentIntentId}": ${reason}`,
+      "PAYMENT_VERIFICATION_FAILED",
+      { retryable: true, metadata: { paymentIntentId, reason } }
+    );
+  }
+};
+var NotFoundError = class extends RevenueError {
+  constructor(message, code, metadata = {}) {
+    super(message, code, { retryable: false, metadata });
+  }
+};
+var SubscriptionNotFoundError = class extends NotFoundError {
+  constructor(subscriptionId) {
+    super(
+      `Subscription not found: ${subscriptionId}`,
+      "SUBSCRIPTION_NOT_FOUND",
+      { subscriptionId }
+    );
+  }
+};
+var TransactionNotFoundError = class extends NotFoundError {
+  constructor(transactionId) {
+    super(
+      `Transaction not found: ${transactionId}`,
+      "TRANSACTION_NOT_FOUND",
+      { transactionId }
+    );
+  }
+};
+var ValidationError = class extends RevenueError {
+  constructor(message, metadata = {}) {
+    super(message, "VALIDATION_ERROR", { retryable: false, metadata });
+  }
+};
+var InvalidAmountError = class extends ValidationError {
+  constructor(amount, message) {
+    super(
+      message ?? `Invalid amount: ${amount}. Amount must be non-negative`,
+      { amount }
+    );
+  }
+};
+var MissingRequiredFieldError = class extends ValidationError {
+  constructor(fieldName) {
+    super(`Missing required field: ${fieldName}`, { fieldName });
+  }
+};
+var StateError = class extends RevenueError {
+  constructor(message, code, metadata = {}) {
+    super(message, code, { retryable: false, metadata });
+  }
+};
+var AlreadyVerifiedError = class extends StateError {
+  constructor(transactionId) {
+    super(
+      `Transaction ${transactionId} is already verified`,
+      "ALREADY_VERIFIED",
+      { transactionId }
+    );
+  }
+};
+var InvalidStateTransitionError = class extends StateError {
+  constructor(resourceType, resourceId, fromState, toState) {
+    super(
+      `Invalid state transition for ${resourceType} ${resourceId}: ${fromState} \u2192 ${toState}`,
+      "INVALID_STATE_TRANSITION",
+      { resourceType, resourceId, fromState, toState }
+    );
+  }
+};
+var SubscriptionNotActiveError = class extends StateError {
+  constructor(subscriptionId, message) {
+    super(
+      message ?? `Subscription ${subscriptionId} is not active`,
+      "SUBSCRIPTION_NOT_ACTIVE",
+      { subscriptionId }
+    );
+  }
+};
+var OperationError = class extends RevenueError {
+  constructor(message, code, options = {}) {
+    super(message, code, options);
+  }
+};
+var RefundNotSupportedError = class extends OperationError {
+  constructor(providerName) {
+    super(
+      `Refunds are not supported by provider "${providerName}"`,
+      "REFUND_NOT_SUPPORTED",
+      { retryable: false, metadata: { providerName } }
+    );
+  }
+};
+var RefundError = class extends OperationError {
+  constructor(transactionId, reason) {
+    super(
+      `Refund failed for transaction ${transactionId}: ${reason}`,
+      "REFUND_FAILED",
+      { retryable: true, metadata: { transactionId, reason } }
+    );
+  }
+};
+var ERROR_CODES = {
+  // Configuration
+  CONFIGURATION_ERROR: "CONFIGURATION_ERROR",
+  MODEL_NOT_REGISTERED: "MODEL_NOT_REGISTERED",
+  // Provider
+  PROVIDER_NOT_FOUND: "PROVIDER_NOT_FOUND",
+  PROVIDER_CAPABILITY_NOT_SUPPORTED: "PROVIDER_CAPABILITY_NOT_SUPPORTED",
+  PAYMENT_INTENT_CREATION_FAILED: "PAYMENT_INTENT_CREATION_FAILED",
+  PAYMENT_VERIFICATION_FAILED: "PAYMENT_VERIFICATION_FAILED",
+  // Not Found
+  SUBSCRIPTION_NOT_FOUND: "SUBSCRIPTION_NOT_FOUND",
+  TRANSACTION_NOT_FOUND: "TRANSACTION_NOT_FOUND",
+  // Validation
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  INVALID_AMOUNT: "INVALID_AMOUNT",
+  MISSING_REQUIRED_FIELD: "MISSING_REQUIRED_FIELD",
+  // State
+  ALREADY_VERIFIED: "ALREADY_VERIFIED",
+  INVALID_STATE_TRANSITION: "INVALID_STATE_TRANSITION",
+  SUBSCRIPTION_NOT_ACTIVE: "SUBSCRIPTION_NOT_ACTIVE",
+  // Operations
+  REFUND_NOT_SUPPORTED: "REFUND_NOT_SUPPORTED",
+  REFUND_FAILED: "REFUND_FAILED"
+};
+function isRetryable(error) {
+  return error instanceof RevenueError && error.retryable;
+}
+function isRevenueError(error) {
+  return error instanceof RevenueError;
+}
+
+// src/utils/hooks.ts
+function triggerHook(hooks, event, data, logger2) {
+  const handlers = hooks[event] ?? [];
+  if (handlers.length === 0) {
+    return;
+  }
+  Promise.all(
+    handlers.map(
+      (handler) => Promise.resolve(handler(data)).catch((error) => {
+        logger2.error(`Hook "${event}" failed:`, {
+          error: error.message,
+          stack: error.stack,
+          event,
+          // Don't log full data (could be huge)
+          dataKeys: Object.keys(data)
+        });
+      })
+    )
+  ).catch(() => {
+  });
+}
+
+// src/enums/transaction.enums.ts
+var TRANSACTION_TYPE = {
+  INCOME: "income",
+  EXPENSE: "expense"
+};
+var TRANSACTION_TYPE_VALUES = Object.values(TRANSACTION_TYPE);
+var TRANSACTION_STATUS = {
+  PENDING: "pending",
+  PAYMENT_INITIATED: "payment_initiated",
+  PROCESSING: "processing",
+  REQUIRES_ACTION: "requires_action",
+  VERIFIED: "verified",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+  EXPIRED: "expired",
+  REFUNDED: "refunded",
+  PARTIALLY_REFUNDED: "partially_refunded"
+};
+var TRANSACTION_STATUS_VALUES = Object.values(TRANSACTION_STATUS);
+var LIBRARY_CATEGORIES = {
+  SUBSCRIPTION: "subscription",
+  PURCHASE: "purchase"
+};
+var LIBRARY_CATEGORY_VALUES = Object.values(LIBRARY_CATEGORIES);
+
+// src/utils/category-resolver.ts
+function resolveCategory(entity, monetizationType, categoryMappings = {}) {
+  if (entity && categoryMappings[entity]) {
+    return categoryMappings[entity];
+  }
+  switch (monetizationType) {
+    case "subscription":
+      return LIBRARY_CATEGORIES.SUBSCRIPTION;
+    // 'subscription'
+    case "purchase":
+      return LIBRARY_CATEGORIES.PURCHASE;
+    // 'purchase'
+    default:
+      return LIBRARY_CATEGORIES.SUBSCRIPTION;
+  }
+}
+function isCategoryValid(category, allowedCategories = []) {
+  return allowedCategories.includes(category);
+}
+
+// src/utils/commission.ts
+function calculateCommission(amount, commissionRate, gatewayFeeRate = 0) {
+  if (!commissionRate || commissionRate <= 0) {
+    return null;
+  }
+  if (amount < 0) {
+    throw new Error("Transaction amount cannot be negative");
+  }
+  if (commissionRate < 0 || commissionRate > 1) {
+    throw new Error("Commission rate must be between 0 and 1");
+  }
+  if (gatewayFeeRate < 0 || gatewayFeeRate > 1) {
+    throw new Error("Gateway fee rate must be between 0 and 1");
+  }
+  const grossAmount = Math.round(amount * commissionRate * 100) / 100;
+  const gatewayFeeAmount = Math.round(amount * gatewayFeeRate * 100) / 100;
+  const netAmount = Math.max(0, Math.round((grossAmount - gatewayFeeAmount) * 100) / 100);
+  return {
+    rate: commissionRate,
+    grossAmount,
+    gatewayFeeRate,
+    gatewayFeeAmount,
+    netAmount,
+    status: "pending"
+  };
+}
+function reverseCommission(originalCommission, originalAmount, refundAmount) {
+  if (!originalCommission?.netAmount) {
+    return null;
+  }
+  const refundRatio = refundAmount / originalAmount;
+  const reversedNetAmount = Math.round(originalCommission.netAmount * refundRatio * 100) / 100;
+  const reversedGrossAmount = Math.round(originalCommission.grossAmount * refundRatio * 100) / 100;
+  const reversedGatewayFee = Math.round(originalCommission.gatewayFeeAmount * refundRatio * 100) / 100;
+  return {
+    rate: originalCommission.rate,
+    grossAmount: reversedGrossAmount,
+    gatewayFeeRate: originalCommission.gatewayFeeRate,
+    gatewayFeeAmount: reversedGatewayFee,
+    netAmount: reversedNetAmount,
+    status: "waived"
+    // Commission waived due to refund
+  };
+}
+
+// src/enums/monetization.enums.ts
+var MONETIZATION_TYPES = {
+  FREE: "free",
+  PURCHASE: "purchase",
+  SUBSCRIPTION: "subscription"
+};
+var MONETIZATION_TYPE_VALUES = Object.values(MONETIZATION_TYPES);
+
+// src/services/monetization.service.ts
+var MonetizationService = class {
+  models;
+  providers;
+  config;
+  hooks;
+  logger;
+  constructor(container) {
+    this.models = container.get("models");
+    this.providers = container.get("providers");
+    this.config = container.get("config");
+    this.hooks = container.get("hooks");
+    this.logger = container.get("logger");
+  }
+  /**
+   * Create a new monetization (purchase, subscription, or free item)
+   *
+   * @param params - Monetization parameters
+   *
+   * @example
+   * // One-time purchase
+   * await revenue.monetization.create({
+   *   data: {
+   *     organizationId: '...',
+   *     customerId: '...',
+   *     referenceId: order._id,
+   *     referenceModel: 'Order',
+   *   },
+   *   planKey: 'one_time',
+   *   monetizationType: 'purchase',
+   *   gateway: 'bkash',
+   *   amount: 1500,
+   * });
+   *
+   * // Recurring subscription
+   * await revenue.monetization.create({
+   *   data: {
+   *     organizationId: '...',
+   *     customerId: '...',
+   *     referenceId: subscription._id,
+   *     referenceModel: 'Subscription',
+   *   },
+   *   planKey: 'monthly',
+   *   monetizationType: 'subscription',
+   *   gateway: 'stripe',
+   *   amount: 2000,
+   * });
+   *
+   * @returns Result with subscription, transaction, and paymentIntent
+   */
+  async create(params) {
+    const {
+      data,
+      planKey,
+      amount,
+      currency = "BDT",
+      gateway = "manual",
+      entity = null,
+      monetizationType = MONETIZATION_TYPES.SUBSCRIPTION,
+      paymentData,
+      metadata = {},
+      idempotencyKey = null
+    } = params;
+    if (!planKey) {
+      throw new MissingRequiredFieldError("planKey");
+    }
+    if (amount < 0) {
+      throw new InvalidAmountError(amount);
+    }
+    const isFree = amount === 0;
+    const provider = this.providers[gateway];
+    if (!provider) {
+      throw new ProviderNotFoundError(gateway, Object.keys(this.providers));
+    }
+    let paymentIntent = null;
+    let transaction = null;
+    if (!isFree) {
+      try {
+        paymentIntent = await provider.createIntent({
+          amount,
+          currency,
+          metadata: {
+            ...metadata,
+            type: "subscription",
+            planKey
+          }
+        });
+      } catch (error) {
+        throw new PaymentIntentCreationError(gateway, error);
+      }
+      const category = resolveCategory(entity, monetizationType, this.config.categoryMappings);
+      const transactionType = this.config.transactionTypeMapping?.subscription ?? this.config.transactionTypeMapping?.[monetizationType] ?? TRANSACTION_TYPE.INCOME;
+      const commissionRate = this.config.commissionRates?.[category] ?? 0;
+      const gatewayFeeRate = this.config.gatewayFeeRates?.[gateway] ?? 0;
+      const commission = calculateCommission(amount, commissionRate, gatewayFeeRate);
+      const TransactionModel = this.models.Transaction;
+      transaction = await TransactionModel.create({
+        organizationId: data.organizationId,
+        customerId: data.customerId ?? null,
+        amount,
+        currency,
+        category,
+        type: transactionType,
+        method: paymentData?.method ?? "manual",
+        status: paymentIntent.status === "succeeded" ? "verified" : "pending",
+        gateway: {
+          type: gateway,
+          sessionId: paymentIntent.sessionId,
+          paymentIntentId: paymentIntent.paymentIntentId,
+          provider: paymentIntent.provider,
+          metadata: paymentIntent.metadata
+        },
+        paymentDetails: {
+          provider: gateway,
+          ...paymentData
+        },
+        ...commission && { commission },
+        // Only include if commission exists
+        // Polymorphic reference (top-level, not metadata)
+        ...data.referenceId && { referenceId: data.referenceId },
+        ...data.referenceModel && { referenceModel: data.referenceModel },
+        metadata: {
+          ...metadata,
+          planKey,
+          entity,
+          monetizationType,
+          paymentIntentId: paymentIntent.id
+        },
+        idempotencyKey: idempotencyKey ?? `sub_${nanoid(16)}`
+      });
+    }
+    let subscription = null;
+    if (this.models.Subscription) {
+      const SubscriptionModel = this.models.Subscription;
+      const subscriptionData = {
+        organizationId: data.organizationId,
+        customerId: data.customerId ?? null,
+        planKey,
+        amount,
+        currency,
+        status: isFree ? "active" : "pending",
+        isActive: isFree,
+        gateway,
+        transactionId: transaction?._id ?? null,
+        paymentIntentId: paymentIntent?.id ?? null,
+        metadata: {
+          ...metadata,
+          isFree,
+          entity,
+          monetizationType
+        },
+        ...data
+      };
+      delete subscriptionData.referenceId;
+      delete subscriptionData.referenceModel;
+      subscription = await SubscriptionModel.create(subscriptionData);
+    }
+    const eventData = {
+      subscription,
+      transaction,
+      paymentIntent,
+      isFree,
+      monetizationType
+    };
+    if (monetizationType === MONETIZATION_TYPES.PURCHASE) {
+      this._triggerHook("purchase.created", eventData);
+    } else if (monetizationType === MONETIZATION_TYPES.SUBSCRIPTION) {
+      this._triggerHook("subscription.created", eventData);
+    } else if (monetizationType === MONETIZATION_TYPES.FREE) {
+      this._triggerHook("free.created", eventData);
+    }
+    this._triggerHook("monetization.created", eventData);
+    return {
+      subscription,
+      transaction,
+      paymentIntent
+    };
+  }
+  /**
+   * Activate subscription after payment verification
+   *
+   * @param subscriptionId - Subscription ID or transaction ID
+   * @param options - Activation options
+   * @returns Updated subscription
+   */
+  async activate(subscriptionId, options = {}) {
+    const { timestamp = /* @__PURE__ */ new Date() } = options;
+    if (!this.models.Subscription) {
+      throw new ModelNotRegisteredError("Subscription");
+    }
+    const SubscriptionModel = this.models.Subscription;
+    const subscription = await SubscriptionModel.findById(subscriptionId);
+    if (!subscription) {
+      throw new SubscriptionNotFoundError(subscriptionId);
+    }
+    if (subscription.isActive) {
+      this.logger.warn("Subscription already active", { subscriptionId });
+      return subscription;
+    }
+    const periodEnd = this._calculatePeriodEnd(subscription.planKey, timestamp);
+    subscription.isActive = true;
+    subscription.status = "active";
+    subscription.startDate = timestamp;
+    subscription.endDate = periodEnd;
+    subscription.activatedAt = timestamp;
+    await subscription.save();
+    this._triggerHook("subscription.activated", {
+      subscription,
+      activatedAt: timestamp
+    });
+    return subscription;
+  }
+  /**
+   * Renew subscription
+   *
+   * @param subscriptionId - Subscription ID
+   * @param params - Renewal parameters
+   * @returns { subscription, transaction, paymentIntent }
+   */
+  async renew(subscriptionId, params = {}) {
+    const {
+      gateway = "manual",
+      entity = null,
+      paymentData,
+      metadata = {},
+      idempotencyKey = null
+    } = params;
+    if (!this.models.Subscription) {
+      throw new ModelNotRegisteredError("Subscription");
+    }
+    const SubscriptionModel = this.models.Subscription;
+    const subscription = await SubscriptionModel.findById(subscriptionId);
+    if (!subscription) {
+      throw new SubscriptionNotFoundError(subscriptionId);
+    }
+    if (subscription.amount === 0) {
+      throw new InvalidAmountError(0, "Free subscriptions do not require renewal");
+    }
+    const provider = this.providers[gateway];
+    if (!provider) {
+      throw new ProviderNotFoundError(gateway, Object.keys(this.providers));
+    }
+    let paymentIntent = null;
+    try {
+      paymentIntent = await provider.createIntent({
+        amount: subscription.amount,
+        currency: subscription.currency ?? "BDT",
+        metadata: {
+          ...metadata,
+          type: "subscription_renewal",
+          subscriptionId: subscription._id.toString()
+        }
+      });
+    } catch (error) {
+      this.logger.error("Failed to create payment intent for renewal:", error);
+      throw new PaymentIntentCreationError(gateway, error);
+    }
+    const effectiveEntity = entity ?? subscription.metadata?.entity;
+    const effectiveMonetizationType = subscription.metadata?.monetizationType ?? MONETIZATION_TYPES.SUBSCRIPTION;
+    const category = resolveCategory(effectiveEntity, effectiveMonetizationType, this.config.categoryMappings);
+    const transactionType = this.config.transactionTypeMapping?.subscription_renewal ?? this.config.transactionTypeMapping?.subscription ?? this.config.transactionTypeMapping?.[effectiveMonetizationType] ?? TRANSACTION_TYPE.INCOME;
+    const commissionRate = this.config.commissionRates?.[category] ?? 0;
+    const gatewayFeeRate = this.config.gatewayFeeRates?.[gateway] ?? 0;
+    const commission = calculateCommission(subscription.amount, commissionRate, gatewayFeeRate);
+    const TransactionModel = this.models.Transaction;
+    const transaction = await TransactionModel.create({
+      organizationId: subscription.organizationId,
+      customerId: subscription.customerId,
+      amount: subscription.amount,
+      currency: subscription.currency ?? "BDT",
+      category,
+      type: transactionType,
+      method: paymentData?.method ?? "manual",
+      status: paymentIntent.status === "succeeded" ? "verified" : "pending",
+      gateway: {
+        type: gateway,
+        sessionId: paymentIntent.sessionId,
+        paymentIntentId: paymentIntent.paymentIntentId,
+        provider: paymentIntent.provider,
+        metadata: paymentIntent.metadata
+      },
+      paymentDetails: {
+        provider: gateway,
+        ...paymentData
+      },
+      ...commission && { commission },
+      // Only include if commission exists
+      // Polymorphic reference to subscription
+      referenceId: subscription._id,
+      referenceModel: "Subscription",
+      metadata: {
+        ...metadata,
+        subscriptionId: subscription._id.toString(),
+        // Keep for backward compat
+        entity: effectiveEntity,
+        monetizationType: effectiveMonetizationType,
+        isRenewal: true,
+        paymentIntentId: paymentIntent.id
+      },
+      idempotencyKey: idempotencyKey ?? `renewal_${nanoid(16)}`
+    });
+    subscription.status = "pending_renewal";
+    subscription.renewalTransactionId = transaction._id;
+    subscription.renewalCount = (subscription.renewalCount ?? 0) + 1;
+    await subscription.save();
+    this._triggerHook("subscription.renewed", {
+      subscription,
+      transaction,
+      paymentIntent,
+      renewalCount: subscription.renewalCount
+    });
+    return {
+      subscription,
+      transaction,
+      paymentIntent
+    };
+  }
+  /**
+   * Cancel subscription
+   *
+   * @param subscriptionId - Subscription ID
+   * @param options - Cancellation options
+   * @returns Updated subscription
+   */
+  async cancel(subscriptionId, options = {}) {
+    const { immediate = false, reason = null } = options;
+    if (!this.models.Subscription) {
+      throw new ModelNotRegisteredError("Subscription");
+    }
+    const SubscriptionModel = this.models.Subscription;
+    const subscription = await SubscriptionModel.findById(subscriptionId);
+    if (!subscription) {
+      throw new SubscriptionNotFoundError(subscriptionId);
+    }
+    const now = /* @__PURE__ */ new Date();
+    if (immediate) {
+      subscription.isActive = false;
+      subscription.status = "cancelled";
+      subscription.canceledAt = now;
+      subscription.cancellationReason = reason;
+    } else {
+      subscription.cancelAt = subscription.endDate ?? now;
+      subscription.cancellationReason = reason;
+    }
+    await subscription.save();
+    this._triggerHook("subscription.cancelled", {
+      subscription,
+      immediate,
+      reason,
+      canceledAt: immediate ? now : subscription.cancelAt
+    });
+    return subscription;
+  }
+  /**
+   * Pause subscription
+   *
+   * @param subscriptionId - Subscription ID
+   * @param options - Pause options
+   * @returns Updated subscription
+   */
+  async pause(subscriptionId, options = {}) {
+    const { reason = null } = options;
+    if (!this.models.Subscription) {
+      throw new ModelNotRegisteredError("Subscription");
+    }
+    const SubscriptionModel = this.models.Subscription;
+    const subscription = await SubscriptionModel.findById(subscriptionId);
+    if (!subscription) {
+      throw new SubscriptionNotFoundError(subscriptionId);
+    }
+    if (!subscription.isActive) {
+      throw new SubscriptionNotActiveError(subscriptionId, "Only active subscriptions can be paused");
+    }
+    const pausedAt = /* @__PURE__ */ new Date();
+    subscription.isActive = false;
+    subscription.status = "paused";
+    subscription.pausedAt = pausedAt;
+    subscription.pauseReason = reason;
+    await subscription.save();
+    this._triggerHook("subscription.paused", {
+      subscription,
+      reason,
+      pausedAt
+    });
+    return subscription;
+  }
+  /**
+   * Resume subscription
+   *
+   * @param subscriptionId - Subscription ID
+   * @param options - Resume options
+   * @returns Updated subscription
+   */
+  async resume(subscriptionId, options = {}) {
+    const { extendPeriod = false } = options;
+    if (!this.models.Subscription) {
+      throw new ModelNotRegisteredError("Subscription");
+    }
+    const SubscriptionModel = this.models.Subscription;
+    const subscription = await SubscriptionModel.findById(subscriptionId);
+    if (!subscription) {
+      throw new SubscriptionNotFoundError(subscriptionId);
+    }
+    if (!subscription.pausedAt) {
+      throw new InvalidStateTransitionError(
+        "resume",
+        "paused",
+        subscription.status,
+        "Only paused subscriptions can be resumed"
+      );
+    }
+    const now = /* @__PURE__ */ new Date();
+    const pausedAt = new Date(subscription.pausedAt);
+    const pauseDuration = now.getTime() - pausedAt.getTime();
+    subscription.isActive = true;
+    subscription.status = "active";
+    subscription.pausedAt = null;
+    subscription.pauseReason = null;
+    if (extendPeriod && subscription.endDate) {
+      const currentEnd = new Date(subscription.endDate);
+      subscription.endDate = new Date(currentEnd.getTime() + pauseDuration);
+    }
+    await subscription.save();
+    this._triggerHook("subscription.resumed", {
+      subscription,
+      extendPeriod,
+      pauseDuration,
+      resumedAt: now
+    });
+    return subscription;
+  }
+  /**
+   * List subscriptions with filters
+   *
+   * @param filters - Query filters
+   * @param options - Query options (limit, skip, sort)
+   * @returns Subscriptions
+   */
+  async list(filters = {}, options = {}) {
+    if (!this.models.Subscription) {
+      throw new ModelNotRegisteredError("Subscription");
+    }
+    const SubscriptionModel = this.models.Subscription;
+    const { limit = 50, skip = 0, sort = { createdAt: -1 } } = options;
+    const subscriptions = await SubscriptionModel.find(filters).limit(limit).skip(skip).sort(sort);
+    return subscriptions;
+  }
+  /**
+   * Get subscription by ID
+   *
+   * @param subscriptionId - Subscription ID
+   * @returns Subscription
+   */
+  async get(subscriptionId) {
+    if (!this.models.Subscription) {
+      throw new ModelNotRegisteredError("Subscription");
+    }
+    const SubscriptionModel = this.models.Subscription;
+    const subscription = await SubscriptionModel.findById(subscriptionId);
+    if (!subscription) {
+      throw new SubscriptionNotFoundError(subscriptionId);
+    }
+    return subscription;
+  }
+  /**
+   * Calculate period end date based on plan key
+   * @private
+   */
+  _calculatePeriodEnd(planKey, startDate = /* @__PURE__ */ new Date()) {
+    const start = new Date(startDate);
+    const end = new Date(start);
+    switch (planKey) {
+      case "monthly":
+        end.setMonth(end.getMonth() + 1);
+        break;
+      case "quarterly":
+        end.setMonth(end.getMonth() + 3);
+        break;
+      case "yearly":
+        end.setFullYear(end.getFullYear() + 1);
+        break;
+      default:
+        end.setDate(end.getDate() + 30);
+    }
+    return end;
+  }
+  /**
+   * Trigger event hook (fire-and-forget, non-blocking)
+   * @private
+   */
+  _triggerHook(event, data) {
+    triggerHook(this.hooks, event, data, this.logger);
+  }
+};
+
+// src/services/payment.service.ts
+var PaymentService = class {
+  models;
+  providers;
+  config;
+  hooks;
+  logger;
+  constructor(container) {
+    this.models = container.get("models");
+    this.providers = container.get("providers");
+    this.config = container.get("config");
+    this.hooks = container.get("hooks");
+    this.logger = container.get("logger");
+  }
+  /**
+   * Verify a payment
+   *
+   * @param paymentIntentId - Payment intent ID, session ID, or transaction ID
+   * @param options - Verification options
+   * @returns { transaction, status }
+   */
+  async verify(paymentIntentId, options = {}) {
+    const { verifiedBy = null } = options;
+    const TransactionModel = this.models.Transaction;
+    const transaction = await this._findTransaction(TransactionModel, paymentIntentId);
+    if (!transaction) {
+      throw new TransactionNotFoundError(paymentIntentId);
+    }
+    if (transaction.status === "verified" || transaction.status === "completed") {
+      throw new AlreadyVerifiedError(transaction._id.toString());
+    }
+    const gatewayType = transaction.gateway?.type ?? "manual";
+    const provider = this.providers[gatewayType];
+    if (!provider) {
+      throw new ProviderNotFoundError(gatewayType, Object.keys(this.providers));
+    }
+    let paymentResult = null;
+    try {
+      paymentResult = await provider.verifyPayment(paymentIntentId);
+    } catch (error) {
+      this.logger.error("Payment verification failed:", error);
+      transaction.status = "failed";
+      transaction.failureReason = error.message;
+      transaction.metadata = {
+        ...transaction.metadata,
+        verificationError: error.message,
+        failedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await transaction.save();
+      this._triggerHook("payment.failed", {
+        transaction,
+        error: error.message,
+        provider: gatewayType,
+        paymentIntentId
+      });
+      throw new PaymentVerificationError(paymentIntentId, error.message);
+    }
+    if (paymentResult.amount && paymentResult.amount !== transaction.amount) {
+      throw new ValidationError(
+        `Amount mismatch: expected ${transaction.amount}, got ${paymentResult.amount}`,
+        { expected: transaction.amount, actual: paymentResult.amount }
+      );
+    }
+    if (paymentResult.currency && paymentResult.currency.toUpperCase() !== transaction.currency.toUpperCase()) {
+      throw new ValidationError(
+        `Currency mismatch: expected ${transaction.currency}, got ${paymentResult.currency}`,
+        { expected: transaction.currency, actual: paymentResult.currency }
+      );
+    }
+    transaction.status = paymentResult.status === "succeeded" ? "verified" : paymentResult.status;
+    transaction.verifiedAt = paymentResult.paidAt ?? /* @__PURE__ */ new Date();
+    transaction.verifiedBy = verifiedBy;
+    transaction.gateway = {
+      ...transaction.gateway,
+      type: transaction.gateway?.type ?? "manual",
+      verificationData: paymentResult.metadata
+    };
+    await transaction.save();
+    this._triggerHook("payment.verified", {
+      transaction,
+      paymentResult,
+      verifiedBy
+    });
+    return {
+      transaction,
+      paymentResult,
+      status: transaction.status
+    };
+  }
+  /**
+   * Get payment status
+   *
+   * @param paymentIntentId - Payment intent ID, session ID, or transaction ID
+   * @returns { transaction, status }
+   */
+  async getStatus(paymentIntentId) {
+    const TransactionModel = this.models.Transaction;
+    const transaction = await this._findTransaction(TransactionModel, paymentIntentId);
+    if (!transaction) {
+      throw new TransactionNotFoundError(paymentIntentId);
+    }
+    const gatewayType = transaction.gateway?.type ?? "manual";
+    const provider = this.providers[gatewayType];
+    if (!provider) {
+      throw new ProviderNotFoundError(gatewayType, Object.keys(this.providers));
+    }
+    let paymentResult = null;
+    try {
+      paymentResult = await provider.getStatus(paymentIntentId);
+    } catch (error) {
+      this.logger.warn("Failed to get payment status from provider:", error);
+      return {
+        transaction,
+        status: transaction.status,
+        provider: gatewayType
+      };
+    }
+    return {
+      transaction,
+      paymentResult,
+      status: paymentResult.status,
+      provider: gatewayType
+    };
+  }
+  /**
+   * Refund a payment
+   *
+   * @param paymentId - Payment intent ID, session ID, or transaction ID
+   * @param amount - Amount to refund (optional, full refund if not provided)
+   * @param options - Refund options
+   * @returns { transaction, refundResult }
+   */
+  async refund(paymentId, amount = null, options = {}) {
+    const { reason = null } = options;
+    const TransactionModel = this.models.Transaction;
+    const transaction = await this._findTransaction(TransactionModel, paymentId);
+    if (!transaction) {
+      throw new TransactionNotFoundError(paymentId);
+    }
+    if (transaction.status !== "verified" && transaction.status !== "completed") {
+      throw new RefundError(transaction._id.toString(), "Only verified/completed transactions can be refunded");
+    }
+    const gatewayType = transaction.gateway?.type ?? "manual";
+    const provider = this.providers[gatewayType];
+    if (!provider) {
+      throw new ProviderNotFoundError(gatewayType, Object.keys(this.providers));
+    }
+    const capabilities = provider.getCapabilities();
+    if (!capabilities.supportsRefunds) {
+      throw new RefundNotSupportedError(gatewayType);
+    }
+    const refundedSoFar = transaction.refundedAmount ?? 0;
+    const refundableAmount = transaction.amount - refundedSoFar;
+    const refundAmount = amount ?? refundableAmount;
+    if (refundAmount <= 0) {
+      throw new ValidationError(`Refund amount must be positive, got ${refundAmount}`);
+    }
+    if (refundAmount > refundableAmount) {
+      throw new ValidationError(
+        `Refund amount (${refundAmount}) exceeds refundable balance (${refundableAmount})`,
+        { refundAmount, refundableAmount, alreadyRefunded: refundedSoFar }
+      );
+    }
+    let refundResult;
+    try {
+      refundResult = await provider.refund(paymentId, refundAmount, { reason: reason ?? void 0 });
+    } catch (error) {
+      this.logger.error("Refund failed:", error);
+      throw new RefundError(paymentId, error.message);
+    }
+    const refundTransactionType = this.config.transactionTypeMapping?.refund ?? TRANSACTION_TYPE.EXPENSE;
+    const refundCommission = transaction.commission ? reverseCommission(transaction.commission, transaction.amount, refundAmount) : null;
+    const refundTransaction = await TransactionModel.create({
+      organizationId: transaction.organizationId,
+      customerId: transaction.customerId,
+      amount: refundAmount,
+      currency: transaction.currency,
+      category: transaction.category,
+      type: refundTransactionType,
+      // EXPENSE - money going out
+      method: transaction.method ?? "manual",
+      status: "completed",
+      gateway: {
+        type: transaction.gateway?.type ?? "manual",
+        paymentIntentId: refundResult.id,
+        provider: refundResult.provider
+      },
+      paymentDetails: transaction.paymentDetails,
+      ...refundCommission && { commission: refundCommission },
+      // Reversed commission
+      // Polymorphic reference (copy from original transaction)
+      ...transaction.referenceId && { referenceId: transaction.referenceId },
+      ...transaction.referenceModel && { referenceModel: transaction.referenceModel },
+      metadata: {
+        ...transaction.metadata,
+        isRefund: true,
+        originalTransactionId: transaction._id.toString(),
+        refundReason: reason,
+        refundResult: refundResult.metadata
+      },
+      idempotencyKey: `refund_${transaction._id}_${Date.now()}`
+    });
+    const isPartialRefund = refundAmount < transaction.amount;
+    transaction.status = isPartialRefund ? "partially_refunded" : "refunded";
+    transaction.refundedAmount = (transaction.refundedAmount ?? 0) + refundAmount;
+    transaction.refundedAt = refundResult.refundedAt ?? /* @__PURE__ */ new Date();
+    transaction.metadata = {
+      ...transaction.metadata,
+      refundTransactionId: refundTransaction._id.toString(),
+      refundReason: reason
+    };
+    await transaction.save();
+    this._triggerHook("payment.refunded", {
+      transaction,
+      refundTransaction,
+      refundResult,
+      refundAmount,
+      reason,
+      isPartialRefund
+    });
+    return {
+      transaction,
+      refundTransaction,
+      refundResult,
+      status: transaction.status
+    };
+  }
+  /**
+   * Handle webhook from payment provider
+   *
+   * @param provider - Provider name
+   * @param payload - Webhook payload
+   * @param headers - Request headers
+   * @returns { event, transaction }
+   */
+  async handleWebhook(providerName, payload, headers = {}) {
+    const provider = this.providers[providerName];
+    if (!provider) {
+      throw new ProviderNotFoundError(providerName, Object.keys(this.providers));
+    }
+    const capabilities = provider.getCapabilities();
+    if (!capabilities.supportsWebhooks) {
+      throw new ProviderCapabilityError(providerName, "webhooks");
+    }
+    let webhookEvent;
+    try {
+      webhookEvent = await provider.handleWebhook(payload, headers);
+    } catch (error) {
+      this.logger.error("Webhook processing failed:", error);
+      throw new ProviderError(
+        `Webhook processing failed for ${providerName}: ${error.message}`,
+        "WEBHOOK_PROCESSING_FAILED",
+        { retryable: false }
+      );
+    }
+    if (!webhookEvent?.data?.sessionId && !webhookEvent?.data?.paymentIntentId) {
+      throw new ValidationError(
+        `Invalid webhook event structure from ${providerName}: missing sessionId or paymentIntentId`,
+        { provider: providerName, eventType: webhookEvent?.type }
+      );
+    }
+    const TransactionModel = this.models.Transaction;
+    let transaction = null;
+    if (webhookEvent.data.sessionId) {
+      transaction = await TransactionModel.findOne({
+        "gateway.sessionId": webhookEvent.data.sessionId
+      });
+    }
+    if (!transaction && webhookEvent.data.paymentIntentId) {
+      transaction = await TransactionModel.findOne({
+        "gateway.paymentIntentId": webhookEvent.data.paymentIntentId
+      });
+    }
+    if (!transaction) {
+      this.logger.warn("Transaction not found for webhook event", {
+        provider: providerName,
+        eventId: webhookEvent.id,
+        sessionId: webhookEvent.data.sessionId,
+        paymentIntentId: webhookEvent.data.paymentIntentId
+      });
+      throw new TransactionNotFoundError(
+        webhookEvent.data.sessionId ?? webhookEvent.data.paymentIntentId ?? "unknown"
+      );
+    }
+    if (webhookEvent.data.sessionId && !transaction.gateway?.sessionId) {
+      transaction.gateway = {
+        ...transaction.gateway,
+        type: transaction.gateway?.type ?? "manual",
+        sessionId: webhookEvent.data.sessionId
+      };
+    }
+    if (webhookEvent.data.paymentIntentId && !transaction.gateway?.paymentIntentId) {
+      transaction.gateway = {
+        ...transaction.gateway,
+        type: transaction.gateway?.type ?? "manual",
+        paymentIntentId: webhookEvent.data.paymentIntentId
+      };
+    }
+    if (transaction.webhook?.eventId === webhookEvent.id && transaction.webhook?.processedAt) {
+      this.logger.warn("Webhook already processed", {
+        transactionId: transaction._id,
+        eventId: webhookEvent.id
+      });
+      return {
+        event: webhookEvent,
+        transaction,
+        status: "already_processed"
+      };
+    }
+    transaction.webhook = {
+      eventId: webhookEvent.id,
+      eventType: webhookEvent.type,
+      receivedAt: /* @__PURE__ */ new Date(),
+      processedAt: /* @__PURE__ */ new Date(),
+      data: webhookEvent.data
+    };
+    if (webhookEvent.type === "payment.succeeded") {
+      transaction.status = "verified";
+      transaction.verifiedAt = webhookEvent.createdAt;
+    } else if (webhookEvent.type === "payment.failed") {
+      transaction.status = "failed";
+    } else if (webhookEvent.type === "refund.succeeded") {
+      transaction.status = "refunded";
+      transaction.refundedAt = webhookEvent.createdAt;
+    }
+    await transaction.save();
+    this._triggerHook(`payment.webhook.${webhookEvent.type}`, {
+      event: webhookEvent,
+      transaction
+    });
+    return {
+      event: webhookEvent,
+      transaction,
+      status: "processed"
+    };
+  }
+  /**
+   * List payments/transactions with filters
+   *
+   * @param filters - Query filters
+   * @param options - Query options (limit, skip, sort)
+   * @returns Transactions
+   */
+  async list(filters = {}, options = {}) {
+    const TransactionModel = this.models.Transaction;
+    const { limit = 50, skip = 0, sort = { createdAt: -1 } } = options;
+    const transactions = await TransactionModel.find(filters).limit(limit).skip(skip).sort(sort);
+    return transactions;
+  }
+  /**
+   * Get payment/transaction by ID
+   *
+   * @param transactionId - Transaction ID
+   * @returns Transaction
+   */
+  async get(transactionId) {
+    const TransactionModel = this.models.Transaction;
+    const transaction = await TransactionModel.findById(transactionId);
+    if (!transaction) {
+      throw new TransactionNotFoundError(transactionId);
+    }
+    return transaction;
+  }
+  /**
+   * Get provider instance
+   *
+   * @param providerName - Provider name
+   * @returns Provider instance
+   */
+  getProvider(providerName) {
+    const provider = this.providers[providerName];
+    if (!provider) {
+      throw new ProviderNotFoundError(providerName, Object.keys(this.providers));
+    }
+    return provider;
+  }
+  /**
+   * Trigger event hook (fire-and-forget, non-blocking)
+   * @private
+   */
+  _triggerHook(event, data) {
+    triggerHook(this.hooks, event, data, this.logger);
+  }
+  /**
+   * Find transaction by sessionId, paymentIntentId, or transaction ID
+   * @private
+   */
+  async _findTransaction(TransactionModel, identifier) {
+    let transaction = await TransactionModel.findOne({
+      "gateway.sessionId": identifier
+    });
+    if (!transaction) {
+      transaction = await TransactionModel.findOne({
+        "gateway.paymentIntentId": identifier
+      });
+    }
+    if (!transaction) {
+      transaction = await TransactionModel.findById(identifier);
+    }
+    return transaction;
+  }
+};
+
+// src/services/transaction.service.ts
+var TransactionService = class {
+  models;
+  hooks;
+  logger;
+  constructor(container) {
+    this.models = container.get("models");
+    this.hooks = container.get("hooks");
+    this.logger = container.get("logger");
+  }
+  /**
+   * Get transaction by ID
+   *
+   * @param transactionId - Transaction ID
+   * @returns Transaction
+   */
+  async get(transactionId) {
+    const TransactionModel = this.models.Transaction;
+    const transaction = await TransactionModel.findById(transactionId);
+    if (!transaction) {
+      throw new TransactionNotFoundError(transactionId);
+    }
+    return transaction;
+  }
+  /**
+   * List transactions with filters
+   *
+   * @param filters - Query filters
+   * @param options - Query options (limit, skip, sort, populate)
+   * @returns { transactions, total, page, limit }
+   */
+  async list(filters = {}, options = {}) {
+    const TransactionModel = this.models.Transaction;
+    const {
+      limit = 50,
+      skip = 0,
+      page = null,
+      sort = { createdAt: -1 },
+      populate = []
+    } = options;
+    const actualSkip = page ? (page - 1) * limit : skip;
+    let query = TransactionModel.find(filters).limit(limit).skip(actualSkip).sort(sort);
+    if (populate.length > 0 && typeof query.populate === "function") {
+      populate.forEach((field) => {
+        query = query.populate(field);
+      });
+    }
+    const transactions = await query;
+    const model = TransactionModel;
+    const total = await (model.countDocuments ? model.countDocuments(filters) : model.count?.(filters)) ?? 0;
+    return {
+      transactions,
+      total,
+      page: page ?? Math.floor(actualSkip / limit) + 1,
+      limit,
+      pages: Math.ceil(total / limit)
+    };
+  }
+  /**
+   * Update transaction
+   *
+   * @param transactionId - Transaction ID
+   * @param updates - Fields to update
+   * @returns Updated transaction
+   */
+  async update(transactionId, updates) {
+    const TransactionModel = this.models.Transaction;
+    const model = TransactionModel;
+    let transaction;
+    if (typeof model.update === "function") {
+      transaction = await model.update(transactionId, updates);
+    } else if (typeof model.findByIdAndUpdate === "function") {
+      transaction = await model.findByIdAndUpdate(
+        transactionId,
+        { $set: updates },
+        { new: true }
+      );
+    } else {
+      throw new Error("Transaction model does not support update operations");
+    }
+    if (!transaction) {
+      throw new TransactionNotFoundError(transactionId);
+    }
+    this._triggerHook("transaction.updated", {
+      transaction,
+      updates
+    });
+    return transaction;
+  }
+  /**
+   * Trigger event hook (fire-and-forget, non-blocking)
+   * @private
+   */
+  _triggerHook(event, data) {
+    triggerHook(this.hooks, event, data, this.logger);
+  }
+};
+
+// src/enums/escrow.enums.ts
+var HOLD_STATUS = {
+  PENDING: "pending",
+  HELD: "held",
+  RELEASED: "released",
+  CANCELLED: "cancelled",
+  EXPIRED: "expired",
+  PARTIALLY_RELEASED: "partially_released"
+};
+var HOLD_STATUS_VALUES = Object.values(HOLD_STATUS);
+var RELEASE_REASON = {
+  PAYMENT_VERIFIED: "payment_verified",
+  MANUAL_RELEASE: "manual_release",
+  AUTO_RELEASE: "auto_release",
+  DISPUTE_RESOLVED: "dispute_resolved"
+};
+var RELEASE_REASON_VALUES = Object.values(RELEASE_REASON);
+var HOLD_REASON = {
+  PAYMENT_VERIFICATION: "payment_verification",
+  FRAUD_CHECK: "fraud_check",
+  MANUAL_REVIEW: "manual_review",
+  DISPUTE: "dispute",
+  COMPLIANCE: "compliance"
+};
+var HOLD_REASON_VALUES = Object.values(HOLD_REASON);
+
+// src/enums/split.enums.ts
+var SPLIT_TYPE = {
+  PLATFORM_COMMISSION: "platform_commission",
+  AFFILIATE_COMMISSION: "affiliate_commission",
+  REFERRAL_COMMISSION: "referral_commission",
+  PARTNER_COMMISSION: "partner_commission",
+  CUSTOM: "custom"
+};
+var SPLIT_TYPE_VALUES = Object.values(SPLIT_TYPE);
+var SPLIT_STATUS = {
+  PENDING: "pending",
+  DUE: "due",
+  PAID: "paid",
+  WAIVED: "waived",
+  CANCELLED: "cancelled"
+};
+var SPLIT_STATUS_VALUES = Object.values(SPLIT_STATUS);
+var PAYOUT_METHOD = {
+  BANK_TRANSFER: "bank_transfer",
+  MOBILE_WALLET: "mobile_wallet",
+  PLATFORM_BALANCE: "platform_balance",
+  CRYPTO: "crypto",
+  CHECK: "check",
+  MANUAL: "manual"
+};
+var PAYOUT_METHOD_VALUES = Object.values(PAYOUT_METHOD);
+
+// src/utils/commission-split.ts
+function calculateSplits(amount, splitRules = [], gatewayFeeRate = 0) {
+  if (!splitRules || splitRules.length === 0) {
+    return [];
+  }
+  if (amount < 0) {
+    throw new Error("Transaction amount cannot be negative");
+  }
+  if (gatewayFeeRate < 0 || gatewayFeeRate > 1) {
+    throw new Error("Gateway fee rate must be between 0 and 1");
+  }
+  const totalRate = splitRules.reduce((sum, rule) => sum + rule.rate, 0);
+  if (totalRate > 1) {
+    throw new Error(`Total split rate (${totalRate}) cannot exceed 1.0`);
+  }
+  return splitRules.map((rule, index) => {
+    if (rule.rate < 0 || rule.rate > 1) {
+      throw new Error(`Split rate must be between 0 and 1 for split ${index}`);
+    }
+    const grossAmount = Math.round(amount * rule.rate * 100) / 100;
+    const gatewayFeeAmount = index === 0 && gatewayFeeRate > 0 ? Math.round(amount * gatewayFeeRate * 100) / 100 : 0;
+    const netAmount = Math.max(0, Math.round((grossAmount - gatewayFeeAmount) * 100) / 100);
+    return {
+      type: rule.type ?? SPLIT_TYPE.CUSTOM,
+      recipientId: rule.recipientId,
+      recipientType: rule.recipientType,
+      rate: rule.rate,
+      grossAmount,
+      gatewayFeeRate: gatewayFeeAmount > 0 ? gatewayFeeRate : 0,
+      gatewayFeeAmount,
+      netAmount,
+      status: SPLIT_STATUS.PENDING,
+      dueDate: rule.dueDate ?? null,
+      metadata: rule.metadata ?? {}
+    };
+  });
+}
+function calculateOrganizationPayout(amount, splits = []) {
+  const totalSplitAmount = splits.reduce((sum, split) => sum + split.grossAmount, 0);
+  return Math.max(0, Math.round((amount - totalSplitAmount) * 100) / 100);
+}
+function reverseSplits(originalSplits, originalAmount, refundAmount) {
+  if (!originalSplits || originalSplits.length === 0) {
+    return [];
+  }
+  const refundRatio = refundAmount / originalAmount;
+  return originalSplits.map((split) => ({
+    ...split,
+    grossAmount: Math.round(split.grossAmount * refundRatio * 100) / 100,
+    gatewayFeeAmount: Math.round(split.gatewayFeeAmount * refundRatio * 100) / 100,
+    netAmount: Math.round(split.netAmount * refundRatio * 100) / 100,
+    status: SPLIT_STATUS.WAIVED
+  }));
+}
+function calculateCommissionWithSplits(amount, commissionRate, gatewayFeeRate = 0, options = {}) {
+  const { affiliateRate = 0, affiliateId = null, affiliateType = "user" } = options;
+  if (commissionRate <= 0 && affiliateRate <= 0) {
+    return null;
+  }
+  const splitRules = [];
+  if (commissionRate > 0) {
+    splitRules.push({
+      type: SPLIT_TYPE.PLATFORM_COMMISSION,
+      recipientId: "platform",
+      recipientType: "platform",
+      rate: commissionRate
+    });
+  }
+  if (affiliateRate > 0 && affiliateId) {
+    splitRules.push({
+      type: SPLIT_TYPE.AFFILIATE_COMMISSION,
+      recipientId: affiliateId,
+      recipientType: affiliateType,
+      rate: affiliateRate
+    });
+  }
+  const splits = calculateSplits(amount, splitRules, gatewayFeeRate);
+  const platformSplit = splits.find((s) => s.type === SPLIT_TYPE.PLATFORM_COMMISSION);
+  const affiliateSplit = splits.find((s) => s.type === SPLIT_TYPE.AFFILIATE_COMMISSION);
+  return {
+    rate: commissionRate,
+    grossAmount: platformSplit?.grossAmount ?? 0,
+    gatewayFeeRate: platformSplit?.gatewayFeeRate ?? 0,
+    gatewayFeeAmount: platformSplit?.gatewayFeeAmount ?? 0,
+    netAmount: platformSplit?.netAmount ?? 0,
+    status: "pending",
+    ...splits.length > 0 && { splits },
+    ...affiliateSplit && {
+      affiliate: {
+        recipientId: affiliateSplit.recipientId,
+        recipientType: affiliateSplit.recipientType,
+        rate: affiliateSplit.rate,
+        grossAmount: affiliateSplit.grossAmount,
+        netAmount: affiliateSplit.netAmount
+      }
+    }
+  };
+}
+
+// src/services/escrow.service.ts
+var EscrowService = class {
+  models;
+  hooks;
+  logger;
+  constructor(container) {
+    this.models = container.get("models");
+    this.hooks = container.get("hooks");
+    this.logger = container.get("logger");
+  }
+  /**
+   * Hold funds in escrow
+   *
+   * @param transactionId - Transaction to hold
+   * @param options - Hold options
+   * @returns Updated transaction
+   */
+  async hold(transactionId, options = {}) {
+    const {
+      reason = HOLD_REASON.PAYMENT_VERIFICATION,
+      holdUntil = null,
+      metadata = {}
+    } = options;
+    const TransactionModel = this.models.Transaction;
+    const transaction = await TransactionModel.findById(transactionId);
+    if (!transaction) {
+      throw new TransactionNotFoundError(transactionId);
+    }
+    if (transaction.status !== TRANSACTION_STATUS.VERIFIED) {
+      throw new Error(`Cannot hold transaction with status: ${transaction.status}. Must be verified.`);
+    }
+    transaction.hold = {
+      status: HOLD_STATUS.HELD,
+      heldAmount: transaction.amount,
+      releasedAmount: 0,
+      reason,
+      heldAt: /* @__PURE__ */ new Date(),
+      ...holdUntil && { holdUntil },
+      releases: [],
+      metadata
+    };
+    await transaction.save();
+    this._triggerHook("escrow.held", {
+      transaction,
+      heldAmount: transaction.amount,
+      reason
+    });
+    return transaction;
+  }
+  /**
+   * Release funds from escrow to recipient
+   *
+   * @param transactionId - Transaction to release
+   * @param options - Release options
+   * @returns { transaction, releaseTransaction }
+   */
+  async release(transactionId, options) {
+    const {
+      amount = null,
+      recipientId,
+      recipientType = "organization",
+      reason = RELEASE_REASON.PAYMENT_VERIFIED,
+      releasedBy = null,
+      createTransaction = true,
+      metadata = {}
+    } = options;
+    const TransactionModel = this.models.Transaction;
+    const transaction = await TransactionModel.findById(transactionId);
+    if (!transaction) {
+      throw new TransactionNotFoundError(transactionId);
+    }
+    if (!transaction.hold || transaction.hold.status !== HOLD_STATUS.HELD) {
+      throw new Error(`Transaction is not in held status. Current: ${transaction.hold?.status ?? "none"}`);
+    }
+    if (!recipientId) {
+      throw new Error("recipientId is required for release");
+    }
+    const releaseAmount = amount ?? transaction.hold.heldAmount - transaction.hold.releasedAmount;
+    const availableAmount = transaction.hold.heldAmount - transaction.hold.releasedAmount;
+    if (releaseAmount > availableAmount) {
+      throw new Error(`Release amount (${releaseAmount}) exceeds available held amount (${availableAmount})`);
+    }
+    const releaseRecord = {
+      amount: releaseAmount,
+      recipientId,
+      recipientType,
+      releasedAt: /* @__PURE__ */ new Date(),
+      releasedBy,
+      reason,
+      metadata
+    };
+    transaction.hold.releases.push(releaseRecord);
+    transaction.hold.releasedAmount += releaseAmount;
+    const isFullRelease = transaction.hold.releasedAmount >= transaction.hold.heldAmount;
+    const isPartialRelease = transaction.hold.releasedAmount > 0 && transaction.hold.releasedAmount < transaction.hold.heldAmount;
+    if (isFullRelease) {
+      transaction.hold.status = HOLD_STATUS.RELEASED;
+      transaction.hold.releasedAt = /* @__PURE__ */ new Date();
+      transaction.status = TRANSACTION_STATUS.COMPLETED;
+    } else if (isPartialRelease) {
+      transaction.hold.status = HOLD_STATUS.PARTIALLY_RELEASED;
+    }
+    await transaction.save();
+    let releaseTransaction = null;
+    if (createTransaction) {
+      releaseTransaction = await TransactionModel.create({
+        organizationId: transaction.organizationId,
+        customerId: recipientId,
+        amount: releaseAmount,
+        currency: transaction.currency,
+        category: transaction.category,
+        type: TRANSACTION_TYPE.INCOME,
+        method: transaction.method,
+        status: TRANSACTION_STATUS.COMPLETED,
+        gateway: transaction.gateway,
+        referenceId: transaction.referenceId,
+        referenceModel: transaction.referenceModel,
+        metadata: {
+          ...metadata,
+          isRelease: true,
+          heldTransactionId: transaction._id.toString(),
+          releaseReason: reason,
+          recipientType
+        },
+        idempotencyKey: `release_${transaction._id}_${Date.now()}`
+      });
+    }
+    this._triggerHook("escrow.released", {
+      transaction,
+      releaseTransaction,
+      releaseAmount,
+      recipientId,
+      recipientType,
+      reason,
+      isFullRelease,
+      isPartialRelease
+    });
+    return {
+      transaction,
+      releaseTransaction,
+      releaseAmount,
+      isFullRelease,
+      isPartialRelease
+    };
+  }
+  /**
+   * Cancel hold and release back to customer
+   *
+   * @param transactionId - Transaction to cancel hold
+   * @param options - Cancel options
+   * @returns Updated transaction
+   */
+  async cancel(transactionId, options = {}) {
+    const { reason = "Hold cancelled", metadata = {} } = options;
+    const TransactionModel = this.models.Transaction;
+    const transaction = await TransactionModel.findById(transactionId);
+    if (!transaction) {
+      throw new TransactionNotFoundError(transactionId);
+    }
+    if (!transaction.hold || transaction.hold.status !== HOLD_STATUS.HELD) {
+      throw new Error(`Transaction is not in held status. Current: ${transaction.hold?.status ?? "none"}`);
+    }
+    transaction.hold.status = HOLD_STATUS.CANCELLED;
+    transaction.hold.cancelledAt = /* @__PURE__ */ new Date();
+    transaction.hold.metadata = {
+      ...transaction.hold.metadata,
+      ...metadata,
+      cancelReason: reason
+    };
+    transaction.status = TRANSACTION_STATUS.CANCELLED;
+    await transaction.save();
+    this._triggerHook("escrow.cancelled", {
+      transaction,
+      reason
+    });
+    return transaction;
+  }
+  /**
+   * Split payment to multiple recipients
+   * Deducts splits from held amount and releases remainder to organization
+   *
+   * @param transactionId - Transaction to split
+   * @param splitRules - Split configuration
+   * @returns { transaction, splitTransactions, organizationTransaction }
+   */
+  async split(transactionId, splitRules = []) {
+    const TransactionModel = this.models.Transaction;
+    const transaction = await TransactionModel.findById(transactionId);
+    if (!transaction) {
+      throw new TransactionNotFoundError(transactionId);
+    }
+    if (!transaction.hold || transaction.hold.status !== HOLD_STATUS.HELD) {
+      throw new Error(`Transaction must be held before splitting. Current: ${transaction.hold?.status ?? "none"}`);
+    }
+    if (!splitRules || splitRules.length === 0) {
+      throw new Error("splitRules cannot be empty");
+    }
+    const splits = calculateSplits(
+      transaction.amount,
+      splitRules,
+      transaction.commission?.gatewayFeeRate ?? 0
+    );
+    transaction.splits = splits;
+    await transaction.save();
+    const splitTransactions = [];
+    for (const split of splits) {
+      const splitTransaction = await TransactionModel.create({
+        organizationId: transaction.organizationId,
+        customerId: split.recipientId,
+        amount: split.netAmount,
+        currency: transaction.currency,
+        category: split.type,
+        type: TRANSACTION_TYPE.EXPENSE,
+        method: transaction.method,
+        status: TRANSACTION_STATUS.COMPLETED,
+        gateway: transaction.gateway,
+        referenceId: transaction.referenceId,
+        referenceModel: transaction.referenceModel,
+        metadata: {
+          isSplit: true,
+          splitType: split.type,
+          recipientType: split.recipientType,
+          originalTransactionId: transaction._id.toString(),
+          grossAmount: split.grossAmount,
+          gatewayFeeAmount: split.gatewayFeeAmount
+        },
+        idempotencyKey: `split_${transaction._id}_${split.recipientId}_${Date.now()}`
+      });
+      split.payoutTransactionId = splitTransaction._id.toString();
+      split.status = SPLIT_STATUS.PAID;
+      split.paidDate = /* @__PURE__ */ new Date();
+      splitTransactions.push(splitTransaction);
+    }
+    await transaction.save();
+    const organizationPayout = calculateOrganizationPayout(transaction.amount, splits);
+    const organizationTransaction = await this.release(transactionId, {
+      amount: organizationPayout,
+      recipientId: transaction.organizationId?.toString() ?? "",
+      recipientType: "organization",
+      reason: RELEASE_REASON.PAYMENT_VERIFIED,
+      createTransaction: true,
+      metadata: {
+        afterSplits: true,
+        totalSplits: splits.length,
+        totalSplitAmount: transaction.amount - organizationPayout
+      }
+    });
+    this._triggerHook("escrow.split", {
+      transaction,
+      splits,
+      splitTransactions,
+      organizationTransaction: organizationTransaction.releaseTransaction,
+      organizationPayout
+    });
+    return {
+      transaction,
+      splits,
+      splitTransactions,
+      organizationTransaction: organizationTransaction.releaseTransaction,
+      organizationPayout
+    };
+  }
+  /**
+   * Get escrow status
+   *
+   * @param transactionId - Transaction ID
+   * @returns Escrow status
+   */
+  async getStatus(transactionId) {
+    const TransactionModel = this.models.Transaction;
+    const transaction = await TransactionModel.findById(transactionId);
+    if (!transaction) {
+      throw new TransactionNotFoundError(transactionId);
+    }
+    return {
+      transaction,
+      hold: transaction.hold ?? null,
+      splits: transaction.splits ?? [],
+      hasHold: !!transaction.hold,
+      hasSplits: transaction.splits ? transaction.splits.length > 0 : false
+    };
+  }
+  _triggerHook(event, data) {
+    triggerHook(this.hooks, event, data, this.logger);
+  }
+};
+
+// src/providers/base.ts
+var PaymentIntent = class {
+  id;
+  sessionId;
+  paymentIntentId;
+  provider;
+  status;
+  amount;
+  currency;
+  metadata;
+  clientSecret;
+  paymentUrl;
+  instructions;
+  raw;
+  constructor(data) {
+    this.id = data.id;
+    this.sessionId = data.sessionId ?? null;
+    this.paymentIntentId = data.paymentIntentId ?? null;
+    this.provider = data.provider;
+    this.status = data.status;
+    this.amount = data.amount;
+    this.currency = data.currency ?? "BDT";
+    this.metadata = data.metadata ?? {};
+    this.clientSecret = data.clientSecret;
+    this.paymentUrl = data.paymentUrl;
+    this.instructions = data.instructions;
+    this.raw = data.raw;
+  }
+};
+var PaymentResult = class {
+  id;
+  provider;
+  status;
+  amount;
+  currency;
+  paidAt;
+  metadata;
+  raw;
+  constructor(data) {
+    this.id = data.id;
+    this.provider = data.provider;
+    this.status = data.status;
+    this.amount = data.amount;
+    this.currency = data.currency ?? "BDT";
+    this.paidAt = data.paidAt;
+    this.metadata = data.metadata ?? {};
+    this.raw = data.raw;
+  }
+};
+var RefundResult = class {
+  id;
+  provider;
+  status;
+  amount;
+  currency;
+  refundedAt;
+  reason;
+  metadata;
+  raw;
+  constructor(data) {
+    this.id = data.id;
+    this.provider = data.provider;
+    this.status = data.status;
+    this.amount = data.amount;
+    this.currency = data.currency ?? "BDT";
+    this.refundedAt = data.refundedAt;
+    this.reason = data.reason;
+    this.metadata = data.metadata ?? {};
+    this.raw = data.raw;
+  }
+};
+var WebhookEvent = class {
+  id;
+  provider;
+  type;
+  data;
+  createdAt;
+  raw;
+  constructor(data) {
+    this.id = data.id;
+    this.provider = data.provider;
+    this.type = data.type;
+    this.data = data.data;
+    this.createdAt = data.createdAt;
+    this.raw = data.raw;
+  }
+};
+var PaymentProvider = class {
+  config;
+  name;
+  constructor(config = {}) {
+    this.config = config;
+    this.name = "base";
+  }
+  /**
+   * Verify webhook signature (optional)
+   * @param payload - Webhook payload
+   * @param signature - Webhook signature
+   * @returns boolean
+   */
+  verifyWebhookSignature(_payload, _signature) {
+    return true;
+  }
+  /**
+   * Get provider capabilities
+   * @returns ProviderCapabilities
+   */
+  getCapabilities() {
+    return {
+      supportsWebhooks: false,
+      supportsRefunds: false,
+      supportsPartialRefunds: false,
+      requiresManualVerification: true
+    };
+  }
+};
+
+// src/core/revenue.ts
+var Revenue = class {
+  // ============ CORE ============
+  _container;
+  _events;
+  _plugins;
+  _idempotency;
+  _circuitBreaker;
+  _options;
+  _logger;
+  _providers;
+  _config;
+  // ============ SERVICES ============
+  /** Monetization service - purchases, subscriptions, free items */
+  monetization;
+  /** Payment service - verify, refund, webhooks */
+  payments;
+  /** Transaction service - query, update transactions */
+  transactions;
+  /** Escrow service - hold, release, splits */
+  escrow;
+  constructor(container, events, plugins, options, providers, config) {
+    this._container = container;
+    this._events = events;
+    this._plugins = plugins;
+    this._options = options;
+    this._logger = options.logger;
+    this._providers = providers;
+    this._config = config;
+    this._idempotency = createIdempotencyManager({
+      ttl: options.idempotencyTtl
+    });
+    if (options.circuitBreaker) {
+      this._circuitBreaker = createCircuitBreaker();
+    }
+    container.singleton("events", events);
+    container.singleton("plugins", plugins);
+    container.singleton("idempotency", this._idempotency);
+    container.singleton("logger", this._logger);
+    this.monetization = new MonetizationService(container);
+    this.payments = new PaymentService(container);
+    this.transactions = new TransactionService(container);
+    this.escrow = new EscrowService(container);
+    Object.freeze(this._providers);
+    Object.freeze(this._config);
+  }
+  // ============ STATIC FACTORY ============
+  /**
+   * Create a new Revenue builder
+   *
+   * @example
+   * ```typescript
+   * const revenue = Revenue
+   *   .create({ defaultCurrency: 'BDT' })
+   *   .withModels({ Transaction, Subscription })
+   *   .withProvider('manual', new ManualProvider())
+   *   .build();
+   * ```
+   */
+  static create(options = {}) {
+    return new RevenueBuilder(options);
+  }
+  // ============ ACCESSORS ============
+  /** DI container (for advanced usage) */
+  get container() {
+    return this._container;
+  }
+  /** Event bus */
+  get events() {
+    return this._events;
+  }
+  /** Registered providers (frozen) */
+  get providers() {
+    return this._providers;
+  }
+  /** Configuration (frozen) */
+  get config() {
+    return this._config;
+  }
+  /** Default currency */
+  get defaultCurrency() {
+    return this._options.defaultCurrency;
+  }
+  /** Current environment */
+  get environment() {
+    return this._options.environment;
+  }
+  // ============ PROVIDER METHODS ============
+  /**
+   * Get a provider by name
+   */
+  getProvider(name) {
+    const provider = this._providers[name];
+    if (!provider) {
+      throw new ConfigurationError(
+        `Provider "${name}" not found. Available: ${Object.keys(this._providers).join(", ")}`
+      );
+    }
+    return provider;
+  }
+  /**
+   * Get all provider names
+   */
+  getProviderNames() {
+    return Object.keys(this._providers);
+  }
+  /**
+   * Check if provider exists
+   */
+  hasProvider(name) {
+    return name in this._providers;
+  }
+  // ============ EVENT SYSTEM ============
+  /**
+   * Subscribe to events
+   *
+   * @example
+   * ```typescript
+   * revenue.on('payment.succeeded', (event) => {
+   *   console.log('Payment:', event.transactionId);
+   * });
+   * ```
+   */
+  on = (event, handler) => {
+    return this._events.on(event, handler);
+  };
+  /**
+   * Subscribe once
+   */
+  once = (event, handler) => {
+    return this._events.once(event, handler);
+  };
+  /**
+   * Unsubscribe
+   */
+  off = (event, handler) => {
+    this._events.off(event, handler);
+  };
+  /**
+   * Emit an event
+   */
+  emit = (event, payload) => {
+    this._events.emit(event, payload);
+  };
+  // ============ RESILIENCE ============
+  /**
+   * Execute operation with retry and idempotency
+   */
+  async execute(operation, options = {}) {
+    const { idempotencyKey, params, useRetry = true, useCircuitBreaker = true } = options;
+    const idempotentOp = async () => {
+      if (idempotencyKey) {
+        const result = await this._idempotency.execute(idempotencyKey, params, operation);
+        if (!result.ok) throw result.error;
+        return result.value;
+      }
+      return operation();
+    };
+    const resilientOp = async () => {
+      if (useCircuitBreaker && this._circuitBreaker) {
+        return this._circuitBreaker.execute(idempotentOp);
+      }
+      return idempotentOp();
+    };
+    if (useRetry && this._options.retry) {
+      return tryCatch(() => retry(resilientOp, this._options.retry));
+    }
+    return tryCatch(resilientOp);
+  }
+  /**
+   * Create plugin context (for advanced usage)
+   */
+  createContext(meta = {}) {
+    return {
+      events: this._events,
+      logger: this._logger,
+      get: (key) => this._container.get(key),
+      storage: /* @__PURE__ */ new Map(),
+      meta: {
+        ...meta,
+        requestId: nanoid(12),
+        timestamp: /* @__PURE__ */ new Date()
+      }
+    };
+  }
+  /**
+   * Destroy instance and cleanup
+   */
+  async destroy() {
+    await this._plugins.destroy();
+    this._events.clear();
+  }
+};
+var RevenueBuilder = class {
+  options;
+  models = null;
+  providers = {};
+  plugins = [];
+  hooks = {};
+  categoryMappings = {};
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Register models (required)
+   *
+   * @example
+   * ```typescript
+   * .withModels({
+   *   Transaction: TransactionModel,
+   *   Subscription: SubscriptionModel,
+   * })
+   * ```
+   */
+  withModels(models) {
+    this.models = models;
+    return this;
+  }
+  /**
+   * Register a single model
+   */
+  withModel(name, model) {
+    if (!this.models) {
+      this.models = { Transaction: model };
+    }
+    this.models[name] = model;
+    return this;
+  }
+  /**
+   * Register a payment provider
+   *
+   * @example
+   * ```typescript
+   * .withProvider('stripe', new StripeProvider({ apiKey: '...' }))
+   * .withProvider('manual', new ManualProvider())
+   * ```
+   */
+  withProvider(name, provider) {
+    this.providers[name] = provider;
+    return this;
+  }
+  /**
+   * Register multiple providers at once
+   */
+  withProviders(providers) {
+    this.providers = { ...this.providers, ...providers };
+    return this;
+  }
+  /**
+   * Register a plugin
+   *
+   * @example
+   * ```typescript
+   * .withPlugin(loggingPlugin())
+   * .withPlugin(auditPlugin({ store: saveToDb }))
+   * ```
+   */
+  withPlugin(plugin) {
+    this.plugins.push(plugin);
+    return this;
+  }
+  /**
+   * Register multiple plugins
+   */
+  withPlugins(plugins) {
+    this.plugins.push(...plugins);
+    return this;
+  }
+  /**
+   * Register event hooks (for backward compatibility)
+   *
+   * @example
+   * ```typescript
+   * .withHooks({
+   *   onPaymentVerified: async (tx) => { ... },
+   *   onSubscriptionRenewed: async (sub) => { ... },
+   * })
+   * ```
+   */
+  withHooks(hooks) {
+    this.hooks = { ...this.hooks, ...hooks };
+    return this;
+  }
+  /**
+   * Set retry configuration
+   *
+   * @example
+   * ```typescript
+   * .withRetry({ maxAttempts: 5, baseDelay: 2000 })
+   * ```
+   */
+  withRetry(config) {
+    this.options.retry = config;
+    return this;
+  }
+  /**
+   * Enable circuit breaker
+   */
+  withCircuitBreaker(enabled = true) {
+    this.options.circuitBreaker = enabled;
+    return this;
+  }
+  /**
+   * Set custom logger
+   */
+  withLogger(logger2) {
+    this.options.logger = logger2;
+    return this;
+  }
+  /**
+   * Set environment
+   */
+  forEnvironment(env) {
+    this.options.environment = env;
+    return this;
+  }
+  /**
+   * Enable debug mode
+   */
+  withDebug(enabled = true) {
+    this.options.debug = enabled;
+    return this;
+  }
+  /**
+   * Set commission rate (0-100)
+   */
+  withCommission(rate, gatewayFeeRate = 0) {
+    this.options.commissionRate = rate;
+    this.options.gatewayFeeRate = gatewayFeeRate;
+    return this;
+  }
+  /**
+   * Set category mappings (entity → category)
+   *
+   * @example
+   * ```typescript
+   * .withCategoryMappings({
+   *   PlatformSubscription: 'platform_subscription',
+   *   CourseEnrollment: 'course_enrollment',
+   *   ProductOrder: 'product_order',
+   * })
+   * ```
+   */
+  withCategoryMappings(mappings) {
+    this.categoryMappings = { ...this.categoryMappings, ...mappings };
+    return this;
+  }
+  /**
+   * Build the Revenue instance
+   */
+  build() {
+    if (!this.models) {
+      throw new ConfigurationError(
+        "Models are required. Use .withModels({ Transaction, Subscription })"
+      );
+    }
+    if (!this.models.Transaction) {
+      throw new ConfigurationError(
+        "Transaction model is required in models configuration"
+      );
+    }
+    if (Object.keys(this.providers).length === 0) {
+      throw new ConfigurationError(
+        "At least one provider is required. Use .withProvider(name, provider)"
+      );
+    }
+    const container = new Container();
+    const defaultLogger = {
+      debug: (msg, data) => this.options.debug && console.debug(`[Revenue] ${msg}`, data ?? ""),
+      info: (msg, data) => console.info(`[Revenue] ${msg}`, data ?? ""),
+      warn: (msg, data) => console.warn(`[Revenue] ${msg}`, data ?? ""),
+      error: (msg, data) => console.error(`[Revenue] ${msg}`, data ?? "")
+    };
+    const resolvedOptions = {
+      defaultCurrency: this.options.defaultCurrency ?? "USD",
+      environment: this.options.environment ?? "development",
+      debug: this.options.debug ?? false,
+      retry: this.options.retry ?? { maxAttempts: 3 },
+      idempotencyTtl: this.options.idempotencyTtl ?? 24 * 60 * 60 * 1e3,
+      circuitBreaker: this.options.circuitBreaker ?? false,
+      logger: this.options.logger ?? defaultLogger,
+      commissionRate: this.options.commissionRate ?? 0,
+      gatewayFeeRate: this.options.gatewayFeeRate ?? 0
+    };
+    const config = {
+      defaultCurrency: resolvedOptions.defaultCurrency,
+      commissionRate: resolvedOptions.commissionRate,
+      gatewayFeeRate: resolvedOptions.gatewayFeeRate,
+      categoryMappings: this.categoryMappings
+    };
+    container.singleton("models", this.models);
+    container.singleton("providers", this.providers);
+    container.singleton("hooks", this.hooks);
+    container.singleton("config", config);
+    const events = createEventBus();
+    const pluginManager = new PluginManager();
+    for (const plugin of this.plugins) {
+      pluginManager.register(plugin);
+    }
+    const revenue = new Revenue(
+      container,
+      events,
+      pluginManager,
+      resolvedOptions,
+      this.providers,
+      config
+    );
+    const ctx = revenue.createContext();
+    pluginManager.init(ctx).catch((err2) => {
+      resolvedOptions.logger.error("Failed to initialize plugins", err2);
+    });
+    return revenue;
+  }
+};
+function createRevenue(config) {
+  let builder = Revenue.create(config.options);
+  builder = builder.withModels(config.models);
+  builder = builder.withProviders(config.providers);
+  if (config.plugins) {
+    builder = builder.withPlugins(config.plugins);
+  }
+  if (config.hooks) {
+    builder = builder.withHooks(config.hooks);
+  }
+  return builder.build();
+}
+
+// src/utils/money.ts
+var CURRENCIES = {
+  USD: { code: "USD", decimals: 2, symbol: "$", name: "US Dollar" },
+  EUR: { code: "EUR", decimals: 2, symbol: "\u20AC", name: "Euro" },
+  GBP: { code: "GBP", decimals: 2, symbol: "\xA3", name: "British Pound" },
+  BDT: { code: "BDT", decimals: 2, symbol: "\u09F3", name: "Bangladeshi Taka" },
+  INR: { code: "INR", decimals: 2, symbol: "\u20B9", name: "Indian Rupee" },
+  JPY: { code: "JPY", decimals: 0, symbol: "\xA5", name: "Japanese Yen" },
+  CNY: { code: "CNY", decimals: 2, symbol: "\xA5", name: "Chinese Yuan" },
+  AED: { code: "AED", decimals: 2, symbol: "\u062F.\u0625", name: "UAE Dirham" },
+  SAR: { code: "SAR", decimals: 2, symbol: "\uFDFC", name: "Saudi Riyal" },
+  SGD: { code: "SGD", decimals: 2, symbol: "S$", name: "Singapore Dollar" },
+  AUD: { code: "AUD", decimals: 2, symbol: "A$", name: "Australian Dollar" },
+  CAD: { code: "CAD", decimals: 2, symbol: "C$", name: "Canadian Dollar" }
+};
+var Money = class _Money {
+  amount;
+  currency;
+  constructor(amount, currency) {
+    if (!Number.isInteger(amount)) {
+      throw new Error(`Money amount must be integer (smallest unit). Got: ${amount}`);
+    }
+    this.amount = amount;
+    this.currency = currency.toUpperCase();
+  }
+  // ============ FACTORY METHODS ============
+  /**
+   * Create money from smallest unit (cents, paisa)
+   * @example Money.cents(1999, 'USD') // $19.99
+   */
+  static cents(amount, currency = "USD") {
+    return new _Money(Math.round(amount), currency);
+  }
+  /**
+   * Create money from major unit (dollars, taka)
+   * @example Money.of(19.99, 'USD') // $19.99 (stored as 1999 cents)
+   */
+  static of(amount, currency = "USD") {
+    const config = CURRENCIES[currency.toUpperCase()] ?? { decimals: 2 };
+    const multiplier = Math.pow(10, config.decimals);
+    return new _Money(Math.round(amount * multiplier), currency);
+  }
+  /**
+   * Create zero money
+   */
+  static zero(currency = "USD") {
+    return new _Money(0, currency);
+  }
+  // ============ SHORTHAND FACTORIES ============
+  static usd(cents) {
+    return _Money.cents(cents, "USD");
+  }
+  static eur(cents) {
+    return _Money.cents(cents, "EUR");
+  }
+  static gbp(pence) {
+    return _Money.cents(pence, "GBP");
+  }
+  static bdt(paisa) {
+    return _Money.cents(paisa, "BDT");
+  }
+  static inr(paisa) {
+    return _Money.cents(paisa, "INR");
+  }
+  static jpy(yen) {
+    return _Money.cents(yen, "JPY");
+  }
+  // ============ ARITHMETIC ============
+  /**
+   * Add two money values (must be same currency)
+   */
+  add(other) {
+    this.assertSameCurrency(other);
+    return new _Money(this.amount + other.amount, this.currency);
+  }
+  /**
+   * Subtract money (must be same currency)
+   */
+  subtract(other) {
+    this.assertSameCurrency(other);
+    return new _Money(this.amount - other.amount, this.currency);
+  }
+  /**
+   * Multiply by a factor (rounds to nearest integer)
+   */
+  multiply(factor) {
+    return new _Money(Math.round(this.amount * factor), this.currency);
+  }
+  /**
+   * Divide by a divisor (rounds to nearest integer)
+   */
+  divide(divisor) {
+    if (divisor === 0) throw new Error("Cannot divide by zero");
+    return new _Money(Math.round(this.amount / divisor), this.currency);
+  }
+  /**
+   * Calculate percentage
+   * @example money.percentage(10) // 10% of money
+   */
+  percentage(percent) {
+    return this.multiply(percent / 100);
+  }
+  /**
+   * Allocate money among recipients (handles rounding)
+   * @example Money.usd(100).allocate([1, 1, 1]) // [34, 33, 33] cents
+   */
+  allocate(ratios) {
+    const total = ratios.reduce((a, b) => a + b, 0);
+    if (total === 0) throw new Error("Ratios must sum to more than 0");
+    let remainder = this.amount;
+    const results = [];
+    for (let i = 0; i < ratios.length; i++) {
+      const share = Math.floor(this.amount * ratios[i] / total);
+      results.push(new _Money(share, this.currency));
+      remainder -= share;
+    }
+    for (let i = 0; i < remainder; i++) {
+      results[i] = new _Money(results[i].amount + 1, this.currency);
+    }
+    return results;
+  }
+  /**
+   * Split equally among n recipients
+   */
+  split(parts) {
+    return this.allocate(Array(parts).fill(1));
+  }
+  // ============ COMPARISON ============
+  isZero() {
+    return this.amount === 0;
+  }
+  isPositive() {
+    return this.amount > 0;
+  }
+  isNegative() {
+    return this.amount < 0;
+  }
+  equals(other) {
+    return this.amount === other.amount && this.currency === other.currency;
+  }
+  greaterThan(other) {
+    this.assertSameCurrency(other);
+    return this.amount > other.amount;
+  }
+  lessThan(other) {
+    this.assertSameCurrency(other);
+    return this.amount < other.amount;
+  }
+  greaterThanOrEqual(other) {
+    return this.greaterThan(other) || this.equals(other);
+  }
+  lessThanOrEqual(other) {
+    return this.lessThan(other) || this.equals(other);
+  }
+  // ============ FORMATTING ============
+  /**
+   * Get amount in major unit (dollars, taka)
+   */
+  toUnit() {
+    const config = CURRENCIES[this.currency] ?? { decimals: 2 };
+    return this.amount / Math.pow(10, config.decimals);
+  }
+  /**
+   * Format for display
+   * @example Money.usd(1999).format() // "$19.99"
+   */
+  format(locale = "en-US") {
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: this.currency
+    }).format(this.toUnit());
+  }
+  /**
+   * Format without currency symbol
+   */
+  formatAmount(locale = "en-US") {
+    const config = CURRENCIES[this.currency] ?? { decimals: 2 };
+    return new Intl.NumberFormat(locale, {
+      minimumFractionDigits: config.decimals,
+      maximumFractionDigits: config.decimals
+    }).format(this.toUnit());
+  }
+  /**
+   * Convert to JSON-serializable object
+   */
+  toJSON() {
+    return { amount: this.amount, currency: this.currency };
+  }
+  /**
+   * Create from JSON
+   */
+  static fromJSON(json) {
+    return new _Money(json.amount, json.currency);
+  }
+  toString() {
+    return `${this.currency} ${this.amount}`;
+  }
+  // ============ HELPERS ============
+  assertSameCurrency(other) {
+    if (this.currency !== other.currency) {
+      throw new Error(
+        `Currency mismatch: ${this.currency} vs ${other.currency}. Convert first.`
+      );
+    }
+  }
+};
+function toSmallestUnit(amount, currency = "USD") {
+  return Money.of(amount, currency).amount;
+}
+function fromSmallestUnit(amount, currency = "USD") {
+  return Money.cents(amount, currency).toUnit();
+}
+var ObjectIdSchema = z.string().regex(
+  /^[a-fA-F0-9]{24}$/,
+  "Invalid ObjectId format"
+);
+var CurrencySchema = z.string().length(3, "Currency must be 3 characters").transform((val) => val.toUpperCase()).default("USD");
+var MoneyAmountSchema = z.number().int("Amount must be integer (smallest unit)").nonnegative("Amount cannot be negative");
+var MoneySchema = z.object({
+  amount: MoneyAmountSchema,
+  currency: z.string().length(3).default("USD")
+});
+var EmailSchema = z.string().email();
+var IdempotencyKeySchema = z.string().min(1).max(255).optional();
+var MetadataSchema = z.record(z.string(), z.unknown()).optional().default({});
+var CreatePaymentSchema = z.object({
+  /** Amount in smallest currency unit (cents) */
+  amount: MoneyAmountSchema,
+  /** ISO 4217 currency code */
+  currency: z.string().length(3).default("USD"),
+  /** Customer identifier */
+  customerId: z.string().min(1, "Customer ID is required"),
+  /** Organization/merchant identifier */
+  organizationId: z.string().min(1, "Organization ID is required"),
+  /** Payment provider to use */
+  provider: z.string().min(1, "Provider is required"),
+  /** Idempotency key for safe retries */
+  idempotencyKey: IdempotencyKeySchema,
+  /** Description of the payment */
+  description: z.string().optional(),
+  /** Additional metadata */
+  metadata: MetadataSchema,
+  /** Success redirect URL */
+  successUrl: z.string().url().optional(),
+  /** Cancel redirect URL */
+  cancelUrl: z.string().url().optional()
+});
+var VerifyPaymentSchema = z.object({
+  /** Transaction ID or payment intent ID */
+  id: z.string().min(1),
+  /** Provider name (optional, auto-detected) */
+  provider: z.string().optional(),
+  /** Additional verification data */
+  data: z.record(z.string(), z.unknown()).optional()
+});
+var RefundSchema = z.object({
+  /** Transaction ID to refund */
+  transactionId: z.string().min(1),
+  /** Amount to refund (optional, full refund if not provided) */
+  amount: MoneyAmountSchema.optional(),
+  /** Reason for refund */
+  reason: z.string().optional(),
+  /** Idempotency key */
+  idempotencyKey: IdempotencyKeySchema,
+  /** Additional metadata */
+  metadata: MetadataSchema
+});
+var SubscriptionStatusSchema = z.enum([
+  "pending",
+  "active",
+  "paused",
+  "cancelled",
+  "expired",
+  "past_due"
+]);
+var IntervalSchema = z.enum([
+  "day",
+  "week",
+  "month",
+  "year",
+  "one_time"
+]);
+var CreateSubscriptionSchema = z.object({
+  /** Customer ID */
+  customerId: z.string().min(1),
+  /** Organization ID */
+  organizationId: z.string().min(1),
+  /** Plan identifier */
+  planKey: z.string().min(1),
+  /** Amount per period (smallest unit) */
+  amount: MoneyAmountSchema,
+  /** Currency */
+  currency: z.string().length(3).default("USD"),
+  /** Billing interval */
+  interval: IntervalSchema.default("month"),
+  /** Interval count (e.g., 2 for bi-monthly) */
+  intervalCount: z.number().int().positive().default(1),
+  /** Payment provider */
+  provider: z.string().min(1),
+  /** Reference to external entity */
+  referenceId: z.string().optional(),
+  /** Reference model name */
+  referenceModel: z.string().optional(),
+  /** Idempotency key */
+  idempotencyKey: IdempotencyKeySchema,
+  /** Metadata */
+  metadata: MetadataSchema,
+  /** Trial period in days */
+  trialDays: z.number().int().nonnegative().optional()
+});
+var CancelSubscriptionSchema = z.object({
+  /** Subscription ID */
+  subscriptionId: z.string().min(1),
+  /** Cancel immediately or at period end */
+  immediate: z.boolean().default(false),
+  /** Cancellation reason */
+  reason: z.string().optional()
+});
+var MonetizationTypeSchema = z.enum([
+  "purchase",
+  "subscription",
+  "free"
+]);
+var CreateMonetizationSchema = z.object({
+  /** Type of monetization */
+  type: MonetizationTypeSchema.default("purchase"),
+  /** Amount (smallest unit) - required for purchase/subscription */
+  amount: MoneyAmountSchema.optional(),
+  /** Currency */
+  currency: z.string().length(3).default("USD"),
+  /** Customer ID */
+  customerId: z.string().min(1),
+  /** Organization ID */
+  organizationId: z.string().min(1),
+  /** Payment provider */
+  provider: z.string().min(1),
+  /** Plan key for categorization */
+  planKey: z.string().optional(),
+  /** Reference ID */
+  referenceId: z.string().optional(),
+  /** Reference model */
+  referenceModel: z.string().optional(),
+  /** Idempotency key */
+  idempotencyKey: IdempotencyKeySchema,
+  /** Metadata */
+  metadata: MetadataSchema,
+  /** Subscription-specific: interval */
+  interval: IntervalSchema.optional(),
+  /** Subscription-specific: trial days */
+  trialDays: z.number().int().nonnegative().optional()
+}).refine(
+  (data) => {
+    if (data.type !== "free" && !data.amount) {
+      return false;
+    }
+    return true;
+  },
+  { message: "Amount is required for non-free monetization types" }
+);
+var SplitRecipientSchema = z.object({
+  /** Recipient ID */
+  recipientId: z.string().min(1),
+  /** Recipient type (user, organization, etc.) */
+  recipientType: z.string().default("user"),
+  /** Percentage of net amount (0-100) */
+  percentage: z.number().min(0).max(100),
+  /** Role description */
+  role: z.string().optional()
+});
+var CommissionConfigSchema = z.object({
+  /** Platform commission rate (0-100) */
+  platformRate: z.number().min(0).max(100).default(0),
+  /** Gateway fee rate (0-100) */
+  gatewayFeeRate: z.number().min(0).max(100).default(0),
+  /** Fixed gateway fee (smallest unit) */
+  gatewayFixedFee: MoneyAmountSchema.default(0),
+  /** Split recipients */
+  splits: z.array(SplitRecipientSchema).optional(),
+  /** Affiliate configuration */
+  affiliate: z.object({
+    recipientId: z.string(),
+    recipientType: z.string().default("user"),
+    rate: z.number().min(0).max(100)
+  }).optional()
+});
+var HoldStatusSchema = z.enum([
+  "none",
+  "held",
+  "partial_release",
+  "released",
+  "cancelled"
+]);
+var CreateHoldSchema = z.object({
+  /** Transaction ID */
+  transactionId: z.string().min(1),
+  /** Hold amount (optional, defaults to full transaction amount) */
+  amount: MoneyAmountSchema.optional(),
+  /** Hold until date */
+  holdUntil: z.date().optional(),
+  /** Reason for hold */
+  reason: z.string().optional()
+});
+var ReleaseHoldSchema = z.object({
+  /** Transaction ID */
+  transactionId: z.string().min(1),
+  /** Amount to release (optional, full release if not provided) */
+  amount: MoneyAmountSchema.optional(),
+  /** Recipient ID */
+  recipientId: z.string().min(1),
+  /** Recipient type */
+  recipientType: z.string().default("user"),
+  /** Release notes */
+  notes: z.string().optional()
+});
+var ProviderConfigSchema = z.record(z.string(), z.unknown());
+var RetryConfigSchema = z.object({
+  /** Maximum retry attempts */
+  maxAttempts: z.number().int().positive().default(3),
+  /** Base delay in ms */
+  baseDelay: z.number().positive().default(1e3),
+  /** Maximum delay in ms */
+  maxDelay: z.number().positive().default(3e4),
+  /** Backoff multiplier */
+  backoffMultiplier: z.number().positive().default(2),
+  /** Jitter factor (0-1) */
+  jitter: z.number().min(0).max(1).default(0.1)
+});
+var RevenueConfigSchema = z.object({
+  /** Default currency */
+  defaultCurrency: z.string().length(3).default("USD"),
+  /** Commission configuration */
+  commission: CommissionConfigSchema.optional(),
+  /** Retry configuration */
+  retry: RetryConfigSchema.optional(),
+  /** Enable debug logging */
+  debug: z.boolean().default(false),
+  /** Environment */
+  environment: z.enum(["development", "staging", "production"]).default("development")
+});
+function validate(schema, data) {
+  return schema.parse(data);
+}
+function safeValidate(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}
+function formatZodError(error) {
+  return error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
+}
+
+// src/enums/payment.enums.ts
+var PAYMENT_STATUS = {
+  PENDING: "pending",
+  VERIFIED: "verified",
+  FAILED: "failed",
+  REFUNDED: "refunded",
+  CANCELLED: "cancelled"
+};
+var PAYMENT_STATUS_VALUES = Object.values(PAYMENT_STATUS);
+var PAYMENT_GATEWAY_TYPE = {
+  MANUAL: "manual",
+  STRIPE: "stripe",
+  SSLCOMMERZ: "sslcommerz"
+};
+var PAYMENT_GATEWAY_TYPE_VALUES = Object.values(PAYMENT_GATEWAY_TYPE);
+var GATEWAY_TYPES = PAYMENT_GATEWAY_TYPE;
+var GATEWAY_TYPE_VALUES = PAYMENT_GATEWAY_TYPE_VALUES;
+
+// src/enums/subscription.enums.ts
+var SUBSCRIPTION_STATUS = {
+  ACTIVE: "active",
+  PAUSED: "paused",
+  CANCELLED: "cancelled",
+  EXPIRED: "expired",
+  PENDING: "pending",
+  INACTIVE: "inactive"
+};
+var SUBSCRIPTION_STATUS_VALUES = Object.values(SUBSCRIPTION_STATUS);
+var PLAN_KEYS = {
+  MONTHLY: "monthly",
+  QUARTERLY: "quarterly",
+  YEARLY: "yearly"
+};
+var PLAN_KEY_VALUES = Object.values(PLAN_KEYS);
+var baseMetadataSchema = new Schema(
+  {
+    // Flexible key-value metadata
+  },
+  { _id: false, strict: false }
+);
+var referenceSchema = {
+  referenceId: {
+    type: Schema.Types.ObjectId,
+    refPath: "referenceModel",
+    index: true
+  },
+  referenceModel: {
+    type: String,
+    enum: ["Subscription", "Order", "Membership", "Booking", "Invoice"]
+  }
+};
+var gatewaySchema = new Schema(
+  {
+    type: {
+      type: String,
+      required: true,
+      index: true
+    },
+    sessionId: {
+      type: String,
+      sparse: true,
+      index: true
+    },
+    paymentIntentId: {
+      type: String,
+      sparse: true,
+      index: true
+    },
+    provider: {
+      type: String
+    },
+    metadata: {
+      type: Schema.Types.Mixed,
+      default: {}
+    },
+    verificationData: {
+      type: Schema.Types.Mixed
+    }
+  },
+  { _id: false }
+);
+var currentPaymentSchema = new Schema(
+  {
+    transactionId: {
+      type: Schema.Types.ObjectId,
+      ref: "Transaction",
+      index: true
+    },
+    amount: {
+      type: Number,
+      min: 0
+    },
+    status: {
+      type: String,
+      enum: PAYMENT_STATUS_VALUES,
+      default: "pending",
+      index: true
+    },
+    method: {
+      type: String
+      // Users define payment methods in their transaction model
+    },
+    reference: {
+      type: String,
+      trim: true
+    },
+    verifiedAt: {
+      type: Date
+    },
+    verifiedBy: {
+      type: Schema.Types.ObjectId,
+      ref: "User"
+    },
+    // Refund tracking fields
+    refundedAmount: {
+      type: Number,
+      default: 0,
+      min: 0
+    },
+    refundedAt: {
+      type: Date
+    }
+  },
+  { _id: false }
+);
+var paymentSummarySchema = new Schema(
+  {
+    totalPayments: {
+      type: Number,
+      default: 0,
+      min: 0
+    },
+    totalAmountPaid: {
+      type: Number,
+      default: 0,
+      min: 0
+    },
+    lastPaymentDate: {
+      type: Date
+    },
+    lastPaymentAmount: {
+      type: Number,
+      min: 0
+    }
+  },
+  { _id: false }
+);
+var paymentDetailsSchema = new Schema(
+  {
+    provider: { type: String },
+    walletNumber: { type: String },
+    walletType: { type: String },
+    trxId: { type: String },
+    bankName: { type: String },
+    accountNumber: { type: String },
+    accountName: { type: String },
+    proofUrl: { type: String }
+  },
+  { _id: false }
+);
+var tenantSnapshotSchema = new Schema(
+  {
+    paymentInstructions: { type: String },
+    bkashNumber: { type: String },
+    nagadNumber: { type: String },
+    bankAccount: { type: String }
+  },
+  { _id: false }
+);
+var commissionSchema = new Schema(
+  {
+    // Commission rate (e.g., 0.10 for 10%)
+    rate: {
+      type: Number,
+      min: 0,
+      max: 1
+    },
+    // Gross commission amount (before gateway fees)
+    grossAmount: {
+      type: Number,
+      min: 0
+    },
+    // Gateway fee rate (e.g., 0.029 for 2.9%)
+    gatewayFeeRate: {
+      type: Number,
+      min: 0,
+      max: 1
+    },
+    // Gateway fee amount deducted from commission
+    gatewayFeeAmount: {
+      type: Number,
+      min: 0
+    },
+    // Net commission (grossAmount - gatewayFeeAmount)
+    netAmount: {
+      type: Number,
+      min: 0
+    },
+    // Commission status
+    status: {
+      type: String,
+      enum: ["pending", "paid", "waived", "reversed"],
+      default: "pending"
+    },
+    // For affiliate tracking
+    affiliate: {
+      recipientId: String,
+      recipientType: {
+        type: String,
+        enum: ["user", "organization", "partner"]
+      },
+      rate: Number,
+      grossAmount: Number,
+      netAmount: Number
+    },
+    // For multi-party splits
+    splits: [
+      {
+        type: String,
+        recipientId: String,
+        rate: Number,
+        grossAmount: Number,
+        netAmount: Number
+      }
+    ]
+  },
+  { _id: false }
+);
+var planSchema = new Schema(
+  {
+    key: {
+      type: String,
+      enum: PLAN_KEY_VALUES,
+      required: true
+    },
+    name: {
+      type: String,
+      required: true
+    },
+    description: {
+      type: String
+    },
+    amount: {
+      type: Number,
+      required: true,
+      min: 0
+    },
+    currency: {
+      type: String,
+      default: "BDT"
+    },
+    interval: {
+      type: String,
+      enum: ["day", "week", "month", "year"],
+      default: "month"
+    },
+    intervalCount: {
+      type: Number,
+      default: 1,
+      min: 1
+    },
+    features: [
+      {
+        type: String
+      }
+    ],
+    metadata: {
+      type: Schema.Types.Mixed,
+      default: {}
+    },
+    isActive: {
+      type: Boolean,
+      default: true
+    }
+  },
+  { _id: false }
+);
+var subscriptionInfoSchema = new Schema(
+  {
+    planKey: {
+      type: String,
+      enum: PLAN_KEY_VALUES,
+      required: true
+    },
+    status: {
+      type: String,
+      enum: SUBSCRIPTION_STATUS_VALUES,
+      default: "pending",
+      index: true
+    },
+    isActive: {
+      type: Boolean,
+      default: false,
+      index: true
+    },
+    startDate: {
+      type: Date
+    },
+    endDate: {
+      type: Date,
+      index: true
+    },
+    canceledAt: {
+      type: Date
+    },
+    cancelAt: {
+      type: Date
+    },
+    pausedAt: {
+      type: Date
+    },
+    lastPaymentDate: {
+      type: Date
+    },
+    lastPaymentAmount: {
+      type: Number
+    },
+    renewalCount: {
+      type: Number,
+      default: 0
+    }
+  },
+  { _id: false }
+);
+
+// src/schemas/escrow/hold.schema.ts
+var holdSchema = {
+  status: {
+    type: String,
+    enum: HOLD_STATUS_VALUES,
+    default: HOLD_STATUS.PENDING,
+    index: true
+  },
+  heldAmount: {
+    type: Number,
+    required: false
+  },
+  releasedAmount: {
+    type: Number,
+    default: 0
+  },
+  reason: {
+    type: String,
+    enum: HOLD_REASON_VALUES,
+    required: false
+  },
+  holdUntil: {
+    type: Date,
+    required: false
+  },
+  heldAt: Date,
+  releasedAt: Date,
+  cancelledAt: Date,
+  releases: [
+    {
+      amount: Number,
+      recipientId: String,
+      recipientType: String,
+      releasedAt: Date,
+      releasedBy: String,
+      reason: String,
+      metadata: Object
+    }
+  ],
+  metadata: {
+    type: Object,
+    default: {}
+  }
+};
+var splitSchema = new Schema(
+  {
+    type: {
+      type: String,
+      enum: SPLIT_TYPE_VALUES,
+      required: true
+    },
+    recipientId: {
+      type: String,
+      required: true,
+      index: true
+    },
+    recipientType: {
+      type: String,
+      enum: ["platform", "organization", "user", "affiliate", "partner"],
+      required: true
+    },
+    rate: {
+      type: Number,
+      required: true,
+      min: 0,
+      max: 1
+    },
+    grossAmount: {
+      type: Number,
+      required: true,
+      min: 0
+    },
+    gatewayFeeRate: {
+      type: Number,
+      default: 0,
+      min: 0,
+      max: 1
+    },
+    gatewayFeeAmount: {
+      type: Number,
+      default: 0,
+      min: 0
+    },
+    netAmount: {
+      type: Number,
+      required: true,
+      min: 0
+    },
+    status: {
+      type: String,
+      enum: SPLIT_STATUS_VALUES,
+      default: SPLIT_STATUS.PENDING,
+      index: true
+    },
+    dueDate: {
+      type: Date
+    },
+    paidDate: {
+      type: Date
+    },
+    payoutMethod: {
+      type: String,
+      enum: PAYOUT_METHOD_VALUES
+    },
+    payoutTransactionId: {
+      type: String
+    },
+    metadata: {
+      type: Schema.Types.Mixed,
+      default: {}
+    }
+  },
+  { _id: false }
+);
+
+// src/utils/transaction-type.ts
+var TRANSACTION_MANAGEMENT_TYPE = {
+  MONETIZATION: "monetization",
+  // Library-managed (subscriptions, purchases)
+  MANUAL: "manual"
+  // Admin-managed (expenses, income, adjustments)
+};
+var DEFAULT_MONETIZATION_CATEGORIES = [
+  "subscription",
+  "purchase"
+];
+function isMonetizationCategory(category, additionalCategories = []) {
+  const allCategories = [...DEFAULT_MONETIZATION_CATEGORIES, ...additionalCategories];
+  return allCategories.includes(category);
+}
+function isMonetizationTransaction(transaction, options = {}) {
+  const {
+    targetModels = ["Subscription", "Membership"],
+    additionalCategories = []
+  } = options;
+  if (transaction.referenceModel && targetModels.includes(transaction.referenceModel)) {
+    return true;
+  }
+  if (transaction.category) {
+    return isMonetizationCategory(transaction.category, additionalCategories);
+  }
+  return false;
+}
+function isManualTransaction(transaction, options = {}) {
+  return !isMonetizationTransaction(transaction, options);
+}
+function getTransactionType(transaction, options = {}) {
+  return isMonetizationTransaction(transaction, options) ? TRANSACTION_MANAGEMENT_TYPE.MONETIZATION : TRANSACTION_MANAGEMENT_TYPE.MANUAL;
+}
+var PROTECTED_MONETIZATION_FIELDS = [
+  "status",
+  "amount",
+  "platformCommission",
+  "netAmount",
+  "verifiedAt",
+  "verifiedBy",
+  "gateway",
+  "webhook",
+  "metadata.commission",
+  "metadata.gateway",
+  "type",
+  "category",
+  "referenceModel",
+  "referenceId"
+];
+var EDITABLE_MONETIZATION_FIELDS_PRE_VERIFICATION = [
+  "reference",
+  "paymentDetails",
+  "notes"
+];
+var MANUAL_TRANSACTION_CREATE_FIELDS = [
+  "organizationId",
+  "type",
+  "category",
+  "amount",
+  "method",
+  "reference",
+  "paymentDetails",
+  "notes",
+  "date",
+  // Transaction date (can be backdated)
+  "description"
+];
+var MANUAL_TRANSACTION_UPDATE_FIELDS = [
+  "amount",
+  "method",
+  "reference",
+  "paymentDetails",
+  "notes",
+  "date",
+  "description"
+];
+function getAllowedUpdateFields(transaction, options = {}) {
+  const type = getTransactionType(transaction, options);
+  if (type === TRANSACTION_MANAGEMENT_TYPE.MONETIZATION) {
+    if (transaction.status === "pending") {
+      return EDITABLE_MONETIZATION_FIELDS_PRE_VERIFICATION;
+    }
+    return [];
+  }
+  if (transaction.status === "verified" || transaction.status === "completed") {
+    return ["notes"];
+  }
+  return MANUAL_TRANSACTION_UPDATE_FIELDS;
+}
+function validateFieldUpdate(transaction, fieldName, options = {}) {
+  const allowedFields = getAllowedUpdateFields(transaction, options);
+  if (allowedFields.includes(fieldName)) {
+    return { allowed: true };
+  }
+  const type = getTransactionType(transaction, options);
+  if (type === TRANSACTION_MANAGEMENT_TYPE.MONETIZATION) {
+    if (PROTECTED_MONETIZATION_FIELDS.includes(fieldName)) {
+      return {
+        allowed: false,
+        reason: `Field "${fieldName}" is protected for monetization transactions. Updates must go through payment flow.`
+      };
+    }
+  }
+  return {
+    allowed: false,
+    reason: `Field "${fieldName}" cannot be updated for ${transaction.status} transactions.`
+  };
+}
+function canSelfVerify(transaction, options = {}) {
+  const type = getTransactionType(transaction, options);
+  if (type === TRANSACTION_MANAGEMENT_TYPE.MANUAL) {
+    return transaction.status === "pending";
+  }
+  return false;
+}
+
+// src/utils/logger.ts
+var _logger = console;
+function setLogger(customLogger) {
+  _logger = customLogger;
+}
+var logger = {
+  info: (...args) => {
+    (_logger.info ?? _logger.log)?.call(_logger, ...args);
+  },
+  warn: (...args) => {
+    (_logger.warn ?? _logger.log)?.call(_logger, "WARN:", ...args);
+  },
+  error: (...args) => {
+    (_logger.error ?? _logger.log)?.call(_logger, "ERROR:", ...args);
+  },
+  debug: (...args) => {
+    (_logger.debug ?? _logger.log)?.call(_logger, "DEBUG:", ...args);
+  }
+};
+
+// src/utils/subscription/period.ts
+function addDuration(startDate, duration, unit = "days") {
+  const date2 = new Date(startDate);
+  switch (unit) {
+    case "months":
+    case "month":
+      date2.setMonth(date2.getMonth() + duration);
+      return date2;
+    case "years":
+    case "year":
+      date2.setFullYear(date2.getFullYear() + duration);
+      return date2;
+    case "weeks":
+    case "week":
+      date2.setDate(date2.getDate() + duration * 7);
+      return date2;
+    case "days":
+    case "day":
+    default:
+      date2.setDate(date2.getDate() + duration);
+      return date2;
+  }
+}
+function calculatePeriodRange(params) {
+  const {
+    currentEndDate = null,
+    startDate = null,
+    duration,
+    unit = "days",
+    now = /* @__PURE__ */ new Date()
+  } = params;
+  let periodStart;
+  if (startDate) {
+    periodStart = new Date(startDate);
+  } else if (currentEndDate) {
+    const end = new Date(currentEndDate);
+    periodStart = end > now ? end : now;
+  } else {
+    periodStart = now;
+  }
+  const periodEnd = addDuration(periodStart, duration, unit);
+  return { startDate: periodStart, endDate: periodEnd };
+}
+function calculateProratedAmount(params) {
+  const {
+    amountPaid,
+    startDate,
+    endDate,
+    asOfDate = /* @__PURE__ */ new Date(),
+    precision = 2
+  } = params;
+  if (!amountPaid || amountPaid <= 0) return 0;
+  const start = new Date(startDate);
+  const end = new Date(endDate);
+  const asOf = new Date(asOfDate);
+  const totalMs = end.getTime() - start.getTime();
+  if (totalMs <= 0) return 0;
+  const remainingMs = Math.max(0, end.getTime() - asOf.getTime());
+  if (remainingMs <= 0) return 0;
+  const ratio = remainingMs / totalMs;
+  const amount = amountPaid * ratio;
+  const factor = 10 ** precision;
+  return Math.round(amount * factor) / factor;
+}
+function resolveIntervalToDuration(interval = "month", intervalCount = 1) {
+  const normalized = (interval || "month").toLowerCase();
+  const count = Number(intervalCount) > 0 ? Number(intervalCount) : 1;
+  switch (normalized) {
+    case "year":
+    case "years":
+      return { duration: count, unit: "years" };
+    case "week":
+    case "weeks":
+      return { duration: count, unit: "weeks" };
+    case "quarter":
+    case "quarters":
+      return { duration: count * 3, unit: "months" };
+    case "day":
+    case "days":
+      return { duration: count, unit: "days" };
+    case "month":
+    case "months":
+    default:
+      return { duration: count, unit: "months" };
+  }
+}
+
+// src/utils/subscription/actions.ts
+function isSubscriptionActive(subscription) {
+  if (!subscription) return false;
+  if (!subscription.isActive) return false;
+  if (subscription.endDate) {
+    const now = /* @__PURE__ */ new Date();
+    const endDate = new Date(subscription.endDate);
+    if (endDate < now) return false;
+  }
+  return true;
+}
+function canRenewSubscription(entity) {
+  if (!entity?.subscription) return false;
+  return isSubscriptionActive(entity.subscription);
+}
+function canCancelSubscription(entity) {
+  if (!entity?.subscription) return false;
+  if (!isSubscriptionActive(entity.subscription)) return false;
+  return !entity.subscription.canceledAt;
+}
+function canPauseSubscription(entity) {
+  if (!entity?.subscription) return false;
+  if (entity.status === SUBSCRIPTION_STATUS.PAUSED) return false;
+  if (entity.status === SUBSCRIPTION_STATUS.CANCELLED) return false;
+  return isSubscriptionActive(entity.subscription);
+}
+function canResumeSubscription(entity) {
+  if (!entity?.subscription) return false;
+  return entity.status === SUBSCRIPTION_STATUS.PAUSED;
+}
+
+// src/index.ts
+var index_default = {
+  Revenue,
+  createRevenue,
+  PaymentProvider,
+  RevenueError,
+  Money,
+  Result,
+  EventBus
+};
+/**
+ * @classytic/revenue
+ * Enterprise Revenue Management System
+ *
+ * Modern • Type-safe • Resilient • Composable
+ *
+ * @version 1.0.0
+ * @author Classytic
+ * @license MIT
+ */
+
+export { AlreadyVerifiedError, CancelSubscriptionSchema, CircuitBreaker, CircuitOpenError, CommissionConfigSchema, ConfigurationError, Container, CreateHoldSchema, CreateMonetizationSchema, CreatePaymentSchema, CreateSubscriptionSchema, CurrencySchema, EDITABLE_MONETIZATION_FIELDS_PRE_VERIFICATION, ERROR_CODES, EmailSchema, EscrowService, EventBus, GATEWAY_TYPES, GATEWAY_TYPE_VALUES, HOLD_REASON, HOLD_REASON_VALUES, HOLD_STATUS, HOLD_STATUS_VALUES, HoldStatusSchema, IdempotencyError, IdempotencyKeySchema, IdempotencyManager, IntervalSchema, InvalidAmountError, InvalidStateTransitionError, LIBRARY_CATEGORIES, LIBRARY_CATEGORY_VALUES, MANUAL_TRANSACTION_CREATE_FIELDS, MANUAL_TRANSACTION_UPDATE_FIELDS, MONETIZATION_TYPES, MONETIZATION_TYPE_VALUES, MemoryIdempotencyStore, MetadataSchema, MissingRequiredFieldError, ModelNotRegisteredError, MonetizationService, MonetizationTypeSchema, Money, MoneyAmountSchema, MoneySchema, NotFoundError, ObjectIdSchema, OperationError, PAYMENT_GATEWAY_TYPE, PAYMENT_GATEWAY_TYPE_VALUES, PAYMENT_STATUS, PAYMENT_STATUS_VALUES, PAYOUT_METHOD, PAYOUT_METHOD_VALUES, PLAN_KEYS, PLAN_KEY_VALUES, PROTECTED_MONETIZATION_FIELDS, PaymentIntent, PaymentIntentCreationError, PaymentProvider, PaymentResult, PaymentService, PaymentVerificationError, PluginManager, ProviderCapabilityError, ProviderConfigSchema, ProviderError, ProviderNotFoundError, RELEASE_REASON, RELEASE_REASON_VALUES, RefundError, RefundNotSupportedError, RefundResult, RefundSchema, ReleaseHoldSchema, Result, RetryConfigSchema, RetryExhaustedError, Revenue, RevenueBuilder, RevenueConfigSchema, RevenueError, SPLIT_STATUS, SPLIT_STATUS_VALUES, SPLIT_TYPE, SPLIT_TYPE_VALUES, SUBSCRIPTION_STATUS, SUBSCRIPTION_STATUS_VALUES, SplitRecipientSchema, StateError, SubscriptionNotActiveError, SubscriptionNotFoundError, SubscriptionStatusSchema, TRANSACTION_MANAGEMENT_TYPE, TRANSACTION_STATUS, TRANSACTION_STATUS_VALUES, TRANSACTION_TYPE, TRANSACTION_TYPE_VALUES, TransactionNotFoundError, TransactionService, ValidationError, VerifyPaymentSchema, WebhookEvent, addDuration, all, auditPlugin, baseMetadataSchema, calculateCommission, calculateCommissionWithSplits, calculateDelay, calculateOrganizationPayout, calculatePeriodRange, calculateProratedAmount, calculateSplits, canCancelSubscription, canPauseSubscription, canRenewSubscription, canResumeSubscription, canSelfVerify, commissionSchema, createCircuitBreaker, createEventBus, createIdempotencyManager, createRevenue, currentPaymentSchema, index_default as default, definePlugin, err, flatMap, formatZodError, fromSmallestUnit, gatewaySchema, getAllowedUpdateFields, getTransactionType, holdSchema, isCategoryValid, isErr, isManualTransaction, isMonetizationTransaction, isOk, isRetryable, isRetryableError, isRevenueError, isSubscriptionActive, logger, loggingPlugin, map, mapErr, match, metricsPlugin, ok, paymentDetailsSchema, paymentSummarySchema, planSchema, referenceSchema, resilientExecute, resolveCategory, resolveIntervalToDuration, retry, retryWithResult, reverseCommission, reverseSplits, safeValidate, setLogger, splitSchema, subscriptionInfoSchema, tenantSnapshotSchema, toSmallestUnit, tryCatch, tryCatchSync, unwrap, unwrapOr, validate, validateFieldUpdate };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map