@classytic/revenue 2.0.1 → 2.1.0

package/dist/{engine-types-CcjIb4Fy.d.mts → engine-types-txFXOiQS.d.mts}

@@ -1,19 +1,50 @@
-import { t as RevenueContext } from "./context-DRqSeTPM.mjs";
-import { t as RevenueBridges } from "./revenue-bridges-sdlrR85c.mjs";
-import { o as PaymentProvider, t as ProviderRegistry } from "./registry-SvIGPAx_.mjs";
+import { t as RevenueContext } from "./context-pjP1QeE3.mjs";
+import { t as RevenueBridges } from "./revenue-bridges-BtkWFsJu.mjs";
+import { u as TransactionKindValue } from "./bank-feed.enums-BadqNJTC.mjs";
+import { a as BankFeedProviderRegistry, d as PaymentProvider, o as FetchTransactionsParams, r as BankFeedProvider, t as ProviderRegistry } from "./registry-h8sasoLh.mjs";
 import { RepositoryPluginBundle, RevenueRepositories } from "./repositories/create-repositories.mjs";
 import { PluginType, Repository } from "@classytic/mongokit";
-import { TenantConfig } from "@classytic/primitives/tenant";
+import { TenantConfig } from "@classytic/repo-core/tenant";
 import mongoose, { Connection, Model, Schema } from "mongoose";
 import { EventTransport } from "@classytic/primitives/events";
 import { OutboxStore } from "@classytic/primitives/outbox";
+import { BankImportReport, BankImportRowError, BankTransaction } from "@classytic/primitives/bank-transaction";
+import { ApprovalChain } from "@classytic/primitives/approval";
 
 //#region src/models/transaction.schema.d.ts
+/**
+ * Counterparty on a bank-feed entry. Untyped Mixed at the Mongoose level
+ * (banks populate different fields), but typed here so consumers and
+ * validators can introspect.
+ */
+interface TransactionCounterparty {
+  name?: string;
+  identifier?: string;
+  iban?: string;
+  accountNumber?: string;
+  bic?: string;
+  routingNumber?: string;
+}
+/**
+ * Polymorphic ledger journal-entry reference. String-typed (PACKAGE_RULES
+ * §7) so it works for ledger documents stored in another connection,
+ * Postgres ledgers, or external accounting systems (QBO Journal IDs).
+ */
+interface JournalEntryRef {
+  type: string;
+  id: string;
+}
 interface TransactionDocument {
   _id: mongoose.Types.ObjectId;
   publicId: string;
   organizationId?: string;
   customerId?: string | null;
+  /**
+   * Selects the state machine that governs this row's `status` field.
+   * Defaults to `'payment_flow'` so existing data reads identically.
+   * See `core/state-machines.ts:smFor()`.
+   */
+  kind: TransactionKindValue;
   type: string;
   flow: 'inflow' | 'outflow';
   tags: string[];
@@ -27,8 +58,32 @@ interface TransactionDocument {
     rate?: number;
     isInclusive?: boolean;
   };
+  /**
+   * Multi-currency reconciliation (3.0). When the bank deposit clears
+   * in a currency different from the originating charge, store the
+   * other side here. Cross-currency `findMatchCandidates` reads these
+   * to compare same-currency-equivalent amounts.
+   */
+  fxRate?: number;
+  originalAmount?: number;
+  originalCurrency?: string;
   method: string;
   status: string;
+  /**
+   * Optional embedded approval chain — P7. Hosts that gate manual /
+   * non-gateway transactions on a maker-checker review attach a chain via
+   * `createChain()` from `@classytic/primitives/approval`; the host's
+   * approval action checks `isApproved(doc.approvals)` before flipping
+   * status to `succeeded`. Auto-gateway transactions (Stripe, SSLCommerz,
+   * etc.) bypass this entirely — synchronous gateway success is the gate.
+   *
+   * Use cases:
+   *   - Manual cash receipts (front desk → bookkeeper verify)
+   *   - Manual bank transfers (supplier-paid → finance verify)
+   *   - Cheque deposits (queued until cleared)
+   *   - **Refunds especially** — the audit-defining moment
+   */
+  approvals?: ApprovalChain;
   gateway?: {
     type: string;
     sessionId?: string;
@@ -77,6 +132,59 @@ interface TransactionDocument {
     }>;
     metadata?: Record<string, unknown>;
   };
+  /**
+   * Vendor-stable id from the upstream feed (FITID, NtryRef, qbo Id,
+   * Plaid transaction_id). Used to enforce idempotent re-import via the
+   * `(orgId, bankAccountId, externalId)` partial unique index.
+   *
+   * Distinct from `idempotencyKey` (host-chosen, request-scoped). See
+   * `@classytic/primitives/bank-transaction` and PACKAGE_RULES §8.
+   */
+  externalId?: string;
+  /** When the bank booked the entry. */
+  postedDate?: Date;
+  /** When funds clear / become available. */
+  valueDate?: Date;
+  /** Free-text bank description. */
+  description?: string;
+  counterparty?: TransactionCounterparty;
+  /** Check number, payment reference, end-to-end ID. */
+  reference?: string;
+  /** Running balance on the account after this entry, if the format provides it. */
+  balanceAfter?: number;
+  /** Bank's own category (rare in OFX, common in Plaid / Mint exports). */
+  vendorCategory?: string;
+  /**
+   * Polymorphic external ref to the bank account this row belongs to.
+   * String per PACKAGE_RULES §7 — accepts ObjectId hex, UUID, external
+   * IDs (Plaid `account_id`, QBO Account Id). Distinct from
+   * `customerId`; the `bankAccount` resource lives on the host side.
+   */
+  bankAccountId?: string;
+  /**
+   * Provenance — which feed produced this row. One of the values from
+   * `BANK_FEED_SOURCE` (`'ofx'`, `'plaid'`, `'qbo'`, …). Drives admin UI
+   * filtering and duplicate-detection rules.
+   */
+  source?: string;
+  /**
+   * Bidirectional link to the journal entry that posted this row to the
+   * GL. Stamped by `journalize()` after the host's LedgerBridge confirms
+   * the JE was created. Polymorphic — `type` names the foreign model
+   * (`'JournalEntry'`, `'QboJournalEntry'`, …).
+   */
+  journalEntryRef?: JournalEntryRef;
+  /**
+   * Operator-supplied mapping from bank line → GL accounts. Stored at
+   * match time so re-running the journalize step is deterministic.
+   */
+  matching?: {
+    debitAccount?: string;
+    creditAccount?: string;
+    notes?: string;
+    matchedAt?: Date;
+    matchedBy?: string;
+  };
   sourceId?: string;
   sourceModel?: string;
   relatedTransactionId?: mongoose.Types.ObjectId;
@@ -121,6 +229,19 @@ interface SubscriptionDocument {
   canceledAt?: Date;
   cancelAt?: Date;
   cancellationReason?: string;
+  /**
+   * Optional embedded approval chain — P7. Hosts that gate high-value
+   * subscription transitions on a maker-checker review attach a chain via
+   * `createChain()` from `@classytic/primitives/approval`; the host's
+   * approval action checks `isApproved(doc.approvals)` before applying
+   * the change. Routine renewals/auto-pause flows leave it undefined.
+   *
+   * Use cases:
+   *   - Cancel-with-refund (manager sign-off before issuing credit)
+   *   - Plan change with credit note (finance verifies proration)
+   *   - Manual reactivation after dunning failure
+   */
+  approvals?: ApprovalChain;
   renewalTransactionId?: mongoose.Types.ObjectId;
   renewalCount: number;
   metadata?: Record<string, unknown>;
@@ -138,6 +259,19 @@ interface SettlementDocument {
   recipientType: string;
   type: string;
   status: string;
+  /**
+   * Optional embedded approval chain — P7. Hosts that gate payout release
+   * on a maker-checker review attach a chain via `createChain()` from
+   * `@classytic/primitives/approval`; the host's approval action checks
+   * `isApproved(doc.approvals)` before transitioning the settlement to
+   * `processed`/`completed`. Auto-disbursement flows leave it undefined.
+   *
+   * Use cases:
+   *   - Vendor payout sign-off (finance verifies before funds release)
+   *   - High-value mobile-wallet / crypto disbursement review
+   *   - Manual bank-transfer payouts to recipients
+   */
+  approvals?: ApprovalChain;
   payoutMethod: string;
   amount: number;
   currency: string;
@@ -203,6 +337,12 @@ interface TransactionRepoDeps {
    */
   outbox?: OutboxStore | undefined;
   providers: ProviderRegistry;
+  /**
+   * Bank-feed provider registry (3.0). Optional — when omitted, the
+   * `drainSync` and `parseAndImport` verbs throw on use. The host typically
+   * wires Plaid / fin-io / a custom CSV provider here.
+   */
+  bankFeedProviders?: BankFeedProviderRegistry | undefined;
   bridges: RevenueBridges;
   commission?: CommissionConfig;
   defaultCurrency: string;
@@ -210,15 +350,6 @@ interface TransactionRepoDeps {
     error(...args: unknown[]): void;
   } | undefined;
 }
-/**
- * TransactionRepository — extends mongokit Repository.
- *
- * CRUD inherited: getAll, getById, getByQuery, create, update, delete, count, exists.
- * Domain verbs: createPaymentIntent, verify, refund, handleWebhook, hold, release, split.
- *
- * All domain verbs return raw mongokit docs — no custom envelopes.
- * Composite results (refund creates a new doc) are stored in metadata on the primary doc.
- */
 declare class TransactionRepository extends Repository<TransactionDocument> {
   private deps;
   constructor(model: Model<TransactionDocument>, plugins?: PluginType[]);
@@ -326,6 +457,223 @@ declare class TransactionRepository extends Repository<TransactionDocument> {
     recipientType: string;
     rate: number;
   }>, ctx?: RevenueContext): Promise<TransactionDocument>;
+  /**
+   * Idempotent bulk import of bank-feed rows.
+   *
+   * Each row is upserted by `(orgId, bankAccountId, externalId)` — the
+   * partial unique index declared in `create-models.ts`. Re-running the
+   * same Plaid sync, OFX upload, or QBO CDC drain produces zero new
+   * inserts on the second call (modified counts may rise as
+   * descriptions/categories evolve upstream).
+   *
+   * Signed bank `amount` is normalized into the (`amount` >= 0, `flow`)
+   * shape revenue uses internally so downstream queries (`flow:
+   * 'inflow'`) work uniformly across kinds.
+   *
+   * Emits one `revenue:transaction.imported` event per **inserted** row
+   * (not per row in `rows` — re-imports do not re-fire). Hosts wanting
+   * batch-level signal subscribe to the per-doc events and aggregate.
+   *
+   * Per-row failures (validation, hash collisions on a non-unique
+   * `externalId`) collect into `errors[]` instead of aborting the whole
+   * batch — the typical Plaid drain pulls thousands of rows; one bad
+   * row should not block the rest.
+   *
+   * @param rows  Canonical bank transactions, structurally compatible
+   *              with `@classytic/fin-io` parsers' output.
+   * @param opts  `bankAccountId` (required, polymorphic ID) and
+   *              `source` (provenance — `'plaid'`, `'ofx'`, …).
+   */
+  import(rows: BankTransaction[], opts: {
+    bankAccountId: string;
+    source: string;
+    method?: string;
+  }, ctx?: RevenueContext): Promise<BankImportReport>;
+  /**
+   * Drain a bank-feed provider into the collection.
+   *
+   * Pulls pages from `provider.fetchTransactions()` (Plaid cursor, QBO
+   * CDC) and feeds each batch through `import()`. Yields the running
+   * report so a host cron can stream-progress-report to logs / metrics.
+   *
+   * Stops when the provider returns no new rows AND no removals AND no
+   * `nextCursor`. Caller is responsible for persisting the final cursor
+   * in their own checkpoint table — `result.nextCursor` is returned so
+   * the host can write it after a successful drain.
+   *
+   * Plaid `removed[]` rows (and any provider that retracts entries) are
+   * routed through `removeByFeed` so the host's LedgerBridge can void
+   * any JE that was already posted.
+   */
+  drainSync(providerName: string, params: FetchTransactionsParams & {
+    bankAccountId: string;
+  }, ctx?: RevenueContext): Promise<{
+    totalImported: number;
+    totalUpdated: number;
+    totalRemoved: number;
+    nextCursor?: string;
+    errors: BankImportRowError[];
+  }>;
+  /**
+   * Parse an upload (OFX / CAMT.053 / MT940 / CSV) via a registered
+   * bank-feed provider, then `import()` the result.
+   *
+   * Convenience over manually calling `provider.parseUpload()` and
+   * threading the canonical rows into `import()` — the file-upload
+   * route handler is one line.
+   */
+  parseAndImport(providerName: string, upload: {
+    buffer: Buffer | string | Uint8Array;
+    format?: string;
+    bankAccountId: string;
+  }, ctx?: RevenueContext): Promise<BankImportReport>;
+  /**
+   * Hand-keyed entry — treasurer logs a cash deposit, owner injects
+   * capital, refund correction. Created in `pending` (manual SM); host
+   * proceeds with `match()` → `journalize()` to post it to the ledger.
+   *
+   * `kind: 'manual'` is enforced — calls passing other kinds throw.
+   */
+  createManual(data: {
+    amount: number;
+    currency: string;
+    flow: 'inflow' | 'outflow';
+    type: string;
+    description?: string;
+    counterparty?: TransactionDocument['counterparty'];
+    reference?: string;
+    postedDate?: Date;
+    valueDate?: Date;
+    bankAccountId?: string;
+    sourceId?: string;
+    sourceModel?: string;
+    metadata?: Record<string, unknown>;
+  }, ctx?: RevenueContext): Promise<TransactionDocument>;
+  /**
+   * Match a bank-feed / manual transaction to GL accounts, optionally
+   * cross-linking to an upstream payment-flow transaction.
+   *
+   * Atomic state CAS via `claim()` — the `where: { kind: { $in: [...] } }`
+   * predicate prevents a payment-flow row from being matched through this
+   * verb. Multi-source `from` (`['imported', 'matched']`) supports
+   * re-match after `unmatch()` (`matched → imported → matched`) without
+   * losing the prior mapping if the host wants to overwrite it.
+   *
+   * After a successful claim, `LedgerBridge.onTransactionMatched` runs
+   * — the canonical implementation creates a journal entry and chains
+   * `journalize()` to record the JE ref. The bridge call is OUTSIDE the
+   * claim's CAS window because JE posting is a side effect that may
+   * take seconds (cross-process call to ledger).
+   */
+  match(id: string, data: {
+    mapping: {
+      debitAccount?: string;
+      creditAccount?: string;
+      notes?: string;
+    };
+    relatedTransactionId?: string;
+    matchedBy?: string;
+  }, ctx?: RevenueContext): Promise<TransactionDocument>;
+  /**
+   * Revert a matched transaction back to `imported`. Clears the
+   * `matching` block and `relatedTransactionId`. Notifies the
+   * LedgerBridge (which typically voids the journal entry) AFTER the
+   * state CAS lands.
+   *
+   * Only legal for `kind: 'bank_feed'` — manual entries don't allow
+   * un-match (the manual SM has no `matched → pending` edge).
+   */
+  unmatch(id: string, options?: {
+    unmatchedBy?: string;
+  }, ctx?: RevenueContext): Promise<TransactionDocument>;
+  /**
+   * Stamp the journal entry reference and transition `matched →
+   * journalized`. Typical caller is the `LedgerBridge.onTransactionMatched`
+   * implementation — after creating a JE, it calls this verb so the row
+   * carries the back-reference.
+   */
+  journalize(id: string, data: {
+    journalEntryRef: {
+      type: string;
+      id: string;
+    };
+    journalizedBy?: string;
+  }, ctx?: RevenueContext): Promise<TransactionDocument>;
+  /**
+   * Operator skip — marks an imported / matched / pending row as
+   * rejected (terminal). Use cases: duplicate of an already-imported
+   * row, non-cash entry the host doesn't want in the ledger, manual
+   * correction overrides.
+   *
+   * `relatedTransactionId` is preserved; reversal is the host's call.
+   */
+  reject(id: string, data: {
+    reason: string;
+    rejectedBy?: string;
+  }, ctx?: RevenueContext): Promise<TransactionDocument>;
+  /**
+   * Soft-delete bank-feed rows that the upstream feed has retracted
+   * (Plaid `removed[]`, OFX correction).
+   *
+   * Each row is matched by `(orgId, bankAccountId, externalId)`; rows
+   * already journalized are NOT silently kept — they're surfaced in
+   * `retainedJournalized` so the caller can surface them in the UI
+   * ("the feed retracted these N rows but they're posted; reverse
+   * manually"). The host's `LedgerBridge` should post a reversing JE
+   * for those before any subsequent `delete()` can succeed.
+   *
+   * @returns `removed` (count soft-deleted), `retainedJournalized`
+   *          (rows kept because they're already in the GL).
+   */
+  removeByFeed(externalIds: string[], opts: {
+    bankAccountId: string;
+    source: string;
+  }, ctx?: RevenueContext): Promise<{
+    removed: number;
+    retainedJournalized: TransactionDocument[];
+  }>;
+  /**
+   * Find candidate matches for cross-referencing a payment-flow row to
+   * its bank deposit (or vice-versa).
+   *
+   * Heuristic:
+   *   - same currency by default; cross-currency requires `fxRate` on
+   *     the candidate row (multi-currency reconciliation).
+   *   - amount within `amountTolerancePct` (default 1%) — accounts for
+   *     gateway fees / FX rounding.
+   *   - posted/created within `toleranceDays` of the target date
+   *     (default 3 days — covers ACH delays, weekend settlement).
+   *   - terminal verified states only (`verified` / `completed` for
+   *     payment_flow, `imported` / `matched` for bank_feed).
+   *
+   * Returned candidates are unsorted; callers rank by their own
+   * confidence model (counterparty fuzzy match, currency identity,
+   * exact-amount preference, …).
+   */
+  findMatchCandidates(filter: {
+    amount: number;
+    currency?: string;
+    postedDate: Date;
+    toleranceDays?: number;
+    amountTolerancePct?: number;
+    counterpartyName?: string;
+    kind?: TransactionKindValue;
+  }, ctx?: RevenueContext): Promise<TransactionDocument[]>;
+  /**
+   * Running balance for a bank account as of `asOf` (defaults to now).
+   *
+   * Uses mongokit's tenant-scoped read via `findAll` — inflows minus
+   * outflows over `kind: 'bank_feed'`, terminal states only. For audit
+   * pages where exact-to-the-cent reconciliation is required, prefer
+   * the most recent row's `balanceAfter` (banks ship that field on
+   * every entry).
+   */
+  getRunningBalance(bankAccountId: string, asOf?: Date, ctx?: RevenueContext): Promise<{
+    balance: number;
+    currency: string | null;
+    rowCount: number;
+    asOf: Date;
+  }>;
 }
 //#endregion
 //#region src/repositories/subscription.repository.d.ts
@@ -456,6 +804,51 @@ interface RetryConfig {
   maxAttempts?: number | undefined;
   baseDelay?: number | undefined;
 }
+/**
+ * Per-index opt-in for the bank-feed lifecycle. Each flag controls one
+ * MongoDB index on the `Transaction` collection. Defaults are tuned for
+ * "moderate use" — required indexes are on, dashboard indexes are on,
+ * heavy reconciliation indexes are off.
+ *
+ * Toggle these to match real usage. Index builds are non-trivial on a
+ * collection with millions of rows; turning unused ones off saves disk +
+ * write amplification.
+ */
+interface BankFeedIndexConfig {
+  /**
+   * `(orgId, bankAccountId, externalId)` partial unique index. Required
+   * for `import()` to enforce idempotent re-import — turning this off
+   * means a Plaid drain that retries can produce duplicate rows.
+   *
+   * Default: `true`. Disable only if you don't use `import()` /
+   * `drainSync()` / `parseAndImport()`.
+   */
+  idempotentImport?: boolean | undefined;
+  /**
+   * `(bankAccountId, postedDate -1)` partial — drives the treasurer
+   * dashboard ("show me last 30 days of transactions for account X").
+   * Cheap; on by default.
+   */
+  byAccount?: boolean | undefined;
+  /**
+   * `(kind, amount, postedDate)` and `(kind, amount, createdAt)` —
+   * back the cross-reference query in `findMatchCandidates`. Two
+   * compound indexes; turn on when you actively reconcile bank
+   * deposits to gateway charges.
+   *
+   * Default: `false`. Enable when running a recon dashboard.
+   */
+  matchCandidates?: boolean | undefined;
+}
+/**
+ * Bank-feed module configuration. Pass `true` for defaults, `false` to
+ * disable the module (skips the bulkWrite plugin + every bank-feed
+ * index), or an object to fine-tune indexes.
+ */
+interface BankFeedModuleConfig {
+  enabled?: boolean | undefined;
+  indexes?: BankFeedIndexConfig | undefined;
+}
 interface RevenueConfig {
   connection: Connection;
   defaultCurrency: string;
@@ -534,8 +927,44 @@ interface RevenueConfig {
     escrow?: boolean | undefined;
     settlement?: boolean | undefined;
     commission?: CommissionConfig | boolean | undefined;
+    /**
+     * Bank-feed / accounting-feed module (3.0). Default: enabled (the
+     * schema fields are always present so the discriminator works
+     * uniformly). Disabling this suppresses the auto-wiring of
+     * `bankFeedProviders`, the bulk-write plugin, AND every bank-feed
+     * index — set to `false` for hosts that purely use the payment-
+     * flow lifecycle and want to omit those costs.
+     *
+     * Pass an object to fine-tune which bank-feed indexes are built.
+     * Examples:
+     *   `{ bankFeed: { indexes: { matchCandidates: true } } }`
+     *     — turn on cross-ref indexes for an active recon dashboard.
+     *   `{ bankFeed: { indexes: { idempotentImport: false, byAccount: false } } }`
+     *     — host doesn't use `import()` and doesn't need treasurer dashboards.
+     */
+    bankFeed?: boolean | BankFeedModuleConfig | undefined;
   } | undefined;
   providers?: Record<string, PaymentProvider> | undefined;
+  /**
+   * Bank-feed providers — Plaid, fin-io OFX/CAMT/MT940/CSV, QBO/Xero CDC
+   * adapters. Wired into `engine.bankFeedProviders` and consumed by
+   * `transactionRepository.drainSync()` and `parseAndImport()`.
+   *
+   * @example
+   * ```ts
+   * import { PlaidBankFeedProvider } from '@classytic/revenue-plaid';
+   * import { FinIoBankFeedProvider } from '@classytic/revenue-fin-io';
+   *
+   * const engine = await createRevenue({
+   *   ...,
+   *   bankFeedProviders: {
+   *     plaid: new PlaidBankFeedProvider({ clientId, secret }),
+   *     ofx:   new FinIoBankFeedProvider(),
+   *   },
+   * });
+   * ```
+   */
+  bankFeedProviders?: Record<string, BankFeedProvider> | undefined;
   bridges?: RevenueBridges | undefined;
   repositoryPlugins?: RepositoryPluginBundle | undefined;
   schemaOptions?: RevenueSchemaOptions | undefined;
@@ -602,10 +1031,18 @@ interface RevenueEngine {
   models: RevenueModels;
   repositories: RevenueRepositories;
   providers: ProviderRegistry;
+  /**
+   * Bank-feed providers registry (3.0). Populated when `bankFeed`
+   * module is enabled and `bankFeedProviders` config is non-empty.
+   * Used by `transactionRepository.drainSync()` and
+   * `parseAndImport()`. Hosts can `register` providers at runtime too
+   * (e.g. after the engine boots, to add a per-tenant Plaid client).
+   */
+  bankFeedProviders: BankFeedProviderRegistry;
   events: EventTransport;
   /** Explicitly build all schema-declared indexes. Non-destructive. */
   syncIndexes(): Promise<void>;
   destroy(): Promise<void>;
 }
 //#endregion
-export { SettlementRepository as a, RevenueModels as c, SubscriptionDocument as d, TransactionDocument as f, RevenueEngine as i, RevenueSchemaOptions as l, RetryConfig as n, SubscriptionRepository as o, RevenueConfig as r, TransactionRepository as s, CommissionConfig as t, SettlementDocument as u };
+export { RevenueConfig as a, SubscriptionRepository as c, RevenueSchemaOptions as d, SettlementDocument as f, RetryConfig as i, TransactionRepository as l, TransactionDocument as m, BankFeedModuleConfig as n, RevenueEngine as o, SubscriptionDocument as p, CommissionConfig as r, SettlementRepository as s, BankFeedIndexConfig as t, RevenueModels as u };

package/dist/enums/index.d.mts

@@ -1,3 +1,4 @@
-import { $ as HOLD_STATUS, A as SPLIT_STATUS, B as isSplitType, C as SubscriptionStatusValue, D as PAYOUT_METHOD_VALUES, E as PAYOUT_METHOD, F as SplitStatusValue, G as SettlementStatus, H as SETTLEMENT_STATUS_VALUES, I as SplitType, J as SettlementTypeValue, K as SettlementStatusValue, L as SplitTypeValue, M as SPLIT_TYPE, N as SPLIT_TYPE_VALUES, O as PayoutMethod, P as SplitStatus, Q as HOLD_REASON_VALUES, R as isPayoutMethod, S as SubscriptionStatus, T as isSubscriptionStatus, U as SETTLEMENT_TYPE, V as SETTLEMENT_STATUS, W as SETTLEMENT_TYPE_VALUES, X as isSettlementType, Y as isSettlementStatus, Z as HOLD_REASON, _ as PLAN_KEY_VALUES, a as TRANSACTION_FLOW, at as RELEASE_REASON, b as SUBSCRIPTION_STATUS, c as TRANSACTION_STATUS_VALUES, ct as ReleaseReasonValue, d as TransactionStatus, dt as isReleaseReason, et as HOLD_STATUS_VALUES, f as TransactionStatusValue, g as PLAN_KEYS, h as isTransactionStatus, i as LibraryCategoryValue, it as HoldStatusValue, j as SPLIT_STATUS_VALUES, k as PayoutMethodValue, l as TransactionFlow, lt as isHoldReason, m as isTransactionFlow, n as LIBRARY_CATEGORY_VALUES, nt as HoldReasonValue, o as TRANSACTION_FLOW_VALUES, ot as RELEASE_REASON_VALUES, p as isLibraryCategory, q as SettlementType, r as LibraryCategories, rt as HoldStatus, s as TRANSACTION_STATUS, st as ReleaseReason, t as LIBRARY_CATEGORIES, tt as HoldReason, u as TransactionFlowValue, ut as isHoldStatus, v as PlanKeyValue, w as isPlanKey, x as SUBSCRIPTION_STATUS_VALUES, y as PlanKeys, z as isSplitStatus } from "../transaction.enums-u4MshXcL.mjs";
-import { a as isMonetizationType, c as PAYMENT_STATUS, d as PaymentGatewayTypeValue, f as PaymentStatus, h as isPaymentStatus, i as MonetizationTypes, l as PAYMENT_STATUS_VALUES, m as isPaymentGatewayType, n as MONETIZATION_TYPE_VALUES, o as PAYMENT_GATEWAY_TYPE, p as PaymentStatusValue, r as MonetizationTypeValue, s as PAYMENT_GATEWAY_TYPE_VALUES, t as MONETIZATION_TYPES, u as PaymentGatewayType } from "../monetization.enums-D2xbxXJM.mjs";
-export { HOLD_REASON, HOLD_REASON_VALUES, HOLD_STATUS, HOLD_STATUS_VALUES, HoldReason, HoldReasonValue, HoldStatus, HoldStatusValue, LIBRARY_CATEGORIES, LIBRARY_CATEGORY_VALUES, LibraryCategories, LibraryCategoryValue, MONETIZATION_TYPES, MONETIZATION_TYPE_VALUES, MonetizationTypeValue, MonetizationTypes, PAYMENT_GATEWAY_TYPE, PAYMENT_GATEWAY_TYPE_VALUES, PAYMENT_STATUS, PAYMENT_STATUS_VALUES, PAYOUT_METHOD, PAYOUT_METHOD_VALUES, PLAN_KEYS, PLAN_KEY_VALUES, PaymentGatewayType, PaymentGatewayTypeValue, PaymentStatus, PaymentStatusValue, PayoutMethod, PayoutMethodValue, PlanKeyValue, PlanKeys, RELEASE_REASON, RELEASE_REASON_VALUES, ReleaseReason, ReleaseReasonValue, SETTLEMENT_STATUS, SETTLEMENT_STATUS_VALUES, SETTLEMENT_TYPE, SETTLEMENT_TYPE_VALUES, SPLIT_STATUS, SPLIT_STATUS_VALUES, SPLIT_TYPE, SPLIT_TYPE_VALUES, SUBSCRIPTION_STATUS, SUBSCRIPTION_STATUS_VALUES, SettlementStatus, SettlementStatusValue, SettlementType, SettlementTypeValue, SplitStatus, SplitStatusValue, SplitType, SplitTypeValue, SubscriptionStatus, SubscriptionStatusValue, TRANSACTION_FLOW, TRANSACTION_FLOW_VALUES, TRANSACTION_STATUS, TRANSACTION_STATUS_VALUES, TransactionFlow, TransactionFlowValue, TransactionStatus, TransactionStatusValue, isHoldReason, isHoldStatus, isLibraryCategory, isMonetizationType, isPaymentGatewayType, isPaymentStatus, isPayoutMethod, isPlanKey, isReleaseReason, isSettlementStatus, isSettlementType, isSplitStatus, isSplitType, isSubscriptionStatus, isTransactionFlow, isTransactionStatus };
+import { A as SettlementStatus, B as HoldReason, C as isPayoutMethod, D as SETTLEMENT_STATUS_VALUES, E as SETTLEMENT_STATUS, F as isSettlementType, G as RELEASE_REASON_VALUES, H as HoldStatus, I as HOLD_REASON, J as isHoldReason, K as ReleaseReason, L as HOLD_REASON_VALUES, M as SettlementType, N as SettlementTypeValue, O as SETTLEMENT_TYPE, P as isSettlementStatus, R as HOLD_STATUS, S as SplitTypeValue, T as isSplitType, U as HoldStatusValue, V as HoldReasonValue, W as RELEASE_REASON, X as isReleaseReason, Y as isHoldStatus, _ as SPLIT_TYPE, a as SUBSCRIPTION_STATUS, b as SplitStatusValue, c as SubscriptionStatusValue, d as PAYOUT_METHOD, f as PAYOUT_METHOD_VALUES, g as SPLIT_STATUS_VALUES, h as SPLIT_STATUS, i as PlanKeys, j as SettlementStatusValue, k as SETTLEMENT_TYPE_VALUES, l as isPlanKey, m as PayoutMethodValue, n as PLAN_KEY_VALUES, o as SUBSCRIPTION_STATUS_VALUES, p as PayoutMethod, q as ReleaseReasonValue, r as PlanKeyValue, s as SubscriptionStatus, t as PLAN_KEYS, u as isSubscriptionStatus, v as SPLIT_TYPE_VALUES, w as isSplitStatus, x as SplitType, y as SplitStatus, z as HOLD_STATUS_VALUES } from "../subscription.enums-k24kLpF7.mjs";
+import { A as isTransactionFlow, C as TRANSACTION_STATUS, D as TransactionStatus, E as TransactionFlowValue, O as TransactionStatusValue, S as TRANSACTION_FLOW_VALUES, T as TransactionFlow, _ as LIBRARY_CATEGORIES, a as BankFeedSourceValue, b as LibraryCategoryValue, c as TRANSACTION_KIND_VALUES, d as initialStatusFor, f as isBankFeedSource, g as statusesForKind, h as isTransactionKind, i as BANK_FEED_STATUS_VALUES, j as isTransactionStatus, k as isLibraryCategory, l as TransactionKind, m as isStatusValidForKind, n as BANK_FEED_SOURCE_VALUES, o as BankFeedStatusValue, p as isBankFeedStatus, r as BANK_FEED_STATUS, s as TRANSACTION_KIND, t as BANK_FEED_SOURCE, u as TransactionKindValue, v as LIBRARY_CATEGORY_VALUES, w as TRANSACTION_STATUS_VALUES, x as TRANSACTION_FLOW, y as LibraryCategories } from "../bank-feed.enums-BadqNJTC.mjs";
+import { a as isMonetizationType, c as PAYMENT_STATUS, d as PaymentGatewayTypeValue, f as PaymentStatus, h as isPaymentStatus, i as MonetizationTypes, l as PAYMENT_STATUS_VALUES, m as isPaymentGatewayType, n as MONETIZATION_TYPE_VALUES, o as PAYMENT_GATEWAY_TYPE, p as PaymentStatusValue, r as MonetizationTypeValue, s as PAYMENT_GATEWAY_TYPE_VALUES, t as MONETIZATION_TYPES, u as PaymentGatewayType } from "../monetization.enums-DzAI4sT7.mjs";
+export { BANK_FEED_SOURCE, BANK_FEED_SOURCE_VALUES, BANK_FEED_STATUS, BANK_FEED_STATUS_VALUES, BankFeedSourceValue, BankFeedStatusValue, HOLD_REASON, HOLD_REASON_VALUES, HOLD_STATUS, HOLD_STATUS_VALUES, HoldReason, HoldReasonValue, HoldStatus, HoldStatusValue, LIBRARY_CATEGORIES, LIBRARY_CATEGORY_VALUES, LibraryCategories, LibraryCategoryValue, MONETIZATION_TYPES, MONETIZATION_TYPE_VALUES, MonetizationTypeValue, MonetizationTypes, PAYMENT_GATEWAY_TYPE, PAYMENT_GATEWAY_TYPE_VALUES, PAYMENT_STATUS, PAYMENT_STATUS_VALUES, PAYOUT_METHOD, PAYOUT_METHOD_VALUES, PLAN_KEYS, PLAN_KEY_VALUES, PaymentGatewayType, PaymentGatewayTypeValue, PaymentStatus, PaymentStatusValue, PayoutMethod, PayoutMethodValue, PlanKeyValue, PlanKeys, RELEASE_REASON, RELEASE_REASON_VALUES, ReleaseReason, ReleaseReasonValue, SETTLEMENT_STATUS, SETTLEMENT_STATUS_VALUES, SETTLEMENT_TYPE, SETTLEMENT_TYPE_VALUES, SPLIT_STATUS, SPLIT_STATUS_VALUES, SPLIT_TYPE, SPLIT_TYPE_VALUES, SUBSCRIPTION_STATUS, SUBSCRIPTION_STATUS_VALUES, SettlementStatus, SettlementStatusValue, SettlementType, SettlementTypeValue, SplitStatus, SplitStatusValue, SplitType, SplitTypeValue, SubscriptionStatus, SubscriptionStatusValue, TRANSACTION_FLOW, TRANSACTION_FLOW_VALUES, TRANSACTION_KIND, TRANSACTION_KIND_VALUES, TRANSACTION_STATUS, TRANSACTION_STATUS_VALUES, TransactionFlow, TransactionFlowValue, TransactionKind, TransactionKindValue, TransactionStatus, TransactionStatusValue, initialStatusFor, isBankFeedSource, isBankFeedStatus, isHoldReason, isHoldStatus, isLibraryCategory, isMonetizationType, isPaymentGatewayType, isPaymentStatus, isPayoutMethod, isPlanKey, isReleaseReason, isSettlementStatus, isSettlementType, isSplitStatus, isSplitType, isStatusValidForKind, isSubscriptionStatus, isTransactionFlow, isTransactionKind, isTransactionStatus, statusesForKind };

package/dist/enums/index.mjs

@@ -1,4 +1,5 @@
-import { A as isReleaseReason, C as HOLD_REASON_VALUES, D as RELEASE_REASON_VALUES, E as RELEASE_REASON, F as TRANSACTION_STATUS, I as TRANSACTION_STATUS_VALUES, L as isLibraryCategory, M as LIBRARY_CATEGORY_VALUES, N as TRANSACTION_FLOW, O as isHoldReason, P as TRANSACTION_FLOW_VALUES, R as isTransactionFlow, S as HOLD_REASON, T as HOLD_STATUS_VALUES, _ as SETTLEMENT_STATUS_VALUES, a as isPlanKey, b as isSettlementStatus, c as PAYOUT_METHOD_VALUES, d as SPLIT_TYPE, f as SPLIT_TYPE_VALUES, g as SETTLEMENT_STATUS, h as isSplitType, i as SUBSCRIPTION_STATUS_VALUES, j as LIBRARY_CATEGORIES, k as isHoldStatus, l as SPLIT_STATUS, m as isSplitStatus, n as PLAN_KEY_VALUES, o as isSubscriptionStatus, p as isPayoutMethod, r as SUBSCRIPTION_STATUS, s as PAYOUT_METHOD, t as PLAN_KEYS, u as SPLIT_STATUS_VALUES, v as SETTLEMENT_TYPE, w as HOLD_STATUS, x as isSettlementType, y as SETTLEMENT_TYPE_VALUES, z as isTransactionStatus } from "../subscription.enums-tfoAgsTv.mjs";
-import { a as PAYMENT_GATEWAY_TYPE_VALUES, c as isPaymentGatewayType, i as PAYMENT_GATEWAY_TYPE, l as isPaymentStatus, n as MONETIZATION_TYPE_VALUES, o as PAYMENT_STATUS, r as isMonetizationType, s as PAYMENT_STATUS_VALUES, t as MONETIZATION_TYPES } from "../monetization.enums-BtiU3t8o.mjs";
+import { _ as TRANSACTION_STATUS, a as TRANSACTION_KIND, b as isTransactionFlow, c as isBankFeedSource, d as isTransactionKind, f as statusesForKind, g as TRANSACTION_FLOW_VALUES, h as TRANSACTION_FLOW, i as BANK_FEED_STATUS_VALUES, l as isBankFeedStatus, m as LIBRARY_CATEGORY_VALUES, n as BANK_FEED_SOURCE_VALUES, o as TRANSACTION_KIND_VALUES, p as LIBRARY_CATEGORIES, r as BANK_FEED_STATUS, s as initialStatusFor, t as BANK_FEED_SOURCE, u as isStatusValidForKind, v as TRANSACTION_STATUS_VALUES, x as isTransactionStatus, y as isLibraryCategory } from "../bank-feed.enums-kYTLTTbe.mjs";
+import { A as isReleaseReason, C as HOLD_REASON_VALUES, D as RELEASE_REASON_VALUES, E as RELEASE_REASON, O as isHoldReason, S as HOLD_REASON, T as HOLD_STATUS_VALUES, _ as SETTLEMENT_STATUS_VALUES, a as isPlanKey, b as isSettlementStatus, c as PAYOUT_METHOD_VALUES, d as SPLIT_TYPE, f as SPLIT_TYPE_VALUES, g as SETTLEMENT_STATUS, h as isSplitType, i as SUBSCRIPTION_STATUS_VALUES, k as isHoldStatus, l as SPLIT_STATUS, m as isSplitStatus, n as PLAN_KEY_VALUES, o as isSubscriptionStatus, p as isPayoutMethod, r as SUBSCRIPTION_STATUS, s as PAYOUT_METHOD, t as PLAN_KEYS, u as SPLIT_STATUS_VALUES, v as SETTLEMENT_TYPE, w as HOLD_STATUS, x as isSettlementType, y as SETTLEMENT_TYPE_VALUES } from "../subscription.enums-DoIr56O6.mjs";
+import { a as PAYMENT_GATEWAY_TYPE_VALUES, c as isPaymentGatewayType, i as PAYMENT_GATEWAY_TYPE, l as isPaymentStatus, n as MONETIZATION_TYPE_VALUES, o as PAYMENT_STATUS, r as isMonetizationType, s as PAYMENT_STATUS_VALUES, t as MONETIZATION_TYPES } from "../monetization.enums-B9HBOecd.mjs";
 
-export { HOLD_REASON, HOLD_REASON_VALUES, HOLD_STATUS, HOLD_STATUS_VALUES, LIBRARY_CATEGORIES, LIBRARY_CATEGORY_VALUES, MONETIZATION_TYPES, MONETIZATION_TYPE_VALUES, PAYMENT_GATEWAY_TYPE, PAYMENT_GATEWAY_TYPE_VALUES, PAYMENT_STATUS, PAYMENT_STATUS_VALUES, PAYOUT_METHOD, PAYOUT_METHOD_VALUES, PLAN_KEYS, PLAN_KEY_VALUES, RELEASE_REASON, RELEASE_REASON_VALUES, SETTLEMENT_STATUS, SETTLEMENT_STATUS_VALUES, SETTLEMENT_TYPE, SETTLEMENT_TYPE_VALUES, SPLIT_STATUS, SPLIT_STATUS_VALUES, SPLIT_TYPE, SPLIT_TYPE_VALUES, SUBSCRIPTION_STATUS, SUBSCRIPTION_STATUS_VALUES, TRANSACTION_FLOW, TRANSACTION_FLOW_VALUES, TRANSACTION_STATUS, TRANSACTION_STATUS_VALUES, isHoldReason, isHoldStatus, isLibraryCategory, isMonetizationType, isPaymentGatewayType, isPaymentStatus, isPayoutMethod, isPlanKey, isReleaseReason, isSettlementStatus, isSettlementType, isSplitStatus, isSplitType, isSubscriptionStatus, isTransactionFlow, isTransactionStatus };
+export { BANK_FEED_SOURCE, BANK_FEED_SOURCE_VALUES, BANK_FEED_STATUS, BANK_FEED_STATUS_VALUES, HOLD_REASON, HOLD_REASON_VALUES, HOLD_STATUS, HOLD_STATUS_VALUES, LIBRARY_CATEGORIES, LIBRARY_CATEGORY_VALUES, MONETIZATION_TYPES, MONETIZATION_TYPE_VALUES, PAYMENT_GATEWAY_TYPE, PAYMENT_GATEWAY_TYPE_VALUES, PAYMENT_STATUS, PAYMENT_STATUS_VALUES, PAYOUT_METHOD, PAYOUT_METHOD_VALUES, PLAN_KEYS, PLAN_KEY_VALUES, RELEASE_REASON, RELEASE_REASON_VALUES, SETTLEMENT_STATUS, SETTLEMENT_STATUS_VALUES, SETTLEMENT_TYPE, SETTLEMENT_TYPE_VALUES, SPLIT_STATUS, SPLIT_STATUS_VALUES, SPLIT_TYPE, SPLIT_TYPE_VALUES, SUBSCRIPTION_STATUS, SUBSCRIPTION_STATUS_VALUES, TRANSACTION_FLOW, TRANSACTION_FLOW_VALUES, TRANSACTION_KIND, TRANSACTION_KIND_VALUES, TRANSACTION_STATUS, TRANSACTION_STATUS_VALUES, initialStatusFor, isBankFeedSource, isBankFeedStatus, isHoldReason, isHoldStatus, isLibraryCategory, isMonetizationType, isPaymentGatewayType, isPaymentStatus, isPayoutMethod, isPlanKey, isReleaseReason, isSettlementStatus, isSettlementType, isSplitStatus, isSplitType, isStatusValidForKind, isSubscriptionStatus, isTransactionFlow, isTransactionKind, isTransactionStatus, statusesForKind };

package/dist/{errors-DHa8JVQ-.mjs → errors-Dt46UZL_.mjs}

@@ -87,6 +87,28 @@ var PaymentVerificationError = class extends RevenueError {
 		this.name = "PaymentVerificationError";
 	}
 };
+var BankFeedImportError = class extends RevenueError {
+	constructor(message, details) {
+		super(message, "BANK_FEED_IMPORT_ERROR", details);
+		this.name = "BankFeedImportError";
+	}
+};
+var WrongTransactionKindError = class extends RevenueError {
+	constructor(transactionId, expected, actual) {
+		super(`Transaction '${transactionId}' is kind '${actual}', not '${expected}'`, "WRONG_TRANSACTION_KIND", {
+			transactionId,
+			expected,
+			actual
+		});
+		this.name = "WrongTransactionKindError";
+	}
+};
+var BankFeedProviderNotFoundError = class extends RevenueError {
+	constructor(providerName) {
+		super(`Bank-feed provider '${providerName}' not registered. Use \`engine.bankFeedProviders.register(name, provider)\`.`, "BANK_FEED_PROVIDER_NOT_FOUND", { providerName });
+		this.name = "BankFeedProviderNotFoundError";
+	}
+};
 
 //#endregion
-export { PaymentVerificationError as a, RefundNotSupportedError as c, SubscriptionNotFoundError as d, TransactionNotFoundError as f, PaymentIntentCreationError as i, RevenueError as l, ConfigurationError as n, ProviderCapabilityError as o, ValidationError as p, InvalidStateTransitionError as r, ProviderNotFoundError as s, AlreadyVerifiedError as t, SettlementNotFoundError as u };
+export { InvalidStateTransitionError as a, ProviderCapabilityError as c, RevenueError as d, SettlementNotFoundError as f, WrongTransactionKindError as g, ValidationError as h, ConfigurationError as i, ProviderNotFoundError as l, TransactionNotFoundError as m, BankFeedImportError as n, PaymentIntentCreationError as o, SubscriptionNotFoundError as p, BankFeedProviderNotFoundError as r, PaymentVerificationError as s, AlreadyVerifiedError as t, RefundNotSupportedError as u };