@zeniai/client-epic-state 5.3.22 → 5.3.23-beta0AN

package/lib/view/expenseAutomationView/reducers/reconciliationViewReducer.js

@@ -1,1231 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reparseStatementFailure = exports.reparseStatementSuccess = exports.reparseStatement = exports.parseStatementFailure = exports.parseStatementSuccess = exports.parseCombinedStatement = exports.parseStatement = exports.uploadAccountStatementFailure = exports.uploadAccountStatementSuccess = exports.uploadAccountStatement = exports.includeAccountInReconciliationFailure = exports.includeAccountInReconciliationSuccess = exports.includeAccountInReconciliation = exports.excludeAccountFromReconciliationFailure = exports.excludeAccountFromReconciliationSuccess = exports.excludeAccountFromReconciliation = exports.deleteAccountStatementFailure = exports.deleteAccountStatementSuccess = exports.deleteCombinedStatement = exports.deleteAccountStatement = exports.updateAccountReconciliationLocalData = exports.updateReconListScrollPosition = exports.updateSaveReconciliationReviewFetchStatus = exports.saveReconciliationReview = exports.updateReviewTabLocalData = exports.initializeReconciliationReviewTabLocalData = exports.updateReviewTabSortState = exports.updateStatementProcessingFailed = exports.updateSelectedDrawerAccountId = exports.clearExpenseAutomationReconciliationView = exports.initialiseLocalDataForSelectedAccountId = exports.updateBalancesLocalData = exports.updateSelectedTab = exports.saveReconciliationDetailSuccess = exports.updateReconcileTabListScrollState = exports.updateReconcileTabListSortState = exports.updateReconcileTabLocalData = exports.updateStatementProcessingBackgroundCompletedSteps = exports.setStatementProcessingDismissedToBackground = exports.setStatementParseInProgress = exports.setConnectionInProgressForAccount = exports.updateSelectedAccountId = exports.saveReconciliationDetailFailure = exports.saveReconciliationDetail = exports.fetchReconciliationSuccess = exports.fetchReconciliationFailure = exports.fetchReconciliation = exports.initialState = exports.initialActionFetchState = exports.initialReconciliationTabsState = void 0;
-exports.updateNodeCollapseState = exports.updateStatementUploadChosen = exports.confirmStatementMappingFailure = exports.confirmStatementMappingSuccess = exports.confirmStatementMapping = exports.clearStatementDateConflict = exports.submitStatementUpdateFailure = exports.submitStatementUpdateSuccess = exports.submitCombinedStatementUpdate = exports.submitStatementUpdate = exports.updateStatementUpdateLocalData = exports.updateParsedStatementData = exports.resetReparseStatementStatus = void 0;
-const toolkit_1 = require("@reduxjs/toolkit");
-const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
-const accountState_1 = require("../../../entity/account/accountState");
-const accountReconState_1 = require("../../../entity/accountRecon/accountReconState");
-const rootActions_1 = require("../../../rootActions");
-const reconciliationPayload_1 = require("../payload/reconciliationPayload");
-// Initial state
-exports.initialReconciliationTabsState = {
-    balances: {
-        clearedBalance: { amount: 0, currencyCode: 'USD', currencySymbol: '$' },
-        variance: { amount: 0, currencyCode: 'USD', currencySymbol: '$' },
-        variancePercentage: 0,
-        deposits: {
-            count: 0,
-            totalAmount: { amount: 0, currencyCode: 'USD', currencySymbol: '$' },
-        },
-        payments: {
-            count: 0,
-            totalAmount: { amount: 0, currencyCode: 'USD', currencySymbol: '$' },
-        },
-    },
-    reconcile: {
-        localData: {
-            selectedTransactionIds: [],
-        },
-        uiState: {
-            scrollYOffset: undefined,
-            sortKey: 'date',
-            sortOrder: 'descending',
-        },
-    },
-    review: {
-        localData: {},
-        uiState: {
-            scrollPosition: undefined,
-            sortKey: 'date',
-            sortOrder: 'descending',
-        },
-    },
-};
-exports.initialActionFetchState = {
-    excludeAccountFetch: {
-        fetchState: 'Not-Started',
-        error: undefined,
-    },
-    excludeFetchById: {},
-    includeAccountFetch: {
-        fetchState: 'Not-Started',
-        error: undefined,
-    },
-    reconcileFetch: {
-        fetchState: 'Not-Started',
-        error: undefined,
-    },
-    saveForLaterFetch: {
-        fetchState: 'Not-Started',
-        error: undefined,
-    },
-    saveReconciliationReviewFetch: {},
-};
-exports.initialState = {
-    accountReconciliationRecordsBySelectedPeriod: {},
-    accountConnectionStatusByAccountID: {},
-    excludedAccountExclusionInfo: {},
-    fetchState: 'Not-Started',
-    error: undefined,
-    selectedTab: 'review',
-    reconTabsState: exports.initialReconciliationTabsState,
-    refreshStatus: { fetchState: 'Not-Started', error: undefined },
-    actionFetchState: exports.initialActionFetchState,
-    selectedAccountId: undefined,
-    statementUploadChosen: false,
-    reconListUIState: {
-        nodeCollapseState: {},
-        scrollPosition: {
-            scrollTop: 0,
-        },
-    },
-    excludedAccountIDs: [],
-    summary: undefined,
-};
-// Create slice with reducers
-const expenseAutomationReconciliationView = (0, toolkit_1.createSlice)({
-    name: 'expenseAutomationReconciliationView',
-    initialState: exports.initialState,
-    reducers: {
-        fetchReconciliation: {
-            reducer(draft, action) {
-                if (action.payload.accountId == null) {
-                    if (action.payload.refreshViewInBackground === true) {
-                        draft.refreshStatus = { fetchState: 'In-Progress', error: undefined };
-                    }
-                    else {
-                        draft.fetchState = 'In-Progress';
-                        draft.error = undefined;
-                    }
-                }
-                else {
-                    // Visiting an account detail page selects it and opens review; background
-                    // refresh (e.g. statement Pusher) must not change navigation selection.
-                    if (action.payload.refreshViewInBackground !== true) {
-                        draft.selectedTab = 'review';
-                        draft.selectedAccountId = action.payload.accountId;
-                    }
-                    const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(action.payload.selectedPeriod)]?.reconciliationByAccountID[action.payload.accountId];
-                    if (accountRecon == null) {
-                        return;
-                    }
-                    if (accountRecon.transactionFetchState.fetchState !== 'Completed' ||
-                        action.payload.cacheOverride === true) {
-                        if (action.payload.refreshViewInBackground === true) {
-                            accountRecon.refreshStatus = {
-                                fetchState: 'In-Progress',
-                                error: undefined,
-                            };
-                            accountRecon.accountId = action.payload.accountId;
-                            accountRecon.reconciliationId = undefined;
-                        }
-                        else {
-                            accountRecon.transactionFetchState = {
-                                fetchState: 'In-Progress',
-                                error: undefined,
-                            };
-                            accountRecon.accountId = action.payload.accountId;
-                            accountRecon.reconciliationId = undefined;
-                        }
-                    }
-                }
-            },
-            prepare(selectedPeriod, accountId, cacheOverride = false, refreshViewInBackground = false) {
-                return {
-                    payload: {
-                        selectedPeriod,
-                        accountId,
-                        cacheOverride,
-                        refreshViewInBackground,
-                    },
-                };
-            },
-        },
-        fetchReconciliationSuccess: {
-            reducer(draft, action) {
-                if (action.payload.accountId == null) {
-                    updateAllReconciliation(draft, action.payload.reconciliation.accounts, action.payload.selectedPeriod, action.payload.reconciliation.reconciliation, action.payload.refreshViewInBackground, action.payload.reconciliation.excluded_accounts ?? [], action.payload.reconciliation.summary);
-                }
-                else if (action.payload.reconciliation.reconciliation.length > 0 &&
-                    action.payload.reconciliation.accounts.length > 0) {
-                    updateReconciliationByAccountID(draft, action.payload.reconciliation.accounts[0], action.payload.selectedPeriod, action.payload.accountId, action.payload.reconciliation.reconciliation[0], action.payload.refreshViewInBackground);
-                }
-            },
-            prepare(selectedPeriod, reconciliation, refreshViewInBackground = false, accountId, reconciliationId) {
-                return {
-                    payload: {
-                        selectedPeriod,
-                        reconciliation,
-                        refreshViewInBackground,
-                        accountId,
-                        reconciliationId,
-                    },
-                };
-            },
-        },
-        fetchReconciliationFailure: (draft, action) => {
-            if (action.payload.accountId == null) {
-                if (action.payload.refreshViewInBackground === true) {
-                    draft.refreshStatus = {
-                        fetchState: 'Error',
-                        error: action.payload.error,
-                    };
-                }
-                else {
-                    draft.error = action.payload.error;
-                    draft.fetchState = 'Error';
-                }
-            }
-            else {
-                const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(action.payload.selectedPeriod)]?.reconciliationByAccountID[action.payload.accountId];
-                if (accountRecon == null) {
-                    return;
-                }
-                if (action.payload.refreshViewInBackground === true) {
-                    accountRecon.refreshStatus.error = action.payload.error;
-                    accountRecon.refreshStatus.fetchState = 'Error';
-                }
-                else {
-                    accountRecon.transactionFetchState.error = action.payload.error;
-                    accountRecon.transactionFetchState.fetchState = 'Error';
-                }
-            }
-        },
-        saveReconciliationDetail: (draft, action) => {
-            const { reconcileAction } = action.payload;
-            if (reconcileAction === 'reconcile') {
-                draft.actionFetchState.reconcileFetch = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-            }
-            else if (reconcileAction === 'save_reconcile_for_later') {
-                draft.actionFetchState.saveForLaterFetch = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-            }
-            else if (reconcileAction === 'exclude') {
-                const excludeTransactionId = action.payload.excludeTransactionId;
-                const excludeFetchStates = draft.actionFetchState.excludeFetchById;
-                draft.actionFetchState.excludeFetchById = {
-                    ...excludeFetchStates,
-                    [excludeTransactionId]: {
-                        fetchState: 'In-Progress',
-                        error: undefined,
-                    },
-                };
-            }
-        },
-        saveReconciliationDetailFailure: (draft, action) => {
-            const { reconcileAction } = action.payload.fetchStateByAction;
-            const { error } = action.payload;
-            if (reconcileAction === 'reconcile') {
-                draft.actionFetchState.reconcileFetch = {
-                    fetchState: 'Error',
-                    error: error,
-                };
-            }
-            else if (reconcileAction === 'save_reconcile_for_later') {
-                draft.actionFetchState.saveForLaterFetch = {
-                    fetchState: 'Error',
-                    error: error,
-                };
-            }
-            else if (reconcileAction === 'exclude') {
-                const excludeTransactionId = action.payload.fetchStateByAction.excludeTransactionId;
-                const excludeFetchStates = draft.actionFetchState.excludeFetchById;
-                draft.actionFetchState.excludeFetchById = {
-                    ...excludeFetchStates,
-                    [excludeTransactionId]: {
-                        fetchState: 'Error',
-                        error: error,
-                    },
-                };
-            }
-        },
-        saveReconciliationDetailSuccess: (draft, action) => {
-            const { reconcileAction } = action.payload;
-            if (reconcileAction === 'reconcile') {
-                draft.actionFetchState.reconcileFetch = {
-                    fetchState: 'Completed',
-                    error: undefined,
-                };
-            }
-            else if (reconcileAction === 'save_reconcile_for_later') {
-                draft.actionFetchState.saveForLaterFetch = {
-                    fetchState: 'Completed',
-                    error: undefined,
-                };
-            }
-            else if (reconcileAction === 'exclude') {
-                const excludeTransactionId = action.payload.excludeTransactionId;
-                const excludeFetchStates = draft.actionFetchState.excludeFetchById;
-                draft.actionFetchState.excludeFetchById = {
-                    ...excludeFetchStates,
-                    [excludeTransactionId]: {
-                        fetchState: 'Completed',
-                        error: undefined,
-                    },
-                };
-            }
-        },
-        updateReconcileTabLocalData: (draft, action) => {
-            const { selectedTransactionIds } = action.payload;
-            draft.reconTabsState.reconcile.localData.selectedTransactionIds =
-                selectedTransactionIds;
-        },
-        updateBalancesLocalData: (draft, action) => {
-            const { clearedBalance, variance, payments, deposits, variancePercentage } = action.payload;
-            draft.reconTabsState.balances = {
-                clearedBalance,
-                variance,
-                variancePercentage,
-                payments: payments,
-                deposits: deposits,
-            };
-        },
-        updateSelectedAccountId: (draft, action) => {
-            draft.selectedAccountId = action.payload.selectedAccountId;
-        },
-        updateSelectedDrawerAccountId: (draft, action) => {
-            draft.selectedDrawerAccountId = action.payload.selectedDrawerAccountId;
-        },
-        updateStatementProcessingFailed: (draft, action) => {
-            const { accountId, selectedPeriod, statementProcessingFailed } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null) {
-                return;
-            }
-            accountRecon.statementProcessingFailed = statementProcessingFailed;
-            if (statementProcessingFailed === true) {
-                accountRecon.statementProcessingDismissedToBackground = false;
-                accountRecon.statementProcessingBackgroundCompletedSteps = 0;
-                accountRecon.statementProcessingStartedAtMs = undefined;
-                accountRecon.statementProcessingTotalDurationSeconds = undefined;
-                accountRecon.statementParseInProgress = false;
-            }
-        },
-        initialiseLocalDataForSelectedAccountId: () => { },
-        updateSelectedTab: (draft, action) => {
-            const { selectedTab } = action.payload;
-            draft.selectedTab = selectedTab;
-        },
-        updateReconcileTabListSortState: (draft, action) => {
-            draft.reconTabsState.reconcile.uiState = {
-                ...draft.reconTabsState.reconcile.uiState,
-                sortOrder: action.payload.sortOrder,
-                sortKey: action.payload.sortKey,
-            };
-        },
-        updateReviewTabSortState: (draft, action) => {
-            draft.reconTabsState.review.uiState = {
-                ...draft.reconTabsState.review.uiState,
-                sortOrder: action.payload.sortOrder,
-                sortKey: action.payload.sortKey,
-            };
-        },
-        updateReconcileTabListScrollState: (draft, action) => {
-            draft.reconTabsState.reconcile.uiState = {
-                ...draft.reconTabsState.reconcile.uiState,
-                scrollYOffset: action.payload.scrollYOffset,
-            };
-        },
-        updateReviewTabLocalData(draft, action) {
-            const { data, transactionId } = action.payload;
-            draft.reconTabsState.review.localData = {
-                ...draft.reconTabsState.review.localData,
-                [transactionId]: data,
-            };
-        },
-        saveReconciliationReview: {
-            reducer(draft, action) {
-                const { transactionId } = action.payload;
-                draft.actionFetchState.saveReconciliationReviewFetch[transactionId] = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-            },
-            prepare(transactionId) {
-                return {
-                    payload: {
-                        transactionId,
-                    },
-                };
-            },
-        },
-        updateSaveReconciliationReviewFetchStatus: (draft, action) => {
-            const { transactionId, error, fetchState } = action.payload;
-            draft.actionFetchState.saveReconciliationReviewFetch[transactionId] = {
-                fetchState: fetchState,
-                error,
-            };
-        },
-        initializeReconciliationReviewTabLocalData: {
-            reducer(draft, action) {
-                draft.reconTabsState.review.localData = action.payload.localData;
-            },
-            prepare(localData) {
-                return {
-                    payload: { localData },
-                };
-            },
-        },
-        updateReconListScrollPosition: (draft, action) => {
-            draft.reconListUIState.scrollPosition = action.payload.scrollPosition;
-        },
-        updateNodeCollapseState: (draft, action) => {
-            draft.reconListUIState.nodeCollapseState[action.payload.nodeId] =
-                action.payload.collapsed;
-        },
-        setConnectionInProgressForAccount: (draft, action) => {
-            if (draft.accountConnectionStatusByAccountID[action.payload.accountId] ==
-                null) {
-                console.error(`Account ${action.payload.accountId} not found to set connection in progress`);
-            }
-            else {
-                draft.accountConnectionStatusByAccountID[action.payload.accountId] = {
-                    ...draft.accountConnectionStatusByAccountID[action.payload.accountId],
-                    connectionInProgress: action.payload.connectionInProgress,
-                };
-            }
-        },
-        setStatementParseInProgress: (draft, action) => {
-            const { accountId, selectedPeriod, statementParseInProgress } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null) {
-                return;
-            }
-            accountRecon.statementParseInProgress = statementParseInProgress;
-        },
-        setStatementProcessingDismissedToBackground: (draft, action) => {
-            const { accountId, selectedPeriod, dismissedToBackground } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                accountRecon.statementProcessingDismissedToBackground =
-                    dismissedToBackground;
-                if (dismissedToBackground === true) {
-                    accountRecon.statementProcessingBackgroundCompletedSteps =
-                        action.payload.backgroundCompletedSteps ??
-                            accountRecon.statementProcessingBackgroundCompletedSteps;
-                    if (action.payload.startedAtMs != null) {
-                        accountRecon.statementProcessingStartedAtMs =
-                            action.payload.startedAtMs;
-                    }
-                    if (action.payload.totalDurationSeconds != null) {
-                        accountRecon.statementProcessingTotalDurationSeconds =
-                            action.payload.totalDurationSeconds;
-                    }
-                }
-            }
-        },
-        updateStatementProcessingBackgroundCompletedSteps: (draft, action) => {
-            const { accountId, selectedPeriod, backgroundCompletedSteps } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                if (backgroundCompletedSteps === 0) {
-                    accountRecon.statementProcessingBackgroundCompletedSteps = 0;
-                    accountRecon.statementProcessingStartedAtMs = undefined;
-                    accountRecon.statementProcessingTotalDurationSeconds = undefined;
-                }
-                else {
-                    accountRecon.statementProcessingBackgroundCompletedSteps = Math.max(accountRecon.statementProcessingBackgroundCompletedSteps ?? 0, backgroundCompletedSteps);
-                }
-            }
-        },
-        uploadAccountStatement: (draft, action) => {
-            const { accountId, selectedPeriod, statementAccountScope } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                accountRecon.statementUploadStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-                accountRecon.parsedStatementData = undefined;
-                accountRecon.statementParseStatus = {
-                    fetchState: 'Not-Started',
-                    error: undefined,
-                };
-                accountRecon.statementUpdateStatus = {
-                    fetchState: 'Not-Started',
-                    error: undefined,
-                };
-                accountRecon.statementProcessingDismissedToBackground = false;
-                accountRecon.statementProcessingBackgroundCompletedSteps = 0;
-                accountRecon.statementProcessingStartedAtMs = undefined;
-                accountRecon.statementProcessingTotalDurationSeconds = undefined;
-                accountRecon.statementProcessingFailed = false;
-                accountRecon.reparseStatementStatus = {
-                    fetchState: 'Not-Started',
-                    error: undefined,
-                };
-                accountRecon.combinedStatementGroupId = undefined;
-                accountRecon.confirmedCombinedStatementUploads = undefined;
-                accountRecon.confirmStatementMappingStatus = {
-                    fetchState: 'Not-Started',
-                    error: undefined,
-                };
-                accountRecon.confirmStatementMappingConflict = null;
-                if (accountRecon.localData != null) {
-                    accountRecon.localData.statementUpdateLocalDataByUploadId = undefined;
-                    accountRecon.localData.combinedStatementAccountMappings = undefined;
-                }
-                if (statementAccountScope != null) {
-                    accountRecon.localData = {
-                        ...accountRecon.localData,
-                        statementAccountScope,
-                    };
-                }
-            }
-        },
-        uploadAccountStatementSuccess: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null) {
-                return;
-            }
-            accountRecon.statementUploadStatus = {
-                fetchState: 'Completed',
-                error: undefined,
-            };
-            accountRecon.statementParseInProgress = true;
-        },
-        uploadAccountStatementFailure: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null) {
-                return;
-            }
-            accountRecon.statementUploadStatus = {
-                fetchState: 'Error',
-                error: action.payload.error,
-            };
-        },
-        deleteAccountStatement: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null) {
-                return;
-            }
-            accountRecon.statementDeleteStatus = {
-                fetchState: 'In-Progress',
-                error: undefined,
-            };
-            // Drop sticky parse latch on discard so the drawer shows empty upload UI.
-            accountRecon.statementParseInProgress = false;
-        },
-        deleteCombinedStatement: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null) {
-                return;
-            }
-            accountRecon.statementDeleteStatus = {
-                fetchState: 'In-Progress',
-                error: undefined,
-            };
-            accountRecon.statementParseInProgress = false;
-        },
-        deleteAccountStatementSuccess: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                accountRecon.statementDeleteStatus = {
-                    fetchState: 'Completed',
-                    error: undefined,
-                };
-                accountRecon.parsedStatementData = undefined;
-                accountRecon.statementParseInProgress = false;
-                // Reset in-flight parse/upload flags so the follow-up fetch cannot
-                // re-latch statementParseInProgress via In-Progress fetch states.
-                accountRecon.statementParseStatus = {
-                    fetchState: 'Not-Started',
-                    error: undefined,
-                };
-                accountRecon.reparseStatementStatus = {
-                    fetchState: 'Not-Started',
-                    error: undefined,
-                };
-                accountRecon.statementUploadStatus = {
-                    fetchState: 'Not-Started',
-                    error: undefined,
-                };
-                accountRecon.statementProcessingDismissedToBackground = false;
-                accountRecon.statementProcessingBackgroundCompletedSteps = 0;
-                accountRecon.statementProcessingStartedAtMs = undefined;
-                accountRecon.statementProcessingTotalDurationSeconds = undefined;
-                accountRecon.statementUpdateStatus = {
-                    fetchState: 'Not-Started',
-                    error: undefined,
-                };
-                accountRecon.combinedStatementGroupId = undefined;
-                accountRecon.confirmedCombinedStatementUploads = undefined;
-                // Statement delete removes the reconciliation server-side; drop the
-                // stale id so Pusher/follow-up fetches use account_id, not recon-id.
-                accountRecon.reconciliationId = undefined;
-                accountRecon.confirmStatementMappingStatus = {
-                    fetchState: 'Not-Started',
-                    error: undefined,
-                };
-                accountRecon.confirmStatementMappingConflict = null;
-                if (accountRecon.localData != null) {
-                    accountRecon.localData.statementUpdateLocalDataByUploadId = undefined;
-                    accountRecon.localData.combinedStatementAccountMappings = undefined;
-                    accountRecon.localData.statementAccountScope = undefined;
-                }
-            }
-        },
-        deleteAccountStatementFailure: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null) {
-                return;
-            }
-            accountRecon.statementDeleteStatus = {
-                fetchState: 'Error',
-                error: action.payload.error,
-            };
-        },
-        parseStatement: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                accountRecon.parsedStatementData = undefined;
-                accountRecon.statementParseStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-            }
-        },
-        parseCombinedStatement: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                accountRecon.parsedStatementData = undefined;
-                accountRecon.statementParseStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-            }
-        },
-        parseStatementSuccess: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null) {
-                return;
-            }
-            accountRecon.statementParseStatus = {
-                fetchState: 'Completed',
-                error: undefined,
-            };
-            accountRecon.statementParseInProgress = false;
-            accountRecon.statementProcessingFailed = false;
-            // Stop elapsed-time step simulation; keep dismissed flag so the
-            // app-level completion snackbar can still fire.
-            accountRecon.statementProcessingStartedAtMs = undefined;
-            accountRecon.statementProcessingTotalDurationSeconds = undefined;
-        },
-        parseStatementFailure: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null) {
-                return;
-            }
-            accountRecon.statementParseStatus = {
-                fetchState: 'Error',
-                error: action.payload.error,
-            };
-            accountRecon.statementParseInProgress = false;
-            accountRecon.statementProcessingFailed = true;
-        },
-        reparseStatement: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                accountRecon.parsedStatementData = undefined;
-                accountRecon.reparseStatementStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-                accountRecon.statementParseStatus = {
-                    fetchState: 'Not-Started',
-                    error: undefined,
-                };
-                accountRecon.statementUpdateStatus = {
-                    fetchState: 'Not-Started',
-                    error: undefined,
-                };
-                accountRecon.statementProcessingDismissedToBackground = false;
-                accountRecon.statementProcessingBackgroundCompletedSteps = 0;
-                accountRecon.statementProcessingStartedAtMs = undefined;
-                accountRecon.statementProcessingTotalDurationSeconds = undefined;
-                accountRecon.statementProcessingFailed = false;
-                accountRecon.statementParseInProgress = true;
-                if (accountRecon.localData != null) {
-                    accountRecon.localData.statementUpdateLocalDataByUploadId = undefined;
-                }
-            }
-        },
-        reparseStatementSuccess: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null) {
-                return;
-            }
-            accountRecon.reparseStatementStatus = {
-                fetchState: 'Completed',
-                error: undefined,
-            };
-            const parseFetchState = accountRecon.statementParseStatus.fetchState;
-            if (parseFetchState !== 'In-Progress' &&
-                parseFetchState !== 'Completed') {
-                accountRecon.statementParseStatus = {
-                    fetchState: 'Not-Started',
-                    error: undefined,
-                };
-            }
-            accountRecon.statementParseInProgress = true;
-            accountRecon.statementProcessingFailed = false;
-        },
-        reparseStatementFailure: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null) {
-                return;
-            }
-            accountRecon.reparseStatementStatus = {
-                fetchState: 'Error',
-                error: action.payload.error,
-            };
-            accountRecon.statementProcessingFailed = true;
-        },
-        resetReparseStatementStatus: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null) {
-                return;
-            }
-            accountRecon.reparseStatementStatus = {
-                fetchState: 'Not-Started',
-                error: undefined,
-            };
-        },
-        updateParsedStatementData: (draft, action) => {
-            const { accountId, selectedPeriod, parsedStatementData } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null) {
-                return;
-            }
-            accountRecon.parsedStatementData = parsedStatementData;
-        },
-        updateStatementUpdateLocalData: (draft, action) => {
-            const { accountId, selectedPeriod, statementUpdateLocalData, statementUploadId, } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null || statementUploadId === '') {
-                return;
-            }
-            if (accountRecon.localData == null) {
-                accountRecon.localData = {};
-            }
-            accountRecon.localData.statementUpdateLocalDataByUploadId = {
-                ...accountRecon.localData.statementUpdateLocalDataByUploadId,
-                [statementUploadId]: statementUpdateLocalData,
-            };
-        },
-        submitStatementUpdate: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                accountRecon.statementUpdateStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-                // Clear any stale date conflict from a previous attempt.
-                accountRecon.statementDateConflict = null;
-            }
-        },
-        submitCombinedStatementUpdate: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                accountRecon.statementUpdateStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-                accountRecon.statementDateConflict = null;
-            }
-        },
-        submitStatementUpdateSuccess: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                accountRecon.statementUpdateStatus = {
-                    fetchState: 'Completed',
-                    error: undefined,
-                };
-                accountRecon.statementDateConflict = null;
-                accountRecon.statementProcessingDismissedToBackground = false;
-                accountRecon.statementProcessingBackgroundCompletedSteps = 0;
-                accountRecon.statementProcessingStartedAtMs = undefined;
-                accountRecon.statementProcessingTotalDurationSeconds = undefined;
-                if (accountRecon.localData != null) {
-                    accountRecon.localData.statementUpdateLocalDataByUploadId = undefined;
-                }
-            }
-        },
-        submitStatementUpdateFailure: (draft, action) => {
-            const { accountId, selectedPeriod, dateConflict } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                accountRecon.statementUpdateStatus = {
-                    fetchState: 'Error',
-                    error: action.payload.error,
-                };
-                accountRecon.statementDateConflict = dateConflict ?? null;
-            }
-        },
-        clearStatementDateConflict: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                accountRecon.statementDateConflict = null;
-            }
-        },
-        confirmStatementMapping: (draft, action) => {
-            const { accountId, selectedPeriod } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                accountRecon.confirmStatementMappingStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-                accountRecon.confirmStatementMappingConflict = null;
-            }
-        },
-        confirmStatementMappingSuccess: (draft, action) => {
-            const { accountId, selectedPeriod, statementUploads } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                accountRecon.confirmStatementMappingStatus = {
-                    fetchState: 'Completed',
-                    error: undefined,
-                };
-                accountRecon.confirmStatementMappingConflict = null;
-                accountRecon.confirmedCombinedStatementUploads = statementUploads;
-                if (accountRecon.localData != null) {
-                    accountRecon.localData.combinedStatementAccountMappings = undefined;
-                }
-                const combinedStatementDetails = accountRecon.parsedStatementData?.statementUpload
-                    .combinedStatementDetails;
-                if (combinedStatementDetails != null) {
-                    combinedStatementDetails.isMappingConfirmed = true;
-                }
-                const combinedStatementGroupId = combinedStatementDetails?.combinedStatementGroupId ??
-                    accountRecon.parsedStatementData?.statementUpload.statementMeta
-                        .combinedStatementGroupId;
-                if (combinedStatementGroupId != null &&
-                    combinedStatementGroupId !== '') {
-                    accountRecon.combinedStatementGroupId = combinedStatementGroupId;
-                }
-            }
-        },
-        confirmStatementMappingFailure: (draft, action) => {
-            const { accountId, selectedPeriod, mappingConflict } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon != null) {
-                accountRecon.confirmStatementMappingStatus = {
-                    fetchState: 'Error',
-                    error: action.payload.error,
-                };
-                accountRecon.confirmStatementMappingConflict = mappingConflict ?? null;
-            }
-        },
-        updateAccountReconciliationLocalData: (draft, action) => {
-            const { accountId, selectedPeriod, localData } = action.payload;
-            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-            if (accountRecon == null) {
-                return;
-            }
-            const oldLocalData = accountRecon.localData;
-            if (oldLocalData == null) {
-                accountRecon.localData = localData;
-            }
-            else {
-                accountRecon.localData = {
-                    ...oldLocalData,
-                    ...localData,
-                };
-            }
-            accountRecon.localData = {
-                ...oldLocalData,
-                ...localData,
-            };
-        },
-        excludeAccountFromReconciliation: {
-            reducer(draft) {
-                draft.actionFetchState.excludeAccountFetch = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-            },
-            prepare(payload) {
-                return { payload };
-            },
-        },
-        excludeAccountFromReconciliationSuccess: (draft, action) => {
-            draft.actionFetchState.excludeAccountFetch = {
-                fetchState: 'Completed',
-                error: undefined,
-            };
-            const { account, selectedPeriod } = action.payload;
-            if (account != null) {
-                if (!draft.excludedAccountIDs.includes(account.account_id)) {
-                    draft.excludedAccountIDs.push(account.account_id);
-                }
-                updateExcludedAccountExclusionInfo(draft, account);
-                const monthYearPeriodId = (0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod);
-                if (draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId]
-                    ?.accountIDs != null) {
-                    draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId].accountIDs = draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId].accountIDs.filter((id) => id !== account.account_id);
-                }
-            }
-        },
-        excludeAccountFromReconciliationFailure: (draft, action) => {
-            draft.actionFetchState.excludeAccountFetch = {
-                fetchState: 'Error',
-                error: action.payload.error,
-            };
-        },
-        includeAccountInReconciliation: {
-            reducer(draft) {
-                draft.actionFetchState.includeAccountFetch = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-            },
-            prepare(payload) {
-                return { payload };
-            },
-        },
-        includeAccountInReconciliationSuccess: (draft, action) => {
-            draft.actionFetchState.includeAccountFetch = {
-                fetchState: 'Completed',
-                error: undefined,
-            };
-            const { reconciliation, selectedPeriod } = action.payload;
-            if (reconciliation == null) {
-                return;
-            }
-            const accountId = reconciliation.account_id;
-            draft.excludedAccountIDs = draft.excludedAccountIDs.filter((id) => id !== accountId);
-            delete draft.excludedAccountExclusionInfo[accountId];
-            const monthYearPeriodId = (0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod);
-            const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId];
-            if (accountReconciliationRecords != null) {
-                if (!accountReconciliationRecords.accountIDs.includes(accountId)) {
-                    accountReconciliationRecords.accountIDs.push(accountId);
-                }
-                // put this in a function
-                updateReconciliationByAccountIDOnIncludeAccount(draft, accountId, reconciliation, monthYearPeriodId);
-            }
-            draft.accountConnectionStatusByAccountID[accountId] = {
-                status: (0, accountReconState_1.toBankStatusCodeType)(reconciliation.bank_status.code),
-                connectionInProgress: false,
-                paymentAccountId: undefined,
-            };
-        },
-        includeAccountInReconciliationFailure: (draft, action) => {
-            draft.actionFetchState.includeAccountFetch = {
-                fetchState: 'Error',
-                error: action.payload.error,
-            };
-        },
-        updateStatementUploadChosen: (draft, action) => {
-            draft.statementUploadChosen = action.payload.statementUploadChosen;
-        },
-        clearExpenseAutomationReconciliationView: (draft) => {
-            Object.assign(draft, exports.initialState);
-        },
-    },
-    extraReducers: (builder) => {
-        builder.addCase(rootActions_1.clearAll, (draft) => {
-            Object.assign(draft, exports.initialState);
-        });
-    },
-});
-// Export actions
-_a = expenseAutomationReconciliationView.actions, exports.fetchReconciliation = _a.fetchReconciliation, exports.fetchReconciliationFailure = _a.fetchReconciliationFailure, exports.fetchReconciliationSuccess = _a.fetchReconciliationSuccess, exports.saveReconciliationDetail = _a.saveReconciliationDetail, exports.saveReconciliationDetailFailure = _a.saveReconciliationDetailFailure, exports.updateSelectedAccountId = _a.updateSelectedAccountId, exports.setConnectionInProgressForAccount = _a.setConnectionInProgressForAccount, exports.setStatementParseInProgress = _a.setStatementParseInProgress, exports.setStatementProcessingDismissedToBackground = _a.setStatementProcessingDismissedToBackground, exports.updateStatementProcessingBackgroundCompletedSteps = _a.updateStatementProcessingBackgroundCompletedSteps, exports.updateReconcileTabLocalData = _a.updateReconcileTabLocalData, exports.updateReconcileTabListSortState = _a.updateReconcileTabListSortState, exports.updateReconcileTabListScrollState = _a.updateReconcileTabListScrollState, exports.saveReconciliationDetailSuccess = _a.saveReconciliationDetailSuccess, exports.updateSelectedTab = _a.updateSelectedTab, exports.updateBalancesLocalData = _a.updateBalancesLocalData, exports.initialiseLocalDataForSelectedAccountId = _a.initialiseLocalDataForSelectedAccountId, exports.clearExpenseAutomationReconciliationView = _a.clearExpenseAutomationReconciliationView, exports.updateSelectedDrawerAccountId = _a.updateSelectedDrawerAccountId, exports.updateStatementProcessingFailed = _a.updateStatementProcessingFailed, exports.updateReviewTabSortState = _a.updateReviewTabSortState, exports.initializeReconciliationReviewTabLocalData = _a.initializeReconciliationReviewTabLocalData, exports.updateReviewTabLocalData = _a.updateReviewTabLocalData, exports.saveReconciliationReview = _a.saveReconciliationReview, exports.updateSaveReconciliationReviewFetchStatus = _a.updateSaveReconciliationReviewFetchStatus, exports.updateReconListScrollPosition = _a.updateReconListScrollPosition, exports.updateAccountReconciliationLocalData = _a.updateAccountReconciliationLocalData, exports.deleteAccountStatement = _a.deleteAccountStatement, exports.deleteCombinedStatement = _a.deleteCombinedStatement, exports.deleteAccountStatementSuccess = _a.deleteAccountStatementSuccess, exports.deleteAccountStatementFailure = _a.deleteAccountStatementFailure, exports.excludeAccountFromReconciliation = _a.excludeAccountFromReconciliation, exports.excludeAccountFromReconciliationSuccess = _a.excludeAccountFromReconciliationSuccess, exports.excludeAccountFromReconciliationFailure = _a.excludeAccountFromReconciliationFailure, exports.includeAccountInReconciliation = _a.includeAccountInReconciliation, exports.includeAccountInReconciliationSuccess = _a.includeAccountInReconciliationSuccess, exports.includeAccountInReconciliationFailure = _a.includeAccountInReconciliationFailure, exports.uploadAccountStatement = _a.uploadAccountStatement, exports.uploadAccountStatementSuccess = _a.uploadAccountStatementSuccess, exports.uploadAccountStatementFailure = _a.uploadAccountStatementFailure, exports.parseStatement = _a.parseStatement, exports.parseCombinedStatement = _a.parseCombinedStatement, exports.parseStatementSuccess = _a.parseStatementSuccess, exports.parseStatementFailure = _a.parseStatementFailure, exports.reparseStatement = _a.reparseStatement, exports.reparseStatementSuccess = _a.reparseStatementSuccess, exports.reparseStatementFailure = _a.reparseStatementFailure, exports.resetReparseStatementStatus = _a.resetReparseStatementStatus, exports.updateParsedStatementData = _a.updateParsedStatementData, exports.updateStatementUpdateLocalData = _a.updateStatementUpdateLocalData, exports.submitStatementUpdate = _a.submitStatementUpdate, exports.submitCombinedStatementUpdate = _a.submitCombinedStatementUpdate, exports.submitStatementUpdateSuccess = _a.submitStatementUpdateSuccess, exports.submitStatementUpdateFailure = _a.submitStatementUpdateFailure, exports.clearStatementDateConflict = _a.clearStatementDateConflict, exports.confirmStatementMapping = _a.confirmStatementMapping, exports.confirmStatementMappingSuccess = _a.confirmStatementMappingSuccess, exports.confirmStatementMappingFailure = _a.confirmStatementMappingFailure, exports.updateStatementUploadChosen = _a.updateStatementUploadChosen, exports.updateNodeCollapseState = _a.updateNodeCollapseState;
-// Export reducer
-exports.default = expenseAutomationReconciliationView.reducer;
-function isEntityStatementParsing(reconciliation) {
-    return reconciliation.statement_data_status?.code === 'parsing';
-}
-/** Entity no longer in an active parse — client latch should clear. */
-function isEntityStatementParseTerminal(reconciliation) {
-    const statusCode = reconciliation.statement_data_status?.code;
-    return (statusCode === 'processed' ||
-        statusCode === 'validated' ||
-        statusCode === 'parsing_failed' ||
-        statusCode === 'validation_failed' ||
-        statusCode === 'processing_failed' ||
-        statusCode === 'parsed_awaiting_mapping' ||
-        statusCode === 'deleting' ||
-        statusCode === 'deleted');
-}
-function resolveStatementParseInProgressAfterFetch(oldRecord, reconciliation) {
-    if (isEntityStatementParsing(reconciliation)) {
-        return true;
-    }
-    // Keep latch while client upload/parse/reparse is actively in flight, even if
-    // entity already looks terminal (e.g. V3 parseStatement GET still loading).
-    if (oldRecord?.statementParseStatus.fetchState === 'In-Progress') {
-        return true;
-    }
-    if (oldRecord?.reparseStatementStatus.fetchState === 'In-Progress') {
-        return true;
-    }
-    if (oldRecord?.statementUploadStatus.fetchState === 'In-Progress') {
-        return true;
-    }
-    // Reparse POST returned; async parse may not be on entity yet (entity can
-    // still show the previous processed status).
-    if (oldRecord?.reparseStatementStatus.fetchState === 'Completed' &&
-        oldRecord.statementParseStatus.fetchState !== 'Completed' &&
-        oldRecord.statementParseStatus.fetchState !== 'Error') {
-        return true;
-    }
-    // Entity reports parse finished and no client request is in flight — clear
-    // sticky latch. Critical for V1 (no parseStatement) after Pusher refresh.
-    if (isEntityStatementParseTerminal(reconciliation)) {
-        return false;
-    }
-    if (oldRecord?.statementParseInProgress === true) {
-        return true;
-    }
-    // Continue-in-background while parse flow has not finished.
-    if (oldRecord?.statementProcessingDismissedToBackground === true &&
-        oldRecord.statementParseStatus.fetchState !== 'Completed' &&
-        oldRecord.statementParseStatus.fetchState !== 'Error' &&
-        (oldRecord.statementProcessingBackgroundCompletedSteps ?? 0) > 0) {
-        return true;
-    }
-    return false;
-}
-function preserveStatementUploadStatusAfterFetch(oldRecord) {
-    const oldUploadStatus = oldRecord?.statementUploadStatus;
-    if (oldUploadStatus?.fetchState === 'In-Progress') {
-        return oldUploadStatus;
-    }
-    const parseFetchState = oldRecord?.statementParseStatus.fetchState;
-    if (oldUploadStatus?.fetchState === 'Completed' &&
-        parseFetchState !== 'Completed' &&
-        parseFetchState !== 'Error') {
-        return oldUploadStatus;
-    }
-    return { fetchState: 'Not-Started', error: undefined };
-}
-function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliationData, refreshViewInBackground, excludedAccounts, summary) {
-    draft.excludedAccountIDs = excludedAccounts.map((ea) => ea.account_id);
-    draft.excludedAccountExclusionInfo = {};
-    excludedAccounts.forEach((ea) => {
-        const { exclusion_info } = ea;
-        draft.excludedAccountExclusionInfo[ea.account_id] = {
-            bankBalance: exclusion_info.bank_balance != null
-                ? {
-                    amount: exclusion_info.bank_balance,
-                    currencyCode: ea.currency_code ?? 'USD',
-                    currencySymbol: ea.currency_symbol ?? '$',
-                }
-                : undefined,
-            clearedBalance: exclusion_info.cleared_balance != null
-                ? {
-                    amount: exclusion_info.cleared_balance,
-                    currencyCode: ea.currency_code ?? 'USD',
-                    currencySymbol: ea.currency_symbol ?? '$',
-                }
-                : undefined,
-            variance: exclusion_info.variance != null
-                ? {
-                    amount: exclusion_info.variance,
-                    currencyCode: ea.currency_code ?? 'USD',
-                    currencySymbol: ea.currency_symbol ?? '$',
-                }
-                : undefined,
-        };
-    });
-    const oldReconciliationByAccountID = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID ?? {};
-    draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = {
-        accountIDs: [],
-        reconciliationByAccountID: {},
-    };
-    const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)];
-    reconciliationData.forEach((reconciliation) => {
-        const account = accounts.find((account) => account.account_id === reconciliation.account_id);
-        const oldConnectionStatus = draft.accountConnectionStatusByAccountID[reconciliation.account_id];
-        if (oldConnectionStatus == null) {
-            draft.accountConnectionStatusByAccountID[reconciliation.account_id] = {
-                status: (0, accountReconState_1.toBankStatusCodeType)(reconciliation.bank_status.code),
-                connectionInProgress: false,
-                paymentAccountId: account?.payment_account_id ?? undefined,
-            };
-        }
-        else {
-            draft.accountConnectionStatusByAccountID[reconciliation.account_id] = {
-                status: (0, accountReconState_1.toBankStatusCodeType)(reconciliation.bank_status.code),
-                connectionInProgress: reconciliation.bank_status.code === 'not_connected' &&
-                    oldConnectionStatus.connectionInProgress === true,
-                paymentAccountId: account?.payment_account_id ?? undefined,
-            };
-        }
-        const oldRecord = oldReconciliationByAccountID[reconciliation.account_id];
-        accountReconciliationRecords.reconciliationByAccountID[reconciliation.account_id] = {
-            accountId: reconciliation.account_id,
-            reconciliationId: reconciliation.reconciliation_id ?? undefined,
-            // Full list fetch does not load transactions; keep per-account detail
-            // fetch status so an in-flight/completed review load is not reset to
-            // Not-Started (review UI treats that as loading).
-            transactionFetchState: oldRecord?.transactionFetchState ?? {
-                fetchState: 'Not-Started',
-                error: undefined,
-            },
-            refreshStatus: { fetchState: 'Not-Started', error: undefined },
-            statementDeleteStatus: { fetchState: 'Not-Started', error: undefined },
-            statementUploadStatus: preserveStatementUploadStatusAfterFetch(oldRecord),
-            statementUpdateStatus: oldRecord?.statementUpdateStatus ?? {
-                fetchState: 'Not-Started',
-                error: undefined,
-            },
-            statementParseInProgress: resolveStatementParseInProgressAfterFetch(oldRecord, reconciliation),
-            statementProcessingDismissedToBackground: oldRecord?.statementProcessingDismissedToBackground ?? false,
-            statementProcessingBackgroundCompletedSteps: oldRecord?.statementProcessingBackgroundCompletedSteps ?? 0,
-            statementProcessingStartedAtMs: oldRecord?.statementProcessingStartedAtMs,
-            statementProcessingTotalDurationSeconds: oldRecord?.statementProcessingTotalDurationSeconds,
-            statementProcessingFailed: oldRecord?.statementProcessingFailed ?? false,
-            statementParseStatus: oldRecord?.statementParseStatus ?? {
-                fetchState: 'Not-Started',
-                error: undefined,
-            },
-            reparseStatementStatus: oldRecord?.reparseStatementStatus ?? {
-                fetchState: 'Not-Started',
-                error: undefined,
-            },
-            statementDateConflict: oldRecord?.statementDateConflict ?? null,
-            confirmStatementMappingStatus: oldRecord?.confirmStatementMappingStatus ?? {
-                fetchState: 'Not-Started',
-                error: undefined,
-            },
-            confirmStatementMappingConflict: oldRecord?.confirmStatementMappingConflict ?? null,
-            confirmedCombinedStatementUploads: oldRecord?.confirmedCombinedStatementUploads,
-            combinedStatementGroupId: oldRecord?.combinedStatementGroupId,
-            localData: {
-                ...oldRecord?.localData,
-                accountSource: account?.reconciliation_source != null
-                    ? (0, accountState_1.toReconciliationAccountSource)(account.reconciliation_source)
-                    : oldRecord?.localData?.accountSource,
-            },
-            accountDetectionReason: account?.detection_info != null && account.detection_reason != null
-                ? account.detection_reason
-                : undefined,
-            parsedStatementData: oldRecord?.parsedStatementData,
-        };
-        accountReconciliationRecords.accountIDs.push(reconciliation.account_id);
-    });
-    if (refreshViewInBackground === true) {
-        draft.refreshStatus = {
-            fetchState: 'Completed',
-            error: undefined,
-        };
-    }
-    else {
-        draft.fetchState = 'Completed';
-        draft.error = undefined;
-    }
-    if (summary !== undefined) {
-        draft.summary =
-            summary != null ? (0, reconciliationPayload_1.toReconciliationViewSummary)(summary) : undefined;
-    }
-}
-function updateReconciliationByAccountID(draft, accounts, selectedPeriod, accountId, reconciliationData, refreshViewInBackground) {
-    const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]?.reconciliationByAccountID[accountId];
-    if (accountRecon == null) {
-        return;
-    }
-    const oldConnectionStatus = draft.accountConnectionStatusByAccountID[accountId];
-    draft.accountConnectionStatusByAccountID[accountId] = {
-        status: (0, accountReconState_1.toBankStatusCodeType)(reconciliationData.bank_status.code),
-        connectionInProgress: oldConnectionStatus != null
-            ? reconciliationData.bank_status.code === 'not_connected' &&
-                oldConnectionStatus.connectionInProgress === true
-            : false,
-        paymentAccountId: accounts.payment_account_id ?? undefined,
-    };
-    const statementParseInProgress = resolveStatementParseInProgressAfterFetch(accountRecon, reconciliationData);
-    accountRecon.reconciliationId =
-        reconciliationData.reconciliation_id ?? undefined;
-    accountRecon.statementParseInProgress = statementParseInProgress;
-    if (refreshViewInBackground === true) {
-        accountRecon.refreshStatus = { fetchState: 'Completed', error: undefined };
-    }
-    else {
-        accountRecon.transactionFetchState = {
-            fetchState: 'Completed',
-            error: undefined,
-        };
-    }
-}
-const updateExcludedAccountExclusionInfo = (draft, account) => {
-    draft.excludedAccountExclusionInfo[account.account_id] = {
-        bankBalance: account.bank_balance != null
-            ? {
-                amount: account.bank_balance,
-                currencyCode: account.currency_code ?? 'USD',
-                currencySymbol: account.currency_symbol ?? '$',
-            }
-            : undefined,
-        clearedBalance: account.cleared_balance != null
-            ? {
-                amount: account.cleared_balance,
-                currencyCode: account.currency_code ?? 'USD',
-                currencySymbol: account.currency_symbol ?? '$',
-            }
-            : undefined,
-        variance: account.variance != null
-            ? {
-                amount: account.variance,
-                currencyCode: account.currency_code ?? 'USD',
-                currencySymbol: account.currency_symbol ?? '$',
-            }
-            : undefined,
-    };
-};
-const updateReconciliationByAccountIDOnIncludeAccount = (draft, accountId, reconciliation, monthYearPeriodId) => {
-    const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId];
-    if (accountReconciliationRecords == null) {
-        return;
-    }
-    accountReconciliationRecords.reconciliationByAccountID[accountId] = {
-        accountId,
-        reconciliationId: reconciliation.reconciliation_id ?? undefined,
-        transactionFetchState: { fetchState: 'Not-Started', error: undefined },
-        refreshStatus: { fetchState: 'Not-Started', error: undefined },
-        statementDeleteStatus: { fetchState: 'Not-Started', error: undefined },
-        statementUploadStatus: { fetchState: 'Not-Started', error: undefined },
-        statementUpdateStatus: { fetchState: 'Not-Started', error: undefined },
-        statementParseInProgress: reconciliation.bank_status.code === 'parsing',
-        statementProcessingDismissedToBackground: false,
-        statementProcessingBackgroundCompletedSteps: 0,
-        statementProcessingFailed: false,
-        statementParseStatus: { fetchState: 'Not-Started', error: undefined },
-        reparseStatementStatus: { fetchState: 'Not-Started', error: undefined },
-        statementDateConflict: null,
-        confirmStatementMappingStatus: {
-            fetchState: 'Not-Started',
-            error: undefined,
-        },
-        confirmStatementMappingConflict: null,
-        localData: {},
-        accountDetectionReason: undefined,
-    };
-};