@classytic/revenue 1.1.2 → 1.1.4

package/dist/utils/{index.d.ts → index.d.mts}

@@ -1,18 +1,9 @@
-import { C as CommissionInfo, c as SplitRule, a as SplitInfo, d as MonetizationTypeValue, T as TransactionDocument, e as TransactionTypeOptions, F as FieldUpdateValidationResult, L as Logger, f as PeriodRangeParams, g as PeriodRangeResult, h as ProratedAmountParams, D as DurationResult, S as SubscriptionDocument, i as SubscriptionEntity } from '../index-cLJBLUvx.js';
-import { T as TaxConfig, a as TaxCalculation, b as TaxType } from '../tax-CV8A0sxl.js';
-export { M as Money, a as MoneyValue, f as fromSmallestUnit, t as toSmallestUnit } from '../money-widWVD7r.js';
-import { R as Result } from '../retry-D4hFUwVk.js';
-export { C as CircuitBreaker, l as CircuitBreakerConfig, n as CircuitState, k as RetryConfig, j as createCircuitBreaker, r as retry } from '../retry-D4hFUwVk.js';
-import 'mongoose';
-import '@classytic/shared-types';
-
-/**
- * Commission Calculation Utility
- * @classytic/revenue
- *
- * Handles platform commission calculation with gateway fee deduction
- */
+import { B as TransactionDocument, E as ProratedAmountParams, F as SplitInfo, L as SplitRule, R as SubscriptionDocument, T as PeriodRangeResult, U as TransactionTypeOptions, c as FieldUpdateValidationResult, d as Logger, i as CommissionInfo, m as MonetizationTypeValue, o as DurationResult, w as PeriodRangeParams, z as SubscriptionEntity } from "../index-Dsp7H5Wb.mjs";
+import { a as createCircuitBreaker, i as RetryConfig, l as Result, n as CircuitBreakerConfig, o as retry, r as CircuitState, t as CircuitBreaker } from "../retry-HHCOXYdn.mjs";
+import { i as toSmallestUnit, n as MoneyValue, r as fromSmallestUnit, t as Money } from "../money-DPG8AtJ8.mjs";
+import { n as TaxConfig, r as TaxType, t as TaxCalculation } from "../tax-BoCt5cEd.mjs";
 
+//#region src/shared/utils/calculators/commission.d.ts
 /**
  * Build commission object for transaction
  *
@@ -31,15 +22,8 @@ declare function calculateCommission(amount: number, commissionRate: number, gat
  * @returns Reversed commission or null
  */
 declare function reverseCommission(originalCommission: CommissionInfo | null | undefined, originalAmount: number, refundAmount: number): CommissionInfo | null;
-
-/**
- * Tax Utilities
- * @classytic/revenue
- *
- * Tax calculation utilities
- * Philosophy: Apps provide rates, library does math (like Stripe)
- */
-
+//#endregion
+//#region src/shared/utils/calculators/tax.d.ts
 /**
  * Calculate tax for a transaction
  *
@@ -140,18 +124,12 @@ declare function getTaxType(transactionFlow: 'inflow' | 'outflow', category: str
  * ```
  */
 declare function reverseTax(originalTax: TaxCalculation & {
-    type?: TaxType;
+  type?: TaxType;
 }, originalAmount: number, refundAmount: number): TaxCalculation & {
-    type?: TaxType;
+  type?: TaxType;
 };
-
-/**
- * Commission Split Utilities
- * @classytic/revenue
- *
- * Multi-party commission split calculation for affiliate/referral systems
- */
-
+//#endregion
+//#region src/shared/utils/calculators/commission-split.d.ts
 /**
  * Calculate multi-party commission splits
  *
@@ -190,104 +168,91 @@ declare function calculateOrganizationPayout(amount: number, splits?: SplitInfo[
  * @returns Reversed splits
  */
 declare function reverseSplits(originalSplits: SplitInfo[] | undefined | null, originalAmount: number, refundAmount: number): SplitInfo[];
-
-/**
- * Idempotency Utilities
- * @classytic/revenue
- *
- * Prevent duplicate operations with idempotency keys
- * Inspired by: Stripe, Amazon SQS deduplication
- */
-
+//#endregion
+//#region src/shared/utils/resilience/idempotency.d.ts
 interface IdempotencyRecord<T = unknown> {
-    /** Idempotency key */
-    key: string;
-    /** Operation result (if completed) */
-    result?: T;
-    /** Operation status */
-    status: 'pending' | 'completed' | 'failed';
-    /** Creation timestamp */
-    createdAt: Date;
-    /** Completion timestamp */
-    completedAt?: Date;
-    /** Request hash for validation */
-    requestHash: string;
-    /** TTL - when record expires */
-    expiresAt: Date;
+  /** Idempotency key */
+  key: string;
+  /** Operation result (if completed) */
+  result?: T;
+  /** Operation status */
+  status: 'pending' | 'completed' | 'failed';
+  /** Creation timestamp */
+  createdAt: Date;
+  /** Completion timestamp */
+  completedAt?: Date;
+  /** Request hash for validation */
+  requestHash: string;
+  /** TTL - when record expires */
+  expiresAt: Date;
 }
 interface IdempotencyStore {
-    /** Get record by key */
-    get<T>(key: string): Promise<IdempotencyRecord<T> | null>;
-    /** Set or update record */
-    set<T>(key: string, record: IdempotencyRecord<T>): Promise<void>;
-    /** Delete record */
-    delete(key: string): Promise<void>;
-    /** Check if key exists */
-    exists(key: string): Promise<boolean>;
+  /** Get record by key */
+  get<T>(key: string): Promise<IdempotencyRecord<T> | null>;
+  /** Set or update record */
+  set<T>(key: string, record: IdempotencyRecord<T>): Promise<void>;
+  /** Delete record */
+  delete(key: string): Promise<void>;
+  /** Check if key exists */
+  exists(key: string): Promise<boolean>;
 }
 interface IdempotencyConfig {
-    /** TTL in milliseconds (default: 24 hours) */
-    ttl?: number;
-    /** Custom store implementation */
-    store?: IdempotencyStore;
-    /** Key prefix */
-    prefix?: string;
+  /** TTL in milliseconds (default: 24 hours) */
+  ttl?: number;
+  /** Custom store implementation */
+  store?: IdempotencyStore;
+  /** Key prefix */
+  prefix?: string;
 }
 declare class IdempotencyError extends Error {
-    readonly code: 'DUPLICATE_REQUEST' | 'REQUEST_IN_PROGRESS' | 'REQUEST_MISMATCH';
-    constructor(message: string, code: 'DUPLICATE_REQUEST' | 'REQUEST_IN_PROGRESS' | 'REQUEST_MISMATCH');
+  readonly code: 'DUPLICATE_REQUEST' | 'REQUEST_IN_PROGRESS' | 'REQUEST_MISMATCH';
+  constructor(message: string, code: 'DUPLICATE_REQUEST' | 'REQUEST_IN_PROGRESS' | 'REQUEST_MISMATCH');
 }
 /**
  * Idempotency manager
  */
 declare class IdempotencyManager {
-    private store;
-    private ttl;
-    private prefix;
-    constructor(config?: IdempotencyConfig);
-    /**
-     * Generate a unique idempotency key
-     */
-    generateKey(): string;
-    /**
-     * Hash request parameters for validation
-     * Uses deterministic JSON serialization and simple hash function
-     */
-    private hashRequest;
-    /**
-     * Execute operation with idempotency protection
-     */
-    execute<T>(key: string, params: unknown, operation: () => Promise<T>): Promise<Result<T, IdempotencyError>>;
-    /**
-     * Check if operation with key was already completed
-     */
-    wasCompleted(key: string): Promise<boolean>;
-    /**
-     * Get cached result for key
-     */
-    getCached<T>(key: string): Promise<T | null>;
-    /**
-     * Invalidate a key (force re-execution on next call)
-     */
-    invalidate(key: string): Promise<void>;
-    /**
-     * Destroy the idempotency manager and cleanup resources
-     * Call this when shutting down to prevent memory leaks
-     */
-    destroy(): void;
+  private store;
+  private ttl;
+  private prefix;
+  constructor(config?: IdempotencyConfig);
+  /**
+   * Generate a unique idempotency key
+   */
+  generateKey(): string;
+  /**
+   * Hash request parameters for validation
+   * Uses deterministic JSON serialization and simple hash function
+   */
+  private hashRequest;
+  /**
+   * Execute operation with idempotency protection
+   */
+  execute<T>(key: string, params: unknown, operation: () => Promise<T>): Promise<Result<T, IdempotencyError>>;
+  /**
+   * Check if operation with key was already completed
+   */
+  wasCompleted(key: string): Promise<boolean>;
+  /**
+   * Get cached result for key
+   */
+  getCached<T>(key: string): Promise<T | null>;
+  /**
+   * Invalidate a key (force re-execution on next call)
+   */
+  invalidate(key: string): Promise<void>;
+  /**
+   * Destroy the idempotency manager and cleanup resources
+   * Call this when shutting down to prevent memory leaks
+   */
+  destroy(): void;
 }
 /**
  * Create idempotency manager
  */
 declare function createIdempotencyManager(config?: IdempotencyConfig): IdempotencyManager;
-
-/**
- * Category Resolver Utility
- * @classytic/revenue
- *
- * Resolves transaction category based on categoryMappings
- */
-
+//#endregion
+//#region src/shared/utils/validators/category-resolver.d.ts
 /**
  * Resolve category for a transaction based on entity and monetizationType
  *
@@ -324,23 +289,14 @@ declare function createIdempotencyManager(config?: IdempotencyConfig): Idempoten
  * // Returns: 'platform_subscription'
  */
 declare function resolveCategory(entity: string | null | undefined, monetizationType: MonetizationTypeValue, categoryMappings?: Record<string, string>): string;
-
-/**
- * Transaction Type Detection & Classification
- *
- * Distinguishes between:
- * - Monetization-managed transactions (library-controlled, strict rules)
- * - Manual admin transactions (flexible, admin-controlled)
- *
- * @module @classytic/revenue/utils/transaction-type
- */
-
+//#endregion
+//#region src/utils/transaction-type.d.ts
 /**
  * Transaction types with different protection rules
  */
 declare const TRANSACTION_MANAGEMENT_TYPE: {
-    readonly MONETIZATION: "monetization";
-    readonly MANUAL: "manual";
+  readonly MONETIZATION: "monetization";
+  readonly MANUAL: "manual";
 };
 type TransactionManagementType = typeof TRANSACTION_MANAGEMENT_TYPE[keyof typeof TRANSACTION_MANAGEMENT_TYPE];
 /**
@@ -416,22 +372,8 @@ declare function validateFieldUpdate(transaction: Partial<TransactionDocument>,
  * @param options - Options for transaction type detection
  */
 declare function canSelfVerify(transaction: Partial<TransactionDocument>, options?: TransactionTypeOptions): boolean;
-
-/**
- * Logger Abstraction for Monetization Library
- *
- * Defaults to console for standalone usage
- * Can be overridden with custom logger (pino, winston, etc)
- *
- * Usage:
- * ```typescript
- * import { setLogger } from '@classytic/revenue';
- *
- * // Optional: Use your own logger
- * setLogger(myPinoLogger);
- * ```
- */
-
+//#endregion
+//#region src/utils/logger.d.ts
 /**
  * Set custom logger implementation
  * @param customLogger - Logger instance with info, warn, error, debug methods
@@ -441,14 +383,8 @@ declare function setLogger(customLogger: Logger): void;
  * Logger proxy - delegates to current logger implementation
  */
 declare const logger: Logger;
-
-/**
- * Subscription Period Utilities
- * @classytic/revenue/utils/subscription
- *
- * Universal period calculation, proration, and date utilities
- */
-
+//#endregion
+//#region src/utils/subscription/period.d.ts
 type DurationUnit = 'days' | 'day' | 'weeks' | 'week' | 'months' | 'month' | 'years' | 'year';
 /**
  * Add duration to date
@@ -466,14 +402,8 @@ declare function calculateProratedAmount(params: ProratedAmountParams): number;
  * Convert interval + count to duration/unit
  */
 declare function resolveIntervalToDuration(interval?: string, intervalCount?: number): DurationResult;
-
-/**
- * Subscription Action Utilities
- * @classytic/revenue/utils/subscription
- *
- * Eligibility checks for subscription actions
- */
-
+//#endregion
+//#region src/utils/subscription/actions.d.ts
 /**
  * Check if subscription is active
  */
@@ -494,5 +424,5 @@ declare function canPauseSubscription(entity: SubscriptionEntity | null | undefi
  * Check if can resume
  */
 declare function canResumeSubscription(entity: SubscriptionEntity | null | undefined): boolean;
-
-export { type DurationUnit, EDITABLE_MONETIZATION_FIELDS_PRE_VERIFICATION, IdempotencyManager, MANUAL_TRANSACTION_CREATE_FIELDS, MANUAL_TRANSACTION_UPDATE_FIELDS, PROTECTED_MONETIZATION_FIELDS, TRANSACTION_MANAGEMENT_TYPE, type TransactionManagementType, addDuration, calculateCommission, calculateOrganizationPayout, calculatePeriodRange, calculateProratedAmount, calculateSplits, calculateTax, canCancelSubscription, canPauseSubscription, canRenewSubscription, canResumeSubscription, canSelfVerify, createIdempotencyManager, getAllowedUpdateFields, getTaxType, getTransactionType, isManualTransaction, isMonetizationTransaction, isSubscriptionActive, logger, logger as loggerDefault, resolveCategory, resolveIntervalToDuration, reverseCommission, reverseSplits, reverseTax, setLogger, validateFieldUpdate };
+//#endregion
+export { CircuitBreaker, CircuitBreakerConfig, CircuitState, type DurationUnit, EDITABLE_MONETIZATION_FIELDS_PRE_VERIFICATION, IdempotencyManager, MANUAL_TRANSACTION_CREATE_FIELDS, MANUAL_TRANSACTION_UPDATE_FIELDS, Money, MoneyValue, PROTECTED_MONETIZATION_FIELDS, RetryConfig, TRANSACTION_MANAGEMENT_TYPE, TransactionManagementType, addDuration, calculateCommission, calculateOrganizationPayout, calculatePeriodRange, calculateProratedAmount, calculateSplits, calculateTax, canCancelSubscription, canPauseSubscription, canRenewSubscription, canResumeSubscription, canSelfVerify, createCircuitBreaker, createIdempotencyManager, fromSmallestUnit, getAllowedUpdateFields, getTaxType, getTransactionType, isManualTransaction, isMonetizationTransaction, isSubscriptionActive, logger, logger as loggerDefault, resolveCategory, resolveIntervalToDuration, retry, reverseCommission, reverseSplits, reverseTax, setLogger, toSmallestUnit, validateFieldUpdate };

package/dist/utils/index.mjs

@@ -0,0 +1,346 @@
+import { a as reverseCommission, c as retry, i as calculateCommission, n as calculateSplits, o as CircuitBreaker, r as reverseSplits, s as createCircuitBreaker, t as calculateOrganizationPayout } from "../commission-split-BzB8cd39.mjs";
+import { n as createIdempotencyManager, t as IdempotencyManager } from "../idempotency-DaYcUGY1.mjs";
+import { t as resolveCategory } from "../category-resolver-DV83N8ok.mjs";
+import { f as SUBSCRIPTION_STATUS } from "../split.enums-BrjabxIX.mjs";
+import { n as fromSmallestUnit, r as toSmallestUnit, t as Money } from "../money-CvrDOijQ.mjs";
+import { n as getTaxType, r as reverseTax, t as calculateTax } from "../tax-EQ15DO81.mjs";
+
+//#region src/utils/transaction-type.ts
+/**
+* Transaction types with different protection rules
+*/
+const TRANSACTION_MANAGEMENT_TYPE = {
+	MONETIZATION: "monetization",
+	MANUAL: "manual"
+};
+/**
+* Default monetization categories
+* Users can extend this via config.categoryMappings
+*/
+const DEFAULT_MONETIZATION_CATEGORIES = ["subscription", "purchase"];
+/**
+* Check if category is monetization-related
+* @param category - Transaction category
+* @param additionalCategories - Additional categories from user config
+*/
+function isMonetizationCategory(category, additionalCategories = []) {
+	return [...DEFAULT_MONETIZATION_CATEGORIES, ...additionalCategories].includes(category);
+}
+/**
+* Check if transaction is monetization-managed
+*
+* Monetization-managed means:
+* - Created through subscription/purchase flows via the library
+* - Status controlled by payment webhooks/verification
+* - Amount/commission calculated by library
+* - Protected fields: status, amount, commission, gateway, verifiedAt, verifiedBy
+*
+* @param transaction - Transaction document or data
+* @param options - Options
+*/
+function isMonetizationTransaction(transaction, options = {}) {
+	const { targetModels = ["Subscription", "Membership"], additionalCategories = [] } = options;
+	if (transaction.sourceModel && targetModels.includes(transaction.sourceModel)) return true;
+	if (transaction.category) return isMonetizationCategory(transaction.category, additionalCategories);
+	return false;
+}
+/**
+* Check if transaction is manual admin transaction
+*
+* Manual transactions:
+* - Created directly by admins for operational expenses/income
+* - Can be self-verified by admins
+* - More flexible updates allowed
+* - No commission/gateway complexity
+*
+* @param transaction - Transaction document or data
+* @param options - Options (same as isMonetizationTransaction)
+*/
+function isManualTransaction(transaction, options = {}) {
+	return !isMonetizationTransaction(transaction, options);
+}
+/**
+* Get transaction type
+*
+* @param transaction - Transaction document or data
+* @param options - Options (same as isMonetizationTransaction)
+*/
+function getTransactionType(transaction, options = {}) {
+	return isMonetizationTransaction(transaction, options) ? TRANSACTION_MANAGEMENT_TYPE.MONETIZATION : TRANSACTION_MANAGEMENT_TYPE.MANUAL;
+}
+/**
+* Protected fields for monetization transactions
+* These fields cannot be updated directly by admins
+*/
+const PROTECTED_MONETIZATION_FIELDS = [
+	"status",
+	"amount",
+	"platformCommission",
+	"netAmount",
+	"verifiedAt",
+	"verifiedBy",
+	"gateway",
+	"webhook",
+	"metadata.commission",
+	"metadata.gateway",
+	"type",
+	"category",
+	"sourceModel",
+	"sourceId"
+];
+/**
+* Editable fields for monetization transactions (before verification)
+* These fields can be updated by frontend/customer before payment is verified
+*/
+const EDITABLE_MONETIZATION_FIELDS_PRE_VERIFICATION = [
+	"reference",
+	"paymentDetails",
+	"notes"
+];
+/**
+* Allowed fields for manual transaction creation
+*/
+const MANUAL_TRANSACTION_CREATE_FIELDS = [
+	"organizationId",
+	"type",
+	"category",
+	"amount",
+	"method",
+	"reference",
+	"paymentDetails",
+	"notes",
+	"date",
+	"description"
+];
+/**
+* Allowed fields for manual transaction updates
+*/
+const MANUAL_TRANSACTION_UPDATE_FIELDS = [
+	"amount",
+	"method",
+	"reference",
+	"paymentDetails",
+	"notes",
+	"date",
+	"description"
+];
+/**
+* Get allowed update fields based on transaction type and status
+*
+* @param transaction - Transaction document
+* @param options - Options for transaction type detection
+*/
+function getAllowedUpdateFields(transaction, options = {}) {
+	if (getTransactionType(transaction, options) === 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;
+}
+/**
+* Validate if field update is allowed
+*
+* @param transaction - Transaction document
+* @param fieldName - Field being updated
+* @param options - Options for transaction type detection
+*/
+function validateFieldUpdate(transaction, fieldName, options = {}) {
+	if (getAllowedUpdateFields(transaction, options).includes(fieldName)) return { allowed: true };
+	if (getTransactionType(transaction, options) === 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.`
+	};
+}
+/**
+* Check if transaction can be self-verified by admin
+*
+* @param transaction - Transaction document
+* @param options - Options for transaction type detection
+*/
+function canSelfVerify(transaction, options = {}) {
+	if (getTransactionType(transaction, options) === TRANSACTION_MANAGEMENT_TYPE.MANUAL) return transaction.status === "pending";
+	return false;
+}
+
+//#endregion
+//#region src/utils/logger.ts
+let _logger = console;
+/**
+* Set custom logger implementation
+* @param customLogger - Logger instance with info, warn, error, debug methods
+*/
+function setLogger(customLogger) {
+	_logger = customLogger;
+}
+/**
+* Logger proxy - delegates to current logger implementation
+*/
+const 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);
+	}
+};
+
+//#endregion
+//#region src/utils/subscription/period.ts
+/**
+* Add duration to date
+*/
+function addDuration(startDate, duration, unit = "days") {
+	const date = new Date(startDate);
+	switch (unit) {
+		case "months":
+		case "month":
+			date.setMonth(date.getMonth() + duration);
+			return date;
+		case "years":
+		case "year":
+			date.setFullYear(date.getFullYear() + duration);
+			return date;
+		case "weeks":
+		case "week":
+			date.setDate(date.getDate() + duration * 7);
+			return date;
+		default:
+			date.setDate(date.getDate() + duration);
+			return date;
+	}
+}
+/**
+* Calculate subscription period start/end dates
+*/
+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
+	};
+}
+/**
+* Calculate prorated refund amount for unused period
+*/
+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 amount = amountPaid * (remainingMs / totalMs);
+	const factor = 10 ** precision;
+	return Math.round(amount * factor) / factor;
+}
+/**
+* Convert interval + count to duration/unit
+*/
+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"
+		};
+		default: return {
+			duration: count,
+			unit: "months"
+		};
+	}
+}
+
+//#endregion
+//#region src/utils/subscription/actions.ts
+/**
+* Subscription Action Utilities
+* @classytic/revenue/utils/subscription
+*
+* Eligibility checks for subscription actions
+*/
+/**
+* Check if subscription is active
+*/
+function isSubscriptionActive(subscription) {
+	if (!subscription) return false;
+	if (!subscription.isActive) return false;
+	if (subscription.endDate) {
+		const now = /* @__PURE__ */ new Date();
+		if (new Date(subscription.endDate) < now) return false;
+	}
+	return true;
+}
+/**
+* Check if can renew
+*/
+function canRenewSubscription(entity) {
+	if (!entity?.subscription) return false;
+	return isSubscriptionActive(entity.subscription);
+}
+/**
+* Check if can cancel
+*/
+function canCancelSubscription(entity) {
+	if (!entity?.subscription) return false;
+	if (!isSubscriptionActive(entity.subscription)) return false;
+	return !entity.subscription.canceledAt;
+}
+/**
+* Check if can pause
+*/
+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);
+}
+/**
+* Check if can resume
+*/
+function canResumeSubscription(entity) {
+	if (!entity?.subscription) return false;
+	return entity.status === SUBSCRIPTION_STATUS.PAUSED;
+}
+
+//#endregion
+export { CircuitBreaker, EDITABLE_MONETIZATION_FIELDS_PRE_VERIFICATION, IdempotencyManager, MANUAL_TRANSACTION_CREATE_FIELDS, MANUAL_TRANSACTION_UPDATE_FIELDS, Money, PROTECTED_MONETIZATION_FIELDS, TRANSACTION_MANAGEMENT_TYPE, addDuration, calculateCommission, calculateOrganizationPayout, calculatePeriodRange, calculateProratedAmount, calculateSplits, calculateTax, canCancelSubscription, canPauseSubscription, canRenewSubscription, canResumeSubscription, canSelfVerify, createCircuitBreaker, createIdempotencyManager, fromSmallestUnit, getAllowedUpdateFields, getTaxType, getTransactionType, isManualTransaction, isMonetizationTransaction, isSubscriptionActive, logger, logger as loggerDefault, resolveCategory, resolveIntervalToDuration, retry, reverseCommission, reverseSplits, reverseTax, setLogger, toSmallestUnit, validateFieldUpdate };