@fayz-ai/financial 0.0.0-stage → 0.1.0

package/dist/chunk-UERJA7QH.js

@@ -0,0 +1,893 @@
+import { summarizeLedger, trailingWindow } from './chunk-T7WIM2V7.js';
+import { matchStatementLines } from './chunk-ZFUQBYBG.js';
+import { emptyStatement, isRealized, buildStatement, ledgerBalance } from './chunk-HJPUHTI2.js';
+import { transferLegs } from './chunk-YUNLQYOZ.js';
+import { cancellationReason, assertReschedule, lineTotal, invoiceTotal, itemsDescription, invoiceStatusOf } from './chunk-7HISDBUG.js';
+import { openAmount, paymentFee } from './chunk-4GXBOEI3.js';
+import { sessionCashFlow, closingDifference } from './chunk-56NQHYL7.js';
+import { runReconcileAsBill, runReconcileLink } from './chunk-FNXIAIUZ.js';
+import { toReconcileLine, transferForStatementLine, statementLegOf, candidateTolerance, candidateScore, statementLinesPage, pageTotals } from './chunk-MCSPCXQK.js';
+import { round2 } from './chunk-XVELDCSL.js';
+
+// src/data/mock.ts
+var nextId = 1;
+function uid() {
+  return String(nextId++);
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function today() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function matchesDateRange(dateStr, range) {
+  if (!range || !dateStr) return true;
+  return dateStr >= range.from && dateStr <= range.to;
+}
+function matchesStatus(status, filter) {
+  if (!filter) return true;
+  if (Array.isArray(filter)) return filter.includes(status);
+  return status === filter;
+}
+function paginate(items, page, pageSize) {
+  const p = page ?? 1;
+  const ps = pageSize ?? 50;
+  const start = (p - 1) * ps;
+  return { data: items.slice(start, start + ps), total: items.length };
+}
+function createStore(options) {
+  const tenantId = "mock-tenant";
+  const seed = options?.seed;
+  const defaultPMTypes = (options?.paymentMethodTypes ?? [
+    { name: "Cash", transactionType: "cash" },
+    { name: "Credit Card", transactionType: "credit_card" },
+    { name: "Debit Card", transactionType: "debit_card" },
+    { name: "PIX", transactionType: "pix" },
+    { name: "Bank Transfer", transactionType: "transfer" }
+  ]).map((t) => ({
+    id: uid(),
+    name: t.name,
+    transactionType: t.transactionType,
+    isActive: true,
+    tenantId,
+    createdAt: now()
+  }));
+  const cashAccount = {
+    id: uid(),
+    name: "Main Cash Register",
+    accountType: "cash_physical",
+    currentBalance: 0,
+    initialBalance: 0,
+    isActive: true,
+    tenantId,
+    createdAt: now(),
+    updatedAt: now()
+  };
+  const bankAccount = {
+    id: uid(),
+    name: "Business Checking",
+    accountType: "bank",
+    bankName: "Main Bank",
+    currentBalance: 0,
+    initialBalance: 0,
+    isActive: true,
+    tenantId,
+    createdAt: now(),
+    updatedAt: now()
+  };
+  return {
+    // Seeded data (when provided) makes the module render as if the user already
+    // has accounts + transactions — a populated Summary/Statements instead of the
+    // empty onboarding state. Seed arrays are copied so the caller's data is not mutated.
+    invoices: seed?.invoices ? [...seed.invoices] : [],
+    invoiceItems: seed?.invoiceItems ? [...seed.invoiceItems] : [],
+    movements: seed?.movements ? [...seed.movements] : [],
+    statementLines: [],
+    statementSources: [],
+    bankAccounts: seed?.bankAccounts ? [...seed.bankAccounts] : [cashAccount, bankAccount],
+    cashSessions: [],
+    paymentMethods: seed?.paymentMethods ? [...seed.paymentMethods] : [],
+    paymentMethodTypes: defaultPMTypes,
+    chartOfAccounts: [],
+    costCenters: [],
+    cardTransactions: [],
+    notas: [],
+    recurringBills: seed?.recurringBills ? [...seed.recurringBills] : []
+  };
+}
+function createMockFinancialProvider(options) {
+  const store = createStore(options);
+  const tenantId = "mock-tenant";
+  function recalcInvoiceStatus(invoice) {
+    const bills = store.movements.filter((m) => m.invoiceId === invoice.id && m.movementKind === "bill");
+    invoice.status = invoiceStatusOf(invoice, bills, today());
+    invoice.updatedAt = now();
+  }
+  function markReconciled(statementLineId, matchedMovementId) {
+    const line = store.statementLines.find((l) => l.id === statementLineId);
+    const internal = matchedMovementId ? store.movements.find((m) => m.id === matchedMovementId) : void 0;
+    if (line) {
+      line.reconciledAt = now();
+      line.matchedMovementId = matchedMovementId;
+      line.matchedInvoiceId = internal?.invoiceId;
+      line.matchedCounterpartyName = internal?.invoiceId ? store.invoices.find((i) => i.id === internal.invoiceId)?.contactName : void 0;
+      line.updatedAt = now();
+    }
+    if (internal) {
+      internal.reconciledAt = now();
+      internal.updatedAt = now();
+    }
+  }
+  function reconcileFacade() {
+    return {
+      createInvoice: (input) => provider.createInvoice(input),
+      getMovements: (query) => provider.getMovements(query),
+      payMovement: (input) => provider.payMovement(input),
+      reconcileMovement: async ({ bankMovementId, matchedMovementId }) => {
+        markReconciled(bankMovementId, matchedMovementId);
+      }
+    };
+  }
+  const provider = {
+    // --- Invoices ---
+    async getInvoices(query) {
+      let results = [...store.invoices];
+      if (query.direction) results = results.filter((i) => i.direction === query.direction);
+      if (query.status) results = results.filter((i) => matchesStatus(i.status, query.status));
+      if (query.contactId) results = results.filter((i) => i.contactId === query.contactId);
+      if (query.unitId) results = results.filter((i) => i.unitId === query.unitId);
+      if (query.accountId) {
+        const invoiceIds = new Set(store.invoiceItems.filter((item) => item.accountId === query.accountId).map((item) => item.invoiceId));
+        results = results.filter((invoice) => invoiceIds.has(invoice.id));
+      }
+      if (query.costCenterId) {
+        const invoiceIds = new Set(store.invoiceItems.filter((item) => item.costCenterId === query.costCenterId).map((item) => item.invoiceId));
+        results = results.filter((invoice) => invoiceIds.has(invoice.id));
+      }
+      if (query.fiscalNumber) {
+        const nf = query.fiscalNumber.toLowerCase();
+        results = results.filter((i) => i.fiscalNumber?.toLowerCase().includes(nf));
+      }
+      if (query.bankAccountId) {
+        const pagas = new Set(
+          store.movements.filter((m) => m.bankAccountId === query.bankAccountId).map((m) => m.invoiceId).filter(Boolean)
+        );
+        results = results.filter((i) => pagas.has(i.id));
+      }
+      if (query.dateRange) results = results.filter((i) => matchesDateRange(i.invoiceDate, query.dateRange));
+      if (query.search) {
+        const s = query.search.toLowerCase();
+        results = results.filter(
+          (i) => i.contactName?.toLowerCase().includes(s) || i.observations?.toLowerCase().includes(s) || i.fiscalNumber?.toLowerCase().includes(s)
+        );
+      }
+      results.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+      return paginate(results, query.page, query.pageSize);
+    },
+    async getInvoiceById(id) {
+      return store.invoices.find((i) => i.id === id) ?? null;
+    },
+    async getInvoiceItems(invoiceId) {
+      return store.invoiceItems.filter((i) => i.invoiceId === invoiceId);
+    },
+    async createInvoice(input) {
+      const invoiceId = uid();
+      const totalAmount = invoiceTotal(input.items);
+      const itemsSummary = itemsDescription(input.items);
+      const invoice = {
+        id: invoiceId,
+        direction: input.direction,
+        invoiceDate: input.invoiceDate,
+        fiscalNumber: input.fiscalNumber,
+        totalAmount,
+        paidAmount: 0,
+        status: "open",
+        totalInstallments: input.installments.length || 1,
+        contactId: input.contactId,
+        contactName: input.contactName,
+        cashSessionId: input.cashSessionId,
+        unitId: input.unitId,
+        observations: input.observations,
+        itemsSummary: itemsSummary || void 0,
+        metadata: input.metadata,
+        tenantId,
+        createdAt: now(),
+        updatedAt: now()
+      };
+      store.invoices.push(invoice);
+      for (const itemInput of input.items) {
+        const itemTotal = lineTotal(itemInput);
+        const item = {
+          id: uid(),
+          invoiceId,
+          itemKind: itemInput.itemKind,
+          referenceId: itemInput.referenceId,
+          description: itemInput.description,
+          quantity: itemInput.quantity,
+          unitPrice: itemInput.unitPrice,
+          totalAmount: itemTotal,
+          discount: itemInput.discount ?? 0,
+          surcharge: itemInput.surcharge ?? 0,
+          accountId: itemInput.accountId,
+          costCenterId: itemInput.costCenterId,
+          metadata: itemInput.metadata,
+          createdAt: now()
+        };
+        store.invoiceItems.push(item);
+      }
+      for (const movInput of input.installments) {
+        const movement = {
+          id: uid(),
+          invoiceId,
+          direction: input.direction,
+          movementKind: movInput.movementKind,
+          amount: movInput.amount,
+          paidAmount: 0,
+          status: "pending",
+          dueDate: movInput.dueDate,
+          installmentNumber: movInput.installmentNumber,
+          paymentMethodId: movInput.paymentMethodId,
+          bankAccountId: movInput.bankAccountId,
+          notes: movInput.notes,
+          metadata: movInput.metadata,
+          tenantId,
+          createdAt: now(),
+          updatedAt: now()
+        };
+        store.movements.push(movement);
+      }
+      return invoice;
+    },
+    async updateInvoice(id, data) {
+      const invoice = store.invoices.find((i) => i.id === id);
+      if (!invoice) throw new Error(`Invoice ${id} not found`);
+      Object.assign(invoice, data, { updatedAt: now() });
+      return invoice;
+    },
+    async updateInstallment(id, data) {
+      const mov = store.movements.find((mv) => mv.id === id);
+      if (!mov) return;
+      if (data.dueDate !== void 0) mov.dueDate = data.dueDate;
+      if (data.amount !== void 0) mov.amount = data.amount;
+      if (data.metadata !== void 0) mov.metadata = data.metadata;
+    },
+    async replaceInvoiceItems(invoiceId, items) {
+      const invoice = store.invoices.find((i) => i.id === invoiceId);
+      if (!invoice) throw new Error(`Invoice ${invoiceId} not found`);
+      store.invoiceItems = store.invoiceItems.filter((it) => it.invoiceId !== invoiceId);
+      for (const item of items) {
+        store.invoiceItems.push({
+          id: uid(),
+          invoiceId,
+          itemKind: item.itemKind,
+          referenceId: item.referenceId,
+          description: item.description,
+          quantity: item.quantity,
+          unitPrice: item.unitPrice,
+          totalAmount: lineTotal(item),
+          discount: item.discount ?? 0,
+          surcharge: item.surcharge ?? 0,
+          accountId: item.accountId,
+          costCenterId: item.costCenterId,
+          metadata: item.metadata,
+          createdAt: now()
+        });
+      }
+      invoice.totalAmount = invoiceTotal(items);
+      invoice.updatedAt = now();
+    },
+    async rescheduleInvoice(invoiceId, installments) {
+      const invoice = store.invoices.find((i) => i.id === invoiceId);
+      if (!invoice) throw new Error(`Invoice ${invoiceId} not found`);
+      const old = store.movements.filter((mv) => mv.invoiceId === invoiceId && mv.movementKind === "bill");
+      assertReschedule(invoice, old, installments);
+      const carried = new Map(old.map((mv) => [mv.installmentNumber ?? 1, mv.metadata]));
+      store.movements = store.movements.filter((mv) => !old.includes(mv));
+      installments.forEach((inst, i) => {
+        store.movements.push({
+          id: uid(),
+          invoiceId,
+          direction: invoice.direction,
+          movementKind: "bill",
+          amount: inst.amount,
+          paidAmount: 0,
+          status: "pending",
+          dueDate: inst.dueDate,
+          installmentNumber: i + 1,
+          metadata: inst.metadata ?? carried.get(i + 1),
+          tenantId,
+          createdAt: now(),
+          updatedAt: now()
+        });
+      });
+    },
+    async cancelInvoice(input) {
+      cancellationReason(input);
+      const invoice = store.invoices.find((i) => i.id === input.invoiceId);
+      if (!invoice) throw new Error(`Invoice ${input.invoiceId} not found`);
+      invoice.status = "cancelled";
+      invoice.updatedAt = now();
+      store.movements.filter((m) => m.invoiceId === input.invoiceId && m.status === "pending").forEach((m) => {
+        m.status = "cancelled";
+        m.updatedAt = now();
+      });
+    },
+    // --- Movements ---
+    async getMovements(query) {
+      let results = [...store.movements];
+      if (query.invoiceId) results = results.filter((m) => m.invoiceId === query.invoiceId);
+      if (query.direction) results = results.filter((m) => m.direction === query.direction);
+      if (query.status) results = results.filter((m) => matchesStatus(m.status, query.status));
+      if (query.bankAccountId) results = results.filter((m) => m.bankAccountId === query.bankAccountId);
+      if (query.cashSessionId) results = results.filter((m) => m.cashSessionId === query.cashSessionId);
+      if (query.dateRange) results = results.filter((m) => matchesDateRange(m.dueDate, query.dateRange));
+      results.sort((a, b) => a.dueDate.localeCompare(b.dueDate));
+      return paginate(results, query.page, query.pageSize);
+    },
+    // O mock não guarda faturas no formato do read model; devolve a conta vazia
+    // em vez de inventar números que a tela apresentaria como saldo do cliente.
+    async getClientAccount(personId) {
+      return { personId, contracted: 0, paid: 0, open: 0, invoices: [] };
+    },
+    async getCardReceivables() {
+      return [];
+    },
+    async reverseMovement(movementId, reason) {
+      const m = store.movements.find((x) => x.id === movementId);
+      if (m) {
+        m.status = "cancelled";
+        m.notes = [m.notes, `Estorno: ${reason}`].filter(Boolean).join(" \xB7 ");
+      }
+    },
+    async payMovement(input) {
+      const bill = store.movements.find((m) => m.id === input.movementId);
+      if (!bill) throw new Error(`Movement ${input.movementId} not found`);
+      const method = input.paymentMethodId ? store.paymentMethods.find((pm) => pm.id === input.paymentMethodId) : void 0;
+      const thisFee = paymentFee(input.amount, method?.discountValue ?? 0, bill.direction);
+      const payment = {
+        id: uid(),
+        invoiceId: bill.invoiceId,
+        direction: bill.direction,
+        movementKind: "payment",
+        amount: input.amount,
+        paidAmount: input.amount,
+        feeAmount: thisFee,
+        status: "paid",
+        settlesMovementId: bill.id,
+        dueDate: bill.dueDate,
+        paymentDate: input.paymentDate,
+        installmentNumber: bill.installmentNumber,
+        paymentMethodId: input.paymentMethodId,
+        paymentMethodTypeId: input.paymentMethodTypeId,
+        bankAccountId: input.bankAccountId,
+        cashSessionId: input.cashSessionId,
+        cardBrand: input.cardBrand,
+        cardInstallments: input.cardInstallments,
+        notes: input.notes,
+        metadata: input.metadata,
+        tenantId,
+        createdAt: now(),
+        updatedAt: now()
+      };
+      store.movements.push(payment);
+      bill.paidAmount = round2(bill.paidAmount + input.amount);
+      bill.status = bill.paidAmount >= bill.amount ? "paid" : "partial";
+      bill.paymentDate = void 0;
+      bill.bankAccountId = void 0;
+      bill.updatedAt = now();
+      if (input.bankAccountId) {
+        const account = store.bankAccounts.find((a) => a.id === input.bankAccountId);
+        if (account) {
+          if (bill.direction === "credit") {
+            account.currentBalance = round2(account.currentBalance + (input.amount - thisFee));
+          } else {
+            account.currentBalance = round2(account.currentBalance - input.amount);
+          }
+          account.updatedAt = now();
+        }
+      }
+      if (bill.invoiceId) {
+        const invoice = store.invoices.find((i) => i.id === bill.invoiceId);
+        if (invoice) {
+          const bills = store.movements.filter((m) => m.invoiceId === invoice.id && m.movementKind === "bill");
+          invoice.paidAmount = bills.reduce((sum, m) => sum + m.paidAmount, 0);
+          recalcInvoiceStatus(invoice);
+        }
+      }
+      return payment;
+    },
+    async cancelMovement(id) {
+      const movement = store.movements.find((m) => m.id === id);
+      if (!movement) throw new Error(`Movement ${id} not found`);
+      movement.status = "cancelled";
+      movement.updatedAt = now();
+    },
+    // --- Transfers (between accounts) ---
+    async createTransfer(input) {
+      const transferId = uid();
+      const [out, into] = transferLegs(input, transferId);
+      const debitMovementId = uid();
+      const creditMovementId = uid();
+      const base = {
+        movementKind: "transfer",
+        amount: input.amount,
+        paidAmount: input.amount,
+        feeAmount: 0,
+        status: "paid",
+        dueDate: input.date,
+        paymentDate: input.date,
+        notes: input.notes,
+        tenantId,
+        createdAt: now(),
+        updatedAt: now()
+      };
+      store.movements.push({ ...base, id: debitMovementId, ...out });
+      store.movements.push({ ...base, id: creditMovementId, ...into });
+      const from = store.bankAccounts.find((a) => a.id === input.fromAccountId);
+      const to = store.bankAccounts.find((a) => a.id === input.toAccountId);
+      if (from) {
+        from.currentBalance = round2(from.currentBalance - input.amount);
+        from.updatedAt = now();
+      }
+      if (to) {
+        to.currentBalance = round2(to.currentBalance + input.amount);
+        to.updatedAt = now();
+      }
+      return { transferId, debitMovementId, creditMovementId };
+    },
+    // --- Bank Accounts ---
+    // Espelha a view da 113: só conta com ORIGEM ativa. Sem isso o mock diria
+    // que o filtro funciona quando ele não filtra nada.
+    async getStatementAccounts() {
+      const comOrigem = new Set(store.statementSources.filter((o) => o.isActive).map((o) => o.accountId));
+      return store.bankAccounts.filter((a) => comOrigem.has(a.id));
+    },
+    async getBankAccounts() {
+      return store.bankAccounts.filter((a) => a.isActive);
+    },
+    async getAccountsByIds(ids) {
+      return store.bankAccounts.filter((a) => ids.includes(a.id));
+    },
+    async searchFinancialAccounts(query, limit = 20) {
+      const term = query.trim().toLocaleLowerCase("pt-BR");
+      if (term.length < 2) return [];
+      return store.bankAccounts.filter((account) => account.isActive && account.name.toLocaleLowerCase("pt-BR").includes(term)).sort((a, b) => a.name.localeCompare(b.name, "pt-BR")).slice(0, limit);
+    },
+    async createBankAccount(data) {
+      const account = {
+        id: uid(),
+        name: data.name,
+        accountType: data.accountType,
+        bankName: data.bankName,
+        accountNumber: data.accountNumber,
+        agencyNumber: data.agencyNumber,
+        currentBalance: data.initialBalance ?? 0,
+        initialBalance: data.initialBalance ?? 0,
+        creditLimit: data.creditLimit,
+        dueDay: data.dueDay,
+        closingDay: data.closingDay,
+        isActive: true,
+        unitId: data.unitId,
+        tenantId,
+        createdAt: now(),
+        updatedAt: now()
+      };
+      store.bankAccounts.push(account);
+      return account;
+    },
+    async updateBankAccount(id, data) {
+      const account = store.bankAccounts.find((a) => a.id === id);
+      if (!account) throw new Error(`Bank account ${id} not found`);
+      Object.assign(account, data, { updatedAt: now() });
+      return account;
+    },
+    // --- Cash Sessions ---
+    async getCashSessions(bankAccountId) {
+      let results = [...store.cashSessions];
+      if (bankAccountId) results = results.filter((s) => s.bankAccountId === bankAccountId);
+      return results.sort((a, b) => b.openedAt.localeCompare(a.openedAt));
+    },
+    async getOpenSession(bankAccountId) {
+      return store.cashSessions.find((s) => s.bankAccountId === bankAccountId && s.status === "open") ?? null;
+    },
+    async openCashSession(input) {
+      const account = store.bankAccounts.find((a) => a.id === input.bankAccountId);
+      const session = {
+        id: uid(),
+        bankAccountId: input.bankAccountId,
+        bankAccountName: account?.name,
+        status: "open",
+        openedAt: now(),
+        openedByUserId: input.openedByUserId,
+        openedByName: input.openedByName,
+        openingBalance: input.openingBalance,
+        unitId: input.unitId,
+        tenantId,
+        createdAt: now()
+      };
+      store.cashSessions.push(session);
+      return session;
+    },
+    async closeCashSession(input) {
+      const session = store.cashSessions.find((s) => s.id === input.sessionId);
+      if (!session) throw new Error(`Cash session ${input.sessionId} not found`);
+      const flow = sessionCashFlow(store.movements.filter((m) => m.cashSessionId === session.id && m.status === "paid"));
+      const { expectedBalance, difference } = closingDifference(session.openingBalance, flow, input.closingBalance);
+      session.status = "closed";
+      session.closedAt = now();
+      session.closedByUserId = input.closedByUserId;
+      session.closedByName = input.closedByName;
+      session.closingBalance = input.closingBalance;
+      session.expectedBalance = expectedBalance;
+      session.difference = difference;
+      session.notes = input.notes;
+      return session;
+    },
+    async getCashSessionSummary(sessionId) {
+      const session = store.cashSessions.find((s) => s.id === sessionId);
+      if (!session) throw new Error(`Cash session ${sessionId} not found`);
+      return { session, ...sessionCashFlow(store.movements.filter((m) => m.cashSessionId === sessionId && m.status === "paid")) };
+    },
+    // --- Payment Methods ---
+    async getPaymentMethods() {
+      return store.paymentMethods.filter((pm) => pm.isActive);
+    },
+    async getPaymentMethodTypes() {
+      return store.paymentMethodTypes.filter((t) => t.isActive);
+    },
+    // --- Chart of Accounts ---
+    async getChartOfAccounts() {
+      return store.chartOfAccounts.filter((n) => n.isActive);
+    },
+    async resolveChartAccountRefs(refs) {
+      const ids = new Set(store.chartOfAccounts.map((account) => account.id));
+      return Object.fromEntries(refs.filter((ref) => ids.has(ref)).map((ref) => [ref, ref]));
+    },
+    async getCostCenters() {
+      return store.costCenters.filter((c) => c.isActive);
+    },
+    // --- Card Transactions ---
+    async getCardTransactions(dateRange) {
+      let results = [...store.cardTransactions];
+      if (dateRange) results = results.filter((t) => matchesDateRange(t.expectedDate, dateRange));
+      return results.sort((a, b) => a.expectedDate.localeCompare(b.expectedDate));
+    },
+    // --- Statements (ERP extract: opening balance + realized cash + per-row net/fee) ---
+    async getStatement(query) {
+      const consolidated = !query.bankAccountId;
+      const scopeAccounts = consolidated ? store.bankAccounts.filter((a) => a.isActive) : store.bankAccounts.filter((a) => a.id === query.bankAccountId);
+      if (!consolidated && scopeAccounts.length === 0) return emptyStatement(query.bankAccountId);
+      const accountIds = new Set(scopeAccounts.map((a) => a.id));
+      const accountNameById = new Map(store.bankAccounts.map((a) => [a.id, a.name]));
+      const initialSum = scopeAccounts.reduce((s, a) => s + a.initialBalance, 0);
+      const invoiceById = (id) => id ? store.invoices.find((i) => i.id === id) : void 0;
+      const inScope = store.movements.filter((m) => isRealized(m) && (consolidated || m.bankAccountId && accountIds.has(m.bankAccountId)));
+      const statement = buildStatement({
+        openingBalance: ledgerBalance(initialSum, inScope.filter((m) => (m.paymentDate ?? "") < query.dateRange.from)),
+        movements: inScope.filter((m) => matchesDateRange(m.paymentDate, query.dateRange)).sort((a, b) => (a.paymentDate ?? "").localeCompare(b.paymentDate ?? "") || a.createdAt.localeCompare(b.createdAt)),
+        consolidated,
+        accountNameOf: (id) => accountNameById.get(id),
+        invoiceOf: (movement) => invoiceById(movement.invoiceId)
+      });
+      for (const e of statement.entries) {
+        const mid = e.movement.matchedMovementId;
+        const mm = mid ? store.movements.find((m) => m.id === mid) : void 0;
+        if (!mm) continue;
+        const inv = invoiceById(mm.invoiceId);
+        e.reconciledWith = {
+          movementId: mm.id,
+          description: mm.notes ?? void 0,
+          invoiceId: mm.invoiceId,
+          fiscalNumber: inv?.fiscalNumber,
+          contactName: inv?.contactName
+        };
+      }
+      return {
+        ...statement,
+        accountId: query.bankAccountId,
+        accountCurrentBalance: ledgerBalance(initialSum, inScope.filter((m) => (m.paymentDate ?? "") <= today()))
+      };
+    },
+    async getDre(query) {
+      const rows = [];
+      for (const account of store.chartOfAccounts.filter((candidate) => candidate.accountType === "revenue" || candidate.accountType === "expense")) {
+        rows.push({
+          accountId: account.id,
+          accountCode: account.code,
+          accountName: account.name,
+          accountType: account.accountType,
+          parentAccountId: account.parentId,
+          statementCode: account.code,
+          statementName: account.name,
+          unclassified: false,
+          amount: 0,
+          discount: 0,
+          lineCount: 0
+        });
+      }
+      for (const invoice of store.invoices.filter((candidate) => candidate.invoiceDate.startsWith(String(query.year)) && (!query.unitId || candidate.unitId === query.unitId))) {
+        for (const item of store.invoiceItems.filter((candidate) => candidate.invoiceId === invoice.id)) {
+          const account = store.chartOfAccounts.find((candidate) => candidate.id === item.accountId);
+          const accountType = invoice.direction === "credit" ? "revenue" : "expense";
+          rows.push({
+            unitId: invoice.unitId,
+            competenceMonth: `${invoice.invoiceDate.slice(0, 7)}-01`,
+            accountId: account?.id,
+            accountCode: account?.code,
+            accountName: account?.name,
+            accountType,
+            parentAccountId: account?.parentId,
+            statementCode: account?.accountType === accountType ? account.code : void 0,
+            statementName: account?.accountType === accountType ? account.name : void 0,
+            unclassified: !account || account.accountType !== accountType,
+            amount: item.totalAmount,
+            discount: item.discount,
+            lineCount: 1
+          });
+        }
+      }
+      return rows;
+    },
+    // --- Summary ---
+    async getSummary(dateRange) {
+      const todayStr = today();
+      return summarizeLedger({
+        accounts: store.bankAccounts,
+        movements: store.movements,
+        today: todayStr,
+        window: dateRange ?? trailingWindow(todayStr)
+      });
+    },
+    // --- Recurring payables and receivables ---
+    async getRecurringBills(direction) {
+      return store.recurringBills.filter((bill) => bill.direction === direction).sort((a, b) => Number(b.isActive) - Number(a.isActive) || a.description.localeCompare(b.description));
+    },
+    async saveRecurringBill(input) {
+      const timestamp = now();
+      const existing = input.id ? store.recurringBills.find((bill2) => bill2.id === input.id) : void 0;
+      const bill = {
+        id: existing?.id ?? uid(),
+        direction: input.direction,
+        description: input.description.trim(),
+        counterpartyPersonId: input.counterpartyPersonId,
+        counterpartyName: existing?.counterpartyName,
+        amount: round2(input.amount),
+        items: input.items.map((item) => ({ ...item })),
+        unitId: input.unitId || null,
+        chartAccountId: input.chartAccountId || null,
+        costCenterId: input.costCenterId || null,
+        frequency: input.frequency,
+        dueDay: input.dueDay,
+        startsOn: input.startsOn,
+        endsOn: input.endsOn || null,
+        isActive: input.isActive ?? existing?.isActive ?? true,
+        notes: input.notes?.trim() || null,
+        createdAt: existing?.createdAt ?? timestamp,
+        updatedAt: timestamp
+      };
+      if (existing) Object.assign(existing, bill);
+      else store.recurringBills.push(bill);
+      return bill;
+    },
+    async updateRecurringBill(id, patch) {
+      const bill = store.recurringBills.find((candidate) => candidate.id === id);
+      if (!bill) throw new Error("Recurring bill not found");
+      if (patch.isActive !== void 0) bill.isActive = patch.isActive;
+      if (patch.endsOn !== void 0) bill.endsOn = patch.endsOn;
+      bill.updatedAt = now();
+    },
+    async runRecurring() {
+      return { created: 0, total: 0 };
+    },
+    // --- Conciliação Bancária ---
+    // Espelha o provider real: a linha do extrato mora em `store.statementLines`,
+    // não em `store.movements`. O mock tinha a linha como movimento e por isso
+    // passava verde sobre o defeito que o banco recusava (migration 112).
+    async importBankTransactions(input) {
+      let imported = 0, duplicates = 0;
+      for (const line of input.lines) {
+        const key = `${line.externalSource}:${line.externalId}`;
+        if (store.statementLines.some((l) => `${l.externalSource}:${l.externalId}` === key)) {
+          duplicates++;
+          continue;
+        }
+        store.statementLines.push({
+          ...line,
+          id: uid(),
+          amount: Math.abs(line.amount),
+          bankAccountId: line.bankAccountId ?? input.bankAccountId,
+          providerDeleted: false,
+          createdAt: now(),
+          updatedAt: now()
+        });
+        imported++;
+      }
+      return { imported, duplicates };
+    },
+    async getStatementLines(query) {
+      let results = store.statementLines.filter((l) => !l.providerDeleted);
+      if (query?.bankAccountId) results = results.filter((l) => l.bankAccountId === query.bankAccountId);
+      if (query?.dateRange) results = results.filter((l) => matchesDateRange(l.date, query.dateRange));
+      if (query?.direction) results = results.filter((l) => l.direction === query.direction);
+      if (query?.status === "reconciled") results = results.filter((l) => !!l.reconciledAt);
+      else if (query?.status === "pending") results = results.filter((l) => !l.reconciledAt);
+      const term = (query?.search ?? "").trim().toLocaleLowerCase("pt-BR");
+      if (term) {
+        const casa = (v) => (v ?? "").toLocaleLowerCase("pt-BR").includes(term);
+        results = results.filter((l) => casa(l.description) || casa(l.counterpartyName) || casa(l.counterpartyDocument) || casa(l.document) || casa(l.code) || casa(l.category) || casa(l.transactionType) || casa(l.externalId));
+      }
+      results = [...results].sort((a, b) => b.date.localeCompare(a.date));
+      const { page, pageSize } = statementLinesPage(query);
+      const rows = results.slice((page - 1) * pageSize, page * pageSize);
+      return { rows, total: results.length, page, pageSize, ...pageTotals(rows) };
+    },
+    async getUnreconciled(query) {
+      let results = store.statementLines.filter((l) => !l.reconciledAt && !l.providerDeleted);
+      if (query?.bankAccountId) results = results.filter((l) => l.bankAccountId === query.bankAccountId);
+      if (query?.dateRange) results = results.filter((l) => matchesDateRange(l.date, query.dateRange));
+      return [...results].sort((a, b) => b.date.localeCompare(a.date));
+    },
+    async suggestReconciliation(statementLineId) {
+      const line = store.statementLines.find((l) => l.id === statementLineId);
+      if (!line) return [];
+      const tol = candidateTolerance(line.amount);
+      return store.movements.filter((m) => !m.externalSource && !m.reconciledAt && m.direction === line.direction && Math.abs(m.amount - line.amount) <= tol).map((m) => ({
+        movement: m,
+        invoice: m.invoiceId ? store.invoices.find((i) => i.id === m.invoiceId) : void 0,
+        score: candidateScore(line, m)
+      })).sort((a, b) => b.score - a.score).slice(0, 25);
+    },
+    async searchReconciliationTargets(statementLineId, query) {
+      const line = store.statementLines.find((l) => l.id === statementLineId);
+      if (!line) return { data: [], hasMore: false };
+      const status = query.status ?? "all";
+      const termo = query.search?.trim().toLocaleLowerCase("pt-BR");
+      const rows = store.movements.filter((m) => !m.externalSource && !m.reconciledAt && m.direction === line.direction).filter((m) => m.status !== "cancelled").filter((m) => {
+        const paga = m.movementKind === "payment" || m.status === "paid";
+        return status === "all" || (status === "paid" ? paga : !paga);
+      }).filter((m) => !query.dueFrom || (m.dueDate ?? "") >= query.dueFrom).filter((m) => !query.dueTo || (m.dueDate ?? "") <= query.dueTo).filter((m) => query.amountMin == null || m.amount >= query.amountMin).filter((m) => query.amountMax == null || m.amount <= query.amountMax).map((m) => ({ movement: m, invoice: m.invoiceId ? store.invoices.find((i) => i.id === m.invoiceId) : void 0 })).filter(({ movement, invoice }) => !termo || `${invoice?.contactName ?? ""} ${invoice?.fiscalNumber ?? ""} ${movement.notes ?? ""}`.toLocaleLowerCase("pt-BR").includes(termo)).sort((a, b) => (a.movement.dueDate ?? "").localeCompare(b.movement.dueDate ?? ""));
+      const pageSize = query.pageSize ?? 50;
+      const start = ((query.page ?? 1) - 1) * pageSize;
+      return {
+        data: rows.slice(start, start + pageSize).map((c) => ({ ...c, score: 0 })),
+        hasMore: rows.length > start + pageSize
+      };
+    },
+    // A mesma cabeça da conciliação de verdade (match-statement), sobre a
+    // memória: valor, nome e data, e um lançamento por linha.
+    async suggestReconciliationBatch(lines) {
+      const contexto = /* @__PURE__ */ new Map();
+      for (const movement of store.movements) {
+        const invoice = movement.invoiceId ? store.invoices.find((i) => i.id === movement.invoiceId) : void 0;
+        if (invoice) contexto.set(movement.id, { contactName: invoice.contactName, invoice });
+      }
+      const candidatos = store.movements.filter((m) => !m.externalSource && !m.reconciledAt);
+      return matchStatementLines(lines, candidatos, contexto);
+    },
+    async reconcileMovement(input) {
+      if (input.mode === "settle" && input.matchedMovementId) {
+        const line = store.statementLines.find((l) => l.id === input.bankMovementId);
+        if (!line) throw new Error("Linha do extrato n\xE3o encontrada");
+        const alvo = store.movements.find((m) => m.id === input.matchedMovementId);
+        if (!alvo) throw new Error("Lan\xE7amento n\xE3o encontrado");
+        await runReconcileLink(
+          reconcileFacade(),
+          toReconcileLine(line),
+          {
+            movementId: alvo.id,
+            mode: "settle",
+            openAmount: openAmount(alvo)
+          },
+          { payment: input.payment, adjustments: input.adjustments, partial: input.partial }
+        );
+        return;
+      }
+      markReconciled(input.bankMovementId, input.matchedMovementId);
+    },
+    async reconcileAsTransfer(input) {
+      const line = store.statementLines.find((l) => l.id === input.bankMovementId);
+      if (!line) throw new Error("Linha do extrato n\xE3o encontrada");
+      const transfer = await provider.createTransfer(transferForStatementLine(toReconcileLine(line), input));
+      await provider.reconcileMovement({ bankMovementId: input.bankMovementId, matchedMovementId: statementLegOf(line, transfer) });
+      return transfer;
+    },
+    // «Lançar como conta». A conta nasce classificada, é quitada contra a conta
+    // do extrato, e a linha passa a ser a prova dela. É o caminho que faz o
+    // extrato BATER: sem ele, uma linha sem contrapartida fica marcada como
+    // conciliada e o dinheiro continua fora do livro.
+    async reconcileAsBill(input) {
+      const line = store.statementLines.find((l) => l.id === input.bankMovementId);
+      if (!line) throw new Error("Linha do extrato n\xE3o encontrada");
+      const { invoiceId } = await runReconcileAsBill(reconcileFacade(), toReconcileLine(line), input);
+      const invoice = store.invoices.find((i) => i.id === invoiceId);
+      if (!invoice) throw new Error("A conta n\xE3o foi criada");
+      return invoice;
+    },
+    async unreconcileMovement(statementLineId) {
+      const line = store.statementLines.find((l) => l.id === statementLineId);
+      if (!line) return;
+      const matchedId = line.matchedMovementId;
+      line.reconciledAt = void 0;
+      line.matchedMovementId = void 0;
+      line.updatedAt = now();
+      if (matchedId) {
+        const internal = store.movements.find((m) => m.id === matchedId);
+        if (internal) {
+          internal.reconciledAt = void 0;
+          internal.updatedAt = now();
+        }
+      }
+    },
+    // --- Notas fiscais (NF-e / NFC-e / NFS-e) ---
+    // Os vales-presente moram na tabela da loja, que não existe em memória.
+    // Responder "não instalado" faz a tela se explicar; deixar o método fora
+    // faria ela explodir com um TypeError que não diz nada a ninguém.
+    async giftCardsEnabled() {
+      return false;
+    },
+    async getNotas(query) {
+      let list = [...store.notas].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+      if (query.status) list = list.filter((n) => matchesStatus(n.status, query.status));
+      if (query.model) list = list.filter((n) => n.model === query.model);
+      if (query.orderId) list = list.filter((n) => n.orderId === query.orderId);
+      if (query.search) {
+        const q = query.search.toLowerCase();
+        list = list.filter((n) => (n.number ?? "").toLowerCase().includes(q) || (n.contactName ?? "").toLowerCase().includes(q));
+      }
+      return paginate(list, query.page, query.pageSize);
+    },
+    async getNotaById(id) {
+      return store.notas.find((n) => n.id === id) ?? null;
+    },
+    async createNota(input) {
+      const nota = {
+        id: uid(),
+        tenantId: "mock-tenant",
+        model: input.model ?? "nfe",
+        status: "draft",
+        number: null,
+        series: input.series ?? null,
+        orderId: input.orderId,
+        contactId: input.contactId,
+        contactName: input.contactName,
+        totalAmount: input.totalAmount,
+        observations: input.observations,
+        createdAt: now(),
+        updatedAt: now()
+      };
+      store.notas.unshift(nota);
+      return nota;
+    },
+    async updateNota(id, patch) {
+      const nota = store.notas.find((n) => n.id === id);
+      if (!nota) throw new Error("Nota fiscal not found");
+      Object.assign(nota, patch, { updatedAt: now() });
+      return nota;
+    },
+    async issueNota(id) {
+      const nota = store.notas.find((n) => n.id === id);
+      if (!nota) throw new Error("Nota fiscal not found");
+      const issuedCount = store.notas.filter((n) => n.status === "issued").length;
+      nota.status = "issued";
+      nota.number = String(issuedCount + 1).padStart(6, "0");
+      nota.series = nota.series ?? "1";
+      nota.issuedAt = now();
+      nota.emissor = "manual";
+      nota.updatedAt = now();
+      return nota;
+    },
+    async cancelNota(id, reason) {
+      const nota = store.notas.find((n) => n.id === id);
+      if (!nota) throw new Error("Nota fiscal not found");
+      nota.status = "cancelled";
+      nota.errorMessage = reason;
+      nota.updatedAt = now();
+      return nota;
+    }
+  };
+  return provider;
+}
+
+export { createMockFinancialProvider };
+//# sourceMappingURL=chunk-UERJA7QH.js.map
+//# sourceMappingURL=chunk-UERJA7QH.js.map