@classytic/revenue 0.2.4 → 1.0.0

package/dist/index-ChVD3P9k.d.ts

@@ -0,0 +1,504 @@
+import { Types, Document } from 'mongoose';
+
+/**
+ * @classytic/revenue - Core Type Definitions
+ * Enterprise Revenue Management System
+ *
+ * @module @classytic/revenue/types
+ */
+
+/** Generic Mongoose document type */
+type MongooseDoc<T = unknown> = Document & T;
+/** ObjectId type from Mongoose */
+type ObjectId = Types.ObjectId;
+/** Generic Mongoose model interface - simplified for compatibility */
+interface MongooseModel<T = unknown> {
+    findById(id: string | ObjectId): Promise<T | null>;
+    find(filter?: object): unknown;
+    findOne(filter?: object): Promise<T | null>;
+    create(data: Partial<T> | Record<string, unknown>): Promise<T>;
+    countDocuments?(filter?: object): Promise<number>;
+    count?(filter?: object): Promise<number>;
+    findByIdAndUpdate(id: string | ObjectId, update: object, options?: object): Promise<T | null>;
+    update?(id: string, data: object): Promise<T | null>;
+}
+/** Transaction status values */
+type TransactionStatusValue = 'pending' | 'payment_initiated' | 'processing' | 'requires_action' | 'verified' | 'completed' | 'failed' | 'cancelled' | 'expired' | 'refunded' | 'partially_refunded';
+/** Transaction type values */
+type TransactionTypeValue = 'income' | 'expense';
+/** Gateway information stored on transaction */
+interface TransactionGateway {
+    type: string;
+    sessionId?: string | null;
+    paymentIntentId?: string | null;
+    provider?: string;
+    metadata?: Record<string, unknown>;
+    verificationData?: Record<string, unknown>;
+}
+/** Commission information */
+interface CommissionInfo {
+    rate: number;
+    grossAmount: number;
+    gatewayFeeRate: number;
+    gatewayFeeAmount: number;
+    netAmount: number;
+    status: 'pending' | 'paid' | 'waived';
+    splits?: SplitInfo[];
+    affiliate?: {
+        recipientId: string;
+        recipientType: string;
+        rate: number;
+        grossAmount: number;
+        netAmount: number;
+    };
+}
+/** Webhook information */
+interface WebhookInfo {
+    eventId: string;
+    eventType: string;
+    receivedAt: Date;
+    processedAt?: Date;
+    data: Record<string, unknown>;
+}
+/** Hold (escrow) information */
+interface HoldInfo {
+    status: HoldStatusValue;
+    heldAmount: number;
+    releasedAmount: number;
+    reason?: HoldReasonValue;
+    holdUntil?: Date | null;
+    heldAt?: Date;
+    releasedAt?: Date;
+    cancelledAt?: Date;
+    releases: ReleaseRecord[];
+    metadata: Record<string, unknown>;
+}
+/** Release record for escrow */
+interface ReleaseRecord {
+    amount: number;
+    recipientId: string;
+    recipientType: string;
+    releasedAt: Date;
+    releasedBy?: string | null;
+    reason: string;
+    metadata: Record<string, unknown>;
+}
+/** Base transaction document interface */
+interface TransactionDocument {
+    _id: ObjectId;
+    organizationId?: string | ObjectId;
+    customerId?: string | ObjectId | null;
+    amount: number;
+    currency: string;
+    category: string;
+    type: TransactionTypeValue;
+    method: string;
+    status: TransactionStatusValue;
+    gateway?: TransactionGateway;
+    paymentDetails?: Record<string, unknown>;
+    commission?: CommissionInfo | null;
+    referenceId?: string | ObjectId;
+    referenceModel?: string;
+    metadata?: Record<string, unknown>;
+    idempotencyKey?: string;
+    verifiedAt?: Date;
+    verifiedBy?: string | ObjectId | null;
+    failureReason?: string;
+    refundedAmount?: number;
+    refundedAt?: Date;
+    webhook?: WebhookInfo;
+    hold?: HoldInfo;
+    splits?: SplitInfo[];
+    createdAt: Date;
+    updatedAt: Date;
+    save(): Promise<this>;
+}
+/** Subscription status values */
+type SubscriptionStatusValue = 'active' | 'paused' | 'cancelled' | 'expired' | 'pending' | 'inactive' | 'pending_renewal';
+/** Plan key values */
+type PlanKeyValue = 'monthly' | 'quarterly' | 'yearly' | string;
+/** Base subscription document interface */
+interface SubscriptionDocument {
+    _id: ObjectId;
+    organizationId?: string | ObjectId;
+    customerId?: string | ObjectId | null;
+    planKey: PlanKeyValue;
+    amount: number;
+    currency: string;
+    status: SubscriptionStatusValue;
+    isActive: boolean;
+    gateway?: string;
+    transactionId?: ObjectId | null;
+    paymentIntentId?: string | null;
+    startDate?: Date;
+    endDate?: Date;
+    activatedAt?: Date;
+    canceledAt?: Date;
+    cancelAt?: Date;
+    cancellationReason?: string | null;
+    pausedAt?: Date | null;
+    pauseReason?: string | null;
+    renewalCount?: number;
+    renewalTransactionId?: ObjectId;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+    save(): Promise<this>;
+}
+/** Payment status values */
+type PaymentStatusValue = 'pending' | 'verified' | 'failed' | 'refunded' | 'cancelled';
+/** Payment gateway type values */
+type PaymentGatewayTypeValue = 'manual' | 'stripe' | 'sslcommerz' | string;
+/** Monetization type values */
+type MonetizationTypeValue = 'free' | 'purchase' | 'subscription';
+/** Hold status values */
+type HoldStatusValue = 'pending' | 'held' | 'released' | 'cancelled' | 'expired' | 'partially_released';
+/** Hold reason values */
+type HoldReasonValue = 'payment_verification' | 'fraud_check' | 'manual_review' | 'dispute' | 'compliance';
+/** Release reason values */
+type ReleaseReasonValue = 'payment_verified' | 'manual_release' | 'auto_release' | 'dispute_resolved';
+/** Split type values */
+type SplitTypeValue = 'platform_commission' | 'affiliate_commission' | 'referral_commission' | 'partner_commission' | 'custom';
+/** Split status values */
+type SplitStatusValue = 'pending' | 'due' | 'paid' | 'waived' | 'cancelled';
+/** Payout method values */
+type PayoutMethodValue = 'bank_transfer' | 'mobile_wallet' | 'platform_balance' | 'crypto' | 'check' | 'manual';
+/** Split rule configuration */
+interface SplitRule {
+    type?: SplitTypeValue;
+    recipientId: string;
+    recipientType: string;
+    rate: number;
+    dueDate?: Date | null;
+    metadata?: Record<string, unknown>;
+}
+/** Calculated split info */
+interface SplitInfo {
+    type: SplitTypeValue;
+    recipientId: string;
+    recipientType: string;
+    rate: number;
+    grossAmount: number;
+    gatewayFeeRate: number;
+    gatewayFeeAmount: number;
+    netAmount: number;
+    status: SplitStatusValue;
+    dueDate?: Date | null;
+    paidDate?: Date;
+    payoutTransactionId?: string;
+    metadata: Record<string, unknown>;
+}
+/** Payment intent parameters */
+interface CreateIntentParams {
+    amount: number;
+    currency?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Payment intent data */
+interface PaymentIntentData {
+    id: string;
+    sessionId?: string | null;
+    paymentIntentId?: string | null;
+    provider: string;
+    status: string;
+    amount: number;
+    currency?: string;
+    metadata?: Record<string, unknown>;
+    clientSecret?: string;
+    paymentUrl?: string;
+    instructions?: string;
+    raw?: unknown;
+}
+/** Payment result data */
+interface PaymentResultData {
+    id: string;
+    provider: string;
+    status: 'succeeded' | 'failed' | 'processing';
+    amount?: number;
+    currency?: string;
+    paidAt?: Date;
+    metadata?: Record<string, unknown>;
+    raw?: unknown;
+}
+/** Refund result data */
+interface RefundResultData {
+    id: string;
+    provider: string;
+    status: 'succeeded' | 'failed' | 'processing';
+    amount?: number;
+    currency?: string;
+    refundedAt?: Date;
+    reason?: string;
+    metadata?: Record<string, unknown>;
+    raw?: unknown;
+}
+/** Webhook event data */
+interface WebhookEventData {
+    id: string;
+    provider: string;
+    type: string;
+    data: {
+        sessionId?: string;
+        paymentIntentId?: string;
+        [key: string]: unknown;
+    };
+    createdAt?: Date;
+    raw?: unknown;
+}
+/** Provider capabilities */
+interface ProviderCapabilities {
+    supportsWebhooks: boolean;
+    supportsRefunds: boolean;
+    supportsPartialRefunds: boolean;
+    requiresManualVerification: boolean;
+}
+/** Models registry */
+interface ModelsRegistry {
+    Transaction: MongooseModel<TransactionDocument>;
+    Subscription?: MongooseModel<SubscriptionDocument>;
+}
+/** Provider registry */
+interface ProvidersRegistry {
+    [name: string]: PaymentProviderInterface;
+}
+/** Hook handlers registry */
+interface HooksRegistry {
+    [event: string]: Array<(data: unknown) => void | Promise<void>>;
+}
+/** Logger interface */
+interface Logger {
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    log?(...args: unknown[]): void;
+}
+/** Revenue configuration */
+interface RevenueConfig {
+    targetModels: string[];
+    categoryMappings: Record<string, string>;
+    commissionRates?: Record<string, number>;
+    gatewayFeeRates?: Record<string, number>;
+    transactionTypeMapping?: Record<string, TransactionTypeValue>;
+}
+/** Create revenue options */
+interface CreateRevenueOptions {
+    models: ModelsRegistry;
+    providers?: ProvidersRegistry;
+    hooks?: HooksRegistry;
+    config?: Partial<RevenueConfig>;
+    logger?: Logger;
+}
+/** Payment provider interface */
+interface PaymentProviderInterface {
+    name: string;
+    config: Record<string, unknown>;
+    createIntent(params: CreateIntentParams): Promise<PaymentIntentData>;
+    verifyPayment(intentId: string): Promise<PaymentResultData>;
+    getStatus(intentId: string): Promise<PaymentResultData>;
+    refund(paymentId: string, amount?: number | null, options?: {
+        reason?: string;
+    }): Promise<RefundResultData>;
+    handleWebhook(payload: unknown, headers?: Record<string, string>): Promise<WebhookEventData>;
+    verifyWebhookSignature(payload: unknown, signature: string): boolean;
+    getCapabilities(): ProviderCapabilities;
+}
+/** Monetization create data */
+interface MonetizationData {
+    organizationId?: string | ObjectId;
+    customerId?: string | ObjectId;
+    referenceId?: string | ObjectId;
+    referenceModel?: string;
+}
+/** Monetization create params */
+interface MonetizationCreateParams {
+    data: MonetizationData;
+    planKey: string;
+    amount: number;
+    currency?: string;
+    gateway?: string;
+    entity?: string | null;
+    monetizationType?: MonetizationTypeValue;
+    paymentData?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    idempotencyKey?: string | null;
+}
+/** Monetization create result */
+interface MonetizationCreateResult {
+    subscription: SubscriptionDocument | null;
+    transaction: TransactionDocument | null;
+    paymentIntent: PaymentIntentData | null;
+}
+/** Activation options */
+interface ActivateOptions {
+    timestamp?: Date;
+}
+/** Renewal params */
+interface RenewalParams {
+    gateway?: string;
+    entity?: string | null;
+    paymentData?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    idempotencyKey?: string | null;
+}
+/** Cancellation options */
+interface CancelOptions {
+    immediate?: boolean;
+    reason?: string | null;
+}
+/** Pause options */
+interface PauseOptions {
+    reason?: string | null;
+}
+/** Resume options */
+interface ResumeOptions {
+    extendPeriod?: boolean;
+}
+/** List options */
+interface ListOptions {
+    limit?: number;
+    skip?: number;
+    page?: number | null;
+    sort?: Record<string, 1 | -1>;
+    populate?: string[];
+}
+/** Payment verify options */
+interface PaymentVerifyOptions {
+    verifiedBy?: string | null;
+}
+/** Payment verify result */
+interface PaymentVerifyResult {
+    transaction: TransactionDocument;
+    paymentResult: PaymentResultData | null;
+    status: TransactionStatusValue;
+}
+/** Payment status result */
+interface PaymentStatusResult {
+    transaction: TransactionDocument;
+    paymentResult?: PaymentResultData | null;
+    status: TransactionStatusValue | string;
+    provider?: string;
+}
+/** Refund options */
+interface RefundOptions {
+    reason?: string | null;
+}
+/** Payment refund result */
+interface PaymentRefundResult {
+    transaction: TransactionDocument;
+    refundTransaction: TransactionDocument;
+    refundResult: RefundResultData;
+    status: TransactionStatusValue;
+}
+/** Webhook result */
+interface WebhookResult {
+    event: WebhookEventData;
+    transaction: TransactionDocument;
+    status: 'processed' | 'already_processed';
+}
+/** Transaction list result */
+interface TransactionListResult {
+    transactions: TransactionDocument[];
+    total: number;
+    page: number;
+    limit: number;
+    pages: number;
+}
+/** Hold options */
+interface HoldOptions {
+    reason?: HoldReasonValue;
+    holdUntil?: Date | null;
+    metadata?: Record<string, unknown>;
+}
+/** Release options */
+interface ReleaseOptions {
+    amount?: number | null;
+    recipientId: string;
+    recipientType?: string;
+    reason?: ReleaseReasonValue;
+    releasedBy?: string | null;
+    createTransaction?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/** Release result */
+interface ReleaseResult {
+    transaction: TransactionDocument;
+    releaseTransaction: TransactionDocument | null;
+    releaseAmount: number;
+    isFullRelease: boolean;
+    isPartialRelease: boolean;
+}
+/** Cancel hold options */
+interface CancelHoldOptions {
+    reason?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Split result */
+interface SplitResult {
+    transaction: TransactionDocument;
+    splits: SplitInfo[];
+    splitTransactions: TransactionDocument[];
+    organizationTransaction: TransactionDocument | null;
+    organizationPayout: number;
+}
+/** Escrow status result */
+interface EscrowStatusResult {
+    transaction: TransactionDocument;
+    hold: HoldInfo | null;
+    splits: SplitInfo[];
+    hasHold: boolean;
+    hasSplits: boolean;
+}
+/** Period range params */
+interface PeriodRangeParams {
+    currentEndDate?: Date | null;
+    startDate?: Date | null;
+    duration: number;
+    unit?: 'days' | 'weeks' | 'months' | 'years';
+    now?: Date;
+}
+/** Period range result */
+interface PeriodRangeResult {
+    startDate: Date;
+    endDate: Date;
+}
+/** Prorated amount params */
+interface ProratedAmountParams {
+    amountPaid: number;
+    startDate: Date;
+    endDate: Date;
+    asOfDate?: Date;
+    precision?: number;
+}
+/** Duration result */
+interface DurationResult {
+    duration: number;
+    unit: 'days' | 'weeks' | 'months' | 'years';
+}
+/** Subscription entity for action checks */
+interface SubscriptionEntity {
+    subscription?: {
+        isActive?: boolean;
+        endDate?: Date;
+        canceledAt?: Date;
+    };
+    status?: SubscriptionStatusValue;
+}
+/** Commission with splits options */
+interface CommissionWithSplitsOptions {
+    affiliateRate?: number;
+    affiliateId?: string | null;
+    affiliateType?: string;
+}
+/** Transaction type detection options */
+interface TransactionTypeOptions {
+    targetModels?: string[];
+    additionalCategories?: string[];
+}
+/** Field update validation result */
+interface FieldUpdateValidationResult {
+    allowed: boolean;
+    reason?: string;
+}
+
+export type { TransactionListResult as $, RevenueConfig as A, CreateRevenueOptions as B, CommissionInfo as C, MonetizationData as D, MonetizationCreateParams as E, MonetizationCreateResult as F, ActivateOptions as G, HoldInfo as H, RenewalParams as I, CancelOptions as J, PauseOptions as K, Logger as L, MongooseDoc as M, ResumeOptions as N, ObjectId as O, PlanKeyValue as P, ListOptions as Q, ReleaseRecord as R, SubscriptionStatusValue as S, TransactionStatusValue as T, PaymentVerifyOptions as U, PaymentVerifyResult as V, WebhookInfo as W, PaymentStatusResult as X, RefundOptions as Y, PaymentRefundResult as Z, WebhookResult as _, MongooseModel as a, HoldOptions as a0, ReleaseOptions as a1, ReleaseResult as a2, CancelHoldOptions as a3, SplitResult as a4, EscrowStatusResult as a5, PeriodRangeParams as a6, PeriodRangeResult as a7, ProratedAmountParams as a8, DurationResult as a9, SubscriptionEntity as aa, CommissionWithSplitsOptions as ab, TransactionTypeOptions as ac, FieldUpdateValidationResult as ad, TransactionTypeValue as b, TransactionGateway as c, TransactionDocument as d, SubscriptionDocument as e, PaymentStatusValue as f, PaymentGatewayTypeValue as g, MonetizationTypeValue as h, HoldStatusValue as i, HoldReasonValue as j, ReleaseReasonValue as k, SplitTypeValue as l, SplitStatusValue as m, PayoutMethodValue as n, SplitRule as o, SplitInfo as p, CreateIntentParams as q, PaymentIntentData as r, PaymentResultData as s, RefundResultData as t, WebhookEventData as u, ProviderCapabilities as v, PaymentProviderInterface as w, ModelsRegistry as x, ProvidersRegistry as y, HooksRegistry as z };

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+import { o as ok, e as err, i as isOk, a as isErr, u as unwrap, b as unwrapOr, m as map, c as mapErr, f as flatMap, t as tryCatch, d as tryCatchSync, g as all, h as match } from './retry-80lBCmSe.js';
+export { C as CircuitBreaker, w as CircuitBreakerConfig, q as CircuitOpenError, v as CircuitState, E as Err, O as Ok, R as Result, n as RetryExhaustedError, k as calculateDelay, p as createCircuitBreaker, l as isRetryableError, s as resilientExecute, r as retry, j as retryWithResult } from './retry-80lBCmSe.js';
+import { Revenue, createRevenue, RevenueError, EventBus } from './core/index.js';
+export { AlreadyVerifiedError, BaseEvent, ConfigurationError, ERROR_CODES, ErrorCode, EscrowHeldEvent, EscrowReleasedEvent, HooksConfig, InvalidAmountError, InvalidStateTransitionError, MissingRequiredFieldError, ModelNotRegisteredError, ModelsConfig, NotFoundError, OperationError, PaymentFailedEvent, PaymentIntentCreationError, PaymentRefundedEvent, PaymentSucceededEvent, PaymentVerificationError, PluginContext, PluginHooks, PluginLogger, PluginManager, ProviderCapabilityError, ProviderError, ProviderNotFoundError, ProvidersConfig, RefundError, RefundNotSupportedError, RevenueBuilder, RevenueErrorOptions, RevenueEvents, RevenueOptions, RevenuePlugin, StateError, SubscriptionActivatedEvent, SubscriptionCancelledEvent, SubscriptionCreatedEvent, SubscriptionNotActiveError, SubscriptionNotFoundError, SubscriptionRenewedEvent, TransactionCreatedEvent, TransactionNotFoundError, TransactionVerifiedEvent, ValidationError, auditPlugin, createEventBus, definePlugin, isRetryable, isRevenueError, loggingPlugin, metricsPlugin } from './core/index.js';
+export { C as Container, E as EscrowService, M as MonetizationService, P as PaymentService, T as TransactionService } from './index-BnJWVXuw.js';
+import { M as Money } from './actions-CwG-b7fR.js';
+export { E as EDITABLE_MONETIZATION_FIELDS_PRE_VERIFICATION, h as IdempotencyConfig, c as IdempotencyError, I as IdempotencyManager, e as IdempotencyRecord, g as IdempotencyStore, z as MANUAL_TRANSACTION_CREATE_FIELDS, A as MANUAL_TRANSACTION_UPDATE_FIELDS, b as MemoryIdempotencyStore, a as MoneyValue, P as PROTECTED_MONETIZATION_FIELDS, T as TRANSACTION_MANAGEMENT_TYPE, B as addDuration, i as calculateCommission, n as calculateCommissionWithSplits, k as calculateOrganizationPayout, C as calculatePeriodRange, D as calculateProratedAmount, j as calculateSplits, J as canCancelSubscription, K as canPauseSubscription, H as canRenewSubscription, L as canResumeSubscription, y as canSelfVerify, d as createIdempotencyManager, f as fromSmallestUnit, w as getAllowedUpdateFields, v as getTransactionType, p as isCategoryValid, u as isManualTransaction, q as isMonetizationTransaction, G as isSubscriptionActive, l as logger, o as resolveCategory, F as resolveIntervalToDuration, r as reverseCommission, m as reverseSplits, s as setLogger, t as toSmallestUnit, x as validateFieldUpdate } from './actions-CwG-b7fR.js';
+export { CancelSubscriptionInput, CancelSubscriptionSchema, CommissionConfig, CommissionConfigSchema, CreateHoldInput, CreateHoldSchema, CreateMonetizationSchema, CreatePaymentInput, CreatePaymentSchema, CreateSubscriptionInput, CreateSubscriptionSchema, CurrencySchema, EmailSchema, HoldStatus, HoldStatusSchema, IdempotencyKeySchema, Interval, IntervalSchema, MetadataSchema, MonetizationType, MonetizationTypeSchema, MoneyAmountSchema, MoneySchema, ObjectIdSchema, ProviderConfigSchema, RefundInput, RefundSchema, ReleaseHoldInput, ReleaseHoldSchema, RetryConfig, RetryConfigSchema, RevenueConfigInput, RevenueConfigSchema, SplitRecipient, SplitRecipientSchema, SubscriptionStatus, SubscriptionStatusSchema, VerifyPaymentInput, VerifyPaymentSchema, formatZodError, safeValidate, validate } from './schemas/validation.js';
+import { PaymentProvider } from './providers/index.js';
+export { PaymentIntent, PaymentResult, RefundResult, WebhookEvent } from './providers/index.js';
+export { G as GATEWAY_TYPES, n as GATEWAY_TYPE_VALUES, x as HOLD_REASON, z as HOLD_REASON_VALUES, H as HOLD_STATUS, u as HOLD_STATUS_VALUES, y as HoldReason, L as LIBRARY_CATEGORIES, h as LIBRARY_CATEGORY_VALUES, f as LibraryCategories, g as LibraryCategoryValue, M as MONETIZATION_TYPES, t as MONETIZATION_TYPE_VALUES, s as MonetizationTypes, k as PAYMENT_GATEWAY_TYPE, m as PAYMENT_GATEWAY_TYPE_VALUES, P as PAYMENT_STATUS, j as PAYMENT_STATUS_VALUES, I as PAYOUT_METHOD, K as PAYOUT_METHOD_VALUES, p as PLAN_KEYS, r as PLAN_KEY_VALUES, l as PaymentGatewayType, i as PaymentStatus, J as PayoutMethod, q as PlanKeys, R as RELEASE_REASON, w as RELEASE_REASON_VALUES, v as ReleaseReason, D as SPLIT_STATUS, F as SPLIT_STATUS_VALUES, A as SPLIT_TYPE, C as SPLIT_TYPE_VALUES, S as SUBSCRIPTION_STATUS, o as SUBSCRIPTION_STATUS_VALUES, E as SplitStatus, B as SplitType, c as TRANSACTION_STATUS, e as TRANSACTION_STATUS_VALUES, T as TRANSACTION_TYPE, b as TRANSACTION_TYPE_VALUES, d as TransactionStatus, a as TransactionType } from './split.enums-DHdM1YAV.js';
+export { b as baseMetadataSchema, d as commissionSchema, c as currentPaymentSchema, g as gatewaySchema, h as holdSchema, a as paymentDetailsSchema, p as paymentSummarySchema, e as planSchema, r as referenceSchema, f as splitSchema, s as subscriptionInfoSchema, t as tenantSnapshotSchema } from './split.schema-BPdFZMbU.js';
+export { G as ActivateOptions, a3 as CancelHoldOptions, J as CancelOptions, C as CommissionInfo, ab as CommissionWithSplitsOptions, q as CreateIntentParams, B as CreateRevenueOptions, a9 as DurationResult, a5 as EscrowStatusResult, ad as FieldUpdateValidationResult, H as HoldInfo, a0 as HoldOptions, j as HoldReasonValue, i as HoldStatusValue, z as HooksRegistry, Q as ListOptions, L as Logger, x as ModelsRegistry, E as MonetizationCreateParams, F as MonetizationCreateResult, D as MonetizationData, h as MonetizationTypeValue, M as MongooseDoc, a as MongooseModel, O as ObjectId, K as PauseOptions, g as PaymentGatewayTypeValue, r as PaymentIntentData, w as PaymentProviderInterface, Z as PaymentRefundResult, s as PaymentResultData, X as PaymentStatusResult, f as PaymentStatusValue, U as PaymentVerifyOptions, V as PaymentVerifyResult, n as PayoutMethodValue, a6 as PeriodRangeParams, a7 as PeriodRangeResult, P as PlanKeyValue, a8 as ProratedAmountParams, v as ProviderCapabilities, y as ProvidersRegistry, Y as RefundOptions, t as RefundResultData, a1 as ReleaseOptions, k as ReleaseReasonValue, R as ReleaseRecord, a2 as ReleaseResult, I as RenewalParams, N as ResumeOptions, A as RevenueConfig, p as SplitInfo, a4 as SplitResult, o as SplitRule, m as SplitStatusValue, l as SplitTypeValue, e as SubscriptionDocument, aa as SubscriptionEntity, S as SubscriptionStatusValue, d as TransactionDocument, c as TransactionGateway, $ as TransactionListResult, T as TransactionStatusValue, ac as TransactionTypeOptions, b as TransactionTypeValue, u as WebhookEventData, W as WebhookInfo, _ as WebhookResult } from './index-ChVD3P9k.js';
+import * as z from 'zod';
+export { z };
+import 'mongoose';
+
+declare const _default: {
+    Revenue: typeof Revenue;
+    createRevenue: typeof createRevenue;
+    PaymentProvider: typeof PaymentProvider;
+    RevenueError: typeof RevenueError;
+    Money: typeof Money;
+    Result: {
+        readonly ok: typeof ok;
+        readonly err: typeof err;
+        readonly isOk: typeof isOk;
+        readonly isErr: typeof isErr;
+        readonly unwrap: typeof unwrap;
+        readonly unwrapOr: typeof unwrapOr;
+        readonly map: typeof map;
+        readonly mapErr: typeof mapErr;
+        readonly flatMap: typeof flatMap;
+        readonly tryCatch: typeof tryCatch;
+        readonly tryCatchSync: typeof tryCatchSync;
+        readonly all: typeof all;
+        readonly match: typeof match;
+    };
+    EventBus: typeof EventBus;
+};
+
+export { EventBus, Money, PaymentProvider, Revenue, RevenueError, all, createRevenue, _default as default, err, flatMap, isErr, isOk, map, mapErr, match, ok, tryCatch, tryCatchSync, unwrap, unwrapOr };