@dizzlkheinz/ynab-mcpb 0.12.1

package/dist/tools/reconciliation/analyzer.js

@@ -0,0 +1,567 @@
+import { randomUUID } from 'crypto';
+import * as bankParser from '../compareTransactions/parser.js';
+import { findMatches } from './matcher.js';
+import { DEFAULT_MATCHING_CONFIG } from './types.js';
+import { toMoneyValueFromDecimal } from '../../utils/money.js';
+import { generateRecommendations } from './recommendationEngine.js';
+function convertYNABTransaction(apiTxn) {
+    return {
+        id: apiTxn.id,
+        date: apiTxn.date,
+        amount: apiTxn.amount,
+        payee_name: apiTxn.payee_name || null,
+        category_name: apiTxn.category_name || null,
+        cleared: apiTxn.cleared,
+        approved: apiTxn.approved,
+        memo: apiTxn.memo || null,
+    };
+}
+const FALLBACK_CSV_FORMAT = {
+    date_column: 'Date',
+    amount_column: 'Amount',
+    description_column: 'Description',
+    date_format: 'MM/DD/YYYY',
+    has_header: true,
+    delimiter: ',',
+};
+const ENABLE_COMBINATION_MATCHING = true;
+const DAYS_IN_MS = 24 * 60 * 60 * 1000;
+function toDollars(milliunits) {
+    return milliunits / 1000;
+}
+function amountTolerance(config) {
+    const toleranceCents = config.amountToleranceCents ?? DEFAULT_MATCHING_CONFIG.amountToleranceCents ?? 1;
+    return Math.max(0, toleranceCents) / 100;
+}
+function dateTolerance(config) {
+    return config.dateToleranceDays ?? DEFAULT_MATCHING_CONFIG.dateToleranceDays ?? 2;
+}
+function daysBetween(dateA, dateB) {
+    const a = new Date(`${dateA}T00:00:00Z`).getTime();
+    const b = new Date(`${dateB}T00:00:00Z`).getTime();
+    if (Number.isNaN(a) || Number.isNaN(b))
+        return Number.POSITIVE_INFINITY;
+    return Math.abs(a - b) / DAYS_IN_MS;
+}
+function withinDateTolerance(bankDate, ynabTxns, toleranceDays) {
+    return ynabTxns.every((txn) => daysBetween(bankDate, txn.date) <= toleranceDays);
+}
+function hasMatchingSign(bankAmount, ynabTxns) {
+    const bankSign = Math.sign(bankAmount);
+    const sumSign = Math.sign(ynabTxns.reduce((sum, txn) => sum + toDollars(txn.amount), 0));
+    return bankSign === sumSign || Math.abs(bankAmount) === 0;
+}
+function computeCombinationConfidence(diff, tolerance, legCount) {
+    const safeTolerance = tolerance > 0 ? tolerance : 0.01;
+    const ratio = diff / safeTolerance;
+    let base = legCount === 2 ? 75 : 70;
+    if (ratio <= 0.25) {
+        base += 5;
+    }
+    else if (ratio <= 0.5) {
+        base += 3;
+    }
+    else if (ratio >= 0.9) {
+        base -= 5;
+    }
+    return Math.max(65, Math.min(80, Math.round(base)));
+}
+function formatDifference(diff) {
+    return formatCurrency(diff);
+}
+function findCombinationMatches(unmatchedBank, unmatchedYNAB, config) {
+    if (!ENABLE_COMBINATION_MATCHING || unmatchedBank.length === 0 || unmatchedYNAB.length === 0) {
+        return { matches: [], insights: [] };
+    }
+    const tolerance = amountTolerance(config);
+    const toleranceDays = dateTolerance(config);
+    const matches = [];
+    const insights = [];
+    const seenCombinations = new Set();
+    for (const bankTxn of unmatchedBank) {
+        const viableYnab = unmatchedYNAB.filter((txn) => hasMatchingSign(bankTxn.amount, [txn]));
+        if (viableYnab.length < 2)
+            continue;
+        const evaluated = [];
+        const addIfValid = (combo) => {
+            const sum = combo.reduce((acc, txn) => acc + toDollars(txn.amount), 0);
+            const diff = Math.abs(sum - bankTxn.amount);
+            if (diff > tolerance)
+                return;
+            if (!withinDateTolerance(bankTxn.date, combo, toleranceDays))
+                return;
+            if (!hasMatchingSign(bankTxn.amount, combo))
+                return;
+            evaluated.push({ txns: combo, diff, sum });
+        };
+        const n = viableYnab.length;
+        for (let i = 0; i < n - 1; i++) {
+            for (let j = i + 1; j < n; j++) {
+                addIfValid([viableYnab[i], viableYnab[j]]);
+            }
+        }
+        if (n >= 3) {
+            for (let i = 0; i < n - 2; i++) {
+                for (let j = i + 1; j < n - 1; j++) {
+                    for (let k = j + 1; k < n; k++) {
+                        addIfValid([viableYnab[i], viableYnab[j], viableYnab[k]]);
+                    }
+                }
+            }
+        }
+        if (evaluated.length === 0)
+            continue;
+        evaluated.sort((a, b) => a.diff - b.diff);
+        const recordedSizes = new Set();
+        for (const combo of evaluated) {
+            if (recordedSizes.has(combo.txns.length))
+                continue;
+            const comboIds = combo.txns.map((txn) => txn.id).sort();
+            const key = `${bankTxn.id}|${comboIds.join('+')}`;
+            if (seenCombinations.has(key))
+                continue;
+            seenCombinations.add(key);
+            recordedSizes.add(combo.txns.length);
+            const score = computeCombinationConfidence(combo.diff, tolerance, combo.txns.length);
+            const candidateConfidence = Math.max(60, score - 5);
+            const descriptionTotal = formatCurrency(combo.sum);
+            const diffLabel = formatDifference(combo.diff);
+            matches.push({
+                bank_transaction: bankTxn,
+                confidence: 'medium',
+                confidence_score: score,
+                match_reason: 'combination_match',
+                top_confidence: score,
+                candidates: combo.txns.map((txn) => ({
+                    ynab_transaction: txn,
+                    confidence: candidateConfidence,
+                    match_reason: 'combination_component',
+                    explanation: `Part of combination totaling ${descriptionTotal} (difference ${diffLabel}).`,
+                })),
+                action_hint: 'review_combination',
+                recommendation: `Combination of ${combo.txns.length} YNAB transactions totals ${descriptionTotal} versus ` +
+                    `${formatCurrency(bankTxn.amount)} on the bank statement.`,
+            });
+            const insightId = `combination-${bankTxn.id}-${comboIds.join('+')}`;
+            insights.push({
+                id: insightId,
+                type: 'combination_match',
+                severity: 'info',
+                title: `Combination of ${combo.txns.length} transactions matches ${formatCurrency(bankTxn.amount)}`,
+                description: `${combo.txns.length} YNAB transactions totaling ${descriptionTotal} align with ` +
+                    `${formatCurrency(bankTxn.amount)} from ${bankTxn.payee}. Difference ${diffLabel}.`,
+                evidence: {
+                    bank_transaction_id: bankTxn.id,
+                    bank_amount: bankTxn.amount,
+                    ynab_transaction_ids: comboIds,
+                    ynab_amounts_milliunits: combo.txns.map((txn) => txn.amount),
+                    combination_size: combo.txns.length,
+                    difference: combo.diff,
+                },
+            });
+        }
+    }
+    return { matches, insights };
+}
+function isParsedCSVData(result) {
+    return (typeof result === 'object' &&
+        result !== null &&
+        !Array.isArray(result) &&
+        'transactions' in result);
+}
+function normalizeDate(value) {
+    if (value instanceof Date) {
+        return value.toISOString().split('T')[0];
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return trimmed;
+        const parsed = new Date(trimmed);
+        if (!Number.isNaN(parsed.getTime())) {
+            return parsed.toISOString().split('T')[0];
+        }
+        return trimmed;
+    }
+    return new Date().toISOString().split('T')[0];
+}
+function normalizeAmount(record) {
+    const raw = record['amount'];
+    if (typeof raw === 'number') {
+        if (record['date'] instanceof Date || 'raw_amount' in record || 'raw_date' in record) {
+            return Math.round(raw) / 1000;
+        }
+        return raw;
+    }
+    if (typeof raw === 'string') {
+        const cleaned = raw.replace(/[$,\s]/g, '');
+        const parsed = Number.parseFloat(cleaned);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+}
+function normalizePayee(record) {
+    const candidates = [record['payee'], record['description'], record['memo']];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    return 'Unknown Payee';
+}
+function determineRow(record, index) {
+    if (typeof record['original_csv_row'] === 'number') {
+        return record['original_csv_row'];
+    }
+    if (typeof record['row_number'] === 'number') {
+        return record['row_number'];
+    }
+    return index + 1;
+}
+function convertParserRecord(record, index) {
+    const data = typeof record === 'object' && record !== null ? record : {};
+    const dateValue = normalizeDate(data['date']);
+    const amountValue = normalizeAmount(data);
+    const payeeValue = normalizePayee(data);
+    const memoValue = typeof data['memo'] === 'string' && data['memo'].trim() ? data['memo'].trim() : undefined;
+    const originalRow = determineRow(data, index);
+    const transaction = {
+        id: randomUUID(),
+        date: dateValue,
+        amount: amountValue,
+        payee: payeeValue,
+        original_csv_row: originalRow,
+    };
+    if (memoValue !== undefined) {
+        transaction.memo = memoValue;
+    }
+    return transaction;
+}
+function parseBankStatement(csvContent, csvFilePath) {
+    const content = csvFilePath ? bankParser.readCSVFile(csvFilePath) : csvContent;
+    let format = FALLBACK_CSV_FORMAT;
+    let autoDetect;
+    try {
+        autoDetect = bankParser
+            .autoDetectCSVFormat;
+    }
+    catch {
+        autoDetect = undefined;
+    }
+    if (typeof autoDetect === 'function') {
+        try {
+            format = autoDetect(content);
+        }
+        catch {
+            format = FALLBACK_CSV_FORMAT;
+        }
+    }
+    const rawResult = bankParser.parseBankCSV(content, format);
+    const records = isParsedCSVData(rawResult) ? rawResult.transactions : rawResult;
+    return records.map(convertParserRecord);
+}
+function categorizeMatches(matches) {
+    const autoMatches = [];
+    const suggestedMatches = [];
+    const unmatchedBank = [];
+    for (const match of matches) {
+        if (match.confidence === 'high') {
+            autoMatches.push(match);
+        }
+        else if (match.confidence === 'medium') {
+            suggestedMatches.push(match);
+        }
+        else {
+            unmatchedBank.push(match.bank_transaction);
+        }
+    }
+    return { autoMatches, suggestedMatches, unmatchedBank };
+}
+function findUnmatchedYNAB(ynabTransactions, matches) {
+    const matchedIds = new Set();
+    for (const match of matches) {
+        if (match.ynab_transaction) {
+            matchedIds.add(match.ynab_transaction.id);
+        }
+    }
+    return ynabTransactions.filter((txn) => !matchedIds.has(txn.id));
+}
+function calculateBalances(ynabTransactions, statementBalance, currency) {
+    let clearedBalance = 0;
+    let unclearedBalance = 0;
+    for (const txn of ynabTransactions) {
+        const amount = txn.amount / 1000;
+        if (txn.cleared === 'cleared' || txn.cleared === 'reconciled') {
+            clearedBalance += amount;
+        }
+        else {
+            unclearedBalance += amount;
+        }
+    }
+    const totalBalance = clearedBalance + unclearedBalance;
+    const discrepancy = clearedBalance - statementBalance;
+    return {
+        current_cleared: toMoneyValueFromDecimal(clearedBalance, currency),
+        current_uncleared: toMoneyValueFromDecimal(unclearedBalance, currency),
+        current_total: toMoneyValueFromDecimal(totalBalance, currency),
+        target_statement: toMoneyValueFromDecimal(statementBalance, currency),
+        discrepancy: toMoneyValueFromDecimal(discrepancy, currency),
+        on_track: Math.abs(discrepancy) < 0.01,
+    };
+}
+function generateSummary(bankTransactions, ynabTransactions, autoMatches, suggestedMatches, unmatchedBank, unmatchedYNAB, balances) {
+    const dates = bankTransactions.map((t) => t.date).sort();
+    const dateRange = dates.length > 0 ? `${dates[0]} to ${dates[dates.length - 1]}` : 'Unknown';
+    let discrepancyExplanation = '';
+    if (balances.on_track) {
+        discrepancyExplanation = 'Cleared balance matches statement';
+    }
+    else {
+        const actionsNeeded = [];
+        if (autoMatches.length > 0) {
+            actionsNeeded.push(`clear ${autoMatches.length} transactions`);
+        }
+        if (unmatchedBank.length > 0) {
+            actionsNeeded.push(`add ${unmatchedBank.length} missing`);
+        }
+        if (unmatchedYNAB.length > 0) {
+            actionsNeeded.push(`review ${unmatchedYNAB.length} unmatched YNAB`);
+        }
+        discrepancyExplanation =
+            actionsNeeded.length > 0 ? `Need to ${actionsNeeded.join(', ')}` : 'Manual review required';
+    }
+    return {
+        statement_date_range: dateRange,
+        bank_transactions_count: bankTransactions.length,
+        ynab_transactions_count: ynabTransactions.length,
+        auto_matched: autoMatches.length,
+        suggested_matches: suggestedMatches.length,
+        unmatched_bank: unmatchedBank.length,
+        unmatched_ynab: unmatchedYNAB.length,
+        current_cleared_balance: balances.current_cleared,
+        target_statement_balance: balances.target_statement,
+        discrepancy: balances.discrepancy,
+        discrepancy_explanation: discrepancyExplanation,
+    };
+}
+function generateNextSteps(summary) {
+    const steps = [];
+    if (summary.auto_matched > 0) {
+        steps.push(`Review ${summary.auto_matched} auto-matched transactions for approval`);
+    }
+    if (summary.suggested_matches > 0) {
+        steps.push(`Review ${summary.suggested_matches} suggested matches and choose best match`);
+    }
+    if (summary.unmatched_bank > 0) {
+        steps.push(`Decide whether to add ${summary.unmatched_bank} missing bank transactions to YNAB`);
+    }
+    if (summary.unmatched_ynab > 0) {
+        steps.push(`Decide what to do with ${summary.unmatched_ynab} unmatched YNAB transactions (unclear/delete/ignore)`);
+    }
+    if (steps.length === 0) {
+        steps.push('All transactions matched! Review and approve to complete reconciliation');
+    }
+    return steps;
+}
+function formatCurrency(amount) {
+    const formatter = new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency: 'USD',
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    });
+    return formatter.format(amount);
+}
+function repeatAmountInsights(unmatchedBank) {
+    const insights = [];
+    if (unmatchedBank.length === 0) {
+        return insights;
+    }
+    const frequency = new Map();
+    for (const txn of unmatchedBank) {
+        const key = txn.amount.toFixed(2);
+        const entry = frequency.get(key) ?? { amount: txn.amount, txns: [] };
+        entry.txns.push(txn);
+        frequency.set(key, entry);
+    }
+    const repeated = Array.from(frequency.values())
+        .filter((entry) => entry.txns.length >= 2)
+        .sort((a, b) => b.txns.length - a.txns.length);
+    if (repeated.length === 0) {
+        return insights;
+    }
+    const top = repeated[0];
+    insights.push({
+        id: `repeat-${top.amount.toFixed(2)}`,
+        type: 'repeat_amount',
+        severity: top.txns.length >= 4 ? 'critical' : 'warning',
+        title: `${top.txns.length} unmatched transactions at ${formatCurrency(top.amount)}`,
+        description: `The bank statement shows ${top.txns.length} unmatched transaction(s) at ${formatCurrency(top.amount)}. ` +
+            'Repeated amounts are usually the quickest wins — reconcile these first.',
+        evidence: {
+            amount: top.amount,
+            occurrences: top.txns.length,
+            dates: top.txns.map((txn) => txn.date),
+            csv_rows: top.txns.map((txn) => txn.original_csv_row),
+        },
+    });
+    return insights;
+}
+function nearMatchInsights(matches, config) {
+    const insights = [];
+    for (const match of matches) {
+        if (!match.candidates || match.candidates.length === 0)
+            continue;
+        if (match.confidence === 'high')
+            continue;
+        const topCandidate = match.candidates[0];
+        const score = topCandidate.confidence;
+        const highSignal = (match.confidence === 'medium' && score >= config.autoMatchThreshold - 5) ||
+            (match.confidence === 'low' && score >= config.suggestionThreshold) ||
+            (match.confidence === 'none' && score >= config.suggestionThreshold);
+        if (!highSignal)
+            continue;
+        const bankTxn = match.bank_transaction;
+        const ynabTxn = topCandidate.ynab_transaction;
+        insights.push({
+            id: `near-${bankTxn.id}`,
+            type: 'near_match',
+            severity: score >= config.autoMatchThreshold ? 'warning' : 'info',
+            title: `${formatCurrency(bankTxn.amount)} nearly matches ${formatCurrency(ynabTxn.amount / 1000)}`,
+            description: `Bank transaction on ${bankTxn.date} (${formatCurrency(bankTxn.amount)}) nearly matches ` +
+                `${ynabTxn.payee_name ?? 'unknown payee'} on ${ynabTxn.date}. Confidence ${score}% — review and confirm.`,
+            evidence: {
+                bank_transaction: {
+                    id: bankTxn.id,
+                    date: bankTxn.date,
+                    amount: bankTxn.amount,
+                    payee: bankTxn.payee,
+                },
+                candidate: {
+                    id: ynabTxn.id,
+                    date: ynabTxn.date,
+                    amount_milliunits: ynabTxn.amount,
+                    payee_name: ynabTxn.payee_name,
+                    confidence: score,
+                    reasons: topCandidate.match_reason,
+                },
+            },
+        });
+    }
+    return insights.slice(0, 3);
+}
+function anomalyInsights(summary, balances) {
+    const insights = [];
+    const discrepancyAbs = Math.abs(balances.discrepancy.value);
+    if (discrepancyAbs >= 1) {
+        insights.push({
+            id: 'balance-gap',
+            type: 'anomaly',
+            severity: discrepancyAbs >= 100 ? 'critical' : 'warning',
+            title: `Cleared balance off by ${balances.discrepancy.value_display}`,
+            description: `YNAB cleared balance is ${balances.current_cleared.value_display} but the statement expects ` +
+                `${balances.target_statement.value_display}. Focus on closing this gap.`,
+            evidence: {
+                cleared_balance: balances.current_cleared,
+                statement_balance: balances.target_statement,
+                discrepancy: balances.discrepancy,
+            },
+        });
+    }
+    if (summary.unmatched_bank >= 5) {
+        insights.push({
+            id: 'bulk-missing-bank',
+            type: 'anomaly',
+            severity: summary.unmatched_bank >= 10 ? 'critical' : 'warning',
+            title: `${summary.unmatched_bank} bank transactions still unmatched`,
+            description: `There are ${summary.unmatched_bank} bank transactions without a match. ` +
+                'Consider bulk importing or reviewing by date sequence.',
+            evidence: {
+                unmatched_bank: summary.unmatched_bank,
+            },
+        });
+    }
+    return insights;
+}
+function detectInsights(matches, unmatchedBank, summary, balances, config) {
+    const insights = [];
+    const seen = new Set();
+    const addUnique = (insight) => {
+        if (seen.has(insight.id))
+            return;
+        seen.add(insight.id);
+        insights.push(insight);
+    };
+    for (const insight of repeatAmountInsights(unmatchedBank)) {
+        addUnique(insight);
+    }
+    for (const insight of nearMatchInsights(matches, config)) {
+        addUnique(insight);
+    }
+    for (const insight of anomalyInsights(summary, balances)) {
+        addUnique(insight);
+    }
+    return insights.slice(0, 5);
+}
+function mergeInsights(base, additional) {
+    if (additional.length === 0) {
+        return base;
+    }
+    const seen = new Set(base.map((insight) => insight.id));
+    const merged = [...base];
+    for (const insight of additional) {
+        if (seen.has(insight.id))
+            continue;
+        seen.add(insight.id);
+        merged.push(insight);
+    }
+    return merged.slice(0, 5);
+}
+export function analyzeReconciliation(csvContent, csvFilePath, ynabTransactions, statementBalance, config = DEFAULT_MATCHING_CONFIG, currency = 'USD', accountId, budgetId, invertBankAmounts = false) {
+    let bankTransactions = parseBankStatement(csvContent, csvFilePath);
+    if (invertBankAmounts) {
+        bankTransactions = bankTransactions.map((txn) => ({
+            ...txn,
+            amount: -txn.amount,
+        }));
+    }
+    const convertedYNABTxns = ynabTransactions.map(convertYNABTransaction);
+    const matches = findMatches(bankTransactions, convertedYNABTxns, config);
+    const { autoMatches, suggestedMatches, unmatchedBank } = categorizeMatches(matches);
+    const unmatchedYNAB = findUnmatchedYNAB(convertedYNABTxns, matches);
+    let combinationMatches = [];
+    let combinationInsights = [];
+    if (ENABLE_COMBINATION_MATCHING) {
+        const combinationResult = findCombinationMatches(unmatchedBank, unmatchedYNAB, config);
+        combinationMatches = combinationResult.matches;
+        combinationInsights = combinationResult.insights;
+    }
+    const enrichedSuggestedMatches = [...suggestedMatches, ...combinationMatches];
+    const balances = calculateBalances(convertedYNABTxns, statementBalance, currency);
+    const summary = generateSummary(bankTransactions, convertedYNABTxns, autoMatches, enrichedSuggestedMatches, unmatchedBank, unmatchedYNAB, balances);
+    const nextSteps = generateNextSteps(summary);
+    const baseInsights = detectInsights(matches, unmatchedBank, summary, balances, config);
+    const insights = mergeInsights(baseInsights, combinationInsights);
+    const analysis = {
+        success: true,
+        phase: 'analysis',
+        summary,
+        auto_matches: autoMatches,
+        suggested_matches: enrichedSuggestedMatches,
+        unmatched_bank: unmatchedBank,
+        unmatched_ynab: unmatchedYNAB,
+        balance_info: balances,
+        next_steps: nextSteps,
+        insights,
+    };
+    if (accountId && budgetId) {
+        const recommendations = generateRecommendations({
+            account_id: accountId,
+            budget_id: budgetId,
+            analysis,
+            matching_config: config,
+        });
+        analysis.recommendations = recommendations;
+    }
+    return analysis;
+}

package/dist/tools/reconciliation/executor.d.ts

@@ -0,0 +1,94 @@
+import type * as ynab from 'ynab';
+import type { ReconciliationAnalysis } from './types.js';
+import type { ReconcileAccountRequest } from './index.js';
+export interface AccountSnapshot {
+    balance: number;
+    cleared_balance: number;
+    uncleared_balance: number;
+}
+export interface ExecutionOptions {
+    ynabAPI: ynab.API;
+    analysis: ReconciliationAnalysis;
+    params: ReconcileAccountRequest;
+    budgetId: string;
+    accountId: string;
+    initialAccount: AccountSnapshot;
+    currencyCode: string;
+}
+export interface ExecutionActionRecord {
+    type: string;
+    transaction: Record<string, unknown> | null;
+    reason: string;
+    bulk_chunk_index?: number;
+    correlation_key?: string;
+    duplicate?: boolean;
+}
+export interface ExecutionSummary {
+    bank_transactions_count: number;
+    ynab_transactions_count: number;
+    matches_found: number;
+    missing_in_ynab: number;
+    missing_in_bank: number;
+    transactions_created: number;
+    transactions_updated: number;
+    dates_adjusted: number;
+    dry_run: boolean;
+}
+export interface BulkOperationDetails {
+    chunks_processed: number;
+    bulk_successes: number;
+    sequential_fallbacks: number;
+    duplicates_detected: number;
+    failed_transactions: number;
+    bulk_chunk_failures: number;
+    transaction_failures: number;
+    sequential_attempts?: number;
+}
+export interface ExecutionResult {
+    summary: ExecutionSummary;
+    account_balance: {
+        before: AccountSnapshot;
+        after: AccountSnapshot;
+    };
+    actions_taken: ExecutionActionRecord[];
+    recommendations: string[];
+    balance_reconciliation?: Awaited<ReturnType<typeof buildBalanceReconciliation>>;
+    bulk_operation_details?: BulkOperationDetails;
+}
+export declare function executeReconciliation(options: ExecutionOptions): Promise<ExecutionResult>;
+declare function buildBalanceReconciliation(args: {
+    ynabAPI: ynab.API;
+    budgetId: string;
+    accountId: string;
+    statementDate: string;
+    statementBalance: number;
+    analysis: ReconciliationAnalysis;
+}): Promise<{
+    status: string;
+    precision_calculations: {
+        bank_statement_balance_milliunits: number;
+        ynab_calculated_balance_milliunits: number;
+        discrepancy_milliunits: number;
+        discrepancy_dollars: number;
+    };
+    discrepancy_analysis?: ReturnType<typeof buildLikelyCauses>;
+    final_verification: {
+        balance_matches_exactly: boolean;
+        all_transactions_accounted: boolean;
+        audit_trail_complete: boolean;
+        reconciliation_complete: boolean;
+    };
+}>;
+declare function buildLikelyCauses(discrepancyMilli: number): {
+    confidence_level: number;
+    likely_causes: {
+        cause_type: string;
+        description: string;
+        confidence: number;
+        amount_milliunits: number;
+        suggested_resolution: string;
+        evidence: unknown[];
+    }[];
+    risk_assessment: string;
+} | undefined;
+export type { ExecutionResult as LegacyReconciliationResult };