@classytic/revenue 0.2.3 → 1.0.0

package/dist/core/index.d.ts

@@ -0,0 +1,884 @@
+import { M as MonetizationService, P as PaymentService, T as TransactionService, E as EscrowService, C as Container } from '../index-BnJWVXuw.js';
+import { d as TransactionDocument, e as SubscriptionDocument, a as MongooseModel, w as PaymentProviderInterface } from '../index-ChVD3P9k.js';
+import { PaymentResult, RefundResult, PaymentProvider } from '../providers/index.js';
+import { x as RetryConfig, R as Result } from '../retry-80lBCmSe.js';
+export { E as Err, O as Ok, g as all, e as err, f as flatMap, a as isErr, i as isOk, m as map, c as mapErr, h as match, o as ok, t as tryCatch, d as tryCatchSync, u as unwrap, b as unwrapOr } from '../retry-80lBCmSe.js';
+import 'mongoose';
+
+/**
+ * Event System - Type-safe pub/sub
+ * @classytic/revenue
+ *
+ * Strongly typed events with async handlers
+ * Inspired by: Node.js EventEmitter, mitt, EventTarget
+ */
+
+/**
+ * All revenue events with their payload types
+ */
+interface RevenueEvents {
+    'payment.initiated': PaymentInitiatedEvent;
+    'payment.succeeded': PaymentSucceededEvent;
+    'payment.failed': PaymentFailedEvent;
+    'payment.refunded': PaymentRefundedEvent;
+    'subscription.created': SubscriptionCreatedEvent;
+    'subscription.activated': SubscriptionActivatedEvent;
+    'subscription.renewed': SubscriptionRenewedEvent;
+    'subscription.cancelled': SubscriptionCancelledEvent;
+    'subscription.paused': SubscriptionPausedEvent;
+    'subscription.resumed': SubscriptionResumedEvent;
+    'subscription.expired': SubscriptionExpiredEvent;
+    'transaction.created': TransactionCreatedEvent;
+    'transaction.verified': TransactionVerifiedEvent;
+    'transaction.completed': TransactionCompletedEvent;
+    'transaction.failed': TransactionFailedEvent;
+    'escrow.held': EscrowHeldEvent;
+    'escrow.released': EscrowReleasedEvent;
+    'escrow.cancelled': EscrowCancelledEvent;
+    'commission.calculated': CommissionCalculatedEvent;
+    'commission.paid': CommissionPaidEvent;
+    'webhook.received': WebhookReceivedEvent;
+    'webhook.processed': WebhookProcessedEvent;
+    '*': BaseEvent;
+}
+interface BaseEvent {
+    readonly type: string;
+    readonly timestamp: Date;
+    readonly metadata?: Record<string, unknown>;
+}
+interface PaymentInitiatedEvent extends BaseEvent {
+    type: 'payment.initiated';
+    transactionId: string;
+    amount: number;
+    currency: string;
+    provider: string;
+    intentId: string;
+}
+interface PaymentSucceededEvent extends BaseEvent {
+    type: 'payment.succeeded';
+    transactionId: string;
+    transaction: TransactionDocument;
+    result: PaymentResult;
+}
+interface PaymentFailedEvent extends BaseEvent {
+    type: 'payment.failed';
+    transactionId: string;
+    error: Error;
+    provider: string;
+}
+interface PaymentRefundedEvent extends BaseEvent {
+    type: 'payment.refunded';
+    transactionId: string;
+    result: RefundResult;
+    amount: number;
+    isPartial: boolean;
+}
+interface SubscriptionCreatedEvent extends BaseEvent {
+    type: 'subscription.created';
+    subscriptionId: string;
+    subscription: SubscriptionDocument;
+    transactionId?: string;
+}
+interface SubscriptionActivatedEvent extends BaseEvent {
+    type: 'subscription.activated';
+    subscriptionId: string;
+    subscription: SubscriptionDocument;
+    transactionId: string;
+}
+interface SubscriptionRenewedEvent extends BaseEvent {
+    type: 'subscription.renewed';
+    subscriptionId: string;
+    subscription: SubscriptionDocument;
+    transactionId: string;
+    period: {
+        start: Date;
+        end: Date;
+    };
+}
+interface SubscriptionCancelledEvent extends BaseEvent {
+    type: 'subscription.cancelled';
+    subscriptionId: string;
+    subscription: SubscriptionDocument;
+    reason?: string;
+    immediate: boolean;
+}
+interface SubscriptionPausedEvent extends BaseEvent {
+    type: 'subscription.paused';
+    subscriptionId: string;
+    subscription: SubscriptionDocument;
+    resumeAt?: Date;
+}
+interface SubscriptionResumedEvent extends BaseEvent {
+    type: 'subscription.resumed';
+    subscriptionId: string;
+    subscription: SubscriptionDocument;
+}
+interface SubscriptionExpiredEvent extends BaseEvent {
+    type: 'subscription.expired';
+    subscriptionId: string;
+    subscription: SubscriptionDocument;
+}
+interface TransactionCreatedEvent extends BaseEvent {
+    type: 'transaction.created';
+    transactionId: string;
+    transaction: TransactionDocument;
+}
+interface TransactionVerifiedEvent extends BaseEvent {
+    type: 'transaction.verified';
+    transactionId: string;
+    transaction: TransactionDocument;
+}
+interface TransactionCompletedEvent extends BaseEvent {
+    type: 'transaction.completed';
+    transactionId: string;
+    transaction: TransactionDocument;
+}
+interface TransactionFailedEvent extends BaseEvent {
+    type: 'transaction.failed';
+    transactionId: string;
+    error: Error;
+}
+interface EscrowHeldEvent extends BaseEvent {
+    type: 'escrow.held';
+    transactionId: string;
+    amount: number;
+    holdUntil?: Date;
+}
+interface EscrowReleasedEvent extends BaseEvent {
+    type: 'escrow.released';
+    transactionId: string;
+    releasedAmount: number;
+    recipientId: string;
+}
+interface EscrowCancelledEvent extends BaseEvent {
+    type: 'escrow.cancelled';
+    transactionId: string;
+    reason: string;
+}
+interface CommissionCalculatedEvent extends BaseEvent {
+    type: 'commission.calculated';
+    transactionId: string;
+    grossAmount: number;
+    netAmount: number;
+    platformFee: number;
+    gatewayFee: number;
+}
+interface CommissionPaidEvent extends BaseEvent {
+    type: 'commission.paid';
+    transactionId: string;
+    recipientId: string;
+    amount: number;
+}
+interface WebhookReceivedEvent extends BaseEvent {
+    type: 'webhook.received';
+    provider: string;
+    eventType: string;
+    payload: unknown;
+}
+interface WebhookProcessedEvent extends BaseEvent {
+    type: 'webhook.processed';
+    provider: string;
+    eventType: string;
+    transactionId?: string;
+    success: boolean;
+}
+type EventHandler<T> = (event: T) => void | Promise<void>;
+type EventKey = keyof RevenueEvents;
+/**
+ * Type-safe event bus
+ */
+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)
+     */
+    emit<K extends EventKey>(event: K, payload: Omit<RevenueEvents[K], 'timestamp'>): void;
+    /**
+     * Emit and wait for all handlers to complete
+     */
+    emitAsync<K extends EventKey>(event: K, payload: Omit<RevenueEvents[K], 'timestamp'>): 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;
+
+/**
+ * Plugin System
+ * @classytic/revenue
+ *
+ * Composable, type-safe plugin architecture
+ * Inspired by: Hono middleware, Fastify plugins, Redux middleware
+ */
+
+/**
+ * Plugin context passed to hooks
+ */
+interface PluginContext {
+    /** Event bus for emitting events */
+    events: EventBus;
+    /** Logger instance */
+    logger: PluginLogger;
+    /** Get registered service */
+    get<T>(key: string): T;
+    /** Plugin-specific storage */
+    storage: Map<string, unknown>;
+    /** Request metadata */
+    meta: {
+        idempotencyKey?: string;
+        requestId: string;
+        timestamp: Date;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Plugin logger interface
+ */
+interface PluginLogger {
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+}
+/**
+ * Hook function type
+ */
+type HookFn<TInput = unknown, TOutput = unknown> = (ctx: PluginContext, input: TInput, next: () => Promise<TOutput>) => Promise<TOutput>;
+/**
+ * Available hook points
+ */
+interface PluginHooks {
+    'payment.create.before': HookFn<PaymentCreateInput>;
+    'payment.create.after': HookFn<PaymentCreateInput, PaymentCreateOutput>;
+    'payment.verify.before': HookFn<PaymentVerifyInput>;
+    'payment.verify.after': HookFn<PaymentVerifyInput, PaymentVerifyOutput>;
+    'payment.refund.before': HookFn<RefundInput>;
+    'payment.refund.after': HookFn<RefundInput, RefundOutput>;
+    'subscription.create.before': HookFn<SubscriptionCreateInput>;
+    'subscription.create.after': HookFn<SubscriptionCreateInput, SubscriptionCreateOutput>;
+    'subscription.cancel.before': HookFn<SubscriptionCancelInput>;
+    'subscription.cancel.after': HookFn<SubscriptionCancelInput, SubscriptionCancelOutput>;
+    'transaction.create.before': HookFn<TransactionCreateInput>;
+    'transaction.create.after': HookFn<TransactionCreateInput, TransactionCreateOutput>;
+    'escrow.hold.before': HookFn<EscrowHoldInput>;
+    'escrow.hold.after': HookFn<EscrowHoldInput, EscrowHoldOutput>;
+    'escrow.release.before': HookFn<EscrowReleaseInput>;
+    'escrow.release.after': HookFn<EscrowReleaseInput, EscrowReleaseOutput>;
+}
+interface PaymentCreateInput {
+    amount: number;
+    currency: string;
+    [key: string]: unknown;
+}
+interface PaymentCreateOutput {
+    transactionId: string;
+    intentId: string;
+    [key: string]: unknown;
+}
+interface PaymentVerifyInput {
+    id: string;
+    [key: string]: unknown;
+}
+interface PaymentVerifyOutput {
+    verified: boolean;
+    [key: string]: unknown;
+}
+interface RefundInput {
+    transactionId: string;
+    amount?: number;
+    [key: string]: unknown;
+}
+interface RefundOutput {
+    refundId: string;
+    [key: string]: unknown;
+}
+interface SubscriptionCreateInput {
+    planKey: string;
+    [key: string]: unknown;
+}
+interface SubscriptionCreateOutput {
+    subscriptionId: string;
+    [key: string]: unknown;
+}
+interface SubscriptionCancelInput {
+    subscriptionId: string;
+    [key: string]: unknown;
+}
+interface SubscriptionCancelOutput {
+    cancelled: boolean;
+    [key: string]: unknown;
+}
+interface TransactionCreateInput {
+    amount: number;
+    [key: string]: unknown;
+}
+interface TransactionCreateOutput {
+    transactionId: string;
+    [key: string]: unknown;
+}
+interface EscrowHoldInput {
+    transactionId: string;
+    [key: string]: unknown;
+}
+interface EscrowHoldOutput {
+    held: boolean;
+    [key: string]: unknown;
+}
+interface EscrowReleaseInput {
+    transactionId: string;
+    [key: string]: unknown;
+}
+interface EscrowReleaseOutput {
+    released: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Plugin definition
+ */
+interface RevenuePlugin {
+    /** Unique plugin name */
+    name: string;
+    /** Plugin version */
+    version?: string;
+    /** Plugin description */
+    description?: string;
+    /** Dependencies on other plugins */
+    dependencies?: string[];
+    /** Hook implementations */
+    hooks?: Partial<PluginHooks>;
+    /** Event listeners */
+    events?: Partial<{
+        [K in keyof RevenueEvents]: (event: RevenueEvents[K]) => void | Promise<void>;
+    }>;
+    /** Initialize plugin */
+    init?: (ctx: PluginContext) => void | Promise<void>;
+    /** Cleanup plugin */
+    destroy?: () => void | Promise<void>;
+}
+/**
+ * Plugin manager - handles registration and execution
+ */
+declare class PluginManager {
+    private plugins;
+    private hooks;
+    private initialized;
+    /**
+     * Register a plugin
+     */
+    register(plugin: RevenuePlugin): this;
+    /**
+     * Initialize all plugins
+     */
+    init(ctx: PluginContext): Promise<void>;
+    /**
+     * Execute a hook chain
+     */
+    executeHook<TInput, TOutput>(hookName: string, ctx: PluginContext, input: TInput, execute: () => Promise<TOutput>): Promise<TOutput>;
+    /**
+     * Check if plugin is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Get a plugin by name
+     */
+    get(name: string): RevenuePlugin | undefined;
+    /**
+     * Get all registered plugins
+     */
+    list(): RevenuePlugin[];
+    /**
+     * Destroy all plugins
+     */
+    destroy(): Promise<void>;
+}
+/**
+ * Logging plugin - logs all operations
+ */
+declare function loggingPlugin(options?: {
+    level?: 'debug' | 'info';
+}): RevenuePlugin;
+/**
+ * Audit plugin - records all operations for compliance
+ */
+declare function auditPlugin(options?: {
+    store?: (entry: AuditEntry) => Promise<void>;
+}): RevenuePlugin;
+interface AuditEntry {
+    action: string;
+    requestId: string;
+    timestamp: Date;
+    input: Record<string, unknown>;
+    output: Record<string, unknown>;
+    idempotencyKey?: string;
+}
+/**
+ * Metrics plugin - collects operation metrics
+ */
+declare function metricsPlugin(options?: {
+    onMetric?: (metric: Metric) => void;
+}): RevenuePlugin;
+interface Metric {
+    name: string;
+    duration: number;
+    success: boolean;
+    error?: string;
+    [key: string]: unknown;
+}
+/**
+ * Create a custom plugin
+ */
+declare function definePlugin(plugin: RevenuePlugin): RevenuePlugin;
+
+/**
+ * Revenue - Modern Payment Management
+ * @classytic/revenue
+ *
+ * Fluent Builder API with integrated services
+ * Less code, more power
+ *
+ * Inspired by: Vercel AI SDK, Stripe SDK, tRPC
+ */
+
+/** Internal config for Revenue instance */
+interface InternalConfig {
+    defaultCurrency: string;
+    commissionRate: number;
+    gatewayFeeRate: number;
+    targetModels?: string[];
+    categoryMappings?: Record<string, string>;
+}
+interface RevenueOptions {
+    /** Default currency (ISO 4217) */
+    defaultCurrency?: string;
+    /** Environment */
+    environment?: 'development' | 'staging' | 'production';
+    /** Debug mode */
+    debug?: boolean;
+    /** Retry configuration */
+    retry?: Partial<RetryConfig>;
+    /** Idempotency TTL in ms */
+    idempotencyTtl?: number;
+    /** Enable circuit breaker */
+    circuitBreaker?: boolean;
+    /** Custom logger */
+    logger?: PluginLogger;
+    /** Commission rate (0-100) */
+    commissionRate?: number;
+    /** Gateway fee rate (0-100) */
+    gatewayFeeRate?: number;
+}
+interface ModelsConfig {
+    Transaction: MongooseModel<any>;
+    Subscription?: MongooseModel<any>;
+    [key: string]: MongooseModel<any> | undefined;
+}
+interface ProvidersConfig {
+    [name: string]: PaymentProvider;
+}
+interface HooksConfig {
+    [key: string]: ((...args: any[]) => void | Promise<void>) | undefined;
+}
+/**
+ * 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.succeeded', (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;
+    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<InternalConfig>;
+    /** 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.succeeded', (event) => {
+     *   console.log('Payment:', event.transactionId);
+     * });
+     * ```
+     */
+    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 hooks;
+    private categoryMappings;
+    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;
+    /**
+     * Register event hooks (for backward compatibility)
+     *
+     * @example
+     * ```typescript
+     * .withHooks({
+     *   onPaymentVerified: async (tx) => { ... },
+     *   onSubscriptionRenewed: async (sub) => { ... },
+     * })
+     * ```
+     */
+    withHooks(hooks: HooksConfig): 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 (0-100)
+     */
+    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;
+    /**
+     * 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[];
+    hooks?: HooksConfig;
+}): 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;
+
+export { AlreadyVerifiedError, type BaseEvent, type CommissionCalculatedEvent, type CommissionPaidEvent, ConfigurationError, Container, ERROR_CODES, type ErrorCode, type EscrowCancelledEvent, type EscrowHeldEvent, type EscrowReleasedEvent, EventBus, type HookFn, type HooksConfig, InvalidAmountError, InvalidStateTransitionError, MissingRequiredFieldError, ModelNotRegisteredError, type ModelsConfig, NotFoundError, OperationError, type PaymentFailedEvent, type PaymentInitiatedEvent, PaymentIntentCreationError, type PaymentRefundedEvent, type PaymentSucceededEvent, PaymentVerificationError, type PluginContext, type PluginHooks, type PluginLogger, PluginManager, ProviderCapabilityError, ProviderError, ProviderNotFoundError, type ProvidersConfig, RefundError, RefundNotSupportedError, Result, Revenue, RevenueBuilder, RevenueError, type RevenueErrorOptions, type RevenueEvents, type RevenueOptions, type RevenuePlugin, StateError, type SubscriptionActivatedEvent, type SubscriptionCancelledEvent, type SubscriptionCreatedEvent, type SubscriptionExpiredEvent, SubscriptionNotActiveError, SubscriptionNotFoundError, type SubscriptionPausedEvent, type SubscriptionRenewedEvent, type SubscriptionResumedEvent, type TransactionCompletedEvent, type TransactionCreatedEvent, type TransactionFailedEvent, TransactionNotFoundError, type TransactionVerifiedEvent, ValidationError, type WebhookProcessedEvent, type WebhookReceivedEvent, auditPlugin, createEventBus, createRevenue, definePlugin, isRetryable, isRevenueError, loggingPlugin, metricsPlugin };