thevoidforge 21.0.0

package/dist/wizard/lib/financial/platform-planner.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Platform-Specific Funding Planner — pure logic for Google invoice settlement,
+ * Meta debit protection, and multi-project portfolio rebalancing.
+ *
+ * No API calls, no file I/O — fully testable deterministic functions.
+ * All monetary values use branded integer cents (Cents type).
+ *
+ * PRD Reference: §12.3 (Platform Billing), §15 (Rules Engine)
+ * Agents: Dockson (treasury), Heartbeat daemon
+ */
+import type { Cents } from '../patterns/funding-plan.js';
+interface GoogleInvoice {
+    invoiceId: string;
+    amountCents: Cents;
+    dueDate: string;
+    status: 'pending' | 'overdue' | 'paid';
+}
+interface SettlementPlan {
+    invoiceId: string;
+    amountCents: Cents;
+    dueDate: string;
+    wireReference: string;
+    priority: number;
+    remainingBufferAfterCents: Cents;
+}
+interface ProjectTreasury {
+    projectId: string;
+    projectName: string;
+    bankBalanceCents: Cents;
+    minimumBufferCents: Cents;
+    dailySpendRateCents: Cents;
+    runwayDays: number;
+}
+interface RebalanceRecommendation {
+    fromProjectId: string;
+    toProjectId: string;
+    amountCents: Cents;
+    reason: string;
+}
+interface ExpectedDebit {
+    date: string;
+    amountCents: Cents;
+}
+export declare function planGoogleInvoiceSettlement(invoices: GoogleInvoice[], bankBalanceCents: Cents, bufferTargetCents: Cents): SettlementPlan[];
+export declare function planMetaDebitProtection(expectedDebits: ExpectedDebit[], bankBalanceCents: Cents, bufferTargetCents: Cents): Cents;
+export declare function generatePortfolioRebalancing(projects: ProjectTreasury[]): RebalanceRecommendation[];
+export type { GoogleInvoice, SettlementPlan, ExpectedDebit, ProjectTreasury, RebalanceRecommendation, };

package/dist/wizard/lib/financial/platform-planner.js

@@ -0,0 +1,134 @@
+/**
+ * Platform-Specific Funding Planner — pure logic for Google invoice settlement,
+ * Meta debit protection, and multi-project portfolio rebalancing.
+ *
+ * No API calls, no file I/O — fully testable deterministic functions.
+ * All monetary values use branded integer cents (Cents type).
+ *
+ * PRD Reference: §12.3 (Platform Billing), §15 (Rules Engine)
+ * Agents: Dockson (treasury), Heartbeat daemon
+ */
+// ── Google Invoice Settlement Planner ────────────────
+// Prioritize by due date (nearest first). Reserve buffer after settlement.
+// Generate wire instructions for each invoice.
+export function planGoogleInvoiceSettlement(invoices, bankBalanceCents, bufferTargetCents) {
+    if (invoices.length === 0)
+        return [];
+    // Filter to actionable invoices (pending or overdue, not already paid)
+    const actionable = invoices.filter(inv => inv.status !== 'paid');
+    // Sort: overdue first, then by due date ascending
+    const sorted = [...actionable].sort((a, b) => {
+        if (a.status === 'overdue' && b.status !== 'overdue')
+            return -1;
+        if (a.status !== 'overdue' && b.status === 'overdue')
+            return 1;
+        return new Date(a.dueDate).getTime() - new Date(b.dueDate).getTime();
+    });
+    const plans = [];
+    let availableBalance = bankBalanceCents;
+    for (let i = 0; i < sorted.length; i++) {
+        const invoice = sorted[i];
+        const invoiceAmount = invoice.amountCents;
+        // Reserve buffer: only settle if we can still maintain buffer afterward
+        const balanceAfterSettlement = availableBalance - invoiceAmount;
+        if (balanceAfterSettlement < bufferTargetCents) {
+            // Cannot settle this invoice without breaching buffer
+            // Still include it in the plan but mark the buffer breach
+            if (availableBalance > bufferTargetCents) {
+                // Partial settlement up to buffer is not supported — skip
+                continue;
+            }
+            // Balance already below buffer — cannot settle any more
+            break;
+        }
+        const wireReference = `GOOG-INV-${invoice.invoiceId}-${Date.now().toString(36).toUpperCase()}`;
+        plans.push({
+            invoiceId: invoice.invoiceId,
+            amountCents: invoice.amountCents,
+            dueDate: invoice.dueDate,
+            wireReference,
+            priority: i + 1,
+            remainingBufferAfterCents: (balanceAfterSettlement),
+        });
+        availableBalance = balanceAfterSettlement;
+    }
+    return plans;
+}
+// ── Meta Debit Protection Planner ────────────────────
+// Forecast 7-day debit total and ensure bank balance covers debits + buffer.
+export function planMetaDebitProtection(expectedDebits, bankBalanceCents, bufferTargetCents) {
+    if (expectedDebits.length === 0)
+        return 0;
+    // Sum expected debits over the 7-day window
+    const now = Date.now();
+    const sevenDaysMs = 7 * 24 * 60 * 60 * 1000;
+    const cutoff = now + sevenDaysMs;
+    const totalExpectedDebits = expectedDebits
+        .filter(d => new Date(d.date).getTime() <= cutoff)
+        .reduce((sum, d) => sum + d.amountCents, 0);
+    // Required buffer: total debits + buffer target
+    const requiredBalance = totalExpectedDebits + bufferTargetCents;
+    const deficit = requiredBalance - bankBalanceCents;
+    // If balance already covers debits + buffer, no additional buffer needed
+    if (deficit <= 0)
+        return 0;
+    return deficit;
+}
+// ── Portfolio Rebalancing ────────────────────────────
+// For multi-project operators: suggest moving operating float from
+// overfunded to underfunded projects.
+export function generatePortfolioRebalancing(projects) {
+    if (projects.length < 2)
+        return [];
+    const recommendations = [];
+    // Calculate "excess" for each project: balance above (buffer + 30 days of spend)
+    const TARGET_RUNWAY_DAYS = 30;
+    const analyzed = projects.map(p => {
+        const targetBalance = p.minimumBufferCents +
+            p.dailySpendRateCents * TARGET_RUNWAY_DAYS;
+        const excess = p.bankBalanceCents - targetBalance;
+        return { project: p, targetBalanceCents: targetBalance, excessCents: excess };
+    });
+    // Split into overfunded and underfunded
+    const overfunded = analyzed
+        .filter(a => a.excessCents > 0)
+        .sort((a, b) => b.excessCents - a.excessCents); // most excess first
+    const underfunded = analyzed
+        .filter(a => a.excessCents < 0)
+        .sort((a, b) => a.excessCents - b.excessCents); // most deficit first
+    // Match overfunded to underfunded greedily
+    let overIdx = 0;
+    let underIdx = 0;
+    const remainingExcess = overfunded.map(o => o.excessCents);
+    const remainingDeficit = underfunded.map(u => Math.abs(u.excessCents));
+    while (overIdx < overfunded.length && underIdx < underfunded.length) {
+        const available = remainingExcess[overIdx];
+        const needed = remainingDeficit[underIdx];
+        if (available <= 0) {
+            overIdx++;
+            continue;
+        }
+        if (needed <= 0) {
+            underIdx++;
+            continue;
+        }
+        const transferAmount = Math.min(available, needed);
+        const fromProject = overfunded[overIdx].project;
+        const toProject = underfunded[underIdx].project;
+        recommendations.push({
+            fromProjectId: fromProject.projectId,
+            toProjectId: toProject.projectId,
+            amountCents: Math.round(transferAmount),
+            reason: `${fromProject.projectName} has ${overfunded[overIdx].project.runwayDays}d runway ` +
+                `(${TARGET_RUNWAY_DAYS}d target) — transfer to ${toProject.projectName} ` +
+                `which has ${toProject.runwayDays}d runway`,
+        });
+        remainingExcess[overIdx] -= transferAmount;
+        remainingDeficit[underIdx] -= transferAmount;
+        if (remainingExcess[overIdx] <= 0)
+            overIdx++;
+        if (remainingDeficit[underIdx] <= 0)
+            underIdx++;
+    }
+    return recommendations;
+}

package/dist/wizard/lib/financial/reconciliation-engine.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Three-Way Reconciliation Engine — pure logic for financial matching.
+ *
+ * Reconciles three data sources:
+ * 1. Provider transfers (stablecoin off-ramp records)
+ * 2. Bank transactions (settlement arrivals)
+ * 3. Platform spend (ad platform reported spend)
+ *
+ * No API calls, no file I/O — fully testable deterministic functions.
+ * Extends the existing reconciliation.ts pattern with stablecoin-specific matching.
+ *
+ * PRD Reference: §12.6 (ReconciliationRecord), §16 (Reporting and Reconciliation)
+ * Agents: Dockson (treasury), Heartbeat daemon
+ */
+type Cents = number & {
+    readonly __brand: 'Cents';
+};
+interface ProviderTransfer {
+    id: string;
+    providerTransferId: string;
+    amountCents: Cents;
+    feesCents: Cents;
+    netAmountCents: Cents;
+    status: 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled';
+    initiatedAt: string;
+    completedAt?: string;
+    reference?: string;
+}
+interface BankTransaction {
+    id: string;
+    amountCents: Cents;
+    date: string;
+    reference: string;
+    counterparty: string;
+    type: 'credit' | 'debit';
+}
+interface PlatformSpendEntry {
+    platform: 'google' | 'meta';
+    date: string;
+    spendCents: Cents;
+    invoiceId?: string;
+}
+type VarianceClassification = 'MATCHED' | 'WITHIN_THRESHOLD' | 'MISMATCH';
+interface TransferBankMatch {
+    transferId: string;
+    bankTransactionId: string | null;
+    transferAmountCents: Cents;
+    bankAmountCents: Cents;
+    varianceCents: Cents;
+    classification: VarianceClassification;
+}
+interface BankSpendMatch {
+    bankTransactionId: string;
+    platform: 'google' | 'meta';
+    bankAmountCents: Cents;
+    spendAmountCents: Cents;
+    varianceCents: Cents;
+    classification: VarianceClassification;
+}
+interface ReconciliationReport {
+    date: string;
+    transferMatches: TransferBankMatch[];
+    spendMatches: BankSpendMatch[];
+    unmatchedTransfers: ProviderTransfer[];
+    unmatchedBankTransactions: BankTransaction[];
+    unmatchedSpend: PlatformSpendEntry[];
+    totalTransferredCents: Cents;
+    totalBankReceivedCents: Cents;
+    totalPlatformSpendCents: Cents;
+    overallVarianceCents: Cents;
+    mismatchCount: number;
+}
+export declare function classifyVariance(varianceCents: Cents, referenceCents: Cents, thresholdBps: number): VarianceClassification;
+export declare function matchTransferToBank(transfer: ProviderTransfer, transactions: BankTransaction[], thresholdBps?: number): TransferBankMatch;
+export declare function matchBankToSpend(bankTransaction: BankTransaction, platformSpend: PlatformSpendEntry[], thresholdBps?: number): BankSpendMatch | null;
+export declare function reconcileThreeWay(providerTransfers: ProviderTransfer[], bankTransactions: BankTransaction[], platformSpend: PlatformSpendEntry[], thresholdBps?: number): ReconciliationReport;
+export declare function shouldFreeze(mismatchCount: number, consecutiveCount: number, maxConsecutive: number): boolean;
+export type { Cents, ProviderTransfer, BankTransaction, PlatformSpendEntry, VarianceClassification, TransferBankMatch, BankSpendMatch, ReconciliationReport, };

package/dist/wizard/lib/financial/reconciliation-engine.js

@@ -0,0 +1,193 @@
+/**
+ * Three-Way Reconciliation Engine — pure logic for financial matching.
+ *
+ * Reconciles three data sources:
+ * 1. Provider transfers (stablecoin off-ramp records)
+ * 2. Bank transactions (settlement arrivals)
+ * 3. Platform spend (ad platform reported spend)
+ *
+ * No API calls, no file I/O — fully testable deterministic functions.
+ * Extends the existing reconciliation.ts pattern with stablecoin-specific matching.
+ *
+ * PRD Reference: §12.6 (ReconciliationRecord), §16 (Reporting and Reconciliation)
+ * Agents: Dockson (treasury), Heartbeat daemon
+ */
+// ── Variance Classification ──────────────────────────
+export function classifyVariance(varianceCents, referenceCents, thresholdBps) {
+    if (varianceCents === 0)
+        return 'MATCHED';
+    // Basis points: 1 bps = 0.01% = 1/10,000
+    if (referenceCents <= 0) {
+        // Can't compute percentage on zero reference — any variance is a mismatch
+        return varianceCents === 0 ? 'MATCHED' : 'MISMATCH';
+    }
+    const varianceBps = (varianceCents / referenceCents) * 10_000;
+    return varianceBps <= thresholdBps ? 'WITHIN_THRESHOLD' : 'MISMATCH';
+}
+// ── Transfer-to-Bank Matching ────────────────────────
+export function matchTransferToBank(transfer, transactions, thresholdBps = 50) {
+    // Only match completed transfers
+    if (transfer.status !== 'completed') {
+        return {
+            transferId: transfer.id,
+            bankTransactionId: null,
+            transferAmountCents: transfer.netAmountCents,
+            bankAmountCents: 0,
+            varianceCents: transfer.netAmountCents,
+            classification: 'MISMATCH',
+        };
+    }
+    // Find matching bank transaction by reference or amount proximity
+    let bestMatch = null;
+    let bestVariance = Infinity;
+    for (const txn of transactions) {
+        // Only match credits (incoming funds)
+        if (txn.type !== 'credit')
+            continue;
+        // Check reference match first (strongest signal)
+        const refMatch = transfer.reference &&
+            txn.reference.toLowerCase().includes(transfer.reference.toLowerCase());
+        const variance = Math.abs(transfer.netAmountCents - txn.amountCents);
+        // Reference match: accept with any variance within threshold
+        if (refMatch && variance < bestVariance) {
+            bestMatch = txn;
+            bestVariance = variance;
+        }
+        // Amount proximity match: must be within threshold
+        if (!refMatch && variance < bestVariance) {
+            const varianceBps = transfer.netAmountCents > 0
+                ? (variance / transfer.netAmountCents) * 10_000
+                : Infinity;
+            if (varianceBps <= thresholdBps * 2) {
+                // Use 2x threshold for amount-only matching (less confident)
+                bestMatch = txn;
+                bestVariance = variance;
+            }
+        }
+    }
+    if (!bestMatch) {
+        return {
+            transferId: transfer.id,
+            bankTransactionId: null,
+            transferAmountCents: transfer.netAmountCents,
+            bankAmountCents: 0,
+            varianceCents: transfer.netAmountCents,
+            classification: 'MISMATCH',
+        };
+    }
+    const varianceCents = Math.abs(transfer.netAmountCents - bestMatch.amountCents);
+    return {
+        transferId: transfer.id,
+        bankTransactionId: bestMatch.id,
+        transferAmountCents: transfer.netAmountCents,
+        bankAmountCents: bestMatch.amountCents,
+        varianceCents,
+        classification: classifyVariance(varianceCents, transfer.netAmountCents, thresholdBps),
+    };
+}
+// ── Bank-to-Platform-Spend Matching ──────────────────
+export function matchBankToSpend(bankTransaction, platformSpend, thresholdBps = 50) {
+    // Only match debits (outgoing payments to platforms)
+    if (bankTransaction.type !== 'debit')
+        return null;
+    // Find closest platform spend entry by amount
+    let bestMatch = null;
+    let bestVariance = Infinity;
+    for (const spend of platformSpend) {
+        const variance = Math.abs(bankTransaction.amountCents - spend.spendCents);
+        if (variance < bestVariance) {
+            bestMatch = spend;
+            bestVariance = variance;
+        }
+    }
+    if (!bestMatch)
+        return null;
+    const varianceCents = bestVariance;
+    const classification = classifyVariance(varianceCents, bankTransaction.amountCents, thresholdBps);
+    // Only return a match if it's within threshold or exact
+    if (classification === 'MISMATCH')
+        return null;
+    return {
+        bankTransactionId: bankTransaction.id,
+        platform: bestMatch.platform,
+        bankAmountCents: bankTransaction.amountCents,
+        spendAmountCents: bestMatch.spendCents,
+        varianceCents,
+        classification,
+    };
+}
+// ── Three-Way Reconciliation ─────────────────────────
+// The main reconciliation function that ties all three sources together.
+export function reconcileThreeWay(providerTransfers, bankTransactions, platformSpend, thresholdBps = 50) {
+    const transferMatches = [];
+    const spendMatches = [];
+    const matchedBankIds = new Set();
+    const matchedSpendIndices = new Set();
+    // Phase 1: Match provider transfers to bank transactions
+    const completedTransfers = providerTransfers.filter(t => t.status === 'completed');
+    const remainingBankTxns = [...bankTransactions];
+    for (const transfer of completedTransfers) {
+        const match = matchTransferToBank(transfer, remainingBankTxns, thresholdBps);
+        transferMatches.push(match);
+        if (match.bankTransactionId) {
+            matchedBankIds.add(match.bankTransactionId);
+            // Remove matched bank transaction from remaining pool
+            const idx = remainingBankTxns.findIndex(t => t.id === match.bankTransactionId);
+            if (idx >= 0)
+                remainingBankTxns.splice(idx, 1);
+        }
+    }
+    // Phase 2: Match remaining bank debits to platform spend
+    const remainingSpend = [...platformSpend];
+    for (const bankTxn of remainingBankTxns) {
+        if (matchedBankIds.has(bankTxn.id))
+            continue;
+        const match = matchBankToSpend(bankTxn, remainingSpend, thresholdBps);
+        if (match) {
+            spendMatches.push(match);
+            matchedBankIds.add(bankTxn.id);
+            // Remove matched spend from remaining pool
+            const spendIdx = remainingSpend.findIndex(s => s.spendCents === match.spendAmountCents && s.platform === match.platform);
+            if (spendIdx >= 0) {
+                matchedSpendIndices.add(platformSpend.indexOf(remainingSpend[spendIdx]));
+                remainingSpend.splice(spendIdx, 1);
+            }
+        }
+    }
+    // Phase 3: Identify unmatched items
+    const unmatchedTransfers = providerTransfers.filter(t => {
+        if (t.status !== 'completed')
+            return true;
+        const match = transferMatches.find(m => m.transferId === t.id);
+        return !match || match.bankTransactionId === null;
+    });
+    const unmatchedBankTransactions = bankTransactions.filter(t => !matchedBankIds.has(t.id));
+    const unmatchedSpend = platformSpend.filter((_, i) => !matchedSpendIndices.has(i));
+    // Phase 4: Calculate totals
+    const totalTransferredCents = completedTransfers.reduce((sum, t) => (sum + t.netAmountCents), 0);
+    const totalBankReceivedCents = bankTransactions
+        .filter(t => t.type === 'credit')
+        .reduce((sum, t) => (sum + t.amountCents), 0);
+    const totalPlatformSpendCents = platformSpend.reduce((sum, s) => (sum + s.spendCents), 0);
+    const overallVarianceCents = Math.abs(totalTransferredCents - totalBankReceivedCents);
+    const mismatchCount = transferMatches.filter(m => m.classification === 'MISMATCH').length;
+    const today = new Date().toISOString().split('T')[0];
+    return {
+        date: today,
+        transferMatches,
+        spendMatches,
+        unmatchedTransfers,
+        unmatchedBankTransactions,
+        unmatchedSpend,
+        totalTransferredCents,
+        totalBankReceivedCents,
+        totalPlatformSpendCents,
+        overallVarianceCents,
+        mismatchCount,
+    };
+}
+// ── Freeze Decision ──────────────────────────────────
+// Determines if operations should be frozen based on consecutive mismatches.
+export function shouldFreeze(mismatchCount, consecutiveCount, maxConsecutive) {
+    return consecutiveCount >= maxConsecutive || mismatchCount > maxConsecutive;
+}

package/dist/wizard/lib/financial/registry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Financial provider and billing adapter registries.
+ *
+ * Tracks which stablecoin providers, bank adapters, and ad billing adapters
+ * are implemented. New providers are added here first (implemented: false)
+ * then built out.
+ */
+interface ProviderEntry {
+    readonly name: string;
+    readonly implemented: boolean;
+}
+export declare const STABLECOIN_PROVIDERS: Record<string, ProviderEntry>;
+export declare const BANK_ADAPTERS: Record<string, ProviderEntry>;
+export declare const BILLING_ADAPTERS: Record<string, ProviderEntry>;
+export type StablecoinProviderId = keyof typeof STABLECOIN_PROVIDERS;
+export type BankAdapterId = keyof typeof BANK_ADAPTERS;
+export type BillingAdapterId = keyof typeof BILLING_ADAPTERS;
+export { CircleSetup, CircleAdapter } from './stablecoin/circle.js';
+export { MercuryBankAdapter } from './stablecoin/mercury.js';
+export { GoogleBillingSetup, GoogleBillingAdapter } from './billing/google-billing.js';
+export { MetaBillingSetup, MetaBillingAdapter } from './billing/meta-billing.js';
+export { TikTokBillingSetup, TikTokBillingAdapter } from './billing/tiktok-billing.js';

package/dist/wizard/lib/financial/registry.js

@@ -0,0 +1,26 @@
+/**
+ * Financial provider and billing adapter registries.
+ *
+ * Tracks which stablecoin providers, bank adapters, and ad billing adapters
+ * are implemented. New providers are added here first (implemented: false)
+ * then built out.
+ */
+export const STABLECOIN_PROVIDERS = {
+    sandbox: { name: 'Sandbox (Demo)', implemented: true },
+    circle: { name: 'Circle', implemented: true },
+    bridge: { name: 'Bridge', implemented: false },
+};
+export const BANK_ADAPTERS = {
+    mercury: { name: 'Mercury', implemented: true },
+};
+export const BILLING_ADAPTERS = {
+    google: { name: 'Google Ads Billing', implemented: true },
+    meta: { name: 'Meta Ads Billing', implemented: true },
+    tiktok: { name: 'TikTok Ads Billing', implemented: true },
+};
+// ── Re-exports for convenience ───────────────────────
+export { CircleSetup, CircleAdapter } from './stablecoin/circle.js';
+export { MercuryBankAdapter } from './stablecoin/mercury.js';
+export { GoogleBillingSetup, GoogleBillingAdapter } from './billing/google-billing.js';
+export { MetaBillingSetup, MetaBillingAdapter } from './billing/meta-billing.js';
+export { TikTokBillingSetup, TikTokBillingAdapter } from './billing/tiktok-billing.js';

package/dist/wizard/lib/financial/reporting.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Financial Reporting + Export — daily reports, monthly ledgers, and funding simulation.
+ *
+ * Pure logic — no API calls, no file I/O, fully testable.
+ * All monetary values use branded integer cents (Cents type).
+ * Output formats: markdown (daily), JSON (monthly), simulation object.
+ *
+ * PRD Reference: §16 (Reporting and Reconciliation)
+ * Agents: Dockson (treasury), Heartbeat daemon
+ */
+import type { Cents } from '../patterns/funding-plan.js';
+import type { ReconciliationReport } from './reconciliation-engine.js';
+import type { CampaignSpendProjection, FundingPlanConfig } from './treasury-planner.js';
+interface DailyReportInput {
+    date: string;
+    revenueCents: Cents;
+    spendCents: Cents;
+    stablecoinBalanceCents: Cents;
+    pendingTransfersCents: Cents;
+    bankBalanceCents: Cents;
+    settledTodayCents: Cents;
+    reconciliation: ReconciliationReport | null;
+    activeCircuitBreakers: string[];
+    runwayDays: number;
+    fundingFrozen: boolean;
+    freezeReason: string | null;
+}
+export declare function generateDailyReport(input: DailyReportInput): string;
+interface TransferLedgerEntry {
+    id: string;
+    date: string;
+    direction: string;
+    amountCents: Cents;
+    feesCents: Cents;
+    netAmountCents: Cents;
+    status: string;
+    reference: string;
+}
+interface ReconciliationLedgerEntry {
+    id: string;
+    date: string;
+    platform: string;
+    spendCents: Cents;
+    bankSettledCents: Cents;
+    varianceCents: Cents;
+    result: string;
+}
+interface MonthlyLedger {
+    month: string;
+    generatedAt: string;
+    transfers: TransferLedgerEntry[];
+    reconciliations: ReconciliationLedgerEntry[];
+    summary: {
+        totalTransfersCents: Cents;
+        totalFeesCents: Cents;
+        totalNetTransferredCents: Cents;
+        totalSpendCents: Cents;
+        totalBankSettledCents: Cents;
+        totalVarianceCents: Cents;
+        transferCount: number;
+        reconciliationCount: number;
+        mismatchCount: number;
+    };
+}
+export declare function generateMonthlyLedger(month: string, transfers: TransferLedgerEntry[], reconciliations: ReconciliationLedgerEntry[]): MonthlyLedger;
+interface SimulationDay {
+    day: number;
+    date: string;
+    bankBalanceCents: Cents;
+    spendCents: Cents;
+    offrampTriggered: boolean;
+    offrampAmountCents: Cents;
+    policyBlocked: boolean;
+    freezeRisk: boolean;
+}
+interface SimulationResult {
+    config: {
+        startDate: string;
+        days: number;
+        startingBankBalanceCents: Cents;
+        bufferTargetCents: Cents;
+        maxDailyOfframpCents: Cents;
+    };
+    days: SimulationDay[];
+    summary: {
+        firstOfframpDay: number | null;
+        totalOfframpsCents: Cents;
+        offrampCount: number;
+        minimumBalanceCents: Cents;
+        minimumBalanceDay: number;
+        freezeRiskDays: number[];
+        finalBalanceCents: Cents;
+    };
+}
+export declare function simulateFunding(startDate: string, startingBankBalanceCents: Cents, config: FundingPlanConfig, campaigns: CampaignSpendProjection[], days: number, stablecoinAvailableCents: Cents, minimumBufferCents: Cents): SimulationResult;
+export type { DailyReportInput, TransferLedgerEntry, ReconciliationLedgerEntry, MonthlyLedger, SimulationDay, SimulationResult, };