@classytic/revenue 2.0.1 → 2.1.0

package/dist/registry-h8sasoLh.d.mts

@@ -0,0 +1,145 @@
+import { a as BankFeedSourceValue } from "./bank-feed.enums-BadqNJTC.mjs";
+import { CreateIntentParams, PaymentIntent, PaymentResult, ProviderCapabilities, RefundResult, WebhookEvent } from "@classytic/primitives/payment-gateway";
+import { BankStatement, BankTransaction } from "@classytic/primitives/bank-transaction";
+
+//#region src/providers/base.d.ts
+/**
+ * Abstract `PaymentProvider` — the contract revenue's repositories
+ * consume. Provider implementations may extend this for the default
+ * config plumbing, or just satisfy the structural shape.
+ */
+declare abstract class PaymentProvider {
+  readonly config: Record<string, unknown>;
+  readonly name: string;
+  private _defaultCurrency;
+  constructor(config?: Record<string, unknown>);
+  get defaultCurrency(): string;
+  setDefaultCurrency(currency: string): void;
+  abstract createIntent(params: CreateIntentParams): Promise<PaymentIntent>;
+  abstract verifyPayment(intentId: string): Promise<PaymentResult>;
+  abstract getStatus(intentId: string): Promise<PaymentResult>;
+  abstract refund(paymentId: string, amount?: number | null, options?: {
+    reason?: string;
+  }): Promise<RefundResult>;
+  abstract handleWebhook(payload: unknown, headers?: Record<string, string>): Promise<WebhookEvent>;
+  /**
+   * Default: accept all signatures (manual / dev provider). Real
+   * gateways MUST override with HMAC / timing-safe verification.
+   */
+  verifyWebhookSignature(_payload: unknown, _signature: string): boolean;
+  getCapabilities(): ProviderCapabilities;
+}
+//#endregion
+//#region src/providers/bank-feed.d.ts
+interface BankFeedProviderCapabilities {
+  /** Supports continuous sync (Plaid, QBO CDC, Xero CDC). */
+  supportsSync: boolean;
+  /** Supports file upload parsing (OFX, CAMT.053, MT940, CSV, IIF). */
+  supportsUpload: boolean;
+  /** Provider may report retracted entries (Plaid `removed[]`, OFX correction). */
+  supportsRemovals: boolean;
+  /** Cursor-resumable — `fetchTransactions` returns a `nextCursor`. */
+  cursorBased: boolean;
+  /** Multi-account in a single sync call. */
+  multiAccount: boolean;
+}
+interface FetchTransactionsParams {
+  /** Resumption token from a previous call (Plaid cursor, QBO `LastUpdatedTime`, …). */
+  cursor?: string | undefined;
+  /** Account scope. May be undefined for providers that fetch all accounts. */
+  bankAccountId?: string | undefined;
+  /** Optional date floor — supplements cursor-based drains. */
+  from?: Date | undefined;
+  /** Optional date ceiling. */
+  to?: Date | undefined;
+  /** Provider-specific knobs. */
+  options?: Record<string, unknown> | undefined;
+}
+interface FetchTransactionsResult {
+  /** Newly added or updated rows. */
+  transactions: BankTransaction[];
+  /** Vendor-stable IDs of rows the upstream feed has retracted. */
+  removed?: Array<{
+    externalId: string;
+    bankAccountId?: string;
+  }>;
+  /** Resumption cursor for the next call. */
+  nextCursor?: string;
+  /** True when more pages are available — driver may stop calling when false. */
+  hasMore?: boolean;
+  /** Provider raw response for audit. Optional. */
+  raw?: unknown;
+}
+interface ParseUploadParams {
+  /** Raw upload bytes / string. */
+  buffer: Buffer | string | Uint8Array;
+  /** Format hint — providers MAY auto-detect when absent. */
+  format?: BankFeedSourceValue;
+  /** Account scope to stamp on every parsed row (when the file omits it). */
+  bankAccountId?: string;
+  /** Format-specific quirks (e.g. `'chase' | 'boa' | 'lenient'`). */
+  options?: Record<string, unknown>;
+}
+interface ParseUploadResult {
+  /** Statement-level metadata (account, period, balances). */
+  statements: BankStatement[];
+  /** Flat list of all rows across all statements — convenience for `import()`. */
+  transactions: BankTransaction[];
+  /** Per-row parse errors that didn't abort the file. */
+  warnings: Array<{
+    line?: number;
+    reason: string;
+  }>;
+}
+/**
+ * Bank-feed provider — implement one method or both depending on the
+ * upstream's capabilities. Mirrors the optional-method pattern that
+ * works well across PaymentProvider's gateway plurality.
+ */
+declare abstract class BankFeedProvider {
+  readonly config: Record<string, unknown>;
+  readonly name: string;
+  constructor(name: string, config?: Record<string, unknown>);
+  /**
+   * Fetch a batch of transactions. Cursor-based providers (Plaid)
+   * return `nextCursor` for the next call; date-range providers
+   * (older QBO Reports API) ignore cursor and use `from` / `to`.
+   * Throws if the provider does not support sync.
+   */
+  fetchTransactions?(_params: FetchTransactionsParams): Promise<FetchTransactionsResult>;
+  /**
+   * Parse a file upload (OFX / CAMT.053 / MT940 / CSV / IIF). The
+   * canonical implementation delegates to `@classytic/fin-io`. Throws
+   * if the provider does not support uploads.
+   */
+  parseUpload?(_params: ParseUploadParams): Promise<ParseUploadResult>;
+  /**
+   * Async drain — yields one batch per call until the upstream is
+   * caught up. Default implementation pulls `fetchTransactions` in a
+   * loop; providers can override for more efficient pagination
+   * (e.g. SSE / long-poll) or to interleave `removed[]` correctly.
+   */
+  drain(params?: FetchTransactionsParams): AsyncGenerator<FetchTransactionsResult>;
+  abstract getCapabilities(): BankFeedProviderCapabilities;
+}
+declare class BankFeedProviderRegistry {
+  private providers;
+  register(name: string, provider: BankFeedProvider): void;
+  get(name: string): BankFeedProvider;
+  has(name: string): boolean;
+  list(): string[];
+}
+declare function createBankFeedProviderRegistry(providers?: Record<string, BankFeedProvider>): BankFeedProviderRegistry;
+//#endregion
+//#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 { BankFeedProviderRegistry as a, ParseUploadParams as c, PaymentProvider as d, BankFeedProviderCapabilities as i, ParseUploadResult as l, createProviderRegistry as n, FetchTransactionsParams as o, BankFeedProvider as r, FetchTransactionsResult as s, ProviderRegistry as t, createBankFeedProviderRegistry as u };

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

@@ -1,4 +1,4 @@
-import { a as SettlementRepository, c as RevenueModels, o as SubscriptionRepository, s as TransactionRepository } from "../engine-types-CcjIb4Fy.mjs";
+import { c as SubscriptionRepository, l as TransactionRepository, s as SettlementRepository, u as RevenueModels } from "../engine-types-txFXOiQS.mjs";
 import { PluginType } from "@classytic/mongokit";
 
 //#region src/repositories/create-repositories.d.ts

package/dist/repositories/create-repositories.mjs

@@ -1,4 +1,4 @@
-import { n as SubscriptionRepository, r as TransactionRepository, t as SettlementRepository } from "../settlement.repository-DHIPx5S4.mjs";
+import { n as SubscriptionRepository, r as TransactionRepository, t as SettlementRepository } from "../settlement.repository-Ba2U17zY.mjs";
 
 //#region src/repositories/create-repositories.ts
 function createRevenueRepositories(models, builtInPlugins, hostPlugins = {}) {

package/dist/{revenue-bridges-sdlrR85c.d.mts → revenue-bridges-BtkWFsJu.d.mts}

@@ -1,10 +1,116 @@
-import { t as RevenueContext } from "./context-DRqSeTPM.mjs";
+import { t as RevenueContext } from "./context-pjP1QeE3.mjs";
 
 //#region src/bridges/ledger.bridge.d.ts
+/**
+ * LedgerBridge — host-implemented contract for posting revenue events
+ * into a general-ledger / accounting system.
+ *
+ * Revenue does NOT import any ledger package directly (PACKAGE_RULES §23).
+ * The host wires this bridge once at engine creation time; revenue's repo
+ * verbs call the relevant hook after each state transition. Every method
+ * is optional — features degrade gracefully when omitted.
+ *
+ * Two phases of hooks:
+ *
+ *   1. **Payment-flow hooks** (`onPaymentVerified`, `onRefundProcessed`,
+ *      `onSettlementCompleted`) — the original Stripe-style integration.
+ *      Fired when a gateway transaction reaches a terminal accounting
+ *      moment.
+ *
+ *   2. **Bank-feed hooks** (`onTransactionImported`, `onTransactionMatched`,
+ *      `onTransactionJournalized`, `onTransactionRejected`,
+ *      `onTransactionUnmatched`, `onTransactionRemovedByFeed`) — added
+ *      in 3.0. Fired during the bank-feed lifecycle so the host can post
+ *      JEs at match time, recall them on un-match, and chain
+ *      `journalize()` after a successful JE post.
+ *
+ * The canonical wiring for `onTransactionMatched` is:
+ *
+ * ```ts
+ * const ledgerBridge: LedgerBridge = {
+ *   async onTransactionMatched(txn, mapping, ctx) {
+ *     const report = await wireImport({
+ *       source: [{ txn, mapping }],
+ *       mapper: bankToJournalEntryMapper(mapping),
+ *       journalEntries: ledger.repositories.journalEntry,
+ *       context: { organizationId: ctx.organizationId },
+ *     }).run();
+ *     if (report.ok && report.entries[0]) {
+ *       await revenue.repositories.transaction.journalize(
+ *         String(txn._id),
+ *         { journalEntryRef: { type: 'JournalEntry', id: report.entries[0].id } },
+ *         ctx,
+ *       );
+ *     }
+ *   },
+ * };
+ * ```
+ */
 interface LedgerBridge {
+  /** Fired when a gateway transaction reaches `verified` status. */
   onPaymentVerified?(transaction: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
+  /** Fired after a refund posts (the new outflow row + the updated original). */
   onRefundProcessed?(original: Record<string, unknown>, refund: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
+  /** Fired when a settlement record reaches `completed`. */
   onSettlementCompleted?(settlement: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
+  /**
+   * Fired once per row inserted by `import()`. Use this for live preview
+   * dashboards or downstream materialized views — most production hosts
+   * leave this unimplemented and act on the per-batch `events.publish`
+   * stream instead.
+   */
+  onTransactionImported?(transaction: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
+  /**
+   * Fired after `match()` succeeds. The host's typical implementation
+   * posts a journal entry via the host's ledger package (e.g. arc's
+   * `wireImport` over `@classytic/ledger`'s `journalEntry` repository),
+   * then calls `revenue.repositories.transaction.journalize(id, …)` so
+   * the row transitions `matched → journalized`.
+   */
+  onTransactionMatched?(transaction: Record<string, unknown>, mapping: {
+    debitAccount?: string;
+    creditAccount?: string;
+    notes?: string;
+  }, ctx: RevenueContext): Promise<void>;
+  /**
+   * Fired after `unmatch()` succeeds. Hosts can void / reverse the
+   * journal entry created at match time. Pass the prior
+   * `journalEntryRef` so reversal is keyed correctly.
+   */
+  onTransactionUnmatched?(transaction: Record<string, unknown>, priorJournalEntryRef: {
+    type: string;
+    id: string;
+  } | undefined, ctx: RevenueContext): Promise<void>;
+  /**
+   * Fired after `journalize()` stamps `journalEntryRef` on the row.
+   * Most hosts are passive on this hook (the JE was created in
+   * `onTransactionMatched`); useful for audit logs and analytics.
+   */
+  onTransactionJournalized?(transaction: Record<string, unknown>, journalEntryRef: {
+    type: string;
+    id: string;
+  }, ctx: RevenueContext): Promise<void>;
+  /**
+   * Fired after `reject()` — operator skip on a duplicate / non-cash
+   * import. Hosts typically log for audit.
+   *
+   * **JE reversal contract.** `reject()` is legal from `'matched'` as
+   * well as `'imported'`. If your `onTransactionMatched` posted a JE
+   * synchronously (the typical bridge implementation), the JE must be
+   * reversed here — revenue itself never calls into ledger and has no
+   * way to know one exists. Idempotency is the bridge's responsibility:
+   * a reject on a never-journalized row should be a no-op for ledger,
+   * a reject after journalize should void the JE keyed off
+   * `transaction.matching` or whatever the host stamped at match time.
+   */
+  onTransactionRejected?(transaction: Record<string, unknown>, reason: string, ctx: RevenueContext): Promise<void>;
+  /**
+   * Fired when the upstream feed retracts a row (Plaid `removed[]`,
+   * OFX correction, QBO CDC delete). The transaction is soft-deleted
+   * before this hook runs. If a JE was already posted, the host
+   * should reverse it.
+   */
+  onTransactionRemovedByFeed?(transaction: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
 }
 //#endregion
 //#region src/bridges/tax.bridge.d.ts

package/dist/{revenue-event-catalog-LqxPnsU_.mjs → revenue-event-catalog-CgZ57M-f.mjs}

@@ -1,4 +1,4 @@
-import { t as REVENUE_EVENTS } from "./event-constants-CEMitnIV.mjs";
+import { t as REVENUE_EVENTS } from "./event-constants-CTiDNWzc.mjs";
 import { createEvent, matchEventPattern } from "@classytic/primitives/events";
 import { z } from "zod";
 
@@ -225,6 +225,44 @@ const webhookProcessedSchema = z.object({
 	event: z.record(z.string(), z.unknown()),
 	transaction: transactionRef.optional()
 });
+const transactionImportedSchema = z.object({
+	transaction: transactionRef,
+	source: z.string(),
+	bankAccountId: z.string(),
+	externalId: z.string()
+});
+const transactionMatchedSchema = z.object({
+	transaction: transactionRef,
+	mapping: z.object({
+		debitAccount: z.string().optional(),
+		creditAccount: z.string().optional(),
+		notes: z.string().optional()
+	}).passthrough(),
+	relatedTransactionId: z.string().optional(),
+	matchedBy: z.string().optional()
+});
+const transactionUnmatchedSchema = z.object({
+	transaction: transactionRef,
+	unmatchedBy: z.string().optional()
+});
+const transactionJournalizedSchema = z.object({
+	transaction: transactionRef,
+	journalEntryRef: z.object({
+		type: z.string(),
+		id: z.string()
+	}),
+	journalizedBy: z.string().optional()
+});
+const transactionRejectedSchema = z.object({
+	transaction: transactionRef,
+	reason: z.string().min(1),
+	rejectedBy: z.string().optional()
+});
+const transactionRemovedByFeedSchema = z.object({
+	transaction: transactionRef,
+	source: z.string(),
+	externalId: z.string()
+});
 const PaymentVerified = defineRevenueEvent({
 	name: REVENUE_EVENTS.PAYMENT_VERIFIED,
 	description: "A payment transaction was verified by its provider.",
@@ -350,6 +388,36 @@ const WebhookProcessed = defineRevenueEvent({
 	description: "A provider webhook was processed by the revenue engine.",
 	zodSchema: webhookProcessedSchema
 });
+const TransactionImported = defineRevenueEvent({
+	name: REVENUE_EVENTS.TRANSACTION_IMPORTED,
+	description: "A bank-feed / accounting-feed row was imported.",
+	zodSchema: transactionImportedSchema
+});
+const TransactionMatched = defineRevenueEvent({
+	name: REVENUE_EVENTS.TRANSACTION_MATCHED,
+	description: "A bank-feed / manual transaction was matched to GL accounts (and optionally to an upstream payment-flow row).",
+	zodSchema: transactionMatchedSchema
+});
+const TransactionUnmatched = defineRevenueEvent({
+	name: REVENUE_EVENTS.TRANSACTION_UNMATCHED,
+	description: "A previously-matched bank-feed transaction was reverted to the imported state.",
+	zodSchema: transactionUnmatchedSchema
+});
+const TransactionJournalized = defineRevenueEvent({
+	name: REVENUE_EVENTS.TRANSACTION_JOURNALIZED,
+	description: "A bank-feed / manual transaction was journalized — the host LedgerBridge produced a journal entry.",
+	zodSchema: transactionJournalizedSchema
+});
+const TransactionRejected = defineRevenueEvent({
+	name: REVENUE_EVENTS.TRANSACTION_REJECTED,
+	description: "A bank-feed / manual transaction was rejected (operator skip — typically a duplicate / non-cash entry).",
+	zodSchema: transactionRejectedSchema
+});
+const TransactionRemovedByFeed = defineRevenueEvent({
+	name: REVENUE_EVENTS.TRANSACTION_REMOVED_BY_FEED,
+	description: "The upstream feed retracted a previously-imported row (Plaid `removed[]`, OFX correction). The row is soft-deleted.",
+	zodSchema: transactionRemovedByFeedSchema
+});
 /**
 * Every revenue event defined in the package — pass to Arc's
 * `EventRegistry`. Hosts wire ONE array; the whole `revenue:*` namespace
@@ -381,8 +449,14 @@ const revenueEventDefinitions = [
 	SettlementProcessing,
 	SettlementCompleted,
 	SettlementFailed,
-	WebhookProcessed
+	WebhookProcessed,
+	TransactionImported,
+	TransactionMatched,
+	TransactionUnmatched,
+	TransactionJournalized,
+	TransactionRejected,
+	TransactionRemovedByFeed
 ];
 
 //#endregion
-export { SubscriptionResumed as C, InProcessRevenueBus as D, revenueEventDefinitions as E, SubscriptionRenewed as S, WebhookProcessed as T, SettlementScheduled as _, FreeCreated as a, SubscriptionCreated as b, PaymentProcessing as c, PaymentVerified as d, PurchaseCreated as f, SettlementProcessing as g, SettlementFailed as h, EscrowSplit as i, PaymentRefunded as l, SettlementCreated as m, EscrowHeld as n, MonetizationCreated as o, SettlementCompleted as p, EscrowReleased as r, PaymentFailed as s, EscrowCancelled as t, PaymentRequiresAction as u, SubscriptionActivated as v, TransactionUpdated as w, SubscriptionPaused as x, SubscriptionCancelled as y };
+export { TransactionUpdated as A, SubscriptionResumed as C, TransactionRejected as D, TransactionMatched as E, revenueEventDefinitions as M, InProcessRevenueBus as N, TransactionRemovedByFeed as O, SubscriptionRenewed as S, TransactionJournalized as T, SettlementScheduled as _, FreeCreated as a, SubscriptionCreated as b, PaymentProcessing as c, PaymentVerified as d, PurchaseCreated as f, SettlementProcessing as g, SettlementFailed as h, EscrowSplit as i, WebhookProcessed as j, TransactionUnmatched as k, PaymentRefunded as l, SettlementCreated as m, EscrowHeld as n, MonetizationCreated as o, SettlementCompleted as p, EscrowReleased as r, PaymentFailed as s, EscrowCancelled as t, PaymentRequiresAction as u, SubscriptionActivated as v, TransactionImported as w, SubscriptionPaused as x, SubscriptionCancelled as y };

package/dist/{revenue-event-catalog-BX3g7RUi.d.mts → revenue-event-catalog-JpJcyK1E.d.mts}

@@ -1,4 +1,4 @@
-import { t as RevenueContext } from "./context-DRqSeTPM.mjs";
+import { t as RevenueContext } from "./context-pjP1QeE3.mjs";
 import { DomainEvent, EventHandler, EventMeta, EventTransport } from "@classytic/primitives/events";
 import { z } from "zod";
 
@@ -39,6 +39,12 @@ declare const REVENUE_EVENTS: {
   readonly SUBSCRIPTION_PAUSED: "revenue:subscription.paused";
   readonly SUBSCRIPTION_RESUMED: "revenue:subscription.resumed";
   readonly TRANSACTION_UPDATED: "revenue:transaction.updated";
+  readonly TRANSACTION_IMPORTED: "revenue:transaction.imported";
+  readonly TRANSACTION_MATCHED: "revenue:transaction.matched";
+  readonly TRANSACTION_UNMATCHED: "revenue:transaction.unmatched";
+  readonly TRANSACTION_JOURNALIZED: "revenue:transaction.journalized";
+  readonly TRANSACTION_REJECTED: "revenue:transaction.rejected";
+  readonly TRANSACTION_REMOVED_BY_FEED: "revenue:transaction.removed_by_feed";
   readonly ESCROW_HELD: "revenue:escrow.held";
   readonly ESCROW_RELEASED: "revenue:escrow.released";
   readonly ESCROW_CANCELLED: "revenue:escrow.cancelled";
@@ -430,6 +436,98 @@ declare const webhookProcessedSchema: z.ZodObject<{
     }, z.core.$strip>>;
   }, z.core.$loose>>;
 }, z.core.$strip>;
+declare const transactionImportedSchema: z.ZodObject<{
+  transaction: z.ZodObject<{
+    _id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+    publicId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    monetizationType: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodObject<{
+      amount: z.ZodNumber;
+      currency: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$loose>;
+  source: z.ZodString;
+  bankAccountId: z.ZodString;
+  externalId: z.ZodString;
+}, z.core.$strip>;
+declare const transactionMatchedSchema: z.ZodObject<{
+  transaction: z.ZodObject<{
+    _id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+    publicId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    monetizationType: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodObject<{
+      amount: z.ZodNumber;
+      currency: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$loose>;
+  mapping: z.ZodObject<{
+    debitAccount: z.ZodOptional<z.ZodString>;
+    creditAccount: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+  }, z.core.$loose>;
+  relatedTransactionId: z.ZodOptional<z.ZodString>;
+  matchedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const transactionUnmatchedSchema: z.ZodObject<{
+  transaction: z.ZodObject<{
+    _id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+    publicId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    monetizationType: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodObject<{
+      amount: z.ZodNumber;
+      currency: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$loose>;
+  unmatchedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const transactionJournalizedSchema: z.ZodObject<{
+  transaction: z.ZodObject<{
+    _id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+    publicId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    monetizationType: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodObject<{
+      amount: z.ZodNumber;
+      currency: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$loose>;
+  journalEntryRef: z.ZodObject<{
+    type: z.ZodString;
+    id: z.ZodString;
+  }, z.core.$strip>;
+  journalizedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const transactionRejectedSchema: z.ZodObject<{
+  transaction: z.ZodObject<{
+    _id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+    publicId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    monetizationType: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodObject<{
+      amount: z.ZodNumber;
+      currency: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$loose>;
+  reason: z.ZodString;
+  rejectedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const transactionRemovedByFeedSchema: z.ZodObject<{
+  transaction: z.ZodObject<{
+    _id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+    publicId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    monetizationType: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodObject<{
+      amount: z.ZodNumber;
+      currency: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$loose>;
+  source: z.ZodString;
+  externalId: z.ZodString;
+}, z.core.$strip>;
 type PaymentVerifiedPayload = z.infer<typeof paymentVerifiedSchema>;
 type PaymentFailedPayload = z.infer<typeof paymentFailedSchema>;
 type PaymentProcessingPayload = z.infer<typeof paymentProcessingSchema>;
@@ -455,6 +553,12 @@ type SettlementProcessingPayload = z.infer<typeof settlementProcessingSchema>;
 type SettlementCompletedPayload = z.infer<typeof settlementCompletedSchema>;
 type SettlementFailedPayload = z.infer<typeof settlementFailedSchema>;
 type WebhookProcessedPayload = z.infer<typeof webhookProcessedSchema>;
+type TransactionImportedPayload = z.infer<typeof transactionImportedSchema>;
+type TransactionMatchedPayload = z.infer<typeof transactionMatchedSchema>;
+type TransactionUnmatchedPayload = z.infer<typeof transactionUnmatchedSchema>;
+type TransactionJournalizedPayload = z.infer<typeof transactionJournalizedSchema>;
+type TransactionRejectedPayload = z.infer<typeof transactionRejectedSchema>;
+type TransactionRemovedByFeedPayload = z.infer<typeof transactionRemovedByFeedSchema>;
 declare const PaymentVerified: RevenueEventDefinition<z.ZodObject<{
   transaction: z.ZodObject<{
     _id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
@@ -812,6 +916,98 @@ declare const WebhookProcessed: RevenueEventDefinition<z.ZodObject<{
     }, z.core.$strip>>;
   }, z.core.$loose>>;
 }, z.core.$strip>>;
+declare const TransactionImported: RevenueEventDefinition<z.ZodObject<{
+  transaction: z.ZodObject<{
+    _id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+    publicId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    monetizationType: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodObject<{
+      amount: z.ZodNumber;
+      currency: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$loose>;
+  source: z.ZodString;
+  bankAccountId: z.ZodString;
+  externalId: z.ZodString;
+}, z.core.$strip>>;
+declare const TransactionMatched: RevenueEventDefinition<z.ZodObject<{
+  transaction: z.ZodObject<{
+    _id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+    publicId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    monetizationType: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodObject<{
+      amount: z.ZodNumber;
+      currency: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$loose>;
+  mapping: z.ZodObject<{
+    debitAccount: z.ZodOptional<z.ZodString>;
+    creditAccount: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+  }, z.core.$loose>;
+  relatedTransactionId: z.ZodOptional<z.ZodString>;
+  matchedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const TransactionUnmatched: RevenueEventDefinition<z.ZodObject<{
+  transaction: z.ZodObject<{
+    _id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+    publicId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    monetizationType: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodObject<{
+      amount: z.ZodNumber;
+      currency: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$loose>;
+  unmatchedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const TransactionJournalized: RevenueEventDefinition<z.ZodObject<{
+  transaction: z.ZodObject<{
+    _id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+    publicId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    monetizationType: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodObject<{
+      amount: z.ZodNumber;
+      currency: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$loose>;
+  journalEntryRef: z.ZodObject<{
+    type: z.ZodString;
+    id: z.ZodString;
+  }, z.core.$strip>;
+  journalizedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const TransactionRejected: RevenueEventDefinition<z.ZodObject<{
+  transaction: z.ZodObject<{
+    _id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+    publicId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    monetizationType: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodObject<{
+      amount: z.ZodNumber;
+      currency: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$loose>;
+  reason: z.ZodString;
+  rejectedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const TransactionRemovedByFeed: RevenueEventDefinition<z.ZodObject<{
+  transaction: z.ZodObject<{
+    _id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+    publicId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    monetizationType: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodObject<{
+      amount: z.ZodNumber;
+      currency: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$loose>;
+  source: z.ZodString;
+  externalId: z.ZodString;
+}, z.core.$strip>>;
 /**
  * Every revenue event defined in the package — pass to Arc's
  * `EventRegistry`. Hosts wire ONE array; the whole `revenue:*` namespace
@@ -820,4 +1016,4 @@ declare const WebhookProcessed: RevenueEventDefinition<z.ZodObject<{
  */
 declare const revenueEventDefinitions: ReadonlyArray<RevenueEventDefinition>;
 //#endregion
-export { WebhookProcessedPayload as $, SettlementCreated as A, SubscriptionCancelled as B, PurchaseCreated as C, RevenueEventSchema as D, RevenueEventPayloadOf as E, SettlementProcessingPayload as F, SubscriptionPausedPayload as G, SubscriptionCreated as H, SettlementScheduled as I, SubscriptionResumed as J, SubscriptionRenewed as K, SettlementScheduledPayload as L, SettlementFailed as M, SettlementFailedPayload as N, SettlementCompleted as O, SettlementProcessing as P, WebhookProcessed as Q, SubscriptionActivated as R, PaymentVerifiedPayload as S, RevenueEventDefinition as T, SubscriptionCreatedPayload as U, SubscriptionCancelledPayload as V, SubscriptionPaused as W, TransactionUpdated as X, SubscriptionResumedPayload as Y, TransactionUpdatedPayload as Z, PaymentRefunded as _, EscrowReleased as a, InProcessRevenueBusOptions as at, PaymentRequiresActionPayload as b, EscrowSplitPayload as c, MonetizationCreated as d, revenueEventDefinitions as et, MonetizationCreatedPayload as f, PaymentProcessingPayload as g, PaymentProcessing as h, EscrowHeldPayload as i, InProcessRevenueBus as it, SettlementCreatedPayload as j, SettlementCompletedPayload as k, FreeCreated as l, PaymentFailedPayload as m, EscrowCancelledPayload as n, RevenueEventName as nt, EscrowReleasedPayload as o, PaymentFailed as p, SubscriptionRenewedPayload as q, EscrowHeld as r, createEvent$1 as rt, EscrowSplit as s, EscrowCancelled as t, REVENUE_EVENTS as tt, FreeCreatedPayload as u, PaymentRefundedPayload as v, PurchaseCreatedPayload as w, PaymentVerified as x, PaymentRequiresAction as y, SubscriptionActivatedPayload as z };
+export { TransactionJournalizedPayload as $, SettlementCreated as A, SubscriptionCancelled as B, PurchaseCreated as C, RevenueEventSchema as D, RevenueEventPayloadOf as E, SettlementProcessingPayload as F, SubscriptionPausedPayload as G, SubscriptionCreated as H, SettlementScheduled as I, SubscriptionResumed as J, SubscriptionRenewed as K, SettlementScheduledPayload as L, SettlementFailed as M, SettlementFailedPayload as N, SettlementCompleted as O, SettlementProcessing as P, TransactionJournalized as Q, SubscriptionActivated as R, PaymentVerifiedPayload as S, RevenueEventDefinition as T, SubscriptionCreatedPayload as U, SubscriptionCancelledPayload as V, SubscriptionPaused as W, TransactionImported as X, SubscriptionResumedPayload as Y, TransactionImportedPayload as Z, PaymentRefunded as _, InProcessRevenueBusOptions as _t, EscrowReleased as a, TransactionRemovedByFeedPayload as at, PaymentRequiresActionPayload as b, EscrowSplitPayload as c, TransactionUpdated as ct, MonetizationCreated as d, WebhookProcessedPayload as dt, TransactionMatched as et, MonetizationCreatedPayload as f, revenueEventDefinitions as ft, PaymentProcessingPayload as g, InProcessRevenueBus as gt, PaymentProcessing as h, createEvent$1 as ht, EscrowHeldPayload as i, TransactionRemovedByFeed as it, SettlementCreatedPayload as j, SettlementCompletedPayload as k, FreeCreated as l, TransactionUpdatedPayload as lt, PaymentFailedPayload as m, RevenueEventName as mt, EscrowCancelledPayload as n, TransactionRejected as nt, EscrowReleasedPayload as o, TransactionUnmatched as ot, PaymentFailed as p, REVENUE_EVENTS as pt, SubscriptionRenewedPayload as q, EscrowHeld as r, TransactionRejectedPayload as rt, EscrowSplit as s, TransactionUnmatchedPayload as st, EscrowCancelled as t, TransactionMatchedPayload as tt, FreeCreatedPayload as u, WebhookProcessed as ut, PaymentRefundedPayload as v, PurchaseCreatedPayload as w, PaymentVerified as x, PaymentRequiresAction as y, SubscriptionActivatedPayload as z };