plasalid 0.3.5 → 0.5.0

package/dist/db/queries/concerns.js

@@ -0,0 +1,91 @@
+import { randomUUID } from "crypto";
+/**
+ * Insert a new concerns row and flip the `has_concern` boolean on whichever
+ * target (transaction / account) was named. Returns the new `cn:<uuid>` id.
+ */
+export function recordConcern(db, input) {
+    const id = `cn:${randomUUID()}`;
+    db.prepare(`INSERT INTO concerns (id, file_id, transaction_id, account_id, kind, prompt, options_json) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(id, input.file_id, input.transaction_id, input.account_id, input.kind ?? null, input.prompt, input.options ? JSON.stringify(input.options) : null);
+    if (input.transaction_id) {
+        db.prepare(`UPDATE transactions SET has_concern = 1 WHERE id = ?`).run(input.transaction_id);
+    }
+    if (input.account_id) {
+        db.prepare(`UPDATE accounts SET has_concern = 1 WHERE id = ?`).run(input.account_id);
+    }
+    return id;
+}
+/**
+ * Mark an existing concern as resolved with the user's answer and, if no other
+ * open concerns reference the same target, clear the target's `has_concern`
+ * flag. Returns the concern's target so callers can log or react.
+ */
+export function resolveConcern(db, id, answer) {
+    const target = getConcernTarget(db, id);
+    if (!target)
+        return null;
+    db.prepare(`UPDATE concerns SET answer = ?, resolved_at = datetime('now') WHERE id = ?`).run(answer, id);
+    maybeClearHasConcernFlags(db, target);
+    return target;
+}
+/**
+ * Look up the transaction/account a concern is attached to. Returns null when
+ * the concern id doesn't exist.
+ */
+export function getConcernTarget(db, id) {
+    const row = db
+        .prepare(`SELECT transaction_id, account_id FROM concerns WHERE id = ?`)
+        .get(id);
+    return row ?? null;
+}
+/**
+ * Clear `has_concern` on the named transaction / account if no other open concerns
+ * still reference it. Safe to call after any concern resolution; idempotent.
+ */
+export function maybeClearHasConcernFlags(db, target) {
+    if (target.transaction_id) {
+        const open = db
+            .prepare(`SELECT 1 FROM concerns WHERE transaction_id = ? AND resolved_at IS NULL LIMIT 1`)
+            .get(target.transaction_id);
+        if (!open)
+            db.prepare(`UPDATE transactions SET has_concern = 0 WHERE id = ?`).run(target.transaction_id);
+    }
+    if (target.account_id) {
+        const open = db
+            .prepare(`SELECT 1 FROM concerns WHERE account_id = ? AND resolved_at IS NULL LIMIT 1`)
+            .get(target.account_id);
+        if (!open)
+            db.prepare(`UPDATE accounts SET has_concern = 0 WHERE id = ?`).run(target.account_id);
+    }
+}
+export function countOpenConcerns(db, scope = {}) {
+    const conditions = ["resolved_at IS NULL"];
+    const params = [];
+    if (scope.file_id) {
+        conditions.push("file_id = ?");
+        params.push(scope.file_id);
+    }
+    if (scope.transaction_id) {
+        conditions.push("transaction_id = ?");
+        params.push(scope.transaction_id);
+    }
+    if (scope.account_id) {
+        conditions.push("account_id = ?");
+        params.push(scope.account_id);
+    }
+    if (scope.kind) {
+        conditions.push("kind = ?");
+        params.push(scope.kind);
+    }
+    const row = db
+        .prepare(`SELECT COUNT(*) AS n FROM concerns WHERE ${conditions.join(" AND ")}`)
+        .get(...params);
+    return row.n;
+}
+export function listOpenConcerns(db, limit = 50) {
+    const capped = Math.min(Math.max(limit, 1), 200);
+    return db.prepare(`SELECT id, file_id, transaction_id, account_id, kind, prompt, options_json, created_at
+     FROM concerns
+     WHERE resolved_at IS NULL
+     ORDER BY created_at ASC
+     LIMIT ?`).all(capped);
+}

package/dist/db/queries/journal.d.ts

@@ -8,20 +8,14 @@ export interface JournalLineInput {
     pii_flag?: boolean;
 }
 export interface JournalEntryInput {
+    /** Optional pre-assigned id. Used by the buffered-write path so concerns recorded mid-scan can reference the entry before commit. */
+    id?: string;
     date: string;
     description: string;
     source_file_id?: string | null;
     source_page?: number | null;
     lines: JournalLineInput[];
 }
-export interface JournalEntryRow {
-    id: string;
-    date: string;
-    description: string;
-    source_file_id: string | null;
-    source_page: number | null;
-    created_at: string;
-}
 export interface JournalLineRow {
     id: string;
     entry_id: string;
@@ -41,6 +35,22 @@ export interface JournalLineRow {
  * a header, header never lands without lines.
  */
 export declare function recordJournalEntry(db: Database.Database, entry: JournalEntryInput): string;
+/**
+ * Validate balance + invariants and assign an id. Pure (no DB writes). Used by
+ * both `recordJournalEntry` and the buffered-scan commit path; the latter
+ * already runs inside its own transaction and must not open another.
+ */
+export declare function validateJournalEntry(entry: JournalEntryInput): JournalEntryInput & {
+    id: string;
+};
+/**
+ * Insert-only counterpart to `recordJournalEntry`. The caller is responsible
+ * for opening a transaction (or for accepting partial writes). Expects an
+ * already-validated entry from `validateJournalEntry`.
+ */
+export declare function insertJournalEntryRows(db: Database.Database, entry: JournalEntryInput & {
+    id: string;
+}): void;
 export interface ListJournalLinesOptions {
     account_id?: string;
     from?: string;
@@ -92,4 +102,61 @@ export interface FindDuplicateEntriesOptions {
  * account_names (for human-readable presentation to the user).
  */
 export declare function findDuplicateEntries(db: Database.Database, opts?: FindDuplicateEntriesOptions): DuplicateGroupEntry[][];
+export declare function dayDiff(a: string, b: string): number;
+/** Correlations */
+export interface CorrelatedEntryPair {
+    amount: number;
+    currency: string;
+    day_gap: number;
+    a: {
+        id: string;
+        date: string;
+        description: string;
+        account_ids: string[];
+        account_names: string[];
+    };
+    b: {
+        id: string;
+        date: string;
+        description: string;
+        account_ids: string[];
+        account_names: string[];
+    };
+}
+export interface FindCorrelatedEntriesOptions {
+    from?: string;
+    to?: string;
+    /** Max day difference between paired entries. Default 3. */
+    toleranceDays?: number;
+    /** Skip entries below this total debit. Default 0. */
+    minAmount?: number;
+}
+/**
+ * Heuristic: surface pairs of entries that look like the same money movement
+ * recorded against different accounts (e.g. a bank-to-card transfer that lands
+ * once on the bank statement and again on the card statement). Filters out
+ * pairs whose account-id sets overlap (those are duplicates, not correlations).
+ */
+export declare function findCorrelatedEntries(db: Database.Database, opts?: FindCorrelatedEntriesOptions): CorrelatedEntryPair[];
+export interface CorrelationCandidate {
+    id: string;
+    date: string;
+    description: string;
+    amount: number;
+    currency: string;
+    account_ids: string[];
+    account_names: string[];
+}
+/**
+ * Pure pair-finder: given an array of candidates already filtered by amount
+ * and equipped with account_ids/names, return the cross-pairs that look like
+ * the same money movement on different accounts (date within toleranceDays,
+ * same amount + currency, non-overlapping account sets).
+ *
+ * Used by the DB-backed `findCorrelatedEntries` and by the scan-time
+ * coordinator that runs over buffered, not-yet-committed entries.
+ */
+export declare function correlatePairs(entries: CorrelationCandidate[], opts?: {
+    toleranceDays?: number;
+}): CorrelatedEntryPair[];
 export declare function listJournalLines(db: Database.Database, opts?: ListJournalLinesOptions): JournalLineRow[];

package/dist/db/queries/journal.js

@@ -6,6 +6,17 @@ const TOLERANCE = 0.005;
  * a header, header never lands without lines.
  */
 export function recordJournalEntry(db, entry) {
+    const validated = validateJournalEntry(entry);
+    const tx = db.transaction(() => { insertJournalEntryRows(db, validated); });
+    tx();
+    return validated.id;
+}
+/**
+ * Validate balance + invariants and assign an id. Pure (no DB writes). Used by
+ * both `recordJournalEntry` and the buffered-scan commit path; the latter
+ * already runs inside its own transaction and must not open another.
+ */
+export function validateJournalEntry(entry) {
     if (!entry.lines || entry.lines.length < 2) {
         throw new Error("Journal entry must contain at least two lines.");
     }
@@ -29,19 +40,21 @@ export function recordJournalEntry(db, entry) {
     if (Math.abs(debitTotal - creditTotal) > TOLERANCE) {
         throw new Error(`Journal entry does not balance: debits ${debitTotal.toFixed(2)} vs credits ${creditTotal.toFixed(2)}.`);
     }
-    const entryId = `je:${randomUUID()}`;
-    const insertHeader = db.prepare(`INSERT INTO journal_entries (id, date, description, source_file_id, source_page)
-     VALUES (?, ?, ?, ?, ?)`);
+    return { ...entry, id: entry.id ?? `je:${randomUUID()}` };
+}
+/**
+ * Insert-only counterpart to `recordJournalEntry`. The caller is responsible
+ * for opening a transaction (or for accepting partial writes). Expects an
+ * already-validated entry from `validateJournalEntry`.
+ */
+export function insertJournalEntryRows(db, entry) {
+    db.prepare(`INSERT INTO journal_entries (id, date, description, source_file_id, source_page)
+     VALUES (?, ?, ?, ?, ?)`).run(entry.id, entry.date, entry.description, entry.source_file_id ?? null, entry.source_page ?? null);
     const insertLine = db.prepare(`INSERT INTO journal_lines (id, entry_id, account_id, debit, credit, currency, memo, pii_flag)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
-    const tx = db.transaction(() => {
-        insertHeader.run(entryId, entry.date, entry.description, entry.source_file_id ?? null, entry.source_page ?? null);
-        for (const line of entry.lines) {
-            insertLine.run(`jl:${randomUUID()}`, entryId, line.account_id, line.debit ?? 0, line.credit ?? 0, line.currency || "THB", line.memo ?? null, line.pii_flag ? 1 : 0);
-        }
-    });
-    tx();
-    return entryId;
+    for (const line of entry.lines) {
+        insertLine.run(`jl:${randomUUID()}`, entry.id, line.account_id, line.debit ?? 0, line.credit ?? 0, line.currency || "THB", line.memo ?? null, line.pii_flag ? 1 : 0);
+    }
 }
 export function updateJournalEntry(db, entryId, fields) {
     const sets = [];
@@ -104,13 +117,7 @@ export function findDuplicateEntries(db, opts = {}) {
         ? `WHERE je.id IN (SELECT entry_id FROM journal_lines WHERE account_id = ?)`
         : ``;
     const params = opts.accountId ? [opts.accountId] : [];
-    // Small chart of accounts → a single name lookup beats GROUP_CONCAT join
-    // hacks (account names can contain commas which break a comma-separated
-    // concat, and SQLite's GROUP_CONCAT has no robust escape mechanism).
-    const nameById = new Map();
-    for (const row of db.prepare(`SELECT id, name FROM accounts`).all()) {
-        nameById.set(row.id, row.name);
-    }
+    const nameById = loadAccountNames(db);
     const rows = db.prepare(`SELECT je.id, je.date, je.description,
             COALESCE(SUM(jl.debit), 0) AS amount,
             GROUP_CONCAT(jl.account_id) AS account_ids
@@ -164,13 +171,118 @@ export function findDuplicateEntries(db, opts = {}) {
     }
     return groups;
 }
-function dayDiff(a, b) {
+export function dayDiff(a, b) {
     const aDate = Date.parse(a);
     const bDate = Date.parse(b);
     if (Number.isNaN(aDate) || Number.isNaN(bDate))
         return Number.POSITIVE_INFINITY;
     return Math.abs(Math.round((bDate - aDate) / 86_400_000));
 }
+/**
+ * Load all account id → name pairs into an in-memory map. Cheap on the small
+ * charts of accounts Plasalid deals with, and avoids GROUP_CONCAT join hacks
+ * (account names can contain commas which break a comma-separated concat, and
+ * SQLite's GROUP_CONCAT has no robust escape mechanism).
+ */
+function loadAccountNames(db) {
+    const map = new Map();
+    for (const row of db.prepare(`SELECT id, name FROM accounts`).all()) {
+        map.set(row.id, row.name);
+    }
+    return map;
+}
+/**
+ * Heuristic: surface pairs of entries that look like the same money movement
+ * recorded against different accounts (e.g. a bank-to-card transfer that lands
+ * once on the bank statement and again on the card statement). Filters out
+ * pairs whose account-id sets overlap (those are duplicates, not correlations).
+ */
+export function findCorrelatedEntries(db, opts = {}) {
+    const toleranceDays = Math.max(0, Math.floor(opts.toleranceDays ?? 3));
+    const minAmount = opts.minAmount ?? 0;
+    const dateFilter = [];
+    const params = [];
+    if (opts.from) {
+        dateFilter.push("je.date >= ?");
+        params.push(opts.from);
+    }
+    if (opts.to) {
+        dateFilter.push("je.date <= ?");
+        params.push(opts.to);
+    }
+    const where = dateFilter.length ? `WHERE ${dateFilter.join(" AND ")}` : "";
+    const nameById = loadAccountNames(db);
+    const rows = db.prepare(`SELECT je.id, je.date, je.description,
+            COALESCE(SUM(jl.debit), 0) AS amount,
+            COALESCE(MAX(jl.currency), 'THB') AS currency,
+            GROUP_CONCAT(jl.account_id) AS account_ids
+     FROM journal_entries je
+     LEFT JOIN journal_lines jl ON jl.entry_id = je.id
+     ${where}
+     GROUP BY je.id`).all(...params);
+    const entries = rows
+        .filter(r => r.amount >= minAmount)
+        .map(r => {
+        const ids = (r.account_ids ?? "").split(",").filter(Boolean);
+        return {
+            id: r.id,
+            date: r.date,
+            description: r.description,
+            amount: Math.round(r.amount * 100) / 100,
+            currency: r.currency || "THB",
+            account_ids: ids,
+            account_names: ids.map(id => nameById.get(id) ?? id),
+        };
+    });
+    return correlatePairs(entries, { toleranceDays });
+}
+/**
+ * Pure pair-finder: given an array of candidates already filtered by amount
+ * and equipped with account_ids/names, return the cross-pairs that look like
+ * the same money movement on different accounts (date within toleranceDays,
+ * same amount + currency, non-overlapping account sets).
+ *
+ * Used by the DB-backed `findCorrelatedEntries` and by the scan-time
+ * coordinator that runs over buffered, not-yet-committed entries.
+ */
+export function correlatePairs(entries, opts = {}) {
+    const toleranceDays = Math.max(0, Math.floor(opts.toleranceDays ?? 3));
+    // Bucket by (amount-cents, currency) so we only compare entries that could
+    // plausibly pair. O(n) bucketing + O(k²) per bucket dominates only when many
+    // entries share the same amount.
+    const buckets = new Map();
+    for (const e of entries) {
+        const key = `${Math.round(e.amount * 100)}|${e.currency}`;
+        const arr = buckets.get(key) ?? [];
+        arr.push(e);
+        buckets.set(key, arr);
+    }
+    const pairs = [];
+    for (const bucket of buckets.values()) {
+        if (bucket.length < 2)
+            continue;
+        bucket.sort((x, y) => x.date.localeCompare(y.date));
+        for (let i = 0; i < bucket.length; i++) {
+            for (let j = i + 1; j < bucket.length; j++) {
+                const a = bucket[i], b = bucket[j];
+                const gap = dayDiff(a.date, b.date);
+                if (gap > toleranceDays)
+                    break; // bucket is sorted by date
+                const overlap = a.account_ids.some(id => b.account_ids.includes(id));
+                if (overlap)
+                    continue;
+                pairs.push({
+                    amount: a.amount,
+                    currency: a.currency,
+                    day_gap: gap,
+                    a: { id: a.id, date: a.date, description: a.description, account_ids: a.account_ids, account_names: a.account_names },
+                    b: { id: b.id, date: b.date, description: b.description, account_ids: b.account_ids, account_names: b.account_names },
+                });
+            }
+        }
+    }
+    return pairs;
+}
 export function listJournalLines(db, opts = {}) {
     const conditions = [];
     const params = [];

package/dist/db/queries/merchants.d.ts

@@ -0,0 +1,42 @@
+import type Database from "libsql";
+export interface MerchantUpsertInput {
+    canonical_name: string;
+    alias?: string;
+    default_account_id?: string | null;
+}
+export interface MerchantRow {
+    id: string;
+    canonical_name: string;
+    default_account_id: string | null;
+    created_at: string;
+}
+export declare function normalizeDescriptor(raw: string): string;
+/**
+ * Upsert a merchant by canonical_name. Optionally upsert an alias and update
+ * the cached default_account_id. Idempotent: re-running with the same inputs
+ * does not duplicate rows. Designed to be called inside the same DB transaction
+ * as the posting writes so a transaction never lands without its merchant.
+ */
+export declare function upsertMerchant(db: Database.Database, input: MerchantUpsertInput): MerchantRow;
+export interface MerchantWithDefault {
+    merchant: MerchantRow;
+    default_account_id: string | null;
+}
+/**
+ * Resolve a raw PDF descriptor to a known merchant via the alias table.
+ * Returns null if no alias matches. The scanner uses this in its pre-resolution
+ * pass so the LLM can skip re-categorizing already-seen merchants.
+ */
+export declare function findMerchantByAlias(db: Database.Database, rawDescriptor: string): MerchantWithDefault | null;
+export interface ListMerchantsOptions {
+    withDefaultOnly?: boolean;
+    limit?: number;
+}
+export declare function listMerchants(db: Database.Database, opts?: ListMerchantsOptions): (MerchantRow & {
+    alias_count: number;
+})[];
+export declare function findMerchantById(db: Database.Database, id: string): MerchantRow | null;
+export declare function setMerchantDefaultAccount(db: Database.Database, merchantId: string, accountId: string): {
+    before: string | null;
+    after: string;
+};

package/dist/db/queries/merchants.js

@@ -0,0 +1,120 @@
+import { randomUUID } from "crypto";
+/**
+ * Strip the noise that PDF descriptors carry on top of a merchant identity:
+ * trailing store ids, terminal codes, city tags, transaction-type words. The
+ * normalized form is what `merchant_aliases.normalized_pattern` indexes, so
+ * "STARBUCKS #1234 BKK CHARGE" and "Starbucks #5678 BANGKOK" collapse to the
+ * same alias "starbucks".
+ */
+const NOISE_TOKENS = new Set([
+    "bkk", "bangkok", "thailand", "th", "tha",
+    "charge", "purchase", "payment", "pmt", "ref", "txn", "trx", "tx",
+    "pos", "atm", "online", "web", "mobile", "app",
+    "co", "ltd", "company", "inc", "llc", "plc", "intl",
+]);
+export function normalizeDescriptor(raw) {
+    if (!raw)
+        return "";
+    const lowered = raw.toLowerCase();
+    const stripped = lowered
+        .replace(/[#*][a-z0-9]+/gi, " ")
+        .replace(/\b\d{2,}\b/g, " ")
+        .replace(/[^a-z0-9\s]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!stripped)
+        return "";
+    const tokens = stripped.split(" ").filter(t => t.length > 1 && !NOISE_TOKENS.has(t));
+    if (tokens.length === 0)
+        return stripped;
+    return tokens.join(" ");
+}
+/**
+ * Upsert a merchant by canonical_name. Optionally upsert an alias and update
+ * the cached default_account_id. Idempotent: re-running with the same inputs
+ * does not duplicate rows. Designed to be called inside the same DB transaction
+ * as the posting writes so a transaction never lands without its merchant.
+ */
+export function upsertMerchant(db, input) {
+    const canonical = input.canonical_name.trim();
+    if (!canonical) {
+        throw new Error("merchant canonical_name is required");
+    }
+    const existing = db
+        .prepare(`SELECT id, canonical_name, default_account_id, created_at FROM merchants WHERE canonical_name = ?`)
+        .get(canonical);
+    let merchant;
+    if (existing) {
+        merchant = existing;
+        if (input.default_account_id && input.default_account_id !== existing.default_account_id) {
+            db.prepare(`UPDATE merchants SET default_account_id = ? WHERE id = ?`)
+                .run(input.default_account_id, existing.id);
+            merchant = { ...existing, default_account_id: input.default_account_id };
+        }
+    }
+    else {
+        const id = `m:${randomUUID()}`;
+        db.prepare(`INSERT INTO merchants (id, canonical_name, default_account_id) VALUES (?, ?, ?)`).run(id, canonical, input.default_account_id ?? null);
+        merchant = {
+            id,
+            canonical_name: canonical,
+            default_account_id: input.default_account_id ?? null,
+            created_at: new Date().toISOString(),
+        };
+    }
+    if (input.alias) {
+        const normalized = normalizeDescriptor(input.alias);
+        if (normalized) {
+            const existsAlias = db
+                .prepare(`SELECT id FROM merchant_aliases WHERE normalized_pattern = ?`)
+                .get(normalized);
+            if (!existsAlias) {
+                db.prepare(`INSERT INTO merchant_aliases (id, merchant_id, normalized_pattern) VALUES (?, ?, ?)`).run(`ma:${randomUUID()}`, merchant.id, normalized);
+            }
+        }
+    }
+    return merchant;
+}
+/**
+ * Resolve a raw PDF descriptor to a known merchant via the alias table.
+ * Returns null if no alias matches. The scanner uses this in its pre-resolution
+ * pass so the LLM can skip re-categorizing already-seen merchants.
+ */
+export function findMerchantByAlias(db, rawDescriptor) {
+    const normalized = normalizeDescriptor(rawDescriptor);
+    if (!normalized)
+        return null;
+    const row = db.prepare(`SELECT m.id, m.canonical_name, m.default_account_id, m.created_at
+     FROM merchant_aliases ma
+     JOIN merchants m ON m.id = ma.merchant_id
+     WHERE ma.normalized_pattern = ?`).get(normalized);
+    if (!row)
+        return null;
+    return { merchant: row, default_account_id: row.default_account_id };
+}
+export function listMerchants(db, opts = {}) {
+    const where = opts.withDefaultOnly ? `WHERE m.default_account_id IS NOT NULL` : ``;
+    const limit = Math.min(Math.max(opts.limit ?? 200, 1), 1000);
+    return db.prepare(`SELECT m.id, m.canonical_name, m.default_account_id, m.created_at,
+            (SELECT COUNT(*) FROM merchant_aliases ma WHERE ma.merchant_id = m.id) AS alias_count
+     FROM merchants m
+     ${where}
+     ORDER BY m.canonical_name
+     LIMIT ?`).all(limit);
+}
+export function findMerchantById(db, id) {
+    const row = db
+        .prepare(`SELECT id, canonical_name, default_account_id, created_at FROM merchants WHERE id = ?`)
+        .get(id);
+    return row ?? null;
+}
+export function setMerchantDefaultAccount(db, merchantId, accountId) {
+    const before = db
+        .prepare(`SELECT default_account_id FROM merchants WHERE id = ?`)
+        .get(merchantId);
+    if (!before)
+        throw new Error(`merchant not found: ${merchantId}`);
+    db.prepare(`UPDATE merchants SET default_account_id = ? WHERE id = ?`)
+        .run(accountId, merchantId);
+    return { before: before.default_account_id, after: accountId };
+}

package/dist/db/queries/recurrences.d.ts

@@ -0,0 +1,33 @@
+import type Database from "libsql";
+export type RecurrenceFrequency = "weekly" | "biweekly" | "monthly" | "annually";
+export interface RecurrenceCandidate {
+    account_id: string;
+    account_name: string;
+    amount: number;
+    currency: string;
+    side: "debit" | "credit";
+    transactions: {
+        id: string;
+        date: string;
+        description: string;
+    }[];
+    median_days_between: number;
+    implied_frequency: RecurrenceFrequency | "irregular";
+}
+export interface FindRecurrencesOptions {
+    accountId?: string;
+    /** Minimum sightings to qualify. Default 3. */
+    minOccurrences?: number;
+}
+export declare function findRecurrenceCandidates(db: Database.Database, opts?: FindRecurrencesOptions): RecurrenceCandidate[];
+export interface RecordRecurrenceInput {
+    account_id: string;
+    description: string;
+    frequency: RecurrenceFrequency;
+    amount_typical?: number | null;
+    currency?: string;
+    transaction_ids: string[];
+    notes?: string | null;
+}
+export declare function recordRecurrence(db: Database.Database, input: RecordRecurrenceInput): string;
+export declare function linkTransactionToRecurrence(db: Database.Database, transactionId: string, recurrenceId: string): void;