@kirjapro/mcp-server 0.5.10 → 0.6.0

package/dist/tools/transactions.js

@@ -0,0 +1,597 @@
+import { z } from "zod";
+import { getSupabase, getCompanyId } from "../auth.js";
+import { clampPagination, isUuid, paginate, toErrorContent, toResult, sanitizeDbError, roundCents, escapeLike, resolveOpenFiscalYear, withIdempotency, IDEMPOTENCY_KEY_SCHEMA, ISO_DATE_SCHEMA, READ_ONLY_ANNOTATIONS, WRITE_ANNOTATIONS, } from "../utils.js";
+import { PAGINATED_OUTPUT_SHAPE } from "../schemas.js";
+const TRANSACTION_DETAIL_OUTPUT_SHAPE = {
+    id: z.string(),
+    transaction_date: z.string(),
+    description: z.string().nullable(),
+    document_number: z.string().nullable(),
+    journal_entries: z.array(z.record(z.string(), z.unknown())),
+    total_debit: z.number(),
+    total_credit: z.number(),
+    balanced: z.boolean(),
+};
+const LIST_TRANSACTIONS_ROW_SHAPE = {
+    id: z.string().uuid(),
+    transaction_date: z.string(),
+    description: z.string().nullable(),
+    document_number: z.string().nullable(),
+    entries: z.array(z.object({
+        account: z.string(),
+        debit: z.number(),
+        credit: z.number(),
+    })),
+    total_debit: z.number(),
+    total_credit: z.number(),
+};
+export function registerTransactionTools(server) {
+    // ---- READ: List Transactions ----
+    server.registerTool("kirjapro_list_transactions", {
+        description: "List accounting transactions (tositteet) with their journal entries for a fiscal year. Returns transaction date, description, and debit/credit entries with account details.",
+        inputSchema: {
+            fiscalYearId: z
+                .string()
+                .uuid()
+                .optional()
+                .describe("Fiscal year UUID (auto-resolved if omitted)"),
+            limit: z
+                .number()
+                .min(1)
+                .max(200)
+                .default(50)
+                .describe("Max results (default 50)"),
+            offset: z.number().min(0).default(0).describe("Skip first N results"),
+        },
+        outputSchema: {
+            results: z.array(z.object(LIST_TRANSACTIONS_ROW_SHAPE).passthrough()),
+            total_count: z.number(),
+            has_more: z.boolean(),
+            next_offset: z.number(),
+        },
+        annotations: READ_ONLY_ANNOTATIONS,
+    }, async (params) => {
+        const supabase = getSupabase();
+        const companyId = getCompanyId();
+        const { limit, offset } = clampPagination(params.limit, params.offset);
+        let fiscalYearId = params.fiscalYearId;
+        if (!fiscalYearId) {
+            const resolved = await resolveOpenFiscalYear(supabase, companyId);
+            if ("isError" in resolved)
+                return resolved;
+            fiscalYearId = resolved.id;
+        }
+        const { data, count, error } = await supabase
+            .from("transactions")
+            .select(`
+          id, transaction_date, description, document_number, created_at,
+          journal_entries (
+            id, account_id, debit_amount, credit_amount,
+            accounts ( account_number, name )
+          )
+        `, { count: "exact" })
+            .eq("company_id", companyId)
+            .eq("fiscal_year_id", fiscalYearId)
+            .order("transaction_date", { ascending: false })
+            .order("id", { ascending: false })
+            .range(offset, offset + limit - 1);
+        if (error) {
+            return toErrorContent(sanitizeDbError("Failed to list transactions", error));
+        }
+        const transactions = (data || []).map((t) => ({
+            id: t.id,
+            transaction_date: t.transaction_date,
+            description: t.description,
+            document_number: t.document_number,
+            entries: (t.journal_entries || []).map((e) => ({
+                account: `${e.accounts?.account_number} ${e.accounts?.name}`,
+                debit: e.debit_amount || 0,
+                credit: e.credit_amount || 0,
+            })),
+            total_debit: roundCents((t.journal_entries || []).reduce((s, e) => s + (e.debit_amount || 0), 0)),
+            total_credit: roundCents((t.journal_entries || []).reduce((s, e) => s + (e.credit_amount || 0), 0)),
+        }));
+        return toResult(paginate(transactions, count || 0, offset, limit));
+    });
+    // ---- READ: Search Transactions ----
+    server.registerTool("kirjapro_search_transactions", {
+        description: "Search transactions by description, date range, or amount range. Useful for finding specific entries.",
+        inputSchema: {
+            query: z.string().optional().describe("Text search in description"),
+            dateFrom: ISO_DATE_SCHEMA
+                .optional()
+                .describe("Start date (YYYY-MM-DD)"),
+            dateTo: ISO_DATE_SCHEMA
+                .optional()
+                .describe("End date (YYYY-MM-DD)"),
+            minAmount: z
+                .number()
+                .min(0)
+                .optional()
+                .describe("Minimum total debit/credit amount"),
+            maxAmount: z
+                .number()
+                .min(0)
+                .optional()
+                .describe("Maximum total debit/credit amount"),
+            limit: z
+                .number()
+                .min(1)
+                .max(200)
+                .default(50)
+                .describe("Max results (default 50)"),
+            offset: z.number().min(0).default(0).describe("Skip first N results"),
+        },
+        outputSchema: PAGINATED_OUTPUT_SHAPE,
+        annotations: READ_ONLY_ANNOTATIONS,
+    }, async (params) => {
+        const supabase = getSupabase();
+        const companyId = getCompanyId();
+        const { limit, offset } = clampPagination(params.limit, params.offset);
+        let query = supabase
+            .from("transactions")
+            .select(`
+          id, transaction_date, description, document_number, created_at,
+          journal_entries (
+            id, debit_amount, credit_amount,
+            accounts ( account_number, name )
+          )
+        `, { count: "exact" })
+            .eq("company_id", companyId)
+            .order("transaction_date", { ascending: false })
+            .order("id", { ascending: false });
+        if (params.query) {
+            query = query.ilike("description", `%${escapeLike(params.query)}%`);
+        }
+        if (params.dateFrom) {
+            query = query.gte("transaction_date", params.dateFrom);
+        }
+        if (params.dateTo) {
+            query = query.lte("transaction_date", params.dateTo);
+        }
+        const hasAmountFilter = params.minAmount !== undefined || params.maxAmount !== undefined;
+        // When amount filters are active, we must fetch a larger window because
+        // PostgREST can't filter on aggregated journal entry totals server-side.
+        // We cap at 1000 rows to prevent unbounded memory usage.
+        // Future improvement: create an RPC that aggregates and filters in Postgres.
+        const AMOUNT_FILTER_CAP = 1000;
+        if (hasAmountFilter) {
+            query = query.range(0, AMOUNT_FILTER_CAP - 1);
+        }
+        else {
+            query = query.range(offset, offset + limit - 1);
+        }
+        const { data, count, error } = await query;
+        if (error) {
+            return toErrorContent("Failed to search transactions. Check your filters and try again.");
+        }
+        let results = (data || []).map((t) => {
+            const totalDebit = roundCents((t.journal_entries || []).reduce((s, e) => s + (e.debit_amount || 0), 0));
+            const totalCredit = roundCents((t.journal_entries || []).reduce((s, e) => s + (e.credit_amount || 0), 0));
+            return {
+                id: t.id,
+                transaction_date: t.transaction_date,
+                description: t.description,
+                document_number: t.document_number,
+                entries: (t.journal_entries || []).map((e) => ({
+                    account: `${e.accounts?.account_number} ${e.accounts?.name}`,
+                    debit: e.debit_amount || 0,
+                    credit: e.credit_amount || 0,
+                })),
+                total_debit: totalDebit,
+                total_credit: totalCredit,
+            };
+        });
+        if (hasAmountFilter) {
+            // Client-side amount filtering (PostgREST can't filter on aggregated values).
+            if (params.minAmount !== undefined) {
+                results = results.filter((t) => t.total_debit >= params.minAmount);
+            }
+            if (params.maxAmount !== undefined) {
+                results = results.filter((t) => t.total_debit <= params.maxAmount);
+            }
+            const filteredTotal = results.length;
+            const paginatedResults = results.slice(offset, offset + limit);
+            const cappedWarning = (count || 0) >= AMOUNT_FILTER_CAP
+                ? " (results capped at 1000 rows — narrow your date range for complete results)"
+                : "";
+            return toResult({
+                ...paginate(paginatedResults, filteredTotal, offset, limit),
+                amount_filter_note: `Filtered client-side from ${count || 0} transactions${cappedWarning}`,
+            });
+        }
+        return toResult(paginate(results, count || 0, offset, limit));
+    });
+    // ---- WRITE: Create Transaction ----
+    server.registerTool("kirjapro_create_transaction", {
+        description: 'Create a transaction (tosite) with journal entries. Entries must balance (debits = credits). Accepts account numbers resolved to UUIDs server-side. Prefer kirjapro_create_from_template for standard patterns.',
+        inputSchema: {
+            fiscalYearId: z
+                .string()
+                .uuid()
+                .optional()
+                .describe("Fiscal year UUID (auto-resolved if omitted)"),
+            transactionDate: ISO_DATE_SCHEMA
+                .describe("Transaction date (YYYY-MM-DD)"),
+            description: z
+                .string()
+                .min(1)
+                .max(500)
+                .describe("Transaction description"),
+            documentNumber: z.string().optional().describe("Document/receipt number"),
+            entries: z
+                .array(z.object({
+                accountNumber: z
+                    .string()
+                    .describe('Account number (e.g. "4000") or UUID'),
+                debitAmount: z
+                    .number()
+                    .finite()
+                    .min(0)
+                    .max(1_000_000_000)
+                    .default(0)
+                    .describe("Debit amount in EUR"),
+                creditAmount: z
+                    .number()
+                    .finite()
+                    .min(0)
+                    .max(1_000_000_000)
+                    .default(0)
+                    .describe("Credit amount in EUR"),
+            }))
+                .min(2)
+                .describe("Journal entries (min 2, must balance)"),
+            idempotencyKey: IDEMPOTENCY_KEY_SCHEMA,
+        },
+        annotations: WRITE_ANNOTATIONS,
+    }, async (params) => {
+        const supabase = getSupabase();
+        const companyId = getCompanyId();
+        return withIdempotency(supabase, companyId, "kirjapro_create_transaction", params.idempotencyKey, params, async () => {
+            let fiscalYearId = params.fiscalYearId;
+            if (!fiscalYearId) {
+                const resolved = await resolveOpenFiscalYear(supabase, companyId);
+                if ("isError" in resolved)
+                    return resolved;
+                fiscalYearId = resolved.id;
+            }
+            // Verify fiscal year is open
+            const { data: fy, error: fyError } = await supabase
+                .from("fiscal_years")
+                .select("id, is_closed, start_date, end_date")
+                .eq("id", fiscalYearId)
+                .eq("company_id", companyId)
+                .single();
+            if (fyError || !fy) {
+                return toErrorContent(`Fiscal year ${fiscalYearId} not found. Use kirjapro_get_dashboard with a valid fiscal year ID, or read the kirjapro://fiscal-years resource to list available fiscal years.`);
+            }
+            if (fy.is_closed) {
+                return toErrorContent(`Fiscal year is closed (${fy.start_date} to ${fy.end_date}). ` +
+                    `Use an open fiscal year instead.`);
+            }
+            // Validate date is within fiscal year
+            if (params.transactionDate < fy.start_date ||
+                params.transactionDate > fy.end_date) {
+                return toErrorContent(`Transaction date ${params.transactionDate} is outside fiscal year range ` +
+                    `(${fy.start_date} to ${fy.end_date}).`);
+            }
+            // Resolve account numbers or UUIDs to UUIDs
+            const accountIdentifiers = params.entries.map((e) => e.accountNumber);
+            const uuidIdentifiers = [
+                ...new Set(accountIdentifiers.filter((identifier) => isUuid(identifier))),
+            ];
+            const numberIdentifiers = [
+                ...new Set(accountIdentifiers.filter((identifier) => !isUuid(identifier))),
+            ];
+            const [accountsByNumber, accountsById] = await Promise.all([
+                numberIdentifiers.length > 0
+                    ? supabase
+                        .from("accounts")
+                        .select("id, account_number")
+                        .eq("company_id", companyId)
+                        .in("account_number", numberIdentifiers)
+                    : Promise.resolve({ data: [], error: null }),
+                uuidIdentifiers.length > 0
+                    ? supabase
+                        .from("accounts")
+                        .select("id, account_number")
+                        .eq("company_id", companyId)
+                        .in("id", uuidIdentifiers)
+                    : Promise.resolve({ data: [], error: null }),
+            ]);
+            const accError = accountsByNumber.error || accountsById.error;
+            if (accError) {
+                return toErrorContent(sanitizeDbError("Failed to resolve accounts", accError));
+            }
+            const accounts = [
+                ...(accountsByNumber.data || []),
+                ...(accountsById.data || []),
+            ];
+            const accountMap = new Map();
+            for (const account of accounts) {
+                accountMap.set(account.account_number, account.id);
+                accountMap.set(account.id, account.id);
+            }
+            const missingAccounts = accountIdentifiers.filter((identifier) => !accountMap.has(identifier));
+            if (missingAccounts.length > 0) {
+                return toErrorContent(`Accounts not found: ${missingAccounts.join(", ")}. ` +
+                    `Use kirjapro_list_accounts to see available accounts.`);
+            }
+            // Validate balance
+            const totalDebit = roundCents(params.entries.reduce((s, e) => s + e.debitAmount, 0));
+            const totalCredit = roundCents(params.entries.reduce((s, e) => s + e.creditAmount, 0));
+            if (totalDebit !== totalCredit) {
+                return toErrorContent(`Transaction is unbalanced: total debits (${totalDebit.toFixed(2)}) != total credits (${totalCredit.toFixed(2)}). ` +
+                    `Difference: ${Math.abs(totalDebit - totalCredit).toFixed(2)} EUR. ` +
+                    `Add a ${totalDebit > totalCredit ? "credit" : "debit"} entry of ${Math.abs(totalDebit - totalCredit).toFixed(2)} to balance.`);
+            }
+            const journalEntries = params.entries.map((e) => ({
+                account_id: accountMap.get(e.accountNumber),
+                debit_amount: e.debitAmount,
+                credit_amount: e.creditAmount,
+            }));
+            const { data: transactionId, error: txError } = await supabase.rpc("create_transaction_with_entries", {
+                p_company_id: companyId,
+                p_fiscal_year_id: fiscalYearId,
+                p_transaction_date: params.transactionDate,
+                p_description: params.description,
+                p_document_number: params.documentNumber || "",
+                p_entries: journalEntries,
+            });
+            if (txError || !transactionId) {
+                return toErrorContent(txError ? sanitizeDbError("Failed to create transaction", txError) : "Failed to create transaction: no ID returned.");
+            }
+            // Fetch complete transaction with entries
+            const { data: complete } = await supabase
+                .from("transactions")
+                .select(`
+          id, transaction_date, description, document_number, created_at,
+          journal_entries (
+            id, debit_amount, credit_amount,
+            accounts ( account_number, name )
+          )
+        `)
+                .eq("id", transactionId)
+                .single();
+            return toResult({
+                message: "Transaction created successfully",
+                transaction: complete,
+            });
+        });
+    });
+    // ---- WRITE: Create Transactions Batch ----
+    server.registerTool("kirjapro_create_transactions_batch", {
+        description: 'Create multiple transactions in one call (up to 50). Default mode "atomic" rolls back ALL on any failure; "best_effort" collects per-row errors. Prefer kirjapro_create_from_template_batch for standard patterns.',
+        inputSchema: {
+            fiscalYearId: z
+                .string()
+                .uuid()
+                .optional()
+                .describe("Fiscal year UUID (auto-resolved if omitted)"),
+            mode: z
+                .enum(["atomic", "best_effort"])
+                .default("atomic")
+                .describe('Batch mode. "atomic" (default): all-or-nothing, rolls back on any row failure. "best_effort": commits what it can, returns per-row errors.'),
+            transactions: z
+                .array(z.object({
+                transactionDate: ISO_DATE_SCHEMA
+                    .describe("Date (YYYY-MM-DD)"),
+                description: z.string().min(1).max(500),
+                documentNumber: z.string().optional(),
+                entries: z
+                    .array(z.object({
+                    accountNumber: z
+                        .string()
+                        .describe('Account number (e.g. "4000")'),
+                    debitAmount: z
+                        .number()
+                        .finite()
+                        .min(0)
+                        .max(1_000_000_000)
+                        .default(0),
+                    creditAmount: z
+                        .number()
+                        .finite()
+                        .min(0)
+                        .max(1_000_000_000)
+                        .default(0),
+                }))
+                    .min(2),
+            }))
+                .min(1)
+                .max(50)
+                .describe("Array of transactions to create (max 50)"),
+            idempotencyKey: IDEMPOTENCY_KEY_SCHEMA,
+        },
+        annotations: WRITE_ANNOTATIONS,
+    }, async (params) => {
+        const supabase = getSupabase();
+        const companyId = getCompanyId();
+        return withIdempotency(supabase, companyId, "kirjapro_create_transactions_batch", params.idempotencyKey, params, async () => {
+            let fiscalYearId = params.fiscalYearId;
+            if (!fiscalYearId) {
+                const resolved = await resolveOpenFiscalYear(supabase, companyId);
+                if ("isError" in resolved)
+                    return resolved;
+                fiscalYearId = resolved.id;
+            }
+            const { data: fy, error: fyError } = await supabase
+                .from("fiscal_years")
+                .select("id, is_closed, start_date, end_date")
+                .eq("id", fiscalYearId)
+                .eq("company_id", companyId)
+                .single();
+            if (fyError || !fy) {
+                return toErrorContent(`Fiscal year ${fiscalYearId} not found.`);
+            }
+            if (fy.is_closed) {
+                return toErrorContent(`Fiscal year is closed (${fy.start_date} to ${fy.end_date}).`);
+            }
+            // Resolve account numbers -> UUIDs
+            const allAccountNumbers = [
+                ...new Set(params.transactions.flatMap((t) => t.entries.map((e) => e.accountNumber))),
+            ];
+            const uuidIdentifiers = allAccountNumbers.filter((id) => isUuid(id));
+            const numberIdentifiers = allAccountNumbers.filter((id) => !isUuid(id));
+            const [accountsByNumber, accountsById] = await Promise.all([
+                numberIdentifiers.length > 0
+                    ? supabase
+                        .from("accounts")
+                        .select("id, account_number")
+                        .eq("company_id", companyId)
+                        .in("account_number", numberIdentifiers)
+                    : Promise.resolve({ data: [], error: null }),
+                uuidIdentifiers.length > 0
+                    ? supabase
+                        .from("accounts")
+                        .select("id, account_number")
+                        .eq("company_id", companyId)
+                        .in("id", uuidIdentifiers)
+                    : Promise.resolve({ data: [], error: null }),
+            ]);
+            const accError = accountsByNumber.error || accountsById.error;
+            if (accError) {
+                return toErrorContent(sanitizeDbError("Failed to resolve accounts", accError));
+            }
+            const accounts = [
+                ...(accountsByNumber.data || []),
+                ...(accountsById.data || []),
+            ];
+            const accountMap = new Map();
+            for (const account of accounts) {
+                accountMap.set(account.account_number, account.id);
+                accountMap.set(account.id, account.id);
+            }
+            // Pre-validate: resolve entries, check balance and accounts
+            const preValidated = [];
+            const preFailed = [];
+            for (let i = 0; i < params.transactions.length; i++) {
+                const tx = params.transactions[i];
+                if (tx.transactionDate < fy.start_date ||
+                    tx.transactionDate > fy.end_date) {
+                    preFailed.push({
+                        index: i,
+                        error: `Date ${tx.transactionDate} outside fiscal year range.`,
+                    });
+                    continue;
+                }
+                const missing = tx.entries.filter((e) => !accountMap.has(e.accountNumber));
+                if (missing.length > 0) {
+                    preFailed.push({
+                        index: i,
+                        error: `Unknown accounts: ${missing.map((m) => m.accountNumber).join(", ")}`,
+                    });
+                    continue;
+                }
+                const totalDebit = roundCents(tx.entries.reduce((s, e) => s + e.debitAmount, 0));
+                const totalCredit = roundCents(tx.entries.reduce((s, e) => s + e.creditAmount, 0));
+                if (totalDebit !== totalCredit) {
+                    preFailed.push({
+                        index: i,
+                        error: `Unbalanced: debits ${totalDebit} != credits ${totalCredit}`,
+                    });
+                    continue;
+                }
+                preValidated.push({
+                    index: i,
+                    transaction_date: tx.transactionDate,
+                    description: tx.description,
+                    document_number: tx.documentNumber || "",
+                    entries: tx.entries.map((e) => ({
+                        account_id: accountMap.get(e.accountNumber),
+                        debit_amount: e.debitAmount,
+                        credit_amount: e.creditAmount,
+                    })),
+                });
+            }
+            // In atomic mode, abort immediately if any row failed pre-validation
+            if (params.mode === "atomic" && preFailed.length > 0) {
+                return toErrorContent(`Atomic batch aborted: ${preFailed.length} transaction(s) failed validation. ` +
+                    `Fix all errors or use mode "best_effort" for partial commits.\n` +
+                    preFailed.map((f) => `  [${f.index}] ${f.error}`).join("\n"));
+            }
+            if (preValidated.length === 0) {
+                return toResult({
+                    mode: params.mode,
+                    created_count: 0,
+                    failed_count: preFailed.length,
+                    created: [],
+                    failed: preFailed,
+                });
+            }
+            // Build JSONB array for the RPC (strip the index field)
+            const rpcTransactions = preValidated.map((v) => ({
+                transaction_date: v.transaction_date,
+                description: v.description,
+                document_number: v.document_number,
+                entries: v.entries,
+            }));
+            const { data: rpcResult, error: rpcError } = await supabase.rpc("create_transactions_batch_atomic", {
+                p_company_id: companyId,
+                p_fiscal_year_id: fiscalYearId,
+                p_transactions: rpcTransactions,
+                p_mode: params.mode,
+            });
+            if (rpcError) {
+                return toErrorContent(sanitizeDbError("Batch create failed", rpcError));
+            }
+            const result = rpcResult;
+            // Remap RPC indices back to original input indices
+            const created = result.created.map((c) => ({
+                id: c.id,
+                description: c.description,
+                date: c.date,
+                index: preValidated[c.index].index,
+            }));
+            const rpcFailed = result.failed.map((f) => ({
+                index: preValidated[f.index].index,
+                error: sanitizeDbError("Failed to create transaction", {
+                    message: f.error,
+                }),
+            }));
+            return toResult({
+                mode: params.mode,
+                created_count: created.length,
+                failed_count: preFailed.length + rpcFailed.length,
+                created,
+                failed: [...preFailed, ...rpcFailed],
+            });
+        });
+    });
+    // ---- READ: Get Transaction Detail ----
+    server.registerTool("kirjapro_get_transaction", {
+        description: "Get a single transaction with all journal entries and account details. Shows total debits and credits.",
+        inputSchema: {
+            transactionId: z.string().uuid().describe("Transaction UUID"),
+        },
+        outputSchema: TRANSACTION_DETAIL_OUTPUT_SHAPE,
+        annotations: READ_ONLY_ANNOTATIONS,
+    }, async (params) => {
+        const supabase = getSupabase();
+        const companyId = getCompanyId();
+        const { data: transaction, error } = await supabase
+            .from("transactions")
+            .select(`
+          id, transaction_date, description, document_number, created_at,
+          journal_entries (
+            id, account_id, debit_amount, credit_amount, description,
+            accounts ( account_number, name, account_type )
+          )
+        `)
+            .eq("id", params.transactionId)
+            .eq("company_id", companyId)
+            .single();
+        if (error || !transaction) {
+            return toErrorContent(`Transaction ${params.transactionId} not found. Use kirjapro_list_transactions to find transaction IDs.`);
+        }
+        const entries = transaction.journal_entries || [];
+        const totalDebit = roundCents(entries.reduce((s, e) => s + (e.debit_amount || 0), 0));
+        const totalCredit = roundCents(entries.reduce((s, e) => s + (e.credit_amount || 0), 0));
+        return toResult({
+            ...transaction,
+            total_debit: totalDebit,
+            total_credit: totalCredit,
+            balanced: Math.abs(totalDebit - totalCredit) < 0.01,
+        });
+    });
+}

package/dist/tools/validation.d.ts

@@ -0,0 +1,26 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Validate Finnish Y-tunnus (business ID).
+ * Format: NNNNNNN-C, weights [7, 9, 10, 5, 8, 4, 2].
+ */
+declare function validateFinnishBusinessId(input: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Validate Finnish IBAN.
+ * Format: FI + 16 digits, mod-97 check.
+ */
+declare function validateFinnishIBAN(input: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Generate Finnish reference number (viitenumero) with 7-3-1 check digit.
+ */
+declare function generateReferenceNumber(baseNumber: string): {
+    reference: string;
+    error?: string;
+};
+export declare function registerValidationTools(server: McpServer): void;
+export { validateFinnishBusinessId, validateFinnishIBAN, generateReferenceNumber };