@classytic/revenue 1.1.4 → 2.0.0

package/dist/monetization.enums-BtiU3t8o.mjs

@@ -0,0 +1,39 @@
+//#region src/enums/payment.enums.ts
+const PAYMENT_STATUS = {
+	PENDING: "pending",
+	VERIFIED: "verified",
+	FAILED: "failed",
+	REFUNDED: "refunded",
+	CANCELLED: "cancelled"
+};
+const PAYMENT_STATUS_VALUES = Object.values(PAYMENT_STATUS);
+const PAYMENT_GATEWAY_TYPE = {
+	MANUAL: "manual",
+	STRIPE: "stripe",
+	SSLCOMMERZ: "sslcommerz"
+};
+const PAYMENT_GATEWAY_TYPE_VALUES = Object.values(PAYMENT_GATEWAY_TYPE);
+const paymentStatusSet = new Set(PAYMENT_STATUS_VALUES);
+const paymentGatewayTypeSet = new Set(PAYMENT_GATEWAY_TYPE_VALUES);
+function isPaymentStatus(value) {
+	return typeof value === "string" && paymentStatusSet.has(value);
+}
+function isPaymentGatewayType(value) {
+	return typeof value === "string" && paymentGatewayTypeSet.has(value);
+}
+
+//#endregion
+//#region src/enums/monetization.enums.ts
+const MONETIZATION_TYPES = {
+	FREE: "free",
+	PURCHASE: "purchase",
+	SUBSCRIPTION: "subscription"
+};
+const MONETIZATION_TYPE_VALUES = Object.values(MONETIZATION_TYPES);
+const monetizationTypeSet = new Set(MONETIZATION_TYPE_VALUES);
+function isMonetizationType(value) {
+	return typeof value === "string" && monetizationTypeSet.has(value);
+}
+
+//#endregion
+export { PAYMENT_GATEWAY_TYPE_VALUES as a, isPaymentGatewayType as c, PAYMENT_GATEWAY_TYPE as i, isPaymentStatus as l, MONETIZATION_TYPE_VALUES as n, PAYMENT_STATUS as o, isMonetizationType as r, PAYMENT_STATUS_VALUES as s, MONETIZATION_TYPES as t };

package/dist/monetization.enums-D2xbxXJM.d.mts

@@ -0,0 +1,34 @@
+//#region src/enums/payment.enums.d.ts
+declare const PAYMENT_STATUS: {
+  readonly PENDING: "pending";
+  readonly VERIFIED: "verified";
+  readonly FAILED: "failed";
+  readonly REFUNDED: "refunded";
+  readonly CANCELLED: "cancelled";
+};
+type PaymentStatus = typeof PAYMENT_STATUS;
+type PaymentStatusValue = PaymentStatus[keyof PaymentStatus];
+declare const PAYMENT_STATUS_VALUES: PaymentStatusValue[];
+declare const PAYMENT_GATEWAY_TYPE: {
+  readonly MANUAL: "manual";
+  readonly STRIPE: "stripe";
+  readonly SSLCOMMERZ: "sslcommerz";
+};
+type PaymentGatewayType = typeof PAYMENT_GATEWAY_TYPE;
+type PaymentGatewayTypeValue = PaymentGatewayType[keyof PaymentGatewayType];
+declare const PAYMENT_GATEWAY_TYPE_VALUES: PaymentGatewayTypeValue[];
+declare function isPaymentStatus(value: unknown): value is PaymentStatusValue;
+declare function isPaymentGatewayType(value: unknown): value is PaymentGatewayTypeValue;
+//#endregion
+//#region src/enums/monetization.enums.d.ts
+declare const MONETIZATION_TYPES: {
+  readonly FREE: "free";
+  readonly PURCHASE: "purchase";
+  readonly SUBSCRIPTION: "subscription";
+};
+type MonetizationTypes = typeof MONETIZATION_TYPES;
+type MonetizationTypeValue = MonetizationTypes[keyof MonetizationTypes];
+declare const MONETIZATION_TYPE_VALUES: MonetizationTypeValue[];
+declare function isMonetizationType(value: unknown): value is MonetizationTypeValue;
+//#endregion
+export { isMonetizationType as a, PAYMENT_STATUS as c, PaymentGatewayTypeValue as d, PaymentStatus as f, isPaymentStatus as h, MonetizationTypes as i, PAYMENT_STATUS_VALUES as l, isPaymentGatewayType as m, MONETIZATION_TYPE_VALUES as n, PAYMENT_GATEWAY_TYPE as o, PaymentStatusValue as p, MonetizationTypeValue as r, PAYMENT_GATEWAY_TYPE_VALUES as s, MONETIZATION_TYPES as t, PaymentGatewayType as u };

package/dist/plugins/plugin.interface.d.mts

@@ -0,0 +1,28 @@
+//#region src/plugins/plugin.interface.d.ts
+type HookPhase = 'before' | 'after';
+interface PluginContext {
+  logger?: {
+    info: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+  };
+  storage: Map<string, unknown>;
+  meta: {
+    idempotencyKey?: string;
+    requestId: string;
+    timestamp: Date;
+    [key: string]: unknown;
+  };
+}
+type HookHandler = (ctx: PluginContext, input: any, next: () => Promise<any>) => Promise<any>;
+interface RevenuePluginDefinition {
+  name: string;
+  hooks?: Record<string, HookHandler>;
+}
+declare class PluginManager {
+  private plugins;
+  register(plugin: RevenuePluginDefinition): void;
+  getHooks(hookName: string): HookHandler[];
+  executeHook(hookName: string, ctx: PluginContext, input: any, execute: () => Promise<any>): Promise<any>;
+}
+//#endregion
+export { HookHandler, HookPhase, PluginContext, PluginManager, RevenuePluginDefinition };

package/dist/plugins/plugin.interface.mjs

@@ -0,0 +1,26 @@
+//#region src/plugins/plugin.interface.ts
+var PluginManager = class {
+	plugins = [];
+	register(plugin) {
+		this.plugins.push(plugin);
+	}
+	getHooks(hookName) {
+		return this.plugins.filter((p) => p.hooks?.[hookName]).map((p) => p.hooks[hookName]);
+	}
+	async executeHook(hookName, ctx, input, execute) {
+		const hooks = this.getHooks(hookName);
+		if (hooks.length === 0) return execute();
+		let index = 0;
+		const next = async () => {
+			if (index < hooks.length) {
+				const hook = hooks[index++];
+				return hook(ctx, input, next);
+			}
+			return execute();
+		};
+		return next();
+	}
+};
+
+//#endregion
+export { PluginManager };

package/dist/providers/index.d.mts

@@ -1,3 +1,2 @@
-import { D as ProviderCapabilities, W as WebhookEventData, _ as PaymentIntentData, a as CreateIntentParams, b as PaymentResultData, k as RefundResultData } from "../index-Dsp7H5Wb.mjs";
-import { a as WebhookEvent, i as RefundResult, n as PaymentProvider, r as PaymentResult, t as PaymentIntent } from "../base-CsTlVQJe.mjs";
-export { type CreateIntentParams, PaymentIntent, type PaymentIntentData, PaymentProvider, type PaymentProvider as PaymentProviderDefault, PaymentResult, type PaymentResultData, type ProviderCapabilities, RefundResult, type RefundResultData, WebhookEvent, type WebhookEventData };
+import { a as PaymentIntentData, c as PaymentResultData, d as RefundResultData, f as WebhookEvent, i as PaymentIntent, l as ProviderCapabilities, n as createProviderRegistry, o as PaymentProvider, p as WebhookEventData, r as CreateIntentParams, s as PaymentResult, t as ProviderRegistry, u as RefundResult } from "../registry-SvIGPAx_.mjs";
+export { type CreateIntentParams, PaymentIntent, type PaymentIntentData, PaymentProvider, PaymentResult, type PaymentResultData, type ProviderCapabilities, ProviderRegistry, RefundResult, type RefundResultData, WebhookEvent, type WebhookEventData, createProviderRegistry };

package/dist/providers/index.mjs

@@ -1,3 +1,3 @@
-import { a as WebhookEvent, i as RefundResult, n as PaymentProvider, r as PaymentResult, t as PaymentIntent } from "../base-DCoyIUj6.mjs";
+import { a as PaymentResult, i as PaymentProvider, n as createProviderRegistry, o as RefundResult, r as PaymentIntent, s as WebhookEvent, t as ProviderRegistry } from "../registry-DhFMsSn5.mjs";
 
-export { PaymentIntent, PaymentProvider, PaymentResult, RefundResult, WebhookEvent };
+export { PaymentIntent, PaymentProvider, PaymentResult, ProviderRegistry, RefundResult, WebhookEvent, createProviderRegistry };

package/dist/{base-DCoyIUj6.mjs → registry-DhFMsSn5.mjs}

@@ -1,7 +1,6 @@
+import { s as ProviderNotFoundError } from "./errors-DHa8JVQ-.mjs";
+
 //#region src/providers/base.ts
-/**
-* Payment Intent - standardized response from createIntent
-*/
 var PaymentIntent = class {
 	id;
 	sessionId;
@@ -30,9 +29,6 @@ var PaymentIntent = class {
 		this.raw = data.raw;
 	}
 };
-/**
-* Payment Result - standardized response from verifyPayment
-*/
 var PaymentResult = class {
 	id;
 	provider;
@@ -53,9 +49,6 @@ var PaymentResult = class {
 		this.raw = data.raw;
 	}
 };
-/**
-* Refund Result - standardized response from refund
-*/
 var RefundResult = class {
 	id;
 	provider;
@@ -78,9 +71,6 @@ var RefundResult = class {
 		this.raw = data.raw;
 	}
 };
-/**
-* Webhook Event - standardized webhook event
-*/
 var WebhookEvent = class {
 	id;
 	provider;
@@ -97,47 +87,24 @@ var WebhookEvent = class {
 		this.raw = data.raw;
 	}
 };
-/**
-* Base Payment Provider
-* All payment providers must extend this class
-*/
 var PaymentProvider = class {
 	config;
 	name;
-	/** Default currency - injected by Revenue when provider is registered */
 	_defaultCurrency = "USD";
 	constructor(config = {}) {
 		this.config = config;
 		this.name = "base";
 		if (config.defaultCurrency && typeof config.defaultCurrency === "string") this._defaultCurrency = config.defaultCurrency;
 	}
-	/**
-	* Get the default currency for this provider
-	* Used when creating PaymentIntent, PaymentResult, RefundResult without explicit currency
-	*/
 	get defaultCurrency() {
 		return this._defaultCurrency;
 	}
-	/**
-	* Set the default currency (called by Revenue when registering provider)
-	* @internal
-	*/
 	setDefaultCurrency(currency) {
 		this._defaultCurrency = currency;
 	}
-	/**
-	* Verify webhook signature (optional)
-	* @param payload - Webhook payload
-	* @param signature - Webhook signature
-	* @returns boolean
-	*/
 	verifyWebhookSignature(_payload, _signature) {
 		return true;
 	}
-	/**
-	* Get provider capabilities
-	* @returns ProviderCapabilities
-	*/
 	getCapabilities() {
 		return {
 			supportsWebhooks: false,
@@ -149,4 +116,35 @@ var PaymentProvider = class {
 };
 
 //#endregion
-export { WebhookEvent as a, RefundResult as i, PaymentProvider as n, PaymentResult as r, PaymentIntent as t };
+//#region src/providers/registry.ts
+var ProviderRegistry = class {
+	providers = /* @__PURE__ */ new Map();
+	register(name, provider) {
+		this.providers.set(name, provider);
+	}
+	get(name) {
+		const provider = this.providers.get(name);
+		if (!provider) throw new ProviderNotFoundError(name);
+		return provider;
+	}
+	has(name) {
+		return this.providers.has(name);
+	}
+	list() {
+		return Array.from(this.providers.keys());
+	}
+	setDefaultCurrency(currency) {
+		for (const provider of this.providers.values()) provider.setDefaultCurrency(currency);
+	}
+};
+function createProviderRegistry(providers = {}, defaultCurrency) {
+	const registry = new ProviderRegistry();
+	for (const [name, provider] of Object.entries(providers)) {
+		if (defaultCurrency) provider.setDefaultCurrency(defaultCurrency);
+		registry.register(name, provider);
+	}
+	return registry;
+}
+
+//#endregion
+export { PaymentResult as a, PaymentProvider as i, createProviderRegistry as n, RefundResult as o, PaymentIntent as r, WebhookEvent as s, ProviderRegistry as t };

package/dist/{base-CsTlVQJe.d.mts → registry-SvIGPAx_.d.mts}

@@ -1,9 +1,65 @@
-import { D as ProviderCapabilities, W as WebhookEventData, _ as PaymentIntentData, a as CreateIntentParams, b as PaymentResultData, k as RefundResultData } from "./index-Dsp7H5Wb.mjs";
-
 //#region src/providers/base.d.ts
-/**
- * Payment Intent - standardized response from createIntent
- */
+interface CreateIntentParams {
+  amount: number;
+  currency: string;
+  metadata?: Record<string, unknown>;
+  customerId?: string;
+  returnUrl?: string;
+  [key: string]: unknown;
+}
+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;
+}
+interface PaymentResultData {
+  id: string;
+  provider: string;
+  status: 'succeeded' | 'failed' | 'processing' | 'requires_action';
+  amount?: number;
+  currency?: string;
+  paidAt?: Date;
+  metadata?: Record<string, unknown>;
+  raw?: unknown;
+}
+interface RefundResultData {
+  id: string;
+  provider: string;
+  status: 'succeeded' | 'failed' | 'processing';
+  amount?: number;
+  currency?: string;
+  refundedAt?: Date;
+  reason?: string;
+  metadata?: Record<string, unknown>;
+  raw?: unknown;
+}
+interface WebhookEventData {
+  id: string;
+  provider: string;
+  type: string;
+  data: {
+    sessionId?: string;
+    paymentIntentId?: string;
+    [key: string]: unknown;
+  };
+  createdAt?: Date;
+  raw?: unknown;
+}
+interface ProviderCapabilities {
+  supportsWebhooks: boolean;
+  supportsRefunds: boolean;
+  supportsPartialRefunds: boolean;
+  requiresManualVerification: boolean;
+}
 declare class PaymentIntent implements PaymentIntentData {
   readonly id: string;
   readonly sessionId: string | null;
@@ -19,9 +75,6 @@ declare class PaymentIntent implements PaymentIntentData {
   readonly raw?: unknown;
   constructor(data: PaymentIntentData);
 }
-/**
- * Payment Result - standardized response from verifyPayment
- */
 declare class PaymentResult implements PaymentResultData {
   readonly id: string;
   readonly provider: string;
@@ -33,9 +86,6 @@ declare class PaymentResult implements PaymentResultData {
   readonly raw?: unknown;
   constructor(data: PaymentResultData);
 }
-/**
- * Refund Result - standardized response from refund
- */
 declare class RefundResult implements RefundResultData {
   readonly id: string;
   readonly provider: string;
@@ -48,9 +98,6 @@ declare class RefundResult implements RefundResultData {
   readonly raw?: unknown;
   constructor(data: RefundResultData);
 }
-/**
- * Webhook Event - standardized webhook event
- */
 declare class WebhookEvent implements WebhookEventData {
   readonly id: string;
   readonly provider: string;
@@ -64,73 +111,33 @@ declare class WebhookEvent implements WebhookEventData {
   readonly raw?: unknown;
   constructor(data: WebhookEventData);
 }
-/**
- * Base Payment Provider
- * All payment providers must extend this class
- */
 declare abstract class PaymentProvider {
   readonly config: Record<string, unknown>;
   readonly name: string;
-  /** Default currency - injected by Revenue when provider is registered */
   private _defaultCurrency;
   constructor(config?: Record<string, unknown>);
-  /**
-   * Get the default currency for this provider
-   * Used when creating PaymentIntent, PaymentResult, RefundResult without explicit currency
-   */
   get defaultCurrency(): string;
-  /**
-   * Set the default currency (called by Revenue when registering provider)
-   * @internal
-   */
   setDefaultCurrency(currency: string): void;
-  /**
-   * Create a payment intent
-   * @param params - Payment parameters
-   * @returns Promise<PaymentIntent>
-   */
   abstract createIntent(params: CreateIntentParams): Promise<PaymentIntent>;
-  /**
-   * Verify a payment
-   * @param intentId - Payment intent ID
-   * @returns Promise<PaymentResult>
-   */
   abstract verifyPayment(intentId: string): Promise<PaymentResult>;
-  /**
-   * Get payment status
-   * @param intentId - Payment intent ID
-   * @returns Promise<PaymentResult>
-   */
   abstract getStatus(intentId: string): Promise<PaymentResult>;
-  /**
-   * Refund a payment
-   * @param paymentId - Payment ID
-   * @param amount - Amount to refund (optional, full refund if not provided)
-   * @param options - Refund options
-   * @returns Promise<RefundResult>
-   */
   abstract refund(paymentId: string, amount?: number | null, options?: {
     reason?: string;
   }): Promise<RefundResult>;
-  /**
-   * Handle webhook from provider
-   * @param payload - Webhook payload
-   * @param headers - Request headers (for signature verification)
-   * @returns Promise<WebhookEvent>
-   */
   abstract handleWebhook(payload: unknown, headers?: Record<string, string>): Promise<WebhookEvent>;
-  /**
-   * Verify webhook signature (optional)
-   * @param payload - Webhook payload
-   * @param signature - Webhook signature
-   * @returns boolean
-   */
   verifyWebhookSignature(_payload: unknown, _signature: string): boolean;
-  /**
-   * Get provider capabilities
-   * @returns ProviderCapabilities
-   */
   getCapabilities(): ProviderCapabilities;
 }
 //#endregion
-export { WebhookEvent as a, RefundResult as i, PaymentProvider as n, PaymentResult as r, PaymentIntent as t };
+//#region src/providers/registry.d.ts
+declare class ProviderRegistry {
+  private providers;
+  register(name: string, provider: PaymentProvider): void;
+  get(name: string): PaymentProvider;
+  has(name: string): boolean;
+  list(): string[];
+  setDefaultCurrency(currency: string): void;
+}
+declare function createProviderRegistry(providers?: Record<string, PaymentProvider>, defaultCurrency?: string): ProviderRegistry;
+//#endregion
+export { PaymentIntentData as a, PaymentResultData as c, RefundResultData as d, WebhookEvent as f, PaymentIntent as i, ProviderCapabilities as l, createProviderRegistry as n, PaymentProvider as o, WebhookEventData as p, CreateIntentParams as r, PaymentResult as s, ProviderRegistry as t, RefundResult as u };

package/dist/repositories/create-repositories.d.mts

@@ -0,0 +1,21 @@
+import { a as SettlementRepository, c as RevenueModels, o as SubscriptionRepository, s as TransactionRepository } from "../engine-types-CcjIb4Fy.mjs";
+import { PluginType } from "@classytic/mongokit";
+
+//#region src/repositories/create-repositories.d.ts
+interface RevenueRepositories {
+  transaction: TransactionRepository;
+  subscription?: SubscriptionRepository;
+  settlement?: SettlementRepository;
+}
+interface RepositoryPluginBundle {
+  transaction?: PluginType[];
+  subscription?: PluginType[];
+  settlement?: PluginType[];
+}
+declare function createRevenueRepositories(models: RevenueModels, builtInPlugins: {
+  transaction: PluginType[];
+  subscription: PluginType[];
+  settlement: PluginType[];
+}, hostPlugins?: RepositoryPluginBundle): RevenueRepositories;
+//#endregion
+export { RepositoryPluginBundle, RevenueRepositories, createRevenueRepositories };

package/dist/repositories/create-repositories.mjs

@@ -0,0 +1,12 @@
+import { n as SubscriptionRepository, r as TransactionRepository, t as SettlementRepository } from "../settlement.repository-Cy3mMWGH.mjs";
+
+//#region src/repositories/create-repositories.ts
+function createRevenueRepositories(models, builtInPlugins, hostPlugins = {}) {
+	const repos = { transaction: new TransactionRepository(models.Transaction, [...builtInPlugins.transaction, ...hostPlugins.transaction ?? []]) };
+	if (models.Subscription) repos.subscription = new SubscriptionRepository(models.Subscription, [...builtInPlugins.subscription, ...hostPlugins.subscription ?? []]);
+	if (models.Settlement) repos.settlement = new SettlementRepository(models.Settlement, [...builtInPlugins.settlement, ...hostPlugins.settlement ?? []]);
+	return repos;
+}
+
+//#endregion
+export { createRevenueRepositories };

package/dist/revenue-bridges-sdlrR85c.d.mts

@@ -0,0 +1,145 @@
+import { t as RevenueContext } from "./context-DRqSeTPM.mjs";
+
+//#region src/bridges/ledger.bridge.d.ts
+interface LedgerBridge {
+  onPaymentVerified?(transaction: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
+  onRefundProcessed?(original: Record<string, unknown>, refund: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
+  onSettlementCompleted?(settlement: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
+}
+//#endregion
+//#region src/bridges/tax.bridge.d.ts
+interface TaxBridge {
+  computeTax?(amount: number, taxClass: string, ctx: RevenueContext): Promise<{
+    rate: number;
+    amount: number;
+    inclusive: boolean;
+  }>;
+}
+//#endregion
+//#region src/bridges/notification.bridge.d.ts
+interface NotificationBridge {
+  onPaymentVerified?(transaction: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
+  onRefundProcessed?(transaction: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
+  onSubscriptionCreated?(subscription: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
+  onSubscriptionCancelled?(subscription: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
+  onSettlementCompleted?(settlement: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
+}
+//#endregion
+//#region src/bridges/currency.bridge.d.ts
+interface CurrencyBridge {
+  convert?(amount: number, from: string, to: string, date?: Date): Promise<{
+    amount: number;
+    rate: number;
+  }>;
+}
+//#endregion
+//#region src/bridges/customer.bridge.d.ts
+interface CustomerBridge {
+  getCustomer?(customerId: string): Promise<{
+    id: string;
+    name?: string;
+    email?: string;
+    metadata?: Record<string, unknown>;
+  } | null>;
+}
+//#endregion
+//#region src/bridges/analytics.bridge.d.ts
+interface AnalyticsBridge {
+  trackEvent?(name: string, payload: Record<string, unknown>): Promise<void>;
+}
+//#endregion
+//#region src/bridges/source.bridge.d.ts
+/**
+ * SourceBridge — resolve polymorphic source documents (Order, Invoice, Subscription, etc.)
+ *
+ * Revenue stores `sourceId` as a String to support any ID format:
+ *   • Mongoose ObjectId hex strings (same MongoDB)
+ *   • UUIDs (Postgres, external systems)
+ *   • Stripe IDs (pi_..., ch_..., sub_...)
+ *   • REST API IDs (any string)
+ *
+ * The host implements this bridge to teach revenue how to load source documents.
+ *
+ * @example Same MongoDB, same connection
+ * ```typescript
+ * const sourceBridge: SourceBridge = {
+ *   async resolve(sourceId, sourceModel, ctx) {
+ *     const Model = mongoose.connection.models[sourceModel];
+ *     return Model ? await Model.findById(sourceId).lean() : null;
+ *   },
+ * };
+ * ```
+ *
+ * @example Microservices (cross-DB Mongoose)
+ * ```typescript
+ * const sourceBridge: SourceBridge = {
+ *   async resolve(sourceId, sourceModel, ctx) {
+ *     if (sourceModel === 'Order') return await ordersDb.collection('orders').findOne({ _id: sourceId });
+ *     if (sourceModel === 'Invoice') return await invoicesDb.collection('invoices').findOne({ _id: sourceId });
+ *     return null;
+ *   },
+ * };
+ * ```
+ *
+ * @example External systems (REST/Stripe/Postgres)
+ * ```typescript
+ * const sourceBridge: SourceBridge = {
+ *   async resolve(sourceId, sourceModel, ctx) {
+ *     if (sourceModel === 'StripeCharge') {
+ *       return await stripe.charges.retrieve(sourceId);
+ *     }
+ *     if (sourceModel === 'PostgresOrder') {
+ *       const { rows } = await pg.query('SELECT * FROM orders WHERE id = $1', [sourceId]);
+ *       return rows[0];
+ *     }
+ *     return null;
+ *   },
+ * };
+ * ```
+ *
+ * @example Batch resolution (perf optimization)
+ * ```typescript
+ * const sourceBridge: SourceBridge = {
+ *   async resolve(sourceId, sourceModel, ctx) { ... },
+ *   async resolveMany(refs, ctx) {
+ *     // Group by sourceModel, batch fetch, return Map<sourceId, doc>
+ *     const result = new Map();
+ *     const byModel = groupBy(refs, r => r.sourceModel);
+ *     for (const [model, batch] of byModel) {
+ *       const ids = batch.map(b => b.sourceId);
+ *       const docs = await mongoose.connection.models[model].find({ _id: { $in: ids } }).lean();
+ *       docs.forEach(d => result.set(String(d._id), d));
+ *     }
+ *     return result;
+ *   },
+ * };
+ * ```
+ */
+interface SourceBridge {
+  /**
+   * Resolve a single source document by sourceId + sourceModel.
+   * Returns null if not found or if the bridge can't handle this sourceModel.
+   */
+  resolve?(sourceId: string, sourceModel: string, ctx: RevenueContext): Promise<unknown | null>;
+  /**
+   * Optional batch resolver for performance (avoids N+1 in list endpoints).
+   * Returns a Map keyed by sourceId.
+   */
+  resolveMany?(refs: Array<{
+    sourceId: string;
+    sourceModel: string;
+  }>, ctx: RevenueContext): Promise<Map<string, unknown>>;
+}
+//#endregion
+//#region src/bridges/revenue-bridges.d.ts
+interface RevenueBridges {
+  ledger?: LedgerBridge | undefined;
+  tax?: TaxBridge | undefined;
+  notification?: NotificationBridge | undefined;
+  currency?: CurrencyBridge | undefined;
+  customer?: CustomerBridge | undefined;
+  analytics?: AnalyticsBridge | undefined;
+  source?: SourceBridge | undefined;
+}
+//#endregion
+export { CurrencyBridge as a, LedgerBridge as c, CustomerBridge as i, SourceBridge as n, NotificationBridge as o, AnalyticsBridge as r, TaxBridge as s, RevenueBridges as t };