@profullstack/coinpay 0.9.0 → 0.11.0

package/src/finances-reports.js

@@ -0,0 +1,356 @@
+/**
+ * Finance reports, sync jobs, coverage and the statement library.
+ *
+ * Every function takes a `CoinPayClient` authenticated with a merchant
+ * session. Nothing here computes a total: the server freezes each report's
+ * rows and sums them exactly, and these calls fetch what it produced. A
+ * download returns bytes, never a JSON-wrapped blob.
+ */
+
+function query(params) {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === undefined || value === null || value === '') continue;
+    if (Array.isArray(value)) {
+      for (const v of value) search.append(key, String(v));
+    } else {
+      search.set(key, String(value));
+    }
+  }
+  const s = search.toString();
+  return s ? `?${s}` : '';
+}
+
+function headersWith(idempotencyKey) {
+  return idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : {};
+}
+
+/** Surface the server's structured error `{ error: { code, message } }` as an Error with `.code`. */
+async function call(client, endpoint, options = {}) {
+  try {
+    return await client.request(endpoint, options);
+  } catch (err) {
+    const body = err && err.response && err.response.error;
+    if (body && typeof body === 'object') {
+      const wrapped = new Error(body.message || err.message);
+      wrapped.code = body.code;
+      wrapped.status = err.status;
+      wrapped.retryable = body.retryable === true;
+      wrapped.jobId = body.jobId;
+      wrapped.reportId = body.reportId;
+      wrapped.retryAfter = body.retryAfter;
+      wrapped.response = err.response;
+      throw wrapped;
+    }
+    if (err && err.response && typeof err.response.code === 'string' && !err.code) err.code = err.response.code;
+    throw err;
+  }
+}
+
+// ── Connections ──
+
+/**
+ * Claim a SimpleFIN setup token. The token is single-use; the server checks
+ * everything it can before spending it and says plainly when the outcome is
+ * unknown (`err.code === 'claim_outcome_unknown'`).
+ */
+export async function connectSimpleFin(client, { setupToken, label, protocolVersion, idempotencyKey } = {}) {
+  if (!setupToken || !String(setupToken).trim()) throw new Error('A setup token is required');
+  return call(client, '/finances/connections', {
+    method: 'POST',
+    headers: headersWith(idempotencyKey),
+    body: JSON.stringify({ setupToken: String(setupToken).trim(), label, protocolVersion }),
+  });
+}
+
+/** Stop future syncs and remove the credential; history is kept. */
+export async function disconnectFinanceConnection(client, connectionId) {
+  return call(client, `/finances/connections/${encodeURIComponent(connectionId)}/disconnect`, { method: 'POST', body: '{}' });
+}
+
+/** What deleting a connection would remove. */
+export async function describeFinanceConnection(client, connectionId) {
+  return call(client, `/finances/connections/${encodeURIComponent(connectionId)}`);
+}
+
+/** Delete a connection and everything under it. `confirm` must be true. */
+export async function deleteFinanceConnection(client, connectionId, { confirm = false } = {}) {
+  if (!confirm) throw new Error('Deleting a connection removes its account data; pass { confirm: true }');
+  return call(client, `/finances/connections/${encodeURIComponent(connectionId)}?confirm=yes`, {
+    method: 'DELETE',
+    headers: { 'X-Confirm-Delete': 'yes' },
+  });
+}
+
+/** Opt a connection in or out of a once-daily background sync. */
+export async function setFinanceSyncConsent(client, connectionId, dailySync) {
+  return call(client, `/finances/connections/${encodeURIComponent(connectionId)}/consent`, {
+    method: 'POST',
+    body: JSON.stringify({ dailySync: dailySync === true }),
+  });
+}
+
+// ── Jobs ──
+
+/** Queue a period backfill (`{ period: '2026-Q2' }` or `{ from, to }`). Answers 202 with the job(s). */
+export async function createBackfillJob(client, { connectionId, period, from, to, timezone, idempotencyKey } = {}) {
+  return call(client, '/finances/sync-jobs', {
+    method: 'POST',
+    headers: headersWith(idempotencyKey),
+    body: JSON.stringify({ kind: 'backfill', connectionId, period, from, to, timezone }),
+  });
+}
+
+/** Queue a background rolling refresh of one connection. */
+export async function createRefreshJob(client, { connectionId, days, idempotencyKey } = {}) {
+  return call(client, '/finances/sync-jobs', {
+    method: 'POST',
+    headers: headersWith(idempotencyKey),
+    body: JSON.stringify({ kind: 'refresh', connectionId, days }),
+  });
+}
+
+export async function getFinanceJob(client, jobId) {
+  const data = await call(client, `/finances/jobs/${encodeURIComponent(jobId)}`);
+  return data.job;
+}
+
+export async function listFinanceJobs(client, { limit, connectionId } = {}) {
+  const data = await call(client, `/finances/jobs${query({ limit, connection: connectionId })}`);
+  return data.jobs || [];
+}
+
+export async function cancelFinanceJob(client, jobId) {
+  const data = await call(client, `/finances/jobs/${encodeURIComponent(jobId)}/cancel`, { method: 'POST', body: '{}' });
+  return data.job;
+}
+
+const TERMINAL_JOB = new Set(['completed', 'failed', 'cancelled', 'partial']);
+
+/**
+ * Poll a job until it reaches a terminal state or `waiting_for_budget`
+ * (which can take hours to clear and is reported, not waited out).
+ */
+export async function waitForFinanceJob(client, jobId, { intervalMs = 3000, timeoutMs = 30 * 60 * 1000, onProgress, sleep } = {}) {
+  const started = Date.now();
+  const pause = sleep || ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  for (;;) {
+    const job = await getFinanceJob(client, jobId);
+    if (onProgress) onProgress(job);
+    if (TERMINAL_JOB.has(job.status) || job.status === 'waiting_for_budget') return job;
+    if (Date.now() - started > timeoutMs) return job;
+    await pause(intervalMs);
+  }
+}
+
+// ── Coverage ──
+
+export async function getFinanceCoverage(client, { period, from, to, timezone, accountIds, includeHidden } = {}) {
+  return call(client, `/finances/coverage${query({ period, from, to, timezone, account: accountIds, hidden: includeHidden ? 1 : undefined })}`);
+}
+
+// ── Reports ──
+
+/**
+ * Create an immutable report revision. Answers 202 with `{ report, job }`;
+ * use `waitForFinanceReport` to block until it is ready.
+ */
+export async function createFinanceReport(client, {
+  period, from, to, timezone, accountIds, scope, includeHidden, includePendingAppendix, formats, strict, idempotencyKey,
+} = {}) {
+  return call(client, '/finances/reports', {
+    method: 'POST',
+    headers: headersWith(idempotencyKey),
+    body: JSON.stringify({ period, from, to, timezone, accountIds, scope, includeHidden, includePendingAppendix, formats, strict }),
+  });
+}
+
+export async function listFinanceReports(client, { limit, offset } = {}) {
+  return call(client, `/finances/reports${query({ limit, offset })}`);
+}
+
+export async function getFinanceReport(client, reportId) {
+  return call(client, `/finances/reports/${encodeURIComponent(reportId)}`);
+}
+
+export async function deleteFinanceReport(client, reportId) {
+  return call(client, `/finances/reports/${encodeURIComponent(reportId)}`, { method: 'DELETE' });
+}
+
+const TERMINAL_REPORT = new Set(['ready', 'failed', 'superseded', 'deleted']);
+
+export async function waitForFinanceReport(client, reportId, { intervalMs = 3000, timeoutMs = 30 * 60 * 1000, onProgress, sleep } = {}) {
+  const started = Date.now();
+  const pause = sleep || ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  for (;;) {
+    const data = await getFinanceReport(client, reportId);
+    if (onProgress) onProgress(data);
+    if (TERMINAL_REPORT.has(data.report.status)) return data;
+    if (data.job && data.job.status === 'waiting_for_budget') return data;
+    if (Date.now() - started > timeoutMs) return data;
+    await pause(intervalMs);
+  }
+}
+
+/**
+ * Download one format of a ready report. Resolves to
+ * `{ bytes: Uint8Array, contentType, filename, sha256, headers }`.
+ */
+export async function downloadFinanceReport(client, reportId, { format = 'pdf' } = {}) {
+  return client.requestBinary(`/finances/reports/${encodeURIComponent(reportId)}/download${query({ format })}`);
+}
+
+// ── Statements ──
+
+/**
+ * Import an original PDF. `file` is a Uint8Array/Buffer/Blob of the bytes;
+ * nothing is read out of it into the ledger.
+ */
+export async function importFinanceStatement(client, {
+  file, filename = 'statement.pdf', accountId, period, from, to, timezone, institutionLabel, cycle, notes,
+} = {}) {
+  if (!file) throw new Error('A PDF file is required');
+  if (!accountId) throw new Error('accountId is required');
+  const form = new FormData();
+  const blob = file instanceof Blob ? file : new Blob([file], { type: 'application/pdf' });
+  form.append('file', blob, filename);
+  form.append('accountId', accountId);
+  if (period) form.append('period', period);
+  if (from) form.append('from', from);
+  if (to) form.append('to', to);
+  if (timezone) form.append('timezone', timezone);
+  if (institutionLabel) form.append('institutionLabel', institutionLabel);
+  if (cycle) form.append('cycle', cycle);
+  if (notes) form.append('notes', notes);
+  return client.requestForm('/finances/statements', form);
+}
+
+export async function listFinanceStatements(client, { accountId, period, from, to, timezone, limit } = {}) {
+  const data = await call(client, `/finances/statements${query({ account: accountId, period, from, to, timezone, limit })}`);
+  return data.statements || [];
+}
+
+export async function getFinanceStatement(client, statementId) {
+  return call(client, `/finances/statements/${encodeURIComponent(statementId)}`);
+}
+
+export async function downloadFinanceStatement(client, statementId) {
+  return client.requestBinary(`/finances/statements/${encodeURIComponent(statementId)}/download`);
+}
+
+export async function deleteFinanceStatement(client, statementId) {
+  return call(client, `/finances/statements/${encodeURIComponent(statementId)}`, { method: 'DELETE' });
+}
+
+/**
+ * Enter a statement's balances and check them against one report revision.
+ * Amounts are decimal strings in the account currency.
+ */
+export async function reconcileFinanceStatement(client, statementId, {
+  reportId, opening, closing, credits, debits, currency, signConvention, acknowledge,
+} = {}) {
+  const data = await call(client, `/finances/statements/${encodeURIComponent(statementId)}/reconciliations`, {
+    method: 'POST',
+    body: JSON.stringify({ reportId, opening, closing, credits, debits, currency, signConvention, acknowledge }),
+  });
+  return data.reconciliation;
+}
+
+// ── Books ──
+
+/** Rows awaiting review (default) plus the category vocabularies. */
+export async function listBooksQueue(client, { status, scope, accountId, search, start, end, limit, offset } = {}) {
+  return call(client, `/finances/books/queue${query({ status, scope, account: accountId, search, start, end, limit, offset })}`);
+}
+
+/** Confirm one row. Omitted fields keep the row's current values. */
+export async function reviewBooksTransaction(client, transactionId, { category, taxCategory, scope, note, createRule } = {}) {
+  const data = await call(client, `/finances/books/transactions/${encodeURIComponent(transactionId)}`, {
+    method: 'PATCH',
+    body: JSON.stringify({ category, taxCategory, scope, note, createRule }),
+  });
+  return data.transaction;
+}
+
+/** Confirm many rows; with no category given each row's suggestion is accepted. */
+export async function bulkReviewBooks(client, ids, { category, taxCategory, scope, createRule } = {}) {
+  return call(client, '/finances/books/bulk', { method: 'POST', body: JSON.stringify({ ids, category, taxCategory, scope, createRule }) });
+}
+
+/** Queue an auto-categorisation run over unreviewed rows. Answers with the job. */
+export async function categorizeBooks(client, { useModel = true, onlyUncategorized = false } = {}) {
+  return call(client, '/finances/books/categorize', { method: 'POST', body: JSON.stringify({ useModel, onlyUncategorized }) });
+}
+
+export async function listBooksRules(client) {
+  const data = await call(client, '/finances/books/rules');
+  return data.rules || [];
+}
+
+export async function createBooksRule(client, { matchField = 'payee', matchType = 'exact', pattern, category, taxCategory, scope } = {}) {
+  const data = await call(client, '/finances/books/rules', { method: 'POST', body: JSON.stringify({ matchField, matchType, pattern, category, taxCategory, scope }) });
+  return data.rule;
+}
+
+export async function deleteBooksRule(client, ruleId) {
+  return call(client, `/finances/books/rules/${encodeURIComponent(ruleId)}`, { method: 'DELETE' });
+}
+
+/** Totals by tax category for a year (`2026`), quarter or month. */
+export async function getBooksSummary(client, { period, from, to, timezone, scope, rows } = {}) {
+  return call(client, `/finances/books/summary${query({ period, from, to, timezone, scope, rows: rows ? 1 : undefined })}`);
+}
+
+/** The CPA pack as bytes. */
+export async function exportBooks(client, { period, from, to, timezone, scope, format = 'csv' } = {}) {
+  return client.requestBinary(`/finances/books/export${query({ period, from, to, timezone, scope, format })}`);
+}
+
+// ── Raw provider payloads ──
+
+export async function listFinancePayloads(client, { connectionId, limit, offset } = {}) {
+  return call(client, `/finances/payloads${query({ connection: connectionId, limit, offset })}`);
+}
+
+export async function downloadFinancePayload(client, payloadId) {
+  return client.requestBinary(`/finances/payloads/${encodeURIComponent(payloadId)}/download`);
+}
+
+// ── Email ──
+
+/** Email a ready report: attachments plus an expiring no-login link. */
+export async function sendFinanceReportEmail(client, reportId, { to, formats, message, attach, expiresInDays } = {}) {
+  return call(client, `/finances/reports/${encodeURIComponent(reportId)}/send`, {
+    method: 'POST',
+    body: JSON.stringify({ to, formats, message, attach, expiresInDays }),
+  });
+}
+
+/** Email the CPA pack for a period. `toDate` is the exclusive end for a custom range. */
+export async function sendBooksEmail(client, { to, period, from, toDate, timezone, scope, formats, message, attach, expiresInDays } = {}) {
+  return call(client, '/finances/books/send', {
+    method: 'POST',
+    body: JSON.stringify({ to, period, from, toDate, timezone, scope, formats, message, attach, expiresInDays }),
+  });
+}
+
+export async function getWeeklyDigest(client) {
+  const data = await call(client, '/finances/email-schedules');
+  return data.schedule;
+}
+
+export async function setWeeklyDigest(client, { weekdays, hour, timezone, recipients, scope, formats, active } = {}) {
+  const data = await call(client, '/finances/email-schedules', {
+    method: 'POST',
+    body: JSON.stringify({ weekdays, hour, timezone, recipients, scope, formats, active }),
+  });
+  return data.schedule;
+}
+
+export async function deleteWeeklyDigest(client) {
+  return call(client, '/finances/email-schedules', { method: 'DELETE' });
+}
+
+export async function sendWeeklyDigestNow(client) {
+  return call(client, '/finances/email-schedules/send-now', { method: 'POST', body: '{}' });
+}

package/src/finances-tui.js

@@ -312,6 +312,9 @@ function bankScreen(ui, state, theme) {
           { key: 'org_name', title: 'Institution', width: 22, render: (r) => r.org_name || '—', color: theme.muted },
           { key: 'name', title: 'Account', min: 14, max: 36 },
           { key: 'effective_kind', title: 'Kind', width: 10, color: (r) => (r.is_liability ? theme.danger : theme.success) },
+          // A trailing * marks a stored correction, so a wrong split is
+          // traceable to a guess rather than to someone's decision.
+          { key: 'effective_scope', title: 'Side', width: 10, render: (r) => `${r.effective_scope || '—'}${r.scope_override ? '*' : ''}`, color: (r) => (r.effective_scope === 'business' ? theme.info : theme.muted) },
           { key: 'display_balance', title: 'Balance', width: 13, align: 'right', render: (r) => money(r.display_balance ?? r.balance ?? 0, r.currency || cur), color: (r) => (r.is_liability ? theme.danger : theme.success) },
           { key: 'available_balance', title: 'Available', width: 12, align: 'right', render: (r) => (r.available_balance == null ? '—' : money(r.available_balance, r.currency || cur)), color: theme.muted },
           { key: 'balance_date', title: 'As of', width: 10, render: (r) => shortDate(r.balance_date), color: theme.muted },
@@ -1003,3 +1006,14 @@ export async function runFinancesTui({ client, baseUrl, token, days = 30, interv
 }
 
 export { TABS as FINANCE_TABS, WINDOWS as FINANCE_WINDOWS };
+
+/**
+ * The screen renderers, in tab order.
+ *
+ * Exported so a frame can be drawn without a client, a token or a terminal:
+ * each takes `(ui, state, theme)` and is a pure function of the snapshot, so
+ * hqtui's renderToText can produce the real screen from a fixture. That is what
+ * the hqtui.com showcase captures, and it is the only way to assert on this
+ * layout at all.
+ */
+export { SCREENS as FINANCE_SCREENS };

package/src/finances.d.ts

@@ -15,11 +15,15 @@ export interface FinanceAccount {
   balance_date: string | null;
   kind: AccountKind;
   kind_override: string | null;
+  /** Operator correction for which side of the books, or null for the guess. */
+  scope_override: string | null;
   is_hidden: boolean;
   last_seen_at: string;
   effective_kind: AccountKind;
   is_liability: boolean;
   display_balance: number | null;
+  /** `scope_override` when set, otherwise derived from the account name. */
+  effective_scope: AccountScope;
 }
 
 export interface FinanceTransaction {
@@ -57,8 +61,21 @@ export interface FinanceConnection {
   last_sync_error: string | null;
   last_sync_accounts: number | null;
   last_sync_transactions: number | null;
+  /** SimpleFIN protocol shape pinned on the credential; null = tested default. */
+  protocol_version?: 1 | 2 | null;
+  /** When the merchant opted into a once-daily background sync; null = never. */
+  sync_consent_at?: string | null;
+  next_sync_at?: string | null;
+  lifecycle_state?: 'active' | 'reconnect_required' | 'payment_required' | 'disconnected' | string;
+  disconnected_at?: string | null;
 }
 
+/** Every transaction in a window, paged until exhausted or `max` is hit. */
+export function listAllFinanceTransactions(
+  client: CoinPayClient,
+  options?: { startDate?: string | Date; endDate?: string | Date; pageSize?: number; max?: number },
+): Promise<{ rows: FinanceTransaction[]; total: number; complete: boolean }>;
+
 export interface FinanceSummary {
   windowDays: number;
   totals: Array<{ currency: string; assets: number; liabilities: number; net: number; accounts: number }>;
@@ -86,6 +103,21 @@ export interface FinanceSeriesPoint {
 }
 
 export type AccountScope = 'business' | 'personal';
+
+export interface UpdateFinanceAccountInput {
+  /** Corrected account kind, or null to use the derived guess. */
+  kind?: string | null;
+  /** Which side of the books, or null to use the name-derived guess. */
+  scope?: AccountScope | null;
+  /** Drop a closed or duplicate account out of the totals. */
+  hidden?: boolean;
+}
+
+export function updateFinanceAccount(
+  client: CoinPayClient,
+  accountId: string,
+  input: UpdateFinanceAccountInput,
+): Promise<FinanceAccount>;
 export type RecurrenceCadence = 'weekly' | 'biweekly' | 'monthly' | 'quarterly' | 'annual';
 
 /**

package/src/finances.js

@@ -53,6 +53,37 @@ export async function listFinanceAccounts(client, { includeHidden = false } = {}
   return data.accounts || [];
 }
 
+/**
+ * Every transaction in the window, not just the first page.
+ *
+ * The API caps a page well below what it will report as `total` (ask for 5000
+ * and you get 500), so a single call quietly returns a partial ledger. That is
+ * fine for a dashboard and useless for books: a report that silently drops
+ * two thirds of the year cannot be reconciled against anything, and nothing in
+ * the output would say so.
+ */
+export async function listAllFinanceTransactions(client, { startDate, endDate, pageSize = 500, max = 20000 } = {}) {
+  const rows = [];
+  let offset = 0;
+  let total = 0;
+
+  for (;;) {
+    // Both bounds are forwarded. An end date that was accepted here and
+    // dropped on the way to the API would return rows past the window and
+    // report the window as complete.
+    const page = await listFinanceTransactions(client, { limit: pageSize, offset, startDate, endDate });
+    const batch = page?.rows ?? [];
+    total = Number(page?.total) || total;
+    rows.push(...batch);
+    offset += batch.length;
+    // Stop on a short page as well as on the count: a `total` that disagrees
+    // with what is actually returned must not spin this forever.
+    if (!batch.length || rows.length >= total || rows.length >= max) break;
+  }
+
+  return { rows, total: total || rows.length, complete: rows.length >= total };
+}
+
 /** The ledger, newest first. Returns `{ rows, total, limit, offset }`. */
 export async function listFinanceTransactions(client, filters = {}) {
   return client.request(
@@ -69,6 +100,28 @@ export async function listFinanceTransactions(client, filters = {}) {
   );
 }
 
+/**
+ * Correct one account: which side of the books it is on, what kind it is, or
+ * whether it counts at all.
+ *
+ * Every field here is an operator correction stored beside the imported value,
+ * never over it, so the next sync re-deriving its guess cannot clobber the
+ * correction. Pass `null` for an override to hand the account back to the
+ * heuristic. Balances and transactions are deliberately not writable.
+ */
+export async function updateFinanceAccount(client, accountId, { kind, scope, hidden } = {}) {
+  const body = {};
+  if (kind !== undefined) body.kind_override = kind;
+  if (scope !== undefined) body.scope_override = scope;
+  if (hidden !== undefined) body.is_hidden = hidden;
+  if (Object.keys(body).length === 0) throw new Error('Nothing to update');
+  const data = await client.request(`/finances/accounts/${encodeURIComponent(accountId)}`, {
+    method: 'PATCH',
+    body: JSON.stringify(body),
+  });
+  return data.account;
+}
+
 /** Linked institutions and their last sync outcome. */
 export async function listFinanceConnections(client) {
   return client.request('/finances/connections');
@@ -293,6 +346,14 @@ export function buildFinanceSnapshot(raw = {}, { days = 30, now = new Date() } =
     plaidEnabled: Boolean(raw.connections?.plaidEnabled),
     ledger: raw.transactions?.rows || [],
     ledgerTotal: raw.transactions?.total ?? 0,
+    /**
+     * Whether the ledger above is the whole window or one page of it.
+     *
+     * Carried rather than inferred from lengths: a caller cannot tell a short
+     * final page from a truncated one, and anything printing a coverage line
+     * has to know which it is holding before it makes a claim about the period.
+     */
+    ledgerComplete: raw.transactions?.complete ?? ((raw.transactions?.rows?.length ?? 0) >= (raw.transactions?.total ?? 0)),
   };
 
   const refundsUsd = round2(card.refundedUsd + escrow.refundedUsd);
@@ -342,12 +403,17 @@ export function buildFinanceSnapshot(raw = {}, { days = 30, now = new Date() } =
  * Fetch everything and build a snapshot. Routes fail independently: a 500
  * from one of them lands in `snapshot.errors[name]` and its section is empty.
  */
-export async function collectFinanceSnapshot(client, { days = 30, limit = 100, businessId } = {}) {
+export async function collectFinanceSnapshot(client, { days = 30, limit = 100, businessId, allTransactions = false } = {}) {
   const since = Number.isFinite(days) && days > 0 ? new Date(Date.now() - days * 86400000).toISOString() : undefined;
   const sources = {
     summary: () => getFinanceSummary(client, { days }),
     accounts: () => listFinanceAccounts(client),
-    transactions: () => listFinanceTransactions(client, { limit, startDate: since }),
+    // The dashboard wants one page and wants it now; a report wants the whole
+    // window, because a document that silently holds a fifth of the year
+    // cannot be reconciled against anything.
+    transactions: () => (allTransactions
+      ? listAllFinanceTransactions(client, { startDate: since })
+      : listFinanceTransactions(client, { limit, startDate: since })),
     connections: () => listFinanceConnections(client),
     stats: () => getDashboardStats(client, { businessId }),
     analytics: () => getFinanceAnalytics(client, { period: periodForDays(days), businessId }),

package/src/index.d.ts

@@ -149,3 +149,4 @@ import { CoinPayClient } from './client.js';
 export default CoinPayClient;
 
 export * from './finances.js';
+export * from './finances-reports.js';

package/src/index.js

@@ -344,3 +344,6 @@ export {
 };
 
 export default CoinPayClient;
+
+// Finance reports, sync jobs, coverage and the statement library.
+export * from './finances-reports.js';