@dizzlkheinz/ynab-mcpb 0.18.3 → 0.18.4

package/dist/tools/reconcileAdapter.js

@@ -38,6 +38,8 @@ const convertSummary = (analysis) => ({
     statement_date_range: analysis.summary.statement_date_range,
     bank_transactions_count: analysis.summary.bank_transactions_count,
     ynab_transactions_count: analysis.summary.ynab_transactions_count,
+    ynab_in_range_count: analysis.summary.ynab_in_range_count ?? analysis.summary.ynab_transactions_count,
+    ynab_outside_range_count: analysis.summary.ynab_outside_range_count ?? 0,
     auto_matched: analysis.summary.auto_matched,
     suggested_matches: analysis.summary.suggested_matches,
     unmatched_bank: analysis.summary.unmatched_bank,
@@ -152,6 +154,7 @@ export const buildReconciliationPayload = (analysis, options = {}, execution) =>
         unmatched: {
             bank: analysis.unmatched_bank.map((txn) => toBankTransactionView(txn, currency)),
             ynab: analysis.unmatched_ynab.map((txn) => toYNABTransactionView(txn, currency)),
+            ynab_outside_date_range: (analysis.ynab_outside_date_range ?? []).map((txn) => toYNABTransactionView(txn, currency)),
         },
     };
     if (analysis.recommendations && analysis.recommendations.length > 0) {

package/dist/tools/reconciliation/analyzer.js

@@ -3,6 +3,54 @@ import { findMatches, normalizeConfig, DEFAULT_CONFIG } from './matcher.js';
 import { normalizeYNABTransactions } from './ynabAdapter.js';
 import { toMoneyValue } from '../../utils/money.js';
 import { generateRecommendations } from './recommendationEngine.js';
+function calculateDateRange(bankTransactions) {
+    if (bankTransactions.length === 0) {
+        return null;
+    }
+    const dates = bankTransactions
+        .map((t) => t.date)
+        .filter((d) => d && /^\d{4}-\d{2}-\d{2}$/.test(d))
+        .sort();
+    if (dates.length === 0) {
+        return null;
+    }
+    return {
+        minDate: dates[0],
+        maxDate: dates[dates.length - 1],
+    };
+}
+function filterByDateRange(ynabTransactions, dateRange, dateToleranceDays = 7) {
+    if (dateToleranceDays < 0) {
+        console.warn(`[filterByDateRange] dateToleranceDays must be non-negative, got ${dateToleranceDays}. Using 0.`);
+        dateToleranceDays = 0;
+    }
+    const inRange = [];
+    const outsideRange = [];
+    const minParts = dateRange.minDate.split('-').map(Number);
+    const maxParts = dateRange.maxDate.split('-').map(Number);
+    if (minParts.length !== 3 ||
+        maxParts.length !== 3 ||
+        minParts.some((n) => !Number.isFinite(n)) ||
+        maxParts.some((n) => !Number.isFinite(n))) {
+        console.warn(`[filterByDateRange] Invalid date format in range: ${dateRange.minDate} to ${dateRange.maxDate} - returning all transactions`);
+        return { inRange: ynabTransactions, outsideRange: [] };
+    }
+    const [minYear, minMonth, minDay] = minParts;
+    const [maxYear, maxMonth, maxDay] = maxParts;
+    const minDateWithBuffer = new Date(Date.UTC(minYear, minMonth - 1, minDay - dateToleranceDays));
+    const minDateStr = minDateWithBuffer.toISOString().split('T')[0];
+    const maxDateWithBuffer = new Date(Date.UTC(maxYear, maxMonth - 1, maxDay + dateToleranceDays));
+    const maxDateStr = maxDateWithBuffer.toISOString().split('T')[0];
+    for (const txn of ynabTransactions) {
+        if (txn.date >= minDateStr && txn.date <= maxDateStr) {
+            inRange.push(txn);
+        }
+        else {
+            outsideRange.push(txn);
+        }
+    }
+    return { inRange, outsideRange };
+}
 function mapToTransactionMatch(result) {
     const candidates = result.candidates.map((c) => ({
         ynab_transaction: c.ynabTransaction,
@@ -55,9 +103,10 @@ function calculateBalances(ynabTransactions, statementBalanceDecimal, currency,
         on_track: Math.abs(discrepancy) < 10,
     };
 }
-function generateSummary(bankTransactions, ynabTransactions, autoMatches, suggestedMatches, unmatchedBank, unmatchedYNAB, balances) {
+function generateSummary(bankTransactions, ynabTransactionsInRange, ynabTransactionsOutsideRange, autoMatches, suggestedMatches, unmatchedBank, unmatchedYNAB, balances) {
     const dates = bankTransactions.map((t) => t.date).sort();
     const dateRange = dates.length > 0 ? `${dates[0]} to ${dates[dates.length - 1]}` : 'Unknown';
+    const totalYnabCount = ynabTransactionsInRange.length + ynabTransactionsOutsideRange.length;
     let discrepancyExplanation = '';
     if (balances.on_track) {
         discrepancyExplanation = 'Cleared balance matches statement';
@@ -79,7 +128,9 @@ function generateSummary(bankTransactions, ynabTransactions, autoMatches, sugges
     return {
         statement_date_range: dateRange,
         bank_transactions_count: bankTransactions.length,
-        ynab_transactions_count: ynabTransactions.length,
+        ynab_transactions_count: totalYnabCount,
+        ynab_in_range_count: ynabTransactionsInRange.length,
+        ynab_outside_range_count: ynabTransactionsOutsideRange.length,
         auto_matched: autoMatches.length,
         suggested_matches: suggestedMatches.length,
         unmatched_bank: unmatchedBank.length,
@@ -236,9 +287,22 @@ export function analyzeReconciliation(csvContentOrParsed, _csvFilePath, ynabTran
     const newBankTransactions = parseResult.transactions;
     const csvParseErrors = parseResult.errors;
     const csvParseWarnings = parseResult.warnings;
-    const newYNABTransactions = normalizeYNABTransactions(ynabTransactions);
+    const allYNABTransactions = normalizeYNABTransactions(ynabTransactions);
+    const csvDateRange = calculateDateRange(newBankTransactions);
+    let ynabInRange;
+    let ynabOutsideRange;
+    if (csvDateRange) {
+        const dateToleranceDays = config.dateToleranceDays ?? 7;
+        const filtered = filterByDateRange(allYNABTransactions, csvDateRange, dateToleranceDays);
+        ynabInRange = filtered.inRange;
+        ynabOutsideRange = filtered.outsideRange;
+    }
+    else {
+        ynabInRange = allYNABTransactions;
+        ynabOutsideRange = [];
+    }
     const normalizedConfig = normalizeConfig(config);
-    const newMatches = findMatches(newBankTransactions, newYNABTransactions, normalizedConfig);
+    const newMatches = findMatches(newBankTransactions, ynabInRange, normalizedConfig);
     const matches = newMatches.map(mapToTransactionMatch);
     const autoMatches = matches.filter((m) => m.confidence === 'high');
     const autoMatchedYnabIds = new Set();
@@ -255,9 +319,9 @@ export function analyzeReconciliation(csvContentOrParsed, _csvFilePath, ynabTran
         if (m.ynabTransaction)
             matchedYnabIds.add(m.ynabTransaction.id);
     });
-    const unmatchedYNAB = newYNABTransactions.filter((t) => !matchedYnabIds.has(t.id));
-    const balances = calculateBalances(newYNABTransactions, statementBalance, currency, accountSnapshot);
-    const summary = generateSummary(matches.map((m) => m.bankTransaction), newYNABTransactions, autoMatches, suggestedMatches, unmatchedBank, unmatchedYNAB, balances);
+    const unmatchedYNAB = ynabInRange.filter((t) => !matchedYnabIds.has(t.id));
+    const balances = calculateBalances(allYNABTransactions, statementBalance, currency, accountSnapshot);
+    const summary = generateSummary(matches.map((m) => m.bankTransaction), ynabInRange, ynabOutsideRange, autoMatches, suggestedMatches, unmatchedBank, unmatchedYNAB, balances);
     const nextSteps = generateNextSteps(summary);
     const insights = detectInsights(unmatchedBank, summary, balances, currency, csvParseErrors, csvParseWarnings);
     const analysis = {
@@ -268,6 +332,7 @@ export function analyzeReconciliation(csvContentOrParsed, _csvFilePath, ynabTran
         suggested_matches: suggestedMatches,
         unmatched_bank: unmatchedBank,
         unmatched_ynab: unmatchedYNAB,
+        ynab_outside_date_range: ynabOutsideRange,
         balance_info: balances,
         next_steps: nextSteps,
         insights,

package/dist/tools/reconciliation/reportFormatter.js

@@ -59,13 +59,20 @@ function formatTransactionAnalysisSection(analysis, options) {
     lines.push('Transaction Analysis');
     lines.push(SECTION_DIVIDER);
     const summary = analysis.summary;
+    const outsideRangeCount = summary.ynab_outside_range_count ?? 0;
+    if (outsideRangeCount > 0) {
+        const inRangeCount = summary.ynab_in_range_count ?? summary.ynab_transactions_count;
+        lines.push(`Comparing ${summary.bank_transactions_count} bank transactions with ${inRangeCount} YNAB transactions within statement period.`);
+        lines.push(`(${outsideRangeCount} YNAB transactions outside statement period - not compared)`);
+        lines.push('');
+    }
     lines.push(`- Automatically matched:  ${summary.auto_matched} of ${summary.bank_transactions_count} transactions`);
     lines.push(`- Suggested matches:      ${summary.suggested_matches}`);
     lines.push(`- Unmatched bank:         ${summary.unmatched_bank}`);
     lines.push(`- Unmatched YNAB:         ${summary.unmatched_ynab}`);
     if (analysis.unmatched_bank.length > 0) {
         lines.push('');
-        lines.push('Unmatched bank transactions:');
+        lines.push('Missing from YNAB (bank transactions without matches):');
         const maxToShow = options.maxUnmatchedToShow ?? 5;
         const toShow = analysis.unmatched_bank.slice(0, maxToShow);
         for (const txn of toShow) {
@@ -75,9 +82,21 @@ function formatTransactionAnalysisSection(analysis, options) {
             lines.push(`   ... and ${analysis.unmatched_bank.length - maxToShow} more`);
         }
     }
+    if (analysis.unmatched_ynab.length > 0) {
+        lines.push('');
+        lines.push('Missing from bank statement (YNAB transactions without matches):');
+        const maxToShow = options.maxUnmatchedToShow ?? 5;
+        const toShow = analysis.unmatched_ynab.slice(0, maxToShow);
+        for (const txn of toShow) {
+            lines.push(formatYnabTransactionLine(txn));
+        }
+        if (analysis.unmatched_ynab.length > maxToShow) {
+            lines.push(`   ... and ${analysis.unmatched_ynab.length - maxToShow} more`);
+        }
+    }
     if (analysis.suggested_matches.length > 0) {
         lines.push('');
-        lines.push('Suggested matches:');
+        lines.push('Suggested matches (review manually):');
         const maxToShow = options.maxUnmatchedToShow ?? 3;
         const toShow = analysis.suggested_matches.slice(0, maxToShow);
         for (const match of toShow) {
@@ -89,6 +108,11 @@ function formatTransactionAnalysisSection(analysis, options) {
     }
     return lines.join('\n');
 }
+function formatYnabTransactionLine(txn) {
+    const amountStr = formatAmount(txn.amount);
+    const payee = txn.payee ?? 'Unknown';
+    return `   ${txn.date} - ${payee.substring(0, 40).padEnd(40)} ${amountStr}`;
+}
 function formatBankTransactionLine(txn) {
     const amountStr = formatAmount(txn.amount);
     return `   ${txn.date} - ${txn.payee.substring(0, 40).padEnd(40)} ${amountStr}`;

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

@@ -32,6 +32,8 @@ export interface ReconciliationSummary {
     statement_date_range: string;
     bank_transactions_count: number;
     ynab_transactions_count: number;
+    ynab_in_range_count: number;
+    ynab_outside_range_count: number;
     auto_matched: number;
     suggested_matches: number;
     unmatched_bank: number;
@@ -59,6 +61,7 @@ export interface ReconciliationAnalysis {
     suggested_matches: TransactionMatch[];
     unmatched_bank: BankTransaction[];
     unmatched_ynab: YNABTransaction[];
+    ynab_outside_date_range: YNABTransaction[];
     balance_info: BalanceInfo;
     next_steps: string[];
     insights: ReconciliationInsight[];

package/dist/tools/transactionSchemas.d.ts

@@ -0,0 +1,309 @@
+import { z } from 'zod/v4';
+import * as ynab from 'ynab';
+export declare const ListTransactionsSchema: z.ZodObject<{
+    budget_id: z.ZodString;
+    account_id: z.ZodOptional<z.ZodString>;
+    category_id: z.ZodOptional<z.ZodString>;
+    since_date: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<{
+        uncategorized: "uncategorized";
+        unapproved: "unapproved";
+    }>>;
+}, z.core.$strict>;
+export type ListTransactionsParams = z.infer<typeof ListTransactionsSchema>;
+export declare const GetTransactionSchema: z.ZodObject<{
+    budget_id: z.ZodString;
+    transaction_id: z.ZodString;
+}, z.core.$strict>;
+export type GetTransactionParams = z.infer<typeof GetTransactionSchema>;
+export declare const CreateTransactionSchema: z.ZodObject<{
+    budget_id: z.ZodString;
+    account_id: z.ZodString;
+    amount: z.ZodNumber;
+    date: z.ZodString;
+    payee_name: z.ZodOptional<z.ZodString>;
+    payee_id: z.ZodOptional<z.ZodString>;
+    category_id: z.ZodOptional<z.ZodString>;
+    memo: z.ZodOptional<z.ZodString>;
+    cleared: z.ZodOptional<z.ZodEnum<{
+        cleared: "cleared";
+        uncleared: "uncleared";
+        reconciled: "reconciled";
+    }>>;
+    approved: z.ZodOptional<z.ZodBoolean>;
+    flag_color: z.ZodOptional<z.ZodEnum<{
+        red: "red";
+        orange: "orange";
+        yellow: "yellow";
+        green: "green";
+        blue: "blue";
+        purple: "purple";
+    }>>;
+    import_id: z.ZodOptional<z.ZodString>;
+    dry_run: z.ZodOptional<z.ZodBoolean>;
+    subtransactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        amount: z.ZodNumber;
+        payee_name: z.ZodOptional<z.ZodString>;
+        payee_id: z.ZodOptional<z.ZodString>;
+        category_id: z.ZodOptional<z.ZodString>;
+        memo: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type CreateTransactionParams = z.infer<typeof CreateTransactionSchema>;
+export interface SubtransactionInput {
+    amount: number;
+    payee_name?: string;
+    payee_id?: string;
+    category_id?: string;
+    memo?: string;
+}
+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<{
+        date: z.ZodString;
+        cleared: z.ZodOptional<z.ZodEnum<{
+            cleared: "cleared";
+            uncleared: "uncleared";
+            reconciled: "reconciled";
+        }>>;
+        amount: z.ZodNumber;
+        memo: z.ZodOptional<z.ZodString>;
+        approved: z.ZodOptional<z.ZodBoolean>;
+        flag_color: z.ZodOptional<z.ZodEnum<{
+            red: "red";
+            orange: "orange";
+            yellow: "yellow";
+            green: "green";
+            blue: "blue";
+            purple: "purple";
+        }>>;
+        account_id: z.ZodString;
+        payee_id: z.ZodOptional<z.ZodString>;
+        category_id: z.ZodOptional<z.ZodString>;
+        import_id: z.ZodOptional<z.ZodString>;
+        payee_name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    dry_run: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type CreateTransactionsParams = z.infer<typeof CreateTransactionsSchema>;
+export interface BulkTransactionResult {
+    request_index: number;
+    status: 'created' | 'duplicate' | 'failed';
+    transaction_id?: string | undefined;
+    correlation_key: string;
+    error_code?: string | undefined;
+    error?: string | undefined;
+}
+export interface BulkCreateResponse {
+    success: boolean;
+    server_knowledge?: number;
+    summary: {
+        total_requested: number;
+        created: number;
+        duplicates: number;
+        failed: number;
+    };
+    results: BulkTransactionResult[];
+    transactions?: ynab.TransactionDetail[];
+    duplicate_import_ids?: string[];
+    message?: string;
+    mode?: 'full' | 'summary' | 'ids_only';
+}
+export declare const CreateReceiptSplitTransactionSchema: z.ZodObject<{
+    budget_id: z.ZodString;
+    account_id: z.ZodString;
+    payee_name: z.ZodString;
+    date: z.ZodOptional<z.ZodString>;
+    memo: z.ZodOptional<z.ZodString>;
+    receipt_subtotal: z.ZodOptional<z.ZodNumber>;
+    receipt_tax: z.ZodNumber;
+    receipt_total: z.ZodNumber;
+    categories: z.ZodArray<z.ZodObject<{
+        category_id: z.ZodString;
+        category_name: z.ZodOptional<z.ZodString>;
+        items: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            amount: z.ZodNumber;
+            quantity: z.ZodOptional<z.ZodNumber>;
+            memo: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    cleared: z.ZodOptional<z.ZodEnum<{
+        cleared: "cleared";
+        uncleared: "uncleared";
+        reconciled: "reconciled";
+    }>>;
+    approved: z.ZodOptional<z.ZodBoolean>;
+    flag_color: z.ZodOptional<z.ZodEnum<{
+        red: "red";
+        orange: "orange";
+        yellow: "yellow";
+        green: "green";
+        blue: "blue";
+        purple: "purple";
+    }>>;
+    dry_run: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type CreateReceiptSplitTransactionParams = z.infer<typeof CreateReceiptSplitTransactionSchema>;
+export interface ReceiptCategoryCalculation {
+    category_id: string;
+    category_name: string | undefined;
+    subtotal_milliunits: number;
+    tax_milliunits: number;
+    items: {
+        name: string;
+        amount_milliunits: number;
+        quantity: number | undefined;
+        memo: string | undefined;
+    }[];
+}
+export declare const UpdateTransactionSchema: z.ZodObject<{
+    budget_id: z.ZodString;
+    transaction_id: z.ZodString;
+    account_id: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodNumber>;
+    date: z.ZodOptional<z.ZodString>;
+    payee_name: z.ZodOptional<z.ZodString>;
+    payee_id: z.ZodOptional<z.ZodString>;
+    category_id: z.ZodOptional<z.ZodString>;
+    memo: z.ZodOptional<z.ZodString>;
+    cleared: z.ZodOptional<z.ZodEnum<{
+        cleared: "cleared";
+        uncleared: "uncleared";
+        reconciled: "reconciled";
+    }>>;
+    approved: z.ZodOptional<z.ZodBoolean>;
+    flag_color: z.ZodOptional<z.ZodEnum<{
+        red: "red";
+        orange: "orange";
+        yellow: "yellow";
+        green: "green";
+        blue: "blue";
+        purple: "purple";
+    }>>;
+    dry_run: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type UpdateTransactionParams = z.infer<typeof UpdateTransactionSchema>;
+declare const BulkUpdateTransactionInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    amount: z.ZodOptional<z.ZodNumber>;
+    date: z.ZodOptional<z.ZodString>;
+    payee_name: z.ZodOptional<z.ZodString>;
+    payee_id: z.ZodOptional<z.ZodString>;
+    category_id: z.ZodOptional<z.ZodString>;
+    memo: z.ZodOptional<z.ZodString>;
+    cleared: z.ZodOptional<z.ZodEnum<{
+        cleared: "cleared";
+        uncleared: "uncleared";
+        reconciled: "reconciled";
+    }>>;
+    approved: z.ZodOptional<z.ZodBoolean>;
+    flag_color: z.ZodOptional<z.ZodEnum<{
+        red: "red";
+        orange: "orange";
+        yellow: "yellow";
+        green: "green";
+        blue: "blue";
+        purple: "purple";
+    }>>;
+    original_account_id: z.ZodOptional<z.ZodString>;
+    original_date: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type BulkUpdateTransactionInput = z.infer<typeof BulkUpdateTransactionInputSchema>;
+export declare const UpdateTransactionsSchema: z.ZodObject<{
+    budget_id: z.ZodString;
+    transactions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        amount: z.ZodOptional<z.ZodNumber>;
+        date: z.ZodOptional<z.ZodString>;
+        payee_name: z.ZodOptional<z.ZodString>;
+        payee_id: z.ZodOptional<z.ZodString>;
+        category_id: z.ZodOptional<z.ZodString>;
+        memo: z.ZodOptional<z.ZodString>;
+        cleared: z.ZodOptional<z.ZodEnum<{
+            cleared: "cleared";
+            uncleared: "uncleared";
+            reconciled: "reconciled";
+        }>>;
+        approved: z.ZodOptional<z.ZodBoolean>;
+        flag_color: z.ZodOptional<z.ZodEnum<{
+            red: "red";
+            orange: "orange";
+            yellow: "yellow";
+            green: "green";
+            blue: "blue";
+            purple: "purple";
+        }>>;
+        original_account_id: z.ZodOptional<z.ZodString>;
+        original_date: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    dry_run: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type UpdateTransactionsParams = z.infer<typeof UpdateTransactionsSchema>;
+export interface BulkUpdateResult {
+    request_index: number;
+    status: 'updated' | 'failed';
+    transaction_id: string;
+    correlation_key: string;
+    error_code?: string;
+    error?: string;
+}
+export interface BulkUpdateResponse {
+    success: boolean;
+    server_knowledge?: number;
+    summary: {
+        total_requested: number;
+        updated: number;
+        failed: number;
+    };
+    results: BulkUpdateResult[];
+    transactions?: ynab.TransactionDetail[];
+    message?: string;
+    mode?: 'full' | 'summary' | 'ids_only';
+}
+export declare const DeleteTransactionSchema: z.ZodObject<{
+    budget_id: z.ZodString;
+    transaction_id: z.ZodString;
+    dry_run: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type DeleteTransactionParams = z.infer<typeof DeleteTransactionSchema>;
+export interface CorrelationPayload {
+    account_id?: string;
+    date?: string;
+    amount?: number;
+    payee_id?: string | null;
+    payee_name?: string | null;
+    category_id?: string | null;
+    memo?: string | null;
+    cleared?: ynab.TransactionClearedStatus;
+    approved?: boolean;
+    flag_color?: ynab.TransactionFlagColor | null;
+    import_id?: string | null;
+}
+export interface CorrelationPayloadInput {
+    account_id?: string | undefined;
+    date?: string | undefined;
+    amount?: number | undefined;
+    payee_id?: string | null | undefined;
+    payee_name?: string | null | undefined;
+    category_id?: string | null | undefined;
+    memo?: string | null | undefined;
+    cleared?: ynab.TransactionClearedStatus | undefined;
+    approved?: boolean | undefined;
+    flag_color?: ynab.TransactionFlagColor | null | undefined;
+    import_id?: string | null | undefined;
+}
+export interface CategorySource {
+    category_id?: string | null;
+    subtransactions?: {
+        category_id?: string | null;
+    }[] | null | undefined;
+}
+export interface TransactionCacheInvalidationOptions {
+    affectedCategoryIds?: Set<string>;
+    invalidateAllCategories?: boolean;
+    accountTotalsChanged?: boolean;
+    invalidateMonths?: boolean;
+}
+export {};