@classytic/revenue 1.1.2 → 1.1.4

package/dist/index-EnfKzDbs.d.ts

@@ -1,806 +0,0 @@
-import { M as MonetizationService, P as PaymentService, T as TransactionService, E as EscrowService, S as SettlementService, C as Container } from './index-DxIK0UmZ.js';
-import EventBus from './core/events.js';
-import { P as PluginLogger, R as RevenuePlugin, a as PluginContext } from './plugin-Bb9HOE10.js';
-import { k as RetryConfig, l as CircuitBreakerConfig, R as Result } from './retry-D4hFUwVk.js';
-import { PaymentProvider } from './providers/index.js';
-import { M as MongooseModel, j as TransactionFlowValue, R as RevenueConfig, k as PaymentProviderInterface } from './index-cLJBLUvx.js';
-import { a as TransactionStatusValue, t as SettlementStatusValue } from './settlement.enums-ByC1x0ye.js';
-import { S as SubscriptionStatusValue, H as HoldStatusValue } from './escrow.enums-CE0VQsfe.js';
-import { a as SplitStatusValue } from './split.enums-DG3TxQf9.js';
-
-/**
- * Revenue - Modern Payment Management
- * @classytic/revenue
- *
- * Fluent Builder API with integrated services
- * Less code, more power
- *
- * Inspired by: Vercel AI SDK, Stripe SDK, tRPC
- */
-
-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();
-    /**
-     * 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;
-
-/**
- * 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;
-
-/**
- * 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[];
-
-/**
- * Generic State Machine Validator
- * @classytic/revenue
- *
- * Inspired by Stripe's state transition validation
- * Provides centralized, type-safe state transition management
- */
-
-/**
- * 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>;
-}
-
-/**
- * State Machine Definitions
- * @classytic/revenue
- *
- * Centralized state transition rules for all entities
- * Inspired by Stripe, PayPal, and Shopify state management patterns
- */
-
-/**
- * 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>;
-
-export { AlreadyVerifiedError as A, RefundError as B, ConfigurationError as C, type ErrorCode as D, ERROR_CODES as E, isRetryable as F, isRevenueError as G, HOLD_STATE_MACHINE as H, InvalidAmountError as I, type ModelsConfig as M, NotFoundError as N, OperationError as O, type ProvidersConfig as P, Revenue as R, StateMachine as S, TRANSACTION_STATE_MACHINE as T, ValidationError as V, RevenueError as a, RevenueBuilder as b, createRevenue as c, type RevenueOptions as d, SUBSCRIPTION_STATE_MACHINE as e, SETTLEMENT_STATE_MACHINE as f, SPLIT_STATE_MACHINE as g, type StateChangeEvent as h, appendAuditEvent as i, getAuditTrail as j, getLastStateChange as k, filterAuditTrail as l, type RevenueErrorOptions as m, ModelNotRegisteredError as n, ProviderError as o, ProviderNotFoundError as p, ProviderCapabilityError as q, PaymentIntentCreationError as r, PaymentVerificationError as s, SubscriptionNotFoundError as t, TransactionNotFoundError as u, MissingRequiredFieldError as v, StateError as w, InvalidStateTransitionError as x, SubscriptionNotActiveError as y, RefundNotSupportedError as z };