@dizzlkheinz/ynab-mcpb 0.18.4 → 0.19.0

package/dist/tools/transactionReadTools.js

@@ -0,0 +1,202 @@
+import { CACHE_TTLS, CacheManager, cacheManager, } from "../server/cacheManager.js";
+import { responseFormatter } from "../server/responseFormatter.js";
+import { withToolErrorHandling } from "../types/index.js";
+import { milliunitsToAmount } from "../utils/amountUtils.js";
+import { createAdapters, createBudgetResolver } from "./adapters.js";
+import { resolveDeltaFetcherArgs } from "./deltaSupport.js";
+import { ExportTransactionsSchema, handleExportTransactions, } from "./exportTransactions.js";
+import { ToolAnnotationPresets } from "./toolCategories.js";
+import { GetTransactionSchema, ListTransactionsSchema, } from "./transactionSchemas.js";
+import { ensureTransaction, handleTransactionError, } from "./transactionUtils.js";
+export async function handleListTransactions(ynabAPI, deltaFetcherOrParams, maybeParams, errorHandler) {
+    const { deltaFetcher, params } = resolveDeltaFetcherArgs(ynabAPI, deltaFetcherOrParams, maybeParams);
+    return await withToolErrorHandling(async () => {
+        let transactions;
+        let cacheHit = false;
+        let usedDelta = false;
+        if (params.account_id) {
+            const accountsResult = await deltaFetcher.fetchAccounts(params.budget_id);
+            const accountExists = accountsResult.data.some((account) => account.id === params.account_id);
+            if (!accountExists) {
+                throw new Error(`Account ${params.account_id} not found in budget ${params.budget_id}`);
+            }
+            const result = await deltaFetcher.fetchTransactionsByAccount(params.budget_id, params.account_id, params.since_date);
+            transactions = result.data;
+            cacheHit = result.wasCached;
+            usedDelta = result.usedDelta;
+        }
+        else if (params.category_id) {
+            const response = await ynabAPI.transactions.getTransactionsByCategory(params.budget_id, params.category_id, params.since_date);
+            transactions = response.data.transactions;
+        }
+        else {
+            const result = await deltaFetcher.fetchTransactions(params.budget_id, params.since_date, params.type);
+            transactions = result.data;
+            cacheHit = result.wasCached;
+            usedDelta = result.usedDelta;
+        }
+        const estimatedSize = JSON.stringify(transactions).length;
+        const sizeLimit = 90000;
+        if (estimatedSize > sizeLimit) {
+            const preview = transactions.slice(0, 50);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseFormatter.format({
+                            message: `Found ${transactions.length} transactions (${Math.round(estimatedSize / 1024)}KB). Too large to display all.`,
+                            suggestion: "Use 'export_transactions' tool to save all transactions to a file.",
+                            showing: `First ${preview.length} transactions:`,
+                            total_count: transactions.length,
+                            estimated_size_kb: Math.round(estimatedSize / 1024),
+                            cached: cacheHit,
+                            cache_info: cacheHit
+                                ? `Data retrieved from cache for improved performance${usedDelta ? " (delta merge applied)" : ""}`
+                                : "Fresh data retrieved from YNAB API",
+                            preview_transactions: preview.map((transaction) => ({
+                                id: transaction.id,
+                                date: transaction.date,
+                                amount: milliunitsToAmount(transaction.amount),
+                                memo: transaction.memo,
+                                payee_name: transaction.payee_name,
+                                category_name: transaction.category_name,
+                            })),
+                        }),
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: responseFormatter.format({
+                        total_count: transactions.length,
+                        cached: cacheHit,
+                        cache_info: cacheHit
+                            ? `Data retrieved from cache for improved performance${usedDelta ? " (delta merge applied)" : ""}`
+                            : "Fresh data retrieved from YNAB API",
+                        transactions: transactions.map((transaction) => ({
+                            id: transaction.id,
+                            date: transaction.date,
+                            amount: milliunitsToAmount(transaction.amount),
+                            memo: transaction.memo,
+                            cleared: transaction.cleared,
+                            approved: transaction.approved,
+                            flag_color: transaction.flag_color,
+                            account_id: transaction.account_id,
+                            payee_id: transaction.payee_id,
+                            category_id: transaction.category_id,
+                            transfer_account_id: transaction.transfer_account_id,
+                            transfer_transaction_id: transaction.transfer_transaction_id,
+                            matched_transaction_id: transaction.matched_transaction_id,
+                            import_id: transaction.import_id,
+                            deleted: transaction.deleted,
+                        })),
+                    }),
+                },
+            ],
+        };
+    }, "ynab:list_transactions", "listing transactions", errorHandler);
+}
+export async function handleGetTransaction(ynabAPI, params, _errorHandler) {
+    try {
+        const useCache = process.env["NODE_ENV"] !== "test";
+        let transaction;
+        let cacheHit = false;
+        if (useCache) {
+            const cacheKey = CacheManager.generateKey("transaction", "get", params.budget_id, params.transaction_id);
+            cacheHit = cacheManager.has(cacheKey);
+            transaction = await cacheManager.wrap(cacheKey, {
+                ttl: CACHE_TTLS.TRANSACTIONS,
+                loader: async () => {
+                    const response = await ynabAPI.transactions.getTransactionById(params.budget_id, params.transaction_id);
+                    return ensureTransaction(response.data.transaction, "Transaction not found");
+                },
+            });
+        }
+        else {
+            const response = await ynabAPI.transactions.getTransactionById(params.budget_id, params.transaction_id);
+            transaction = ensureTransaction(response.data.transaction, "Transaction not found");
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: responseFormatter.format({
+                        transaction: {
+                            id: transaction.id,
+                            date: transaction.date,
+                            amount: milliunitsToAmount(transaction.amount),
+                            memo: transaction.memo,
+                            cleared: transaction.cleared,
+                            approved: transaction.approved,
+                            flag_color: transaction.flag_color,
+                            account_id: transaction.account_id,
+                            payee_id: transaction.payee_id,
+                            category_id: transaction.category_id,
+                            transfer_account_id: transaction.transfer_account_id,
+                            transfer_transaction_id: transaction.transfer_transaction_id,
+                            matched_transaction_id: transaction.matched_transaction_id,
+                            import_id: transaction.import_id,
+                            deleted: transaction.deleted,
+                            account_name: transaction.account_name,
+                            payee_name: transaction.payee_name,
+                            category_name: transaction.category_name,
+                        },
+                        cached: cacheHit,
+                        cache_info: cacheHit
+                            ? "Data retrieved from cache for improved performance"
+                            : "Fresh data retrieved from YNAB API",
+                    }),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleTransactionError(error, "Failed to get transaction");
+    }
+}
+export function registerTransactionReadTools(registry, context) {
+    const { adapt, adaptWithDelta } = createAdapters(context);
+    const budgetResolver = createBudgetResolver(context);
+    registry.register({
+        name: "list_transactions",
+        description: "List transactions for a budget with optional filtering",
+        inputSchema: ListTransactionsSchema,
+        handler: adaptWithDelta(handleListTransactions),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: "YNAB: List Transactions",
+            },
+        },
+    });
+    registry.register({
+        name: "export_transactions",
+        description: "Export all transactions to a JSON file with descriptive filename",
+        inputSchema: ExportTransactionsSchema,
+        handler: adapt(handleExportTransactions),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: "YNAB: Export Transactions",
+            },
+        },
+    });
+    registry.register({
+        name: "get_transaction",
+        description: "Get detailed information for a specific transaction",
+        inputSchema: GetTransactionSchema,
+        handler: adapt(handleGetTransaction),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: "YNAB: Get Transaction Details",
+            },
+        },
+    });
+}

package/dist/tools/transactionSchemas.d.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod/v4';
-import * as ynab from 'ynab';
+import type * as ynab from "ynab";
+import { z } from "zod/v4";
 export declare const ListTransactionsSchema: z.ZodObject<{
     budget_id: z.ZodString;
     account_id: z.ZodOptional<z.ZodString>;
@@ -57,7 +57,7 @@ export interface SubtransactionInput {
     category_id?: string;
     memo?: string;
 }
-export type BulkTransactionInput = Omit<CreateTransactionParams, 'budget_id' | 'dry_run' | 'subtransactions'>;
+export type BulkTransactionInput = Omit<CreateTransactionParams, "budget_id" | "dry_run" | "subtransactions">;
 export declare const CreateTransactionsSchema: z.ZodObject<{
     budget_id: z.ZodString;
     transactions: z.ZodArray<z.ZodObject<{
@@ -89,7 +89,7 @@ export declare const CreateTransactionsSchema: z.ZodObject<{
 export type CreateTransactionsParams = z.infer<typeof CreateTransactionsSchema>;
 export interface BulkTransactionResult {
     request_index: number;
-    status: 'created' | 'duplicate' | 'failed';
+    status: "created" | "duplicate" | "failed";
     transaction_id?: string | undefined;
     correlation_key: string;
     error_code?: string | undefined;
@@ -108,7 +108,7 @@ export interface BulkCreateResponse {
     transactions?: ynab.TransactionDetail[];
     duplicate_import_ids?: string[];
     message?: string;
-    mode?: 'full' | 'summary' | 'ids_only';
+    mode?: "full" | "summary" | "ids_only";
 }
 export declare const CreateReceiptSplitTransactionSchema: z.ZodObject<{
     budget_id: z.ZodString;
@@ -243,7 +243,7 @@ export declare const UpdateTransactionsSchema: z.ZodObject<{
 export type UpdateTransactionsParams = z.infer<typeof UpdateTransactionsSchema>;
 export interface BulkUpdateResult {
     request_index: number;
-    status: 'updated' | 'failed';
+    status: "updated" | "failed";
     transaction_id: string;
     correlation_key: string;
     error_code?: string;
@@ -260,7 +260,7 @@ export interface BulkUpdateResponse {
     results: BulkUpdateResult[];
     transactions?: ynab.TransactionDetail[];
     message?: string;
-    mode?: 'full' | 'summary' | 'ids_only';
+    mode?: "full" | "summary" | "ids_only";
 }
 export declare const DeleteTransactionSchema: z.ZodObject<{
     budget_id: z.ZodString;

package/dist/tools/transactionSchemas.js

@@ -1,48 +1,54 @@
-import { z } from 'zod/v4';
+import { z } from "zod/v4";
 export const ListTransactionsSchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
+    budget_id: z.string().min(1, "Budget ID is required"),
     account_id: z.string().optional(),
     category_id: z.string().optional(),
     since_date: z
         .string()
-        .regex(/^\d{4}-\d{2}-\d{2}$/, 'Date must be in ISO format (YYYY-MM-DD)')
+        .regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in ISO format (YYYY-MM-DD)")
         .optional(),
-    type: z.enum(['uncategorized', 'unapproved']).optional(),
+    type: z.enum(["uncategorized", "unapproved"]).optional(),
 })
     .strict();
 export const GetTransactionSchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
-    transaction_id: z.string().min(1, 'Transaction ID is required'),
+    budget_id: z.string().min(1, "Budget ID is required"),
+    transaction_id: z.string().min(1, "Transaction ID is required"),
 })
     .strict();
 export const CreateTransactionSchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
-    account_id: z.string().min(1, 'Account ID is required'),
-    amount: z.number().int('Amount must be an integer in milliunits'),
-    date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'Date must be in ISO format (YYYY-MM-DD)'),
+    budget_id: z.string().min(1, "Budget ID is required"),
+    account_id: z.string().min(1, "Account ID is required"),
+    amount: z.number().int("Amount must be an integer in milliunits"),
+    date: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in ISO format (YYYY-MM-DD)"),
     payee_name: z.string().optional(),
     payee_id: z.string().optional(),
     category_id: z.string().optional(),
     memo: z.string().optional(),
-    cleared: z.enum(['cleared', 'uncleared', 'reconciled']).optional(),
+    cleared: z.enum(["cleared", "uncleared", "reconciled"]).optional(),
     approved: z.boolean().optional(),
-    flag_color: z.enum(['red', 'orange', 'yellow', 'green', 'blue', 'purple']).optional(),
-    import_id: z.string().min(1, 'Import ID cannot be empty').optional(),
+    flag_color: z
+        .enum(["red", "orange", "yellow", "green", "blue", "purple"])
+        .optional(),
+    import_id: z.string().min(1, "Import ID cannot be empty").optional(),
     dry_run: z.boolean().optional(),
     subtransactions: z
         .array(z
         .object({
-        amount: z.number().int('Subtransaction amount must be an integer in milliunits'),
+        amount: z
+            .number()
+            .int("Subtransaction amount must be an integer in milliunits"),
         payee_name: z.string().optional(),
         payee_id: z.string().optional(),
         category_id: z.string().optional(),
         memo: z.string().optional(),
     })
         .strict())
-        .min(1, 'At least one subtransaction is required when provided')
+        .min(1, "At least one subtransaction is required when provided")
         .optional(),
 })
     .strict()
@@ -52,8 +58,8 @@ export const CreateTransactionSchema = z
         if (total !== data.amount) {
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
-                message: 'Amount must equal the sum of subtransaction amounts',
-                path: ['amount'],
+                message: "Amount must equal the sum of subtransaction amounts",
+                path: ["amount"],
             });
         }
     }
@@ -74,59 +80,63 @@ const BulkTransactionInputSchemaBase = CreateTransactionSchema.pick({
 const BulkTransactionInputSchema = BulkTransactionInputSchemaBase.strict();
 export const CreateTransactionsSchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
+    budget_id: z.string().min(1, "Budget ID is required"),
     transactions: z
         .array(BulkTransactionInputSchema)
-        .min(1, 'At least one transaction is required')
-        .max(100, 'A maximum of 100 transactions may be created at once'),
+        .min(1, "At least one transaction is required")
+        .max(100, "A maximum of 100 transactions may be created at once"),
     dry_run: z.boolean().optional(),
 })
     .strict();
 const ReceiptSplitItemSchema = z
     .object({
-    name: z.string().min(1, 'Item name is required'),
-    amount: z.number().finite('Item amount must be a finite number'),
+    name: z.string().min(1, "Item name is required"),
+    amount: z.number().finite("Item amount must be a finite number"),
     quantity: z
         .number()
-        .finite('Quantity must be a finite number')
-        .positive('Quantity must be greater than zero')
+        .finite("Quantity must be a finite number")
+        .positive("Quantity must be greater than zero")
         .optional(),
     memo: z.string().optional(),
 })
     .strict();
 const ReceiptSplitCategorySchema = z
     .object({
-    category_id: z.string().min(1, 'Category ID is required'),
+    category_id: z.string().min(1, "Category ID is required"),
     category_name: z.string().optional(),
-    items: z.array(ReceiptSplitItemSchema).min(1, 'Each category must include at least one item'),
+    items: z
+        .array(ReceiptSplitItemSchema)
+        .min(1, "Each category must include at least one item"),
 })
     .strict();
 export const CreateReceiptSplitTransactionSchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
-    account_id: z.string().min(1, 'Account ID is required'),
-    payee_name: z.string().min(1, 'Payee name is required'),
+    budget_id: z.string().min(1, "Budget ID is required"),
+    account_id: z.string().min(1, "Account ID is required"),
+    payee_name: z.string().min(1, "Payee name is required"),
     date: z
         .string()
-        .regex(/^[0-9]{4}-[0-9]{2}-[0-9]{2}$/, 'Date must be in ISO format (YYYY-MM-DD)')
+        .regex(/^[0-9]{4}-[0-9]{2}-[0-9]{2}$/, "Date must be in ISO format (YYYY-MM-DD)")
         .optional(),
     memo: z.string().optional(),
     receipt_subtotal: z
         .number()
-        .finite('Receipt subtotal must be a finite number')
-        .refine((value) => value >= 0, 'Receipt subtotal must be zero or greater')
+        .finite("Receipt subtotal must be a finite number")
+        .refine((value) => value >= 0, "Receipt subtotal must be zero or greater")
         .optional(),
-    receipt_tax: z.number().finite('Receipt tax must be a finite number'),
+    receipt_tax: z.number().finite("Receipt tax must be a finite number"),
     receipt_total: z
         .number()
-        .finite('Receipt total must be a finite number')
-        .refine((value) => value > 0, 'Receipt total must be greater than zero'),
+        .finite("Receipt total must be a finite number")
+        .refine((value) => value > 0, "Receipt total must be greater than zero"),
     categories: z
         .array(ReceiptSplitCategorySchema)
-        .min(1, 'At least one categorized group is required to create a split transaction'),
-    cleared: z.enum(['cleared', 'uncleared', 'reconciled']).optional(),
+        .min(1, "At least one categorized group is required to create a split transaction"),
+    cleared: z.enum(["cleared", "uncleared", "reconciled"]).optional(),
     approved: z.boolean().optional(),
-    flag_color: z.enum(['red', 'orange', 'yellow', 'green', 'blue', 'purple']).optional(),
+    flag_color: z
+        .enum(["red", "orange", "yellow", "green", "blue", "purple"])
+        .optional(),
     dry_run: z.boolean().optional(),
 })
     .strict()
@@ -140,7 +150,7 @@ export const CreateReceiptSplitTransactionSchema = z
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
                 message: `Receipt subtotal (${data.receipt_subtotal.toFixed(2)}) does not match categorized items total (${itemsSubtotal.toFixed(2)})`,
-                path: ['receipt_subtotal'],
+                path: ["receipt_subtotal"],
             });
         }
     }
@@ -150,66 +160,76 @@ export const CreateReceiptSplitTransactionSchema = z
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
             message: `Receipt total (${data.receipt_total.toFixed(2)}) does not match subtotal plus tax (${expectedTotal.toFixed(2)})`,
-            path: ['receipt_total'],
+            path: ["receipt_total"],
         });
     }
 });
 export const UpdateTransactionSchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
-    transaction_id: z.string().min(1, 'Transaction ID is required'),
+    budget_id: z.string().min(1, "Budget ID is required"),
+    transaction_id: z.string().min(1, "Transaction ID is required"),
     account_id: z.string().optional(),
-    amount: z.number().int('Amount must be an integer in milliunits').optional(),
+    amount: z
+        .number()
+        .int("Amount must be an integer in milliunits")
+        .optional(),
     date: z
         .string()
-        .regex(/^\d{4}-\d{2}-\d{2}$/, 'Date must be in ISO format (YYYY-MM-DD)')
+        .regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in ISO format (YYYY-MM-DD)")
         .optional(),
     payee_name: z.string().optional(),
     payee_id: z.string().optional(),
     category_id: z.string().optional(),
     memo: z.string().optional(),
-    cleared: z.enum(['cleared', 'uncleared', 'reconciled']).optional(),
+    cleared: z.enum(["cleared", "uncleared", "reconciled"]).optional(),
     approved: z.boolean().optional(),
-    flag_color: z.enum(['red', 'orange', 'yellow', 'green', 'blue', 'purple']).optional(),
+    flag_color: z
+        .enum(["red", "orange", "yellow", "green", "blue", "purple"])
+        .optional(),
     dry_run: z.boolean().optional(),
 })
     .strict();
 const BulkUpdateTransactionInputSchema = z
     .object({
-    id: z.string().min(1, 'Transaction ID is required'),
-    amount: z.number().int('Amount must be an integer in milliunits').optional(),
+    id: z.string().min(1, "Transaction ID is required"),
+    amount: z
+        .number()
+        .int("Amount must be an integer in milliunits")
+        .optional(),
     date: z
         .string()
-        .regex(/^\d{4}-\d{2}-\d{2}$/, 'Date must be in ISO format (YYYY-MM-DD)')
+        .regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in ISO format (YYYY-MM-DD)")
         .optional(),
     payee_name: z.string().optional(),
     payee_id: z.string().optional(),
     category_id: z.string().optional(),
     memo: z.string().optional(),
-    cleared: z.enum(['cleared', 'uncleared', 'reconciled']).optional(),
+    cleared: z.enum(["cleared", "uncleared", "reconciled"]).optional(),
     approved: z.boolean().optional(),
-    flag_color: z.enum(['red', 'orange', 'yellow', 'green', 'blue', 'purple']).optional(),
+    flag_color: z
+        .enum(["red", "orange", "yellow", "green", "blue", "purple"])
+        .optional(),
     original_account_id: z.string().optional(),
     original_date: z
         .string()
-        .regex(/^\d{4}-\d{2}-\d{2}$/, 'Date must be in ISO format (YYYY-MM-DD)')
+        .regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in ISO format (YYYY-MM-DD)")
         .optional(),
 })
     .strict();
 export const UpdateTransactionsSchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
+    budget_id: z.string().min(1, "Budget ID is required"),
     transactions: z
         .array(BulkUpdateTransactionInputSchema)
-        .min(1, 'At least one transaction is required')
-        .max(100, 'A maximum of 100 transactions may be updated at once'),
+        .min(1, "At least one transaction is required")
+        .max(100, "A maximum of 100 transactions may be updated at once"),
     dry_run: z.boolean().optional(),
 })
     .strict();
 export const DeleteTransactionSchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
-    transaction_id: z.string().min(1, 'Transaction ID is required'),
+    budget_id: z.string().min(1, "Budget ID is required"),
+    transaction_id: z.string().min(1, "Transaction ID is required"),
     dry_run: z.boolean().optional(),
 })
     .strict();

package/dist/tools/transactionTools.d.ts

@@ -1,25 +1,7 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import * as ynab from 'ynab';
-import type { ToolFactory } from '../types/toolRegistration.js';
-import type { DeltaFetcher } from './deltaFetcher.js';
-import type { DeltaCache } from '../server/deltaCache.js';
-import type { ServerKnowledgeStore } from '../server/serverKnowledgeStore.js';
-import { ListTransactionsParams, GetTransactionParams, CreateTransactionParams, CreateTransactionsParams, CreateReceiptSplitTransactionParams, UpdateTransactionParams, UpdateTransactionsParams, DeleteTransactionParams } from './transactionSchemas.js';
-export declare function handleListTransactions(ynabAPI: ynab.API, deltaFetcher: DeltaFetcher, params: ListTransactionsParams): Promise<CallToolResult>;
-export declare function handleListTransactions(ynabAPI: ynab.API, params: ListTransactionsParams): Promise<CallToolResult>;
-export declare function handleGetTransaction(ynabAPI: ynab.API, params: GetTransactionParams): Promise<CallToolResult>;
-export declare function handleCreateTransaction(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: CreateTransactionParams): Promise<CallToolResult>;
-export declare function handleCreateTransaction(ynabAPI: ynab.API, params: CreateTransactionParams): Promise<CallToolResult>;
-export declare function handleCreateReceiptSplitTransaction(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: CreateReceiptSplitTransactionParams): Promise<CallToolResult>;
-export declare function handleCreateReceiptSplitTransaction(ynabAPI: ynab.API, params: CreateReceiptSplitTransactionParams): Promise<CallToolResult>;
-export declare function handleUpdateTransaction(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: UpdateTransactionParams): Promise<CallToolResult>;
-export declare function handleUpdateTransaction(ynabAPI: ynab.API, params: UpdateTransactionParams): Promise<CallToolResult>;
-export declare function handleDeleteTransaction(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: DeleteTransactionParams): Promise<CallToolResult>;
-export declare function handleDeleteTransaction(ynabAPI: ynab.API, params: DeleteTransactionParams): Promise<CallToolResult>;
-export declare function handleCreateTransactions(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: CreateTransactionsParams): Promise<CallToolResult>;
-export declare function handleCreateTransactions(ynabAPI: ynab.API, params: CreateTransactionsParams): Promise<CallToolResult>;
-export declare function handleUpdateTransactions(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: UpdateTransactionsParams): Promise<CallToolResult>;
-export declare function handleUpdateTransactions(ynabAPI: ynab.API, params: UpdateTransactionsParams): Promise<CallToolResult>;
+import type { ToolFactory } from "../types/toolRegistration.js";
+import { handleGetTransaction, handleListTransactions } from "./transactionReadTools.js";
+import { handleCreateReceiptSplitTransaction, handleCreateTransaction, handleCreateTransactions, handleDeleteTransaction, handleUpdateTransaction, handleUpdateTransactions } from "./transactionWriteTools.js";
 export declare const registerTransactionTools: ToolFactory;
-export { ListTransactionsSchema, type ListTransactionsParams, GetTransactionSchema, type GetTransactionParams, CreateTransactionSchema, type CreateTransactionParams, CreateTransactionsSchema, type CreateTransactionsParams, CreateReceiptSplitTransactionSchema, type CreateReceiptSplitTransactionParams, UpdateTransactionSchema, type UpdateTransactionParams, UpdateTransactionsSchema, type UpdateTransactionsParams, type BulkUpdateTransactionInput, DeleteTransactionSchema, type DeleteTransactionParams, type BulkTransactionResult, type BulkCreateResponse, type BulkUpdateResult, type BulkUpdateResponse, type CorrelationPayload, type CorrelationPayloadInput, type CategorySource, type TransactionCacheInvalidationOptions, type ReceiptCategoryCalculation, type SubtransactionInput, type BulkTransactionInput, } from './transactionSchemas.js';
-export { generateCorrelationKey, toCorrelationPayload, correlateResults, estimatePayloadSize, finalizeResponse, finalizeBulkUpdateResponse, handleTransactionError, toMonthKey, ensureTransaction, appendCategoryIds, collectCategoryIdsFromSources, setsEqual, invalidateTransactionCaches, } from './transactionUtils.js';
+export { handleListTransactions, handleGetTransaction, handleCreateTransaction, handleCreateReceiptSplitTransaction, handleUpdateTransaction, handleDeleteTransaction, handleCreateTransactions, handleUpdateTransactions, };
+export { ListTransactionsSchema, type ListTransactionsParams, GetTransactionSchema, type GetTransactionParams, CreateTransactionSchema, type CreateTransactionParams, CreateTransactionsSchema, type CreateTransactionsParams, CreateReceiptSplitTransactionSchema, type CreateReceiptSplitTransactionParams, UpdateTransactionSchema, type UpdateTransactionParams, UpdateTransactionsSchema, type UpdateTransactionsParams, type BulkUpdateTransactionInput, DeleteTransactionSchema, type DeleteTransactionParams, type BulkTransactionResult, type BulkCreateResponse, type BulkUpdateResult, type BulkUpdateResponse, type CorrelationPayload, type CorrelationPayloadInput, type CategorySource, type TransactionCacheInvalidationOptions, type ReceiptCategoryCalculation, type SubtransactionInput, type BulkTransactionInput, } from "./transactionSchemas.js";
+export { generateCorrelationKey, toCorrelationPayload, correlateResults, estimatePayloadSize, finalizeResponse, finalizeBulkUpdateResponse, handleTransactionError, toMonthKey, ensureTransaction, appendCategoryIds, collectCategoryIdsFromSources, setsEqual, invalidateTransactionCaches, } from "./transactionUtils.js";