@classytic/revenue 1.1.4 → 2.0.0

package/dist/errors-rRdOqnWx.d.mts

@@ -1,787 +0,0 @@
-import { a as MonetizationService, i as PaymentService, n as EscrowService, o as Container, r as TransactionService, t as SettlementService } from "./settlement.service-DjzAjezU.mjs";
-import { P as RevenueConfig, V as TransactionFlowValue, h as MongooseModel, v as PaymentProviderInterface } from "./index-Dsp7H5Wb.mjs";
-import { u as SplitStatusValue } from "./split.enums-DmskfLOM.mjs";
-import { n as PaymentProvider } from "./base-CsTlVQJe.mjs";
-import { EventBus } from "./core/events.mjs";
-import { a as PluginManager, i as PluginLogger, n as PluginContext, o as RevenuePlugin } from "./plugin-BbK0OVHy.mjs";
-import { i as RetryConfig, l as Result, n as CircuitBreakerConfig } from "./retry-HHCOXYdn.mjs";
-import { o as SettlementStatusValue, w as TransactionStatusValue } from "./settlement.enums-DFhkqZEY.mjs";
-import { C as SubscriptionStatusValue, c as HoldStatusValue } from "./escrow.enums-DwdLuuve.mjs";
-
-//#region src/core/revenue.d.ts
-interface RevenueOptions {
-  /** Default currency (ISO 4217) */
-  defaultCurrency?: string;
-  /** Environment */
-  environment?: 'development' | 'staging' | 'production';
-  /** Debug mode */
-  debug?: boolean;
-  /** Retry configuration for provider calls */
-  retry?: Partial<RetryConfig>;
-  /** Idempotency TTL in ms */
-  idempotencyTtl?: number;
-  /** Circuit breaker configuration for provider calls */
-  circuitBreaker?: Partial<CircuitBreakerConfig> | boolean;
-  /** Custom logger */
-  logger?: PluginLogger;
-  /** Commission rate as decimal (0-1, e.g., 0.10 for 10%) */
-  commissionRate?: number;
-  /** Gateway fee rate as decimal (0-1, e.g., 0.029 for 2.9%) */
-  gatewayFeeRate?: number;
-}
-interface ModelsConfig {
-  Transaction: MongooseModel<any>;
-  Subscription?: MongooseModel<any>;
-  [key: string]: MongooseModel<any> | undefined;
-}
-interface ProvidersConfig {
-  [name: string]: PaymentProvider;
-}
-/**
- * Revenue - Main entry point
- *
- * @example
- * ```typescript
- * const revenue = Revenue
- *   .create({ defaultCurrency: 'USD' })
- *   .withModels({ Transaction, Subscription })
- *   .withProvider('stripe', new StripeProvider({ apiKey: '...' }))
- *   .withProvider('manual', new ManualProvider())
- *   .withPlugin(auditPlugin())
- *   .build();
- *
- * // Access services directly
- * await revenue.monetization.create({ ... });
- * await revenue.payments.verify({ ... });
- *
- * // Or use events
- * revenue.on('payment.verified', (event) => { ... });
- * ```
- */
-declare class Revenue {
-  private readonly _container;
-  private readonly _events;
-  private readonly _plugins;
-  private readonly _idempotency;
-  private readonly _circuitBreaker?;
-  private readonly _options;
-  private readonly _logger;
-  private readonly _providers;
-  private readonly _config;
-  /** Monetization service - purchases, subscriptions, free items */
-  readonly monetization: MonetizationService;
-  /** Payment service - verify, refund, webhooks */
-  readonly payments: PaymentService;
-  /** Transaction service - query, update transactions */
-  readonly transactions: TransactionService;
-  /** Escrow service - hold, release, splits */
-  readonly escrow: EscrowService;
-  /** Settlement service - payout tracking */
-  readonly settlement: SettlementService;
-  private constructor();
-  /** @internal Used by RevenueBuilder — do not call directly */
-  static _fromBuilder(container: Container, events: EventBus, plugins: PluginManager, options: Required<RevenueOptions>, providers: ProvidersConfig, config: Partial<RevenueConfig>): Revenue;
-  /**
-   * Create a new Revenue builder
-   *
-   * @example
-   * ```typescript
-   * const revenue = Revenue
-   *   .create({ defaultCurrency: 'BDT' })
-   *   .withModels({ Transaction, Subscription })
-   *   .withProvider('manual', new ManualProvider())
-   *   .build();
-   * ```
-   */
-  static create(options?: RevenueOptions): RevenueBuilder;
-  /** DI container (for advanced usage) */
-  get container(): Container;
-  /** Event bus */
-  get events(): EventBus;
-  /** Registered providers (frozen) */
-  get providers(): Readonly<ProvidersConfig>;
-  /** Configuration (frozen) */
-  get config(): Readonly<Partial<RevenueConfig>>;
-  /** Default currency */
-  get defaultCurrency(): string;
-  /** Current environment */
-  get environment(): string;
-  /**
-   * Get a provider by name
-   */
-  getProvider(name: string): PaymentProviderInterface;
-  /**
-   * Get all provider names
-   */
-  getProviderNames(): string[];
-  /**
-   * Check if provider exists
-   */
-  hasProvider(name: string): boolean;
-  /**
-   * Subscribe to events
-   *
-   * @example
-   * ```typescript
-   * revenue.on('payment.verified', (event) => {
-   *   console.log('Payment:', event.transaction._id);
-   * });
-   * ```
-   */
-  on: EventBus['on'];
-  /**
-   * Subscribe once
-   */
-  once: EventBus['once'];
-  /**
-   * Unsubscribe
-   */
-  off: EventBus['off'];
-  /**
-   * Emit an event
-   */
-  emit: EventBus['emit'];
-  /**
-   * Execute operation with retry and idempotency
-   */
-  execute<T>(operation: () => Promise<T>, options?: {
-    idempotencyKey?: string;
-    params?: unknown;
-    useRetry?: boolean;
-    useCircuitBreaker?: boolean;
-  }): Promise<Result<T, Error>>;
-  /**
-   * Create plugin context (for advanced usage)
-   */
-  createContext(meta?: {
-    idempotencyKey?: string;
-  }): PluginContext;
-  /**
-   * Destroy instance and cleanup
-   */
-  destroy(): Promise<void>;
-}
-/**
- * Revenue Builder - Fluent configuration API
- */
-declare class RevenueBuilder {
-  private options;
-  private models;
-  private providers;
-  private plugins;
-  private categoryMappings;
-  private transactionTypeMapping;
-  constructor(options?: RevenueOptions);
-  /**
-   * Register models (required)
-   *
-   * @example
-   * ```typescript
-   * .withModels({
-   *   Transaction: TransactionModel,
-   *   Subscription: SubscriptionModel,
-   * })
-   * ```
-   */
-  withModels(models: ModelsConfig): this;
-  /**
-   * Register a single model
-   */
-  withModel(name: string, model: MongooseModel<any>): this;
-  /**
-   * Register a payment provider
-   *
-   * @example
-   * ```typescript
-   * .withProvider('stripe', new StripeProvider({ apiKey: '...' }))
-   * .withProvider('manual', new ManualProvider())
-   * ```
-   */
-  withProvider(name: string, provider: PaymentProvider): this;
-  /**
-   * Register multiple providers at once
-   */
-  withProviders(providers: ProvidersConfig): this;
-  /**
-   * Register a plugin
-   *
-   * @example
-   * ```typescript
-   * .withPlugin(loggingPlugin())
-   * .withPlugin(auditPlugin({ store: saveToDb }))
-   * ```
-   */
-  withPlugin(plugin: RevenuePlugin): this;
-  /**
-   * Register multiple plugins
-   */
-  withPlugins(plugins: RevenuePlugin[]): this;
-  /**
-   * Set retry configuration
-   *
-   * @example
-   * ```typescript
-   * .withRetry({ maxAttempts: 5, baseDelay: 2000 })
-   * ```
-   */
-  withRetry(config: Partial<RetryConfig>): this;
-  /**
-   * Enable circuit breaker
-   */
-  withCircuitBreaker(enabled?: boolean): this;
-  /**
-   * Set custom logger
-   */
-  withLogger(logger: PluginLogger): this;
-  /**
-   * Set environment
-   */
-  forEnvironment(env: 'development' | 'staging' | 'production'): this;
-  /**
-   * Enable debug mode
-   */
-  withDebug(enabled?: boolean): this;
-  /**
-   * Set commission rate as decimal (0-1, e.g., 0.10 for 10%)
-   *
-   * @param rate - Commission rate (0-1 decimal format)
-   * @param gatewayFeeRate - Gateway fee rate (0-1 decimal format, e.g., 0.029 for 2.9%)
-   *
-   * @example
-   * ```typescript
-   * .withCommission(0.10, 0.029) // 10% commission + 2.9% gateway fee
-   * ```
-   */
-  withCommission(rate: number, gatewayFeeRate?: number): this;
-  /**
-   * Set category mappings (entity → category)
-   *
-   * @example
-   * ```typescript
-   * .withCategoryMappings({
-   *   PlatformSubscription: 'platform_subscription',
-   *   CourseEnrollment: 'course_enrollment',
-   *   ProductOrder: 'product_order',
-   * })
-   * ```
-   */
-  withCategoryMappings(mappings: Record<string, string>): this;
-  /**
-   * Set transaction flow mapping by category or monetization type
-   *
-   * @example
-   * ```typescript
-   * .withTransactionTypeMapping({
-   *   platform_subscription: 'inflow',
-   *   subscription: 'inflow',
-   *   refund: 'outflow',
-   * })
-   * ```
-   */
-  withTransactionTypeMapping(mapping: Record<string, TransactionFlowValue>): this;
-  /**
-   * Build the Revenue instance
-   */
-  build(): Revenue;
-}
-/**
- * Create Revenue instance (shorthand)
- *
- * @example
- * ```typescript
- * const revenue = createRevenue({
- *   models: { Transaction, Subscription },
- *   providers: { manual: new ManualProvider() },
- * });
- * ```
- */
-declare function createRevenue(config: {
-  models: ModelsConfig;
-  providers: ProvidersConfig;
-  options?: RevenueOptions;
-  plugins?: RevenuePlugin[];
-}): Revenue;
-//#endregion
-//#region src/infrastructure/audit/types.d.ts
-/**
- * Audit Trail Types
- * @classytic/revenue
- *
- * State change tracking for compliance and debugging
- * Stored in document.metadata.stateHistory array
- */
-/**
- * State Change Audit Event
- * Records who changed what, when, and why
- *
- * Example usage:
- * ```typescript
- * const event: StateChangeEvent = {
- *   resourceType: 'transaction',
- *   resourceId: 'tx_123',
- *   fromState: 'pending',
- *   toState: 'verified',
- *   changedAt: new Date(),
- *   changedBy: 'admin_user_id',
- *   reason: 'Payment verified by payment gateway',
- *   metadata: { verificationId: 'ver_abc' }
- * };
- * ```
- */
-interface StateChangeEvent<TState = string> {
-  /** Type of resource (e.g., 'transaction', 'subscription') */
-  resourceType: string;
-  /** Unique identifier of the resource */
-  resourceId: string;
-  /** State before the transition */
-  fromState: TState;
-  /** State after the transition */
-  toState: TState;
-  /** Timestamp when the change occurred */
-  changedAt: Date;
-  /** User ID or system identifier who triggered the change */
-  changedBy?: string;
-  /** Human-readable reason for the state change */
-  reason?: string;
-  /** Additional contextual data */
-  metadata?: Record<string, unknown>;
-}
-/**
- * Helper to append audit event to document metadata
- *
- * This is a metadata-based approach that stores audit trail
- * directly in the document's metadata.stateHistory array.
- *
- * Example:
- * ```typescript
- * const transaction = await Transaction.findById(id);
- *
- * const auditEvent = {
- *   resourceType: 'transaction',
- *   resourceId: transaction._id.toString(),
- *   fromState: 'pending',
- *   toState: 'verified',
- *   changedAt: new Date(),
- *   changedBy: 'admin_123',
- * };
- *
- * const updated = appendAuditEvent(transaction, auditEvent);
- * await updated.save();
- * ```
- *
- * @param document - Mongoose document or plain object with optional metadata field
- * @param event - State change event to append
- * @returns Updated document with event in metadata.stateHistory
- */
-declare function appendAuditEvent<T extends {
-  metadata?: any;
-}>(document: T, event: StateChangeEvent): T;
-/**
- * Helper to get audit trail from document metadata
- *
- * Example:
- * ```typescript
- * const transaction = await Transaction.findById(id);
- * const history = getAuditTrail(transaction);
- *
- * console.log(history);
- * // [
- * //   { fromState: 'pending', toState: 'processing', changedAt: ... },
- * //   { fromState: 'processing', toState: 'verified', changedAt: ... },
- * // ]
- * ```
- *
- * @param document - Document to extract audit trail from
- * @returns Array of state change events (empty array if none)
- */
-declare function getAuditTrail<T extends {
-  metadata?: any;
-}>(document: T): StateChangeEvent[];
-/**
- * Helper to get the last state change from audit trail
- *
- * @param document - Document to extract last change from
- * @returns Last state change event or undefined if none
- */
-declare function getLastStateChange<T extends {
-  metadata?: any;
-}>(document: T): StateChangeEvent | undefined;
-/**
- * Helper to find state changes by criteria
- *
- * Example:
- * ```typescript
- * const transaction = await Transaction.findById(id);
- *
- * // Find all changes made by a specific user
- * const userChanges = filterAuditTrail(transaction, {
- *   changedBy: 'admin_123'
- * });
- *
- * // Find all transitions to 'failed' state
- * const failures = filterAuditTrail(transaction, {
- *   toState: 'failed'
- * });
- * ```
- *
- * @param document - Document to filter audit trail from
- * @param criteria - Filter criteria
- * @returns Filtered array of state change events
- */
-declare function filterAuditTrail<T extends {
-  metadata?: any;
-}>(document: T, criteria: Partial<StateChangeEvent>): StateChangeEvent[];
-//#endregion
-//#region src/core/state-machine/StateMachine.d.ts
-/**
- * Generic State Machine for validating state transitions
- *
- * @template TState - The state type (typically a union of string literals)
- *
- * @example
- * ```typescript
- * const stateMachine = new StateMachine(
- *   new Map([
- *     ['pending', new Set(['processing', 'failed'])],
- *     ['processing', new Set(['completed', 'failed'])],
- *     ['completed', new Set([])], // Terminal state
- *     ['failed', new Set([])],     // Terminal state
- *   ]),
- *   'payment'
- * );
- *
- * // Validate transition
- * stateMachine.validate('pending', 'processing', 'pay_123'); // ✅ OK
- * stateMachine.validate('completed', 'pending', 'pay_123');  // ❌ Throws InvalidStateTransitionError
- *
- * // Check without throwing
- * stateMachine.canTransition('pending', 'processing'); // true
- * stateMachine.canTransition('completed', 'pending');  // false
- * ```
- */
-declare class StateMachine<TState extends string> {
-  private readonly transitions;
-  private readonly resourceType;
-  /**
-   * @param transitions - Map of state → allowed next states
-   * @param resourceType - Type of resource (for error messages)
-   */
-  constructor(transitions: Map<TState, Set<TState>>, resourceType: string);
-  /**
-   * Validate state transition is allowed
-   *
-   * @param from - Current state
-   * @param to - Target state
-   * @param resourceId - ID of the resource being transitioned
-   * @throws InvalidStateTransitionError if transition is invalid
-   *
-   * @example
-   * ```typescript
-   * try {
-   *   stateMachine.validate('pending', 'completed', 'tx_123');
-   * } catch (error) {
-   *   if (error instanceof InvalidStateTransitionError) {
-   *     console.error('Invalid transition:', error.message);
-   *   }
-   * }
-   * ```
-   */
-  validate(from: TState, to: TState, resourceId: string): void;
-  /**
-   * Check if transition is valid (non-throwing)
-   *
-   * @param from - Current state
-   * @param to - Target state
-   * @returns true if transition is allowed
-   *
-   * @example
-   * ```typescript
-   * if (stateMachine.canTransition('pending', 'processing')) {
-   *   // Safe to proceed with transition
-   *   transaction.status = 'processing';
-   * }
-   * ```
-   */
-  canTransition(from: TState, to: TState): boolean;
-  /**
-   * Get all allowed next states from current state
-   *
-   * @param from - Current state
-   * @returns Array of allowed next states
-   *
-   * @example
-   * ```typescript
-   * const nextStates = stateMachine.getAllowedTransitions('pending');
-   * console.log(nextStates); // ['processing', 'failed']
-   * ```
-   */
-  getAllowedTransitions(from: TState): TState[];
-  /**
-   * Check if state is terminal (no outgoing transitions)
-   *
-   * @param state - State to check
-   * @returns true if state has no outgoing transitions
-   *
-   * @example
-   * ```typescript
-   * stateMachine.isTerminalState('completed'); // true
-   * stateMachine.isTerminalState('pending');   // false
-   * ```
-   */
-  isTerminalState(state: TState): boolean;
-  /**
-   * Get the resource type this state machine manages
-   *
-   * @returns Resource type string
-   */
-  getResourceType(): string;
-  /**
-   * Validate state transition and create audit event
-   *
-   * This is a convenience method that combines validation with audit event creation.
-   * Use this when you want to both validate a transition and record it in the audit trail.
-   *
-   * @param from - Current state
-   * @param to - Target state
-   * @param resourceId - ID of the resource being transitioned
-   * @param context - Optional audit context (who, why, metadata)
-   * @returns StateChangeEvent ready to be appended to document metadata
-   * @throws InvalidStateTransitionError if transition is invalid
-   *
-   * @example
-   * ```typescript
-   * import { appendAuditEvent } from '@classytic/revenue';
-   *
-   * // Validate and create audit event
-   * const auditEvent = TRANSACTION_STATE_MACHINE.validateAndCreateAuditEvent(
-   *   transaction.status,
-   *   'verified',
-   *   transaction._id.toString(),
-   *   {
-   *     changedBy: 'admin_123',
-   *     reason: 'Payment verified by payment gateway',
-   *     metadata: { verificationId: 'ver_abc' }
-   *   }
-   * );
-   *
-   * // Apply state change
-   * transaction.status = 'verified';
-   *
-   * // Append audit event to metadata
-   * Object.assign(transaction, appendAuditEvent(transaction, auditEvent));
-   *
-   * // Save
-   * await transaction.save();
-   * ```
-   */
-  validateAndCreateAuditEvent(from: TState, to: TState, resourceId: string, context?: {
-    changedBy?: string;
-    reason?: string;
-    metadata?: Record<string, unknown>;
-  }): StateChangeEvent<TState>;
-}
-//#endregion
-//#region src/core/state-machine/definitions.d.ts
-/**
- * Transaction State Machine
- *
- * Flow:
- * ```
- * pending → payment_initiated → processing → verified → completed
- *           ↓                    ↓           ↓
- *         failed         requires_action  refunded
- *                                ↓       partially_refunded
- *                             failed
- * ```
- *
- * Terminal states: failed, refunded, cancelled, expired
- */
-declare const TRANSACTION_STATE_MACHINE: StateMachine<TransactionStatusValue>;
-/**
- * Subscription State Machine
- *
- * Flow:
- * ```
- * pending → active → paused → active
- *            ↓        ↓
- *        cancelled  cancelled
- *            ↓
- *         expired
- * ```
- *
- * Terminal states: cancelled, expired
- */
-declare const SUBSCRIPTION_STATE_MACHINE: StateMachine<SubscriptionStatusValue>;
-/**
- * Settlement State Machine
- *
- * Flow:
- * ```
- * pending → processing → completed
- *            ↓
- *          failed → pending (retry allowed)
- * ```
- *
- * Terminal states: completed, cancelled
- * Note: failed can retry to pending
- */
-declare const SETTLEMENT_STATE_MACHINE: StateMachine<SettlementStatusValue>;
-/**
- * Escrow Hold State Machine
- *
- * Flow:
- * ```
- * held → partially_released → released
- *  ↓
- * cancelled
- * ```
- *
- * Terminal states: released, cancelled, expired
- */
-declare const HOLD_STATE_MACHINE: StateMachine<HoldStatusValue>;
-/**
- * Split Payment State Machine
- *
- * Flow:
- * ```
- * pending → due → paid
- *   ↓
- * waived
- * cancelled
- * ```
- *
- * Terminal states: paid, waived, cancelled
- */
-declare const SPLIT_STATE_MACHINE: StateMachine<SplitStatusValue>;
-//#endregion
-//#region src/core/errors.d.ts
-/**
- * Revenue Error Classes
- * @classytic/revenue
- *
- * Typed errors with codes for better error handling
- */
-interface RevenueErrorOptions {
-  retryable?: boolean;
-  metadata?: Record<string, unknown>;
-}
-/**
- * Base Revenue Error
- */
-declare class RevenueError extends Error {
-  readonly code: string;
-  readonly retryable: boolean;
-  readonly metadata: Record<string, unknown>;
-  constructor(message: string, code: string, options?: RevenueErrorOptions);
-  toJSON(): Record<string, unknown>;
-}
-/**
- * Configuration Errors
- */
-declare class ConfigurationError extends RevenueError {
-  constructor(message: string, metadata?: Record<string, unknown>);
-}
-declare class ModelNotRegisteredError extends ConfigurationError {
-  constructor(modelName: string);
-}
-/**
- * Provider Errors
- */
-declare class ProviderError extends RevenueError {
-  constructor(message: string, code: string, options?: RevenueErrorOptions);
-}
-declare class ProviderNotFoundError extends ProviderError {
-  constructor(providerName: string, availableProviders?: string[]);
-}
-declare class ProviderCapabilityError extends ProviderError {
-  constructor(providerName: string, capability: string);
-}
-declare class PaymentIntentCreationError extends ProviderError {
-  constructor(providerName: string, originalError: Error);
-}
-declare class PaymentVerificationError extends ProviderError {
-  constructor(paymentIntentId: string, reason: string);
-}
-/**
- * Resource Not Found Errors
- */
-declare class NotFoundError extends RevenueError {
-  constructor(message: string, code: string, metadata?: Record<string, unknown>);
-}
-declare class SubscriptionNotFoundError extends NotFoundError {
-  constructor(subscriptionId: string);
-}
-declare class TransactionNotFoundError extends NotFoundError {
-  constructor(transactionId: string);
-}
-/**
- * Validation Errors
- */
-declare class ValidationError extends RevenueError {
-  constructor(message: string, metadata?: Record<string, unknown>);
-}
-declare class InvalidAmountError extends ValidationError {
-  constructor(amount: number, message?: string);
-}
-declare class MissingRequiredFieldError extends ValidationError {
-  constructor(fieldName: string);
-}
-/**
- * State Errors
- */
-declare class StateError extends RevenueError {
-  constructor(message: string, code: string, metadata?: Record<string, unknown>);
-}
-declare class AlreadyVerifiedError extends StateError {
-  constructor(transactionId: string);
-}
-declare class InvalidStateTransitionError extends StateError {
-  constructor(resourceType: string, resourceId: string, fromState: string, toState: string);
-}
-declare class SubscriptionNotActiveError extends StateError {
-  constructor(subscriptionId: string, message?: string);
-}
-/**
- * Operation Errors
- */
-declare class OperationError extends RevenueError {
-  constructor(message: string, code: string, options?: RevenueErrorOptions);
-}
-declare class RefundNotSupportedError extends OperationError {
-  constructor(providerName: string);
-}
-declare class RefundError extends OperationError {
-  constructor(transactionId: string, reason: string);
-}
-/**
- * Error Code Constants
- */
-declare const ERROR_CODES: {
-  readonly CONFIGURATION_ERROR: "CONFIGURATION_ERROR";
-  readonly MODEL_NOT_REGISTERED: "MODEL_NOT_REGISTERED";
-  readonly PROVIDER_NOT_FOUND: "PROVIDER_NOT_FOUND";
-  readonly PROVIDER_CAPABILITY_NOT_SUPPORTED: "PROVIDER_CAPABILITY_NOT_SUPPORTED";
-  readonly PAYMENT_INTENT_CREATION_FAILED: "PAYMENT_INTENT_CREATION_FAILED";
-  readonly PAYMENT_VERIFICATION_FAILED: "PAYMENT_VERIFICATION_FAILED";
-  readonly SUBSCRIPTION_NOT_FOUND: "SUBSCRIPTION_NOT_FOUND";
-  readonly TRANSACTION_NOT_FOUND: "TRANSACTION_NOT_FOUND";
-  readonly VALIDATION_ERROR: "VALIDATION_ERROR";
-  readonly INVALID_AMOUNT: "INVALID_AMOUNT";
-  readonly MISSING_REQUIRED_FIELD: "MISSING_REQUIRED_FIELD";
-  readonly ALREADY_VERIFIED: "ALREADY_VERIFIED";
-  readonly INVALID_STATE_TRANSITION: "INVALID_STATE_TRANSITION";
-  readonly SUBSCRIPTION_NOT_ACTIVE: "SUBSCRIPTION_NOT_ACTIVE";
-  readonly REFUND_NOT_SUPPORTED: "REFUND_NOT_SUPPORTED";
-  readonly REFUND_FAILED: "REFUND_FAILED";
-};
-type ErrorCode = typeof ERROR_CODES[keyof typeof ERROR_CODES];
-/**
- * Check if error is retryable
- */
-declare function isRetryable(error: unknown): boolean;
-/**
- * Check if error is from revenue package
- */
-declare function isRevenueError(error: unknown): error is RevenueError;
-//#endregion
-export { SUBSCRIPTION_STATE_MACHINE as A, Revenue as B, TransactionNotFoundError as C, HOLD_STATE_MACHINE as D, isRevenueError as E, filterAuditTrail as F, RevenueOptions as H, getAuditTrail as I, getLastStateChange as L, StateMachine as M, StateChangeEvent as N, SETTLEMENT_STATE_MACHINE as O, appendAuditEvent as P, ModelsConfig as R, SubscriptionNotFoundError as S, isRetryable as T, createRevenue as U, RevenueBuilder as V, RefundNotSupportedError as _, InvalidAmountError as a, StateError as b, ModelNotRegisteredError as c, PaymentIntentCreationError as d, PaymentVerificationError as f, RefundError as g, ProviderNotFoundError as h, ErrorCode as i, TRANSACTION_STATE_MACHINE as j, SPLIT_STATE_MACHINE as k, NotFoundError as l, ProviderError as m, ConfigurationError as n, InvalidStateTransitionError as o, ProviderCapabilityError as p, ERROR_CODES as r, MissingRequiredFieldError as s, AlreadyVerifiedError as t, OperationError as u, RevenueError as v, ValidationError as w, SubscriptionNotActiveError as x, RevenueErrorOptions as y, ProvidersConfig as z };