@classytic/revenue 1.1.2 → 1.1.4

package/dist/core/events.d.mts

@@ -0,0 +1,294 @@
+import { B as TransactionDocument, F as SplitInfo, R as SubscriptionDocument, W as WebhookEventData, _ as PaymentIntentData, b as PaymentResultData } from "../index-Dsp7H5Wb.mjs";
+import { t as SettlementDocument } from "../settlement.schema-DnNSFpGd.mjs";
+import { i as RefundResult, r as PaymentResult } from "../base-CsTlVQJe.mjs";
+
+//#region src/core/events.d.ts
+/**
+ * All revenue events with their payload types
+ */
+interface RevenueEvents {
+  'payment.verified': PaymentVerifiedEvent;
+  'payment.failed': PaymentFailedEvent;
+  'payment.refunded': PaymentRefundedEvent;
+  'payment.requires_action': PaymentRequiresActionEvent;
+  'payment.processing': PaymentProcessingEvent;
+  'monetization.created': MonetizationCreatedEvent;
+  'purchase.created': PurchaseCreatedEvent;
+  'free.created': FreeCreatedEvent;
+  'subscription.created': SubscriptionCreatedEvent;
+  'subscription.activated': SubscriptionActivatedEvent;
+  'subscription.renewed': SubscriptionRenewedEvent;
+  'subscription.cancelled': SubscriptionCancelledEvent;
+  'subscription.paused': SubscriptionPausedEvent;
+  'subscription.resumed': SubscriptionResumedEvent;
+  'transaction.updated': TransactionUpdatedEvent;
+  'escrow.held': EscrowHeldEvent;
+  'escrow.released': EscrowReleasedEvent;
+  'escrow.cancelled': EscrowCancelledEvent;
+  'escrow.split': EscrowSplitEvent;
+  'settlement.created': SettlementCreatedEvent;
+  'settlement.scheduled': SettlementScheduledEvent;
+  'settlement.processing': SettlementProcessingEvent;
+  'settlement.completed': SettlementCompletedEvent;
+  'settlement.failed': SettlementFailedEvent;
+  'webhook.processed': WebhookProcessedEvent;
+  '*': BaseEvent;
+}
+/**
+ * Base event with auto-injected fields (type + timestamp added by EventBus)
+ */
+interface BaseEvent {
+  readonly type: string;
+  readonly timestamp: Date;
+  readonly metadata?: Record<string, unknown>;
+}
+/** Derive a full event type from its data type */
+type EventOf<K extends string, D> = D & BaseEvent & {
+  readonly type: K;
+};
+interface PaymentVerifiedEventData {
+  transaction: TransactionDocument;
+  paymentResult: PaymentResult | PaymentResultData;
+  verifiedBy?: string | null;
+}
+interface PaymentFailedEventData {
+  transaction: TransactionDocument;
+  error: string;
+  provider: string;
+  paymentIntentId: string;
+}
+interface PaymentRefundedEventData {
+  transaction: TransactionDocument;
+  refundTransaction: TransactionDocument;
+  refundResult: RefundResult;
+  refundAmount: number;
+  reason?: string;
+  isPartialRefund: boolean;
+}
+interface PaymentRequiresActionEventData {
+  transaction: TransactionDocument;
+  paymentResult: PaymentResult | PaymentResultData;
+  action?: string | Record<string, unknown>;
+}
+interface PaymentProcessingEventData {
+  transaction: TransactionDocument;
+  paymentResult: PaymentResult | PaymentResultData;
+}
+interface MonetizationCreatedEventData {
+  monetizationType: string;
+  subscription?: SubscriptionDocument;
+  transaction?: TransactionDocument;
+  paymentIntent?: PaymentIntentData;
+}
+interface PurchaseCreatedEventData {
+  monetizationType: string;
+  subscription?: SubscriptionDocument;
+  transaction: TransactionDocument;
+  paymentIntent?: PaymentIntentData;
+}
+interface FreeCreatedEventData {
+  monetizationType: string;
+  subscription?: SubscriptionDocument;
+  transaction?: TransactionDocument;
+  paymentIntent?: PaymentIntentData;
+}
+interface SubscriptionCreatedEventData {
+  subscriptionId: string;
+  subscription: SubscriptionDocument;
+  transactionId?: string;
+}
+interface SubscriptionActivatedEventData {
+  subscription: SubscriptionDocument;
+  activatedAt: Date;
+}
+interface SubscriptionRenewedEventData {
+  subscription: SubscriptionDocument;
+  transaction: TransactionDocument;
+  paymentIntent?: PaymentIntentData;
+  renewalCount: number;
+}
+interface SubscriptionCancelledEventData {
+  subscription: SubscriptionDocument;
+  immediate: boolean;
+  reason?: string;
+  canceledAt: Date;
+}
+interface SubscriptionPausedEventData {
+  subscription: SubscriptionDocument;
+  reason?: string;
+  pausedAt: Date;
+}
+interface SubscriptionResumedEventData {
+  subscription: SubscriptionDocument;
+  extendPeriod: boolean;
+  pauseDuration: number;
+  resumedAt: Date;
+}
+interface TransactionUpdatedEventData {
+  transaction: TransactionDocument;
+  updates: Partial<TransactionDocument>;
+}
+interface EscrowHeldEventData {
+  transaction: TransactionDocument;
+  heldAmount: number;
+  reason: string;
+}
+interface EscrowReleasedEventData {
+  transaction: TransactionDocument;
+  releaseTransaction: TransactionDocument | null;
+  releaseAmount: number;
+  recipientId: string;
+  recipientType: string;
+  reason: string;
+  isFullRelease: boolean;
+  isPartialRelease: boolean;
+}
+interface EscrowCancelledEventData {
+  transaction: TransactionDocument;
+  reason: string;
+}
+interface EscrowSplitEventData {
+  transaction: TransactionDocument;
+  splits: SplitInfo[];
+  splitTransactions: TransactionDocument[];
+  organizationTransaction: TransactionDocument | null;
+  organizationPayout: number;
+}
+interface SettlementCreatedEventData {
+  settlements: SettlementDocument[];
+  transactionId: string;
+  count: number;
+}
+interface SettlementScheduledEventData {
+  settlement: SettlementDocument;
+  scheduledAt: Date;
+}
+interface SettlementProcessingEventData {
+  settlement: SettlementDocument;
+  processedAt?: Date;
+}
+interface SettlementCompletedEventData {
+  settlement: SettlementDocument;
+  completedAt?: Date;
+}
+interface SettlementFailedEventData {
+  settlement: SettlementDocument;
+  reason: string;
+  code?: string;
+  retry: boolean;
+}
+interface WebhookProcessedEventData {
+  webhookType: string;
+  provider: string;
+  event: WebhookEventData;
+  transaction: TransactionDocument;
+  processedAt: Date;
+}
+type PaymentVerifiedEvent = EventOf<'payment.verified', PaymentVerifiedEventData>;
+type PaymentFailedEvent = EventOf<'payment.failed', PaymentFailedEventData>;
+type PaymentRefundedEvent = EventOf<'payment.refunded', PaymentRefundedEventData>;
+type PaymentRequiresActionEvent = EventOf<'payment.requires_action', PaymentRequiresActionEventData>;
+type PaymentProcessingEvent = EventOf<'payment.processing', PaymentProcessingEventData>;
+type MonetizationCreatedEvent = EventOf<'monetization.created', MonetizationCreatedEventData>;
+type PurchaseCreatedEvent = EventOf<'purchase.created', PurchaseCreatedEventData>;
+type FreeCreatedEvent = EventOf<'free.created', FreeCreatedEventData>;
+type SubscriptionCreatedEvent = EventOf<'subscription.created', SubscriptionCreatedEventData>;
+type SubscriptionActivatedEvent = EventOf<'subscription.activated', SubscriptionActivatedEventData>;
+type SubscriptionRenewedEvent = EventOf<'subscription.renewed', SubscriptionRenewedEventData>;
+type SubscriptionCancelledEvent = EventOf<'subscription.cancelled', SubscriptionCancelledEventData>;
+type SubscriptionPausedEvent = EventOf<'subscription.paused', SubscriptionPausedEventData>;
+type SubscriptionResumedEvent = EventOf<'subscription.resumed', SubscriptionResumedEventData>;
+type TransactionUpdatedEvent = EventOf<'transaction.updated', TransactionUpdatedEventData>;
+type EscrowHeldEvent = EventOf<'escrow.held', EscrowHeldEventData>;
+type EscrowReleasedEvent = EventOf<'escrow.released', EscrowReleasedEventData>;
+type EscrowCancelledEvent = EventOf<'escrow.cancelled', EscrowCancelledEventData>;
+type EscrowSplitEvent = EventOf<'escrow.split', EscrowSplitEventData>;
+type SettlementCreatedEvent = EventOf<'settlement.created', SettlementCreatedEventData>;
+type SettlementScheduledEvent = EventOf<'settlement.scheduled', SettlementScheduledEventData>;
+type SettlementProcessingEvent = EventOf<'settlement.processing', SettlementProcessingEventData>;
+type SettlementCompletedEvent = EventOf<'settlement.completed', SettlementCompletedEventData>;
+type SettlementFailedEvent = EventOf<'settlement.failed', SettlementFailedEventData>;
+type WebhookProcessedEvent = EventOf<'webhook.processed', WebhookProcessedEventData>;
+/**
+ * Maps event names to their data types (what you pass to emit).
+ * EventBus auto-injects type + timestamp.
+ */
+interface EventDataMap {
+  'payment.verified': PaymentVerifiedEventData;
+  'payment.failed': PaymentFailedEventData;
+  'payment.refunded': PaymentRefundedEventData;
+  'payment.requires_action': PaymentRequiresActionEventData;
+  'payment.processing': PaymentProcessingEventData;
+  'monetization.created': MonetizationCreatedEventData;
+  'purchase.created': PurchaseCreatedEventData;
+  'free.created': FreeCreatedEventData;
+  'subscription.created': SubscriptionCreatedEventData;
+  'subscription.activated': SubscriptionActivatedEventData;
+  'subscription.renewed': SubscriptionRenewedEventData;
+  'subscription.cancelled': SubscriptionCancelledEventData;
+  'subscription.paused': SubscriptionPausedEventData;
+  'subscription.resumed': SubscriptionResumedEventData;
+  'transaction.updated': TransactionUpdatedEventData;
+  'escrow.held': EscrowHeldEventData;
+  'escrow.released': EscrowReleasedEventData;
+  'escrow.cancelled': EscrowCancelledEventData;
+  'escrow.split': EscrowSplitEventData;
+  'settlement.created': SettlementCreatedEventData;
+  'settlement.scheduled': SettlementScheduledEventData;
+  'settlement.processing': SettlementProcessingEventData;
+  'settlement.completed': SettlementCompletedEventData;
+  'settlement.failed': SettlementFailedEventData;
+  'webhook.processed': WebhookProcessedEventData;
+}
+type EventHandler<T> = (event: T) => void | Promise<void>;
+type EventKey = keyof RevenueEvents;
+/**
+ * Type-safe event bus with clean, simple API
+ */
+declare class EventBus {
+  private handlers;
+  private onceHandlers;
+  /**
+   * Subscribe to an event
+   */
+  on<K extends EventKey>(event: K, handler: EventHandler<RevenueEvents[K]>): () => void;
+  /**
+   * Subscribe to an event once
+   */
+  once<K extends EventKey>(event: K, handler: EventHandler<RevenueEvents[K]>): () => void;
+  /**
+   * Unsubscribe from an event
+   */
+  off<K extends EventKey>(event: K, handler: EventHandler<RevenueEvents[K]>): void;
+  /**
+   * Emit an event (fire and forget, non-blocking)
+   *
+   * @example
+   * ```typescript
+   * events.emit('payment.verified', {
+   *   transaction: txDoc,
+   *   paymentResult: result,
+   *   verifiedBy: 'admin_123'
+   * });
+   * ```
+   */
+  emit<K extends keyof EventDataMap>(event: K, data: EventDataMap[K]): void;
+  /**
+   * Emit and wait for all handlers to complete
+   */
+  emitAsync<K extends EventKey>(event: K, payload: Omit<RevenueEvents[K], 'timestamp' | 'type'>): Promise<void>;
+  /**
+   * Remove all handlers
+   */
+  clear(): void;
+  /**
+   * Get handler count for an event
+   */
+  listenerCount(event: EventKey): number;
+}
+/**
+ * Create a new event bus
+ */
+declare function createEventBus(): EventBus;
+//#endregion
+export { BaseEvent, EscrowCancelledEvent, EscrowCancelledEventData, EscrowHeldEvent, EscrowHeldEventData, EscrowReleasedEvent, EscrowReleasedEventData, EscrowSplitEvent, EscrowSplitEventData, EventBus, EventBus as default, EventDataMap, FreeCreatedEvent, FreeCreatedEventData, MonetizationCreatedEvent, MonetizationCreatedEventData, PaymentFailedEvent, PaymentFailedEventData, PaymentProcessingEvent, PaymentProcessingEventData, PaymentRefundedEvent, PaymentRefundedEventData, PaymentRequiresActionEvent, PaymentRequiresActionEventData, PaymentVerifiedEvent, PaymentVerifiedEventData, PurchaseCreatedEvent, PurchaseCreatedEventData, RevenueEvents, SettlementCompletedEvent, SettlementCompletedEventData, SettlementCreatedEvent, SettlementCreatedEventData, SettlementFailedEvent, SettlementFailedEventData, SettlementProcessingEvent, SettlementProcessingEventData, SettlementScheduledEvent, SettlementScheduledEventData, SubscriptionActivatedEvent, SubscriptionActivatedEventData, SubscriptionCancelledEvent, SubscriptionCancelledEventData, SubscriptionCreatedEvent, SubscriptionCreatedEventData, SubscriptionPausedEvent, SubscriptionPausedEventData, SubscriptionRenewedEvent, SubscriptionRenewedEventData, SubscriptionResumedEvent, SubscriptionResumedEventData, TransactionUpdatedEvent, TransactionUpdatedEventData, WebhookProcessedEvent, WebhookProcessedEventData, createEventBus };

package/dist/core/events.mjs

@@ -0,0 +1,100 @@
+//#region src/core/events.ts
+/**
+* Type-safe event bus with clean, simple API
+*/
+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(event, data) {
+		const fullPayload = {
+			...data,
+			type: event,
+			timestamp: /* @__PURE__ */ new Date()
+		};
+		const handlers = this.handlers.get(event);
+		if (handlers) for (const handler of handlers) Promise.resolve(handler(fullPayload)).catch((err) => {
+			console.error(`[Revenue] Event handler error for "${event}":`, err);
+		});
+		const onceHandlers = this.onceHandlers.get(event);
+		if (onceHandlers) {
+			for (const handler of onceHandlers) Promise.resolve(handler(fullPayload)).catch((err) => {
+				console.error(`[Revenue] Once handler error for "${event}":`, err);
+			});
+			this.onceHandlers.delete(event);
+		}
+		if (event !== "*") {
+			const wildcardHandlers = this.handlers.get("*");
+			if (wildcardHandlers) for (const handler of wildcardHandlers) Promise.resolve(handler(fullPayload)).catch((err) => {
+				console.error(`[Revenue] Wildcard handler error:`, err);
+			});
+		}
+	}
+	/**
+	* Emit and wait for all handlers to complete
+	*/
+	async emitAsync(event, payload) {
+		const fullPayload = {
+			...payload,
+			type: event,
+			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);
+	}
+};
+/**
+* Create a new event bus
+*/
+function createEventBus() {
+	return new EventBus();
+}
+
+//#endregion
+export { EventBus, EventBus as default, createEventBus };

package/dist/core/index.d.mts

@@ -0,0 +1,9 @@
+import { o as Container } from "../settlement.service-DjzAjezU.mjs";
+import "../index-Dsp7H5Wb.mjs";
+import "../settlement.schema-DnNSFpGd.mjs";
+import "../base-CsTlVQJe.mjs";
+import { BaseEvent, EscrowCancelledEvent, EscrowHeldEvent, EscrowReleasedEvent, EscrowSplitEvent, EventBus, FreeCreatedEvent, MonetizationCreatedEvent, PaymentFailedEvent, PaymentRefundedEvent, PaymentVerifiedEvent, PurchaseCreatedEvent, RevenueEvents, SettlementCompletedEvent, SettlementCreatedEvent, SettlementFailedEvent, SettlementProcessingEvent, SettlementScheduledEvent, SubscriptionActivatedEvent, SubscriptionCancelledEvent, SubscriptionCreatedEvent, SubscriptionPausedEvent, SubscriptionRenewedEvent, SubscriptionResumedEvent, TransactionUpdatedEvent, WebhookProcessedEvent, createEventBus } from "./events.mjs";
+import { a as PluginManager, c as definePlugin, i as PluginLogger, l as loggingPlugin, n as PluginContext, o as RevenuePlugin, r as PluginHooks, s as auditPlugin, t as HookFn, u as metricsPlugin } from "../plugin-BbK0OVHy.mjs";
+import { S as unwrapOr, _ as match, b as tryCatchSync, c as Ok, d as err, f as flatMap, g as mapErr, h as map, l as Result, m as isOk, p as isErr, s as Err, u as all, v as ok, x as unwrap, y as tryCatch } from "../retry-HHCOXYdn.mjs";
+import { A as SUBSCRIPTION_STATE_MACHINE, B as Revenue, C as TransactionNotFoundError, D as HOLD_STATE_MACHINE, E as isRevenueError, H as RevenueOptions, M as StateMachine, O as SETTLEMENT_STATE_MACHINE, R as ModelsConfig, S as SubscriptionNotFoundError, T as isRetryable, U as createRevenue, V as RevenueBuilder, _ as RefundNotSupportedError, a as InvalidAmountError, b as StateError, c as ModelNotRegisteredError, d as PaymentIntentCreationError, f as PaymentVerificationError, g as RefundError, h as ProviderNotFoundError, i as ErrorCode, j as TRANSACTION_STATE_MACHINE, k as SPLIT_STATE_MACHINE, l as NotFoundError, m as ProviderError, n as ConfigurationError, o as InvalidStateTransitionError, p as ProviderCapabilityError, r as ERROR_CODES, s as MissingRequiredFieldError, t as AlreadyVerifiedError, u as OperationError, v as RevenueError, w as ValidationError, x as SubscriptionNotActiveError, y as RevenueErrorOptions, z as ProvidersConfig } from "../errors-rRdOqnWx.mjs";
+export { AlreadyVerifiedError, type BaseEvent, ConfigurationError, Container, ERROR_CODES, type Err, ErrorCode, type EscrowCancelledEvent, type EscrowHeldEvent, type EscrowReleasedEvent, type EscrowSplitEvent, EventBus, type FreeCreatedEvent, HOLD_STATE_MACHINE, type HookFn, InvalidAmountError, InvalidStateTransitionError, MissingRequiredFieldError, ModelNotRegisteredError, type ModelsConfig, type MonetizationCreatedEvent, NotFoundError, type Ok, OperationError, type PaymentFailedEvent, PaymentIntentCreationError, type PaymentRefundedEvent, PaymentVerificationError, type PaymentVerifiedEvent, type PluginContext, type PluginHooks, type PluginLogger, PluginManager, ProviderCapabilityError, ProviderError, ProviderNotFoundError, type ProvidersConfig, type PurchaseCreatedEvent, RefundError, RefundNotSupportedError, Result, Revenue, RevenueBuilder, RevenueError, RevenueErrorOptions, type RevenueEvents, type RevenueOptions, type RevenuePlugin, SETTLEMENT_STATE_MACHINE, SPLIT_STATE_MACHINE, SUBSCRIPTION_STATE_MACHINE, type SettlementCompletedEvent, type SettlementCreatedEvent, type SettlementFailedEvent, type SettlementProcessingEvent, type SettlementScheduledEvent, StateError, StateMachine, type SubscriptionActivatedEvent, type SubscriptionCancelledEvent, type SubscriptionCreatedEvent, SubscriptionNotActiveError, SubscriptionNotFoundError, type SubscriptionPausedEvent, type SubscriptionRenewedEvent, type SubscriptionResumedEvent, TRANSACTION_STATE_MACHINE, TransactionNotFoundError, type TransactionUpdatedEvent, ValidationError, type WebhookProcessedEvent, all, auditPlugin, createEventBus, createRevenue, definePlugin, err, flatMap, isErr, isOk, isRetryable, isRevenueError, loggingPlugin, map, mapErr, match, metricsPlugin, ok, tryCatch, tryCatchSync, unwrap, unwrapOr };

package/dist/core/index.mjs

@@ -0,0 +1,8 @@
+import { i as Container, n as RevenueBuilder, r as createRevenue, t as Revenue } from "../revenue-BhdS7nXh.mjs";
+import { EventBus, createEventBus } from "./events.mjs";
+import { a as metricsPlugin, i as loggingPlugin, n as auditPlugin, r as definePlugin, t as PluginManager } from "../plugin-Cd_V04Em.mjs";
+import { S as unwrapOr, _ as match, b as tryCatchSync, d as err, f as flatMap, g as mapErr, h as map, l as Result, m as isOk, p as isErr, u as all, v as ok, x as unwrap, y as tryCatch } from "../commission-split-BzB8cd39.mjs";
+import { C as ValidationError, S as TransactionNotFoundError, T as isRevenueError, _ as RefundNotSupportedError, a as InvalidAmountError, b as SubscriptionNotActiveError, c as ModelNotRegisteredError, d as PaymentIntentCreationError, f as PaymentVerificationError, g as RefundError, h as ProviderNotFoundError, i as ERROR_CODES, l as NotFoundError, m as ProviderError, n as AlreadyVerifiedError, o as InvalidStateTransitionError, p as ProviderCapabilityError, r as ConfigurationError, s as MissingRequiredFieldError, u as OperationError, v as RevenueError, w as isRetryable, x as SubscriptionNotFoundError, y as StateError } from "../category-resolver-DV83N8ok.mjs";
+import { d as SETTLEMENT_STATE_MACHINE, f as SPLIT_STATE_MACHINE, h as StateMachine, m as TRANSACTION_STATE_MACHINE, p as SUBSCRIPTION_STATE_MACHINE, u as HOLD_STATE_MACHINE } from "../settlement.service-DmdKv0Zu.mjs";
+
+export { AlreadyVerifiedError, ConfigurationError, Container, ERROR_CODES, EventBus, HOLD_STATE_MACHINE, InvalidAmountError, InvalidStateTransitionError, MissingRequiredFieldError, ModelNotRegisteredError, NotFoundError, OperationError, PaymentIntentCreationError, PaymentVerificationError, PluginManager, ProviderCapabilityError, ProviderError, ProviderNotFoundError, RefundError, RefundNotSupportedError, Result, Revenue, RevenueBuilder, RevenueError, SETTLEMENT_STATE_MACHINE, SPLIT_STATE_MACHINE, SUBSCRIPTION_STATE_MACHINE, StateError, StateMachine, SubscriptionNotActiveError, SubscriptionNotFoundError, TRANSACTION_STATE_MACHINE, TransactionNotFoundError, ValidationError, all, auditPlugin, createEventBus, createRevenue, definePlugin, err, flatMap, isErr, isOk, isRetryable, isRevenueError, loggingPlugin, map, mapErr, match, metricsPlugin, ok, tryCatch, tryCatchSync, unwrap, unwrapOr };

package/dist/enums/index.d.mts

@@ -0,0 +1,157 @@
+import { a as SPLIT_STATUS, c as SPLIT_TYPE_VALUES, d as SplitType, f as SplitTypeValue, h as isSplitType, i as PayoutMethodValue, l as SplitStatus, m as isSplitStatus, n as PAYOUT_METHOD_VALUES, o as SPLIT_STATUS_VALUES, p as isPayoutMethod, r as PayoutMethod, s as SPLIT_TYPE, t as PAYOUT_METHOD, u as SplitStatusValue } from "../split.enums-DmskfLOM.mjs";
+import { A as isTransactionType, C as TransactionStatus, D as isLibraryCategory, E as TransactionTypeValue, O as isTransactionFlow, S as TransactionFlowValue, T as TransactionType, _ as TRANSACTION_STATUS, a as SettlementStatus, b as TRANSACTION_TYPE_VALUES, c as SettlementTypeValue, d as LIBRARY_CATEGORIES, f as LIBRARY_CATEGORY_VALUES, g as TRANSACTION_FLOW_VALUES, h as TRANSACTION_FLOW, i as SETTLEMENT_TYPE_VALUES, k as isTransactionStatus, l as isSettlementStatus, m as LibraryCategoryValue, n as SETTLEMENT_STATUS_VALUES, o as SettlementStatusValue, p as LibraryCategories, r as SETTLEMENT_TYPE, s as SettlementType, t as SETTLEMENT_STATUS, u as isSettlementType, v as TRANSACTION_STATUS_VALUES, w as TransactionStatusValue, x as TransactionFlow, y as TRANSACTION_TYPE } from "../settlement.enums-DFhkqZEY.mjs";
+import { C as SubscriptionStatusValue, S as SubscriptionStatus, T as isSubscriptionStatus, _ as PLAN_KEY_VALUES, a as HoldReason, b as SUBSCRIPTION_STATUS, c as HoldStatusValue, d as ReleaseReason, f as ReleaseReasonValue, g as PLAN_KEYS, h as isReleaseReason, i as HOLD_STATUS_VALUES, l as RELEASE_REASON, m as isHoldStatus, n as HOLD_REASON_VALUES, o as HoldReasonValue, p as isHoldReason, r as HOLD_STATUS, s as HoldStatus, t as HOLD_REASON, u as RELEASE_REASON_VALUES, v as PlanKeyValue, w as isPlanKey, x as SUBSCRIPTION_STATUS_VALUES, y as PlanKeys } from "../escrow.enums-DwdLuuve.mjs";
+import { a as PAYMENT_STATUS, c as PaymentGatewayTypeValue, d as isGatewayType, f as isPaymentGatewayType, i as PAYMENT_GATEWAY_TYPE_VALUES, l as PaymentStatus, n as GATEWAY_TYPE_VALUES, o as PAYMENT_STATUS_VALUES, p as isPaymentStatus, r as PAYMENT_GATEWAY_TYPE, s as PaymentGatewayType, t as GATEWAY_TYPES, u as PaymentStatusValue } from "../payment.enums-HAuAS9Pp.mjs";
+
+//#region src/enums/monetization.enums.d.ts
+/**
+ * Monetization Enums
+ * @classytic/revenue
+ *
+ * General monetization enums and constants
+ */
+declare const MONETIZATION_TYPES: {
+  readonly FREE: "free";
+  readonly PURCHASE: "purchase";
+  readonly SUBSCRIPTION: "subscription";
+};
+type MonetizationTypes = typeof MONETIZATION_TYPES;
+type MonetizationTypeValue = MonetizationTypes[keyof MonetizationTypes];
+declare const MONETIZATION_TYPE_VALUES: MonetizationTypeValue[];
+declare function isMonetizationType(value: unknown): value is MonetizationTypeValue;
+//#endregion
+//#region src/enums/index.d.ts
+declare const _default: {
+  readonly TRANSACTION_TYPE: {
+    readonly INFLOW: "inflow";
+    readonly OUTFLOW: "outflow";
+  };
+  readonly TRANSACTION_TYPE_VALUES: TransactionFlowValue[];
+  readonly TRANSACTION_STATUS: {
+    readonly PENDING: "pending";
+    readonly PAYMENT_INITIATED: "payment_initiated";
+    readonly PROCESSING: "processing";
+    readonly REQUIRES_ACTION: "requires_action";
+    readonly VERIFIED: "verified";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+    readonly CANCELLED: "cancelled";
+    readonly EXPIRED: "expired";
+    readonly REFUNDED: "refunded";
+    readonly PARTIALLY_REFUNDED: "partially_refunded";
+  };
+  readonly TRANSACTION_STATUS_VALUES: TransactionStatusValue[];
+  readonly LIBRARY_CATEGORIES: {
+    readonly SUBSCRIPTION: "subscription";
+    readonly PURCHASE: "purchase";
+  };
+  readonly LIBRARY_CATEGORY_VALUES: LibraryCategoryValue[];
+  readonly isLibraryCategory: typeof isLibraryCategory;
+  readonly isTransactionType: typeof isTransactionType;
+  readonly isTransactionStatus: typeof isTransactionStatus;
+  readonly PAYMENT_STATUS: {
+    readonly PENDING: "pending";
+    readonly VERIFIED: "verified";
+    readonly FAILED: "failed";
+    readonly REFUNDED: "refunded";
+    readonly CANCELLED: "cancelled";
+  };
+  readonly PAYMENT_STATUS_VALUES: PaymentStatusValue[];
+  readonly PAYMENT_GATEWAY_TYPE: {
+    readonly MANUAL: "manual";
+    readonly STRIPE: "stripe";
+    readonly SSLCOMMERZ: "sslcommerz";
+  };
+  readonly PAYMENT_GATEWAY_TYPE_VALUES: PaymentGatewayTypeValue[];
+  readonly GATEWAY_TYPES: {
+    readonly MANUAL: "manual";
+    readonly STRIPE: "stripe";
+    readonly SSLCOMMERZ: "sslcommerz";
+  };
+  readonly GATEWAY_TYPE_VALUES: PaymentGatewayTypeValue[];
+  readonly isPaymentStatus: typeof isPaymentStatus;
+  readonly isPaymentGatewayType: typeof isPaymentGatewayType;
+  readonly isGatewayType: typeof isPaymentGatewayType;
+  readonly SUBSCRIPTION_STATUS: {
+    readonly ACTIVE: "active";
+    readonly PAUSED: "paused";
+    readonly CANCELLED: "cancelled";
+    readonly EXPIRED: "expired";
+    readonly PENDING: "pending";
+    readonly PENDING_RENEWAL: "pending_renewal";
+    readonly INACTIVE: "inactive";
+  };
+  readonly SUBSCRIPTION_STATUS_VALUES: SubscriptionStatusValue[];
+  readonly PLAN_KEYS: {
+    readonly MONTHLY: "monthly";
+    readonly QUARTERLY: "quarterly";
+    readonly YEARLY: "yearly";
+  };
+  readonly PLAN_KEY_VALUES: PlanKeyValue[];
+  readonly isSubscriptionStatus: typeof isSubscriptionStatus;
+  readonly isPlanKey: typeof isPlanKey;
+  readonly MONETIZATION_TYPES: {
+    readonly FREE: "free";
+    readonly PURCHASE: "purchase";
+    readonly SUBSCRIPTION: "subscription";
+  };
+  readonly MONETIZATION_TYPE_VALUES: MonetizationTypeValue[];
+  readonly isMonetizationType: typeof isMonetizationType;
+  readonly HOLD_STATUS: {
+    readonly PENDING: "pending";
+    readonly HELD: "held";
+    readonly RELEASED: "released";
+    readonly CANCELLED: "cancelled";
+    readonly EXPIRED: "expired";
+    readonly PARTIALLY_RELEASED: "partially_released";
+  };
+  readonly HOLD_STATUS_VALUES: HoldStatusValue[];
+  readonly RELEASE_REASON: {
+    readonly PAYMENT_VERIFIED: "payment_verified";
+    readonly MANUAL_RELEASE: "manual_release";
+    readonly AUTO_RELEASE: "auto_release";
+    readonly DISPUTE_RESOLVED: "dispute_resolved";
+  };
+  readonly RELEASE_REASON_VALUES: ReleaseReasonValue[];
+  readonly HOLD_REASON: {
+    readonly PAYMENT_VERIFICATION: "payment_verification";
+    readonly FRAUD_CHECK: "fraud_check";
+    readonly MANUAL_REVIEW: "manual_review";
+    readonly DISPUTE: "dispute";
+    readonly COMPLIANCE: "compliance";
+  };
+  readonly HOLD_REASON_VALUES: HoldReasonValue[];
+  readonly isHoldStatus: typeof isHoldStatus;
+  readonly isReleaseReason: typeof isReleaseReason;
+  readonly isHoldReason: typeof isHoldReason;
+  readonly SPLIT_TYPE: {
+    readonly PLATFORM_COMMISSION: "platform_commission";
+    readonly AFFILIATE_COMMISSION: "affiliate_commission";
+    readonly REFERRAL_COMMISSION: "referral_commission";
+    readonly PARTNER_COMMISSION: "partner_commission";
+    readonly CUSTOM: "custom";
+  };
+  readonly SPLIT_TYPE_VALUES: SplitTypeValue[];
+  readonly SPLIT_STATUS: {
+    readonly PENDING: "pending";
+    readonly DUE: "due";
+    readonly PAID: "paid";
+    readonly WAIVED: "waived";
+    readonly CANCELLED: "cancelled";
+  };
+  readonly SPLIT_STATUS_VALUES: SplitStatusValue[];
+  readonly PAYOUT_METHOD: {
+    readonly BANK_TRANSFER: "bank_transfer";
+    readonly MOBILE_WALLET: "mobile_wallet";
+    readonly PLATFORM_BALANCE: "platform_balance";
+    readonly CRYPTO: "crypto";
+    readonly CHECK: "check";
+    readonly MANUAL: "manual";
+  };
+  readonly PAYOUT_METHOD_VALUES: PayoutMethodValue[];
+  readonly isSplitType: typeof isSplitType;
+  readonly isSplitStatus: typeof isSplitStatus;
+  readonly isPayoutMethod: typeof isPayoutMethod;
+};
+//#endregion
+export { GATEWAY_TYPES, GATEWAY_TYPE_VALUES, HOLD_REASON, HOLD_REASON_VALUES, HOLD_STATUS, HOLD_STATUS_VALUES, HoldReason, HoldReasonValue, HoldStatus, HoldStatusValue, LIBRARY_CATEGORIES, LIBRARY_CATEGORY_VALUES, LibraryCategories, LibraryCategoryValue, MONETIZATION_TYPES, MONETIZATION_TYPE_VALUES, MonetizationTypeValue, MonetizationTypes, PAYMENT_GATEWAY_TYPE, PAYMENT_GATEWAY_TYPE_VALUES, PAYMENT_STATUS, PAYMENT_STATUS_VALUES, PAYOUT_METHOD, PAYOUT_METHOD_VALUES, PLAN_KEYS, PLAN_KEY_VALUES, PaymentGatewayType, PaymentGatewayTypeValue, PaymentStatus, PaymentStatusValue, PayoutMethod, PayoutMethodValue, PlanKeyValue, PlanKeys, RELEASE_REASON, RELEASE_REASON_VALUES, ReleaseReason, ReleaseReasonValue, SETTLEMENT_STATUS, SETTLEMENT_STATUS_VALUES, SETTLEMENT_TYPE, SETTLEMENT_TYPE_VALUES, SPLIT_STATUS, SPLIT_STATUS_VALUES, SPLIT_TYPE, SPLIT_TYPE_VALUES, SUBSCRIPTION_STATUS, SUBSCRIPTION_STATUS_VALUES, SettlementStatus, SettlementStatusValue, SettlementType, SettlementTypeValue, SplitStatus, SplitStatusValue, SplitType, SplitTypeValue, SubscriptionStatus, SubscriptionStatusValue, TRANSACTION_FLOW, TRANSACTION_FLOW_VALUES, TRANSACTION_STATUS, TRANSACTION_STATUS_VALUES, TRANSACTION_TYPE, TRANSACTION_TYPE_VALUES, TransactionFlow, TransactionFlowValue, TransactionStatus, TransactionStatusValue, TransactionType, TransactionTypeValue, _default as default, isGatewayType, isHoldReason, isHoldStatus, isLibraryCategory, isMonetizationType, isPaymentGatewayType, isPaymentStatus, isPayoutMethod, isPlanKey, isReleaseReason, isSettlementStatus, isSettlementType, isSplitStatus, isSplitType, isSubscriptionStatus, isTransactionFlow, isTransactionStatus, isTransactionType };

package/dist/enums/index.mjs

@@ -0,0 +1,56 @@
+import { a as TRANSACTION_STATUS, c as TRANSACTION_TYPE_VALUES, d as isTransactionStatus, f as isTransactionType, i as TRANSACTION_FLOW_VALUES, l as isLibraryCategory, n as LIBRARY_CATEGORY_VALUES, o as TRANSACTION_STATUS_VALUES, r as TRANSACTION_FLOW, s as TRANSACTION_TYPE, t as LIBRARY_CATEGORIES, u as isTransactionFlow } from "../transaction.enums-pCyMFT4Z.mjs";
+import { _ as MONETIZATION_TYPE_VALUES, a as RELEASE_REASON, c as isHoldStatus, d as SETTLEMENT_STATUS_VALUES, f as SETTLEMENT_TYPE, g as MONETIZATION_TYPES, h as isSettlementType, i as HOLD_STATUS_VALUES, l as isReleaseReason, m as isSettlementStatus, n as HOLD_REASON_VALUES, o as RELEASE_REASON_VALUES, p as SETTLEMENT_TYPE_VALUES, r as HOLD_STATUS, s as isHoldReason, t as HOLD_REASON, u as SETTLEMENT_STATUS, v as isMonetizationType } from "../escrow.enums-CZGrrdg7.mjs";
+import { a as SPLIT_TYPE, c as isSplitStatus, d as PLAN_KEY_VALUES, f as SUBSCRIPTION_STATUS, h as isSubscriptionStatus, i as SPLIT_STATUS_VALUES, l as isSplitType, m as isPlanKey, n as PAYOUT_METHOD_VALUES, o as SPLIT_TYPE_VALUES, p as SUBSCRIPTION_STATUS_VALUES, r as SPLIT_STATUS, s as isPayoutMethod, t as PAYOUT_METHOD, u as PLAN_KEYS } from "../split.enums-BrjabxIX.mjs";
+import { a as PAYMENT_STATUS, c as isPaymentGatewayType, i as PAYMENT_GATEWAY_TYPE_VALUES, l as isPaymentStatus, n as GATEWAY_TYPE_VALUES, o as PAYMENT_STATUS_VALUES, r as PAYMENT_GATEWAY_TYPE, s as isGatewayType, t as GATEWAY_TYPES } from "../payment.enums-tEFVa-Xp.mjs";
+
+//#region src/enums/index.ts
+var enums_default = {
+	TRANSACTION_TYPE,
+	TRANSACTION_TYPE_VALUES,
+	TRANSACTION_STATUS,
+	TRANSACTION_STATUS_VALUES,
+	LIBRARY_CATEGORIES,
+	LIBRARY_CATEGORY_VALUES,
+	isLibraryCategory,
+	isTransactionType,
+	isTransactionStatus,
+	PAYMENT_STATUS,
+	PAYMENT_STATUS_VALUES,
+	PAYMENT_GATEWAY_TYPE,
+	PAYMENT_GATEWAY_TYPE_VALUES,
+	GATEWAY_TYPES,
+	GATEWAY_TYPE_VALUES,
+	isPaymentStatus,
+	isPaymentGatewayType,
+	isGatewayType,
+	SUBSCRIPTION_STATUS,
+	SUBSCRIPTION_STATUS_VALUES,
+	PLAN_KEYS,
+	PLAN_KEY_VALUES,
+	isSubscriptionStatus,
+	isPlanKey,
+	MONETIZATION_TYPES,
+	MONETIZATION_TYPE_VALUES,
+	isMonetizationType,
+	HOLD_STATUS,
+	HOLD_STATUS_VALUES,
+	RELEASE_REASON,
+	RELEASE_REASON_VALUES,
+	HOLD_REASON,
+	HOLD_REASON_VALUES,
+	isHoldStatus,
+	isReleaseReason,
+	isHoldReason,
+	SPLIT_TYPE,
+	SPLIT_TYPE_VALUES,
+	SPLIT_STATUS,
+	SPLIT_STATUS_VALUES,
+	PAYOUT_METHOD,
+	PAYOUT_METHOD_VALUES,
+	isSplitType,
+	isSplitStatus,
+	isPayoutMethod
+};
+
+//#endregion
+export { GATEWAY_TYPES, GATEWAY_TYPE_VALUES, HOLD_REASON, HOLD_REASON_VALUES, HOLD_STATUS, HOLD_STATUS_VALUES, LIBRARY_CATEGORIES, LIBRARY_CATEGORY_VALUES, MONETIZATION_TYPES, MONETIZATION_TYPE_VALUES, PAYMENT_GATEWAY_TYPE, PAYMENT_GATEWAY_TYPE_VALUES, PAYMENT_STATUS, PAYMENT_STATUS_VALUES, PAYOUT_METHOD, PAYOUT_METHOD_VALUES, PLAN_KEYS, PLAN_KEY_VALUES, RELEASE_REASON, RELEASE_REASON_VALUES, SETTLEMENT_STATUS, SETTLEMENT_STATUS_VALUES, SETTLEMENT_TYPE, SETTLEMENT_TYPE_VALUES, SPLIT_STATUS, SPLIT_STATUS_VALUES, SPLIT_TYPE, SPLIT_TYPE_VALUES, SUBSCRIPTION_STATUS, SUBSCRIPTION_STATUS_VALUES, TRANSACTION_FLOW, TRANSACTION_FLOW_VALUES, TRANSACTION_STATUS, TRANSACTION_STATUS_VALUES, TRANSACTION_TYPE, TRANSACTION_TYPE_VALUES, enums_default as default, isGatewayType, isHoldReason, isHoldStatus, isLibraryCategory, isMonetizationType, isPaymentGatewayType, isPaymentStatus, isPayoutMethod, isPlanKey, isReleaseReason, isSettlementStatus, isSettlementType, isSplitStatus, isSplitType, isSubscriptionStatus, isTransactionFlow, isTransactionStatus, isTransactionType };