@zeniai/client-epic-state 5.1.19 → 5.1.20-betaDI1

package/lib/esm/view/expenseAutomationView/reducers/transactionsViewReducer.js

@@ -1,1058 +0,0 @@
-import { createSlice } from '@reduxjs/toolkit';
-import recordGet from 'lodash/get';
-import uniq from 'lodash/uniq';
-import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
-import { isVendorTransaction } from '../../../entity/transaction/stateTypes/vendorTransaction';
-import { filterAutoTabLineItems, mergeTabSpecificLineItems, removeTransactionFromTabView, setEntityRecommendationForLineIdInLocalData, shouldAutoSelectAndAdd, toSetAllLineItemsToCategoryClass, toTransactionDetailLocalData, } from '../helpers/transactionCategorizationLocalDataHelper';
-import { DEFAULT_COMPLETED_SUB_TAB, } from '../types/completedSubTab';
-import { TRANSACTIONS_TABS, } from '../types/transactionsViewState';
-export const initialTransactionTabViewState = {
-    saveStatus: {
-        fetchState: 'Not-Started',
-        error: undefined,
-    },
-    refreshStatus: {
-        fetchState: 'Not-Started',
-        error: undefined,
-    },
-    markAsNotMiscategorizedStatus: {
-        fetchState: 'Not-Started',
-        error: undefined,
-    },
-    uiState: {
-        sortKey: 'date',
-        sortOrder: 'descending',
-        searchString: '',
-        nodeCollapseState: {},
-        scrollPosition: { scrollTop: 0, scrollLeft: undefined },
-        pageToken: null,
-        totalCount: {},
-        limit: 10,
-    },
-    filters: {
-        categoryCombinationOperator: 'AND',
-        categories: [],
-    },
-    fetchState: 'Not-Started',
-    error: undefined,
-    hasValidState() {
-        return this.fetchState == 'Completed';
-    },
-    transactionReviewLocalDataById: {},
-    transactionIdsBySelectedPeriod: {},
-    selectedCheckBoxTransactionIds: [],
-    transactionIdsWithUnsavedData: [],
-    uploadReceiptStatusById: {},
-    selectedTransactionId: undefined,
-    selectedTransactionLineId: undefined,
-};
-export const initialState = {
-    autoCategorizedSubTabCache: {},
-    parentTotalCountByTab: {
-        review: {},
-        autoCategorized: {},
-    },
-    selectedTransactionCategorizationTab: 'review',
-    selectedTransactionCategorizationCompletedSubTab: DEFAULT_COMPLETED_SUB_TAB,
-    transactionCategorizationView: {
-        review: { ...initialTransactionTabViewState },
-        autoCategorized: { ...initialTransactionTabViewState },
-    },
-};
-/**
- * Capture the autoCategorized tab's current paginated dataset for a sub-tab.
- * The mid-flight `'In-Progress'` state is normalised to `'Completed'` because
- * the in-flight request is cancelled by `switchMap` in the fetch epic when the
- * sub-tab changes — restoring `'In-Progress'` later would leave the UI stuck
- * showing a phantom loading state with no fetch actually running. Length-zero
- * datasets degrade to `'Not-Started'` so the next visit triggers a fresh
- * fetch from page 1 instead of short-circuiting on stale empty caches.
- *
- * Snapshot scope (deliberately narrow):
- * - Captured: `pageToken`, `totalCount`, `transactionIdsBySelectedPeriod`,
- *   `fetchState`, `error`, `scrollPosition`. The first five are the keys the
- *   fetch epic's cache check reads to decide whether to short-circuit a
- *   sub-tab revisit; `scrollPosition` is captured per sub-tab so revisiting
- *   restores the user's last offset and switching to a never-visited sub-tab
- *   starts at the top instead of inheriting the outgoing sub-tab's offset
- *   (which would land the user at a meaningless row index against a
- *   completely different list).
- * - Intentionally NOT captured (left in place on `autoCat` and inherited by
- *   the incoming sub-tab):
- *     - `uiState.searchString`, `uiState.sortKey`, `uiState.sortOrder`,
- *       `uiState.nodeCollapseState`, `uiState.limit` — search and sort are
- *       user-applied preferences that persist across sub-tabs by design (a
- *       search query stays active when the user toggles between Manual / AI
- *       Accountant).
- *     - `selectedCheckBoxTransactionIds` — selection state is intentionally
- *       cleared at the action source (the fetch epic / save flow), not
- *       by the snapshot path. Carrying selection across sub-tabs is safe
- *       because every sub-tab change goes through a fetch round-trip that
- *       reconciles selection against the new row IDs.
- *     - `transactionReviewLocalDataById`, `transactionIdsWithUnsavedData`,
- *       `uploadReceiptStatusById`, `saveStatus`, `refreshStatus`,
- *       `markAsNotMiscategorizedStatus` — these are per-row / per-flight
- *       caches that are write-through global state, not sub-tab-scoped.
- *
- * If the contract changes (e.g. selection should reset on every sub-tab
- * switch), update both this comment and the snapshot return shape together.
- */
-function snapshotAutoCategorizedTab(autoCat) {
-    const transactionIdsBySelectedPeriod = {
-        ...autoCat.transactionIdsBySelectedPeriod,
-    };
-    const hasAnyLoadedRows = Object.values(transactionIdsBySelectedPeriod).some((ids) => ids.length > 0);
-    let normalisedFetchState = autoCat.fetchState;
-    if (normalisedFetchState === 'In-Progress') {
-        normalisedFetchState = hasAnyLoadedRows ? 'Completed' : 'Not-Started';
-    }
-    return {
-        error: autoCat.error,
-        fetchState: normalisedFetchState,
-        pageToken: autoCat.uiState.pageToken,
-        scrollPosition: autoCat.uiState.scrollPosition,
-        totalCount: { ...autoCat.uiState.totalCount },
-        transactionIdsBySelectedPeriod,
-    };
-}
-const expenseAutomationTransactionsView = createSlice({
-    name: 'expenseAutomationTransactionsView',
-    initialState,
-    reducers: {
-        fetchTransactionCategorizationView: {
-            prepare(selectedTab, period, cacheOverride = false, keepExistingListItems = false, searchString, // when this is defined the output should go to search result IDs
-            pageToken, refreshViewInBackground = false, resetListItems = false, isUncategorizedExpenseCategoryEnabled) {
-                return {
-                    payload: {
-                        selectedTab,
-                        period,
-                        searchString,
-                        keepExistingListItems,
-                        pageToken,
-                        cacheOverride,
-                        refreshViewInBackground,
-                        resetListItems,
-                        isUncategorizedExpenseCategoryEnabled,
-                    },
-                };
-            },
-            reducer() {
-                // do nothing
-            },
-        },
-        fetchTransactionCategorization: {
-            reducer(draft, action) {
-                const { refreshViewInBackground, resetListItems, selectedTab, pageToken, searchString, period, } = action.payload;
-                if (refreshViewInBackground === true) {
-                    draft.transactionCategorizationView[selectedTab].refreshStatus = {
-                        fetchState: 'In-Progress',
-                        error: undefined,
-                    };
-                }
-                else {
-                    draft.transactionCategorizationView[selectedTab].fetchState =
-                        'In-Progress';
-                    draft.transactionCategorizationView[selectedTab].error = undefined;
-                }
-                draft.transactionCategorizationView[selectedTab].uiState.pageToken =
-                    pageToken ?? null;
-                draft.transactionCategorizationView[selectedTab].uiState.searchString =
-                    searchString ?? '';
-                draft.transactionCategorizationView[selectedTab].error = undefined;
-                // Reset list when we change the sort order and fetch list again
-                if (resetListItems === true) {
-                    const monthYearPeriod = {
-                        month: period.start.month,
-                        year: period.start.year,
-                    };
-                    const transactionIdsBySelectedPeriod = draft.transactionCategorizationView[selectedTab]
-                        .transactionIdsBySelectedPeriod[toMonthYearPeriodId(monthYearPeriod)];
-                    transactionIdsBySelectedPeriod.forEach((transactionId) => {
-                        delete draft.transactionCategorizationView[selectedTab]
-                            .transactionReviewLocalDataById[transactionId];
-                    });
-                    draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds =
-                        draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds.filter((selectedCheckBoxTransactionId) => transactionIdsBySelectedPeriod.includes(selectedCheckBoxTransactionId));
-                    draft.transactionCategorizationView[selectedTab].transactionIdsBySelectedPeriod[toMonthYearPeriodId(monthYearPeriod)] = [];
-                    draft.transactionCategorizationView[selectedTab].refreshStatus = {
-                        fetchState: 'Not-Started',
-                        error: undefined,
-                    };
-                }
-            },
-            prepare(selectedTab, period, cacheOverride = false, keepExistingListItems = false, searchString, // when this is defined the output should go to search result IDs
-            pageToken, refreshViewInBackground = false, resetListItems, isUncategorizedExpenseCategoryEnabled) {
-                return {
-                    payload: {
-                        selectedTab,
-                        period,
-                        searchString,
-                        keepExistingListItems,
-                        pageToken,
-                        cacheOverride,
-                        refreshViewInBackground,
-                        resetListItems,
-                        isUncategorizedExpenseCategoryEnabled,
-                    },
-                };
-            },
-        },
-        initializeTransactionCategorizationViewLocalData: {
-            prepare(selectedTab, transactionIds, selectedPeriod, keepExistingListItems = false, pageToken, totalCount, lineItemsByTransactionIds, refreshViewInBackground = false, isUncategorizedExpenseCategoryEnabled) {
-                return {
-                    payload: {
-                        selectedTab,
-                        transactionIds,
-                        selectedPeriod,
-                        keepExistingListItems,
-                        pageToken,
-                        totalCount,
-                        lineItemsByTransactionIds,
-                        refreshViewInBackground,
-                        isUncategorizedExpenseCategoryEnabled,
-                    },
-                };
-            },
-            reducer() {
-                // do nothing
-            },
-        },
-        saveTransactionCategorizationLocalData(draft, action) {
-            const { keepExistingListItems, transactionIds, transactionLocalData, selectedPeriod, selectedTab, pageToken, totalCount, } = action.payload;
-            if (keepExistingListItems === false) {
-                draft.transactionCategorizationView[selectedTab].transactionIdsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)] =
-                    transactionIds;
-                draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [];
-                // Reset dirty transaction IDs on page load/refresh
-                draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData = [];
-            }
-            else {
-                const previousData = draft.transactionCategorizationView[selectedTab]
-                    .transactionIdsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)];
-                if (previousData == null) {
-                    draft.transactionCategorizationView[selectedTab].transactionIdsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)] = transactionIds;
-                }
-                else {
-                    const combinedData = uniq([...previousData, ...transactionIds]);
-                    draft.transactionCategorizationView[selectedTab].transactionIdsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)] = [...combinedData];
-                }
-            }
-            draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById = {
-                ...draft.transactionCategorizationView[selectedTab]
-                    .transactionReviewLocalDataById,
-                ...Object.fromEntries(Object.entries(transactionLocalData).map(([transactionId, newData]) => {
-                    const existingData = draft.transactionCategorizationView[selectedTab]
-                        .transactionReviewLocalDataById[transactionId];
-                    // If keepExistingListItems is false, preserve existing tabSpecificLineItems
-                    if (keepExistingListItems === false && existingData != null) {
-                        return [
-                            transactionId,
-                            {
-                                ...newData,
-                                transactionReviewLocalData: {
-                                    ...newData.transactionReviewLocalData,
-                                    tabSpecificLineItems: mergeTabSpecificLineItems(existingData.transactionReviewLocalData
-                                        .tabSpecificLineItems, selectedTab, newData.transactionReviewLocalData.tabSpecificLineItems),
-                                },
-                            },
-                        ];
-                    }
-                    return [transactionId, newData];
-                })),
-            };
-            if (action.payload.refreshViewInBackground === true) {
-                draft.transactionCategorizationView[selectedTab].refreshStatus = {
-                    fetchState: 'Completed',
-                    error: undefined,
-                };
-            }
-            else {
-                draft.transactionCategorizationView[selectedTab].fetchState =
-                    'Completed';
-                draft.transactionCategorizationView[selectedTab].error = undefined;
-            }
-            draft.transactionCategorizationView[selectedTab].uiState = {
-                ...draft.transactionCategorizationView[selectedTab].uiState,
-                pageToken: pageToken ?? null,
-            };
-            draft.transactionCategorizationView[selectedTab].uiState.totalCount[toMonthYearPeriodId(selectedPeriod)] = totalCount;
-        },
-        updateTransactionCategorizationUIState(draft, action) {
-            const selectedTab = action.payload.selectedTab;
-            const uiState = action.payload.uiState;
-            if (uiState.sortKey != null) {
-                draft.transactionCategorizationView[selectedTab].uiState.sortKey =
-                    uiState.sortKey;
-            }
-            if (uiState.sortOrder != null) {
-                draft.transactionCategorizationView[selectedTab].uiState.sortOrder =
-                    uiState.sortOrder;
-            }
-            if (uiState.searchString != null) {
-                draft.transactionCategorizationView[selectedTab].uiState.searchString =
-                    uiState.searchString;
-            }
-            if (uiState.scrollPosition != null) {
-                draft.transactionCategorizationView[selectedTab].uiState.scrollPosition = uiState.scrollPosition;
-            }
-            if (uiState.pageToken != null) {
-                draft.transactionCategorizationView[selectedTab].uiState.pageToken =
-                    uiState.pageToken;
-            }
-            if (uiState.totalCount != null) {
-                draft.transactionCategorizationView[selectedTab].uiState.totalCount =
-                    uiState.totalCount;
-            }
-        },
-        updateTransactionFilters(draft, action) {
-            const { selectedTab, filters } = action.payload;
-            // `filters` is non-nullable per the payload type, so no runtime
-            // null-check is needed — dropping it removes a dead defensive branch.
-            draft.transactionCategorizationView[selectedTab].filters = filters;
-        },
-        saveTransactionCategorization: {
-            prepare(selectedTab, transactionIds, cotTrackingByTransactionId, isUncategorizedExpenseCategoryEnabled) {
-                return {
-                    payload: {
-                        selectedTab,
-                        transactionIds,
-                        cotTrackingByTransactionId,
-                        isUncategorizedExpenseCategoryEnabled,
-                    },
-                };
-            },
-            reducer() {
-                // do nothing
-            },
-        },
-        updateCurrentSelectedTransactionCategorizationTab: {
-            reducer(draft, action) {
-                draft.selectedTransactionCategorizationTab =
-                    action.payload.newSelectedTab;
-            },
-            prepare(newSelectedTab) {
-                return { payload: { newSelectedTab } };
-            },
-        },
-        updateTransactionCategorizationCompletedSubTab: {
-            reducer(draft, action) {
-                const { newSubTab } = action.payload;
-                const previousSubTab = draft.selectedTransactionCategorizationCompletedSubTab;
-                if (previousSubTab === newSubTab) {
-                    return;
-                }
-                const autoCat = draft.transactionCategorizationView.autoCategorized;
-                // Snapshot the outgoing sub-tab so a future revisit can short-circuit
-                // the fetch epic (mirrors the parent-tab "don't refetch what's
-                // already cached" behaviour). Period-scoped data is preserved as-is
-                // because the snapshot itself is keyed only by sub-tab; the active
-                // tab's per-period maps remain the source of truth while live.
-                draft.autoCategorizedSubTabCache[previousSubTab] =
-                    snapshotAutoCategorizedTab(autoCat);
-                const cached = draft.autoCategorizedSubTabCache[newSubTab];
-                if (cached != null) {
-                    autoCat.uiState.pageToken = cached.pageToken;
-                    autoCat.uiState.totalCount = { ...cached.totalCount };
-                    autoCat.uiState.scrollPosition = cached.scrollPosition;
-                    autoCat.transactionIdsBySelectedPeriod = {
-                        ...cached.transactionIdsBySelectedPeriod,
-                    };
-                    autoCat.fetchState = cached.fetchState;
-                    autoCat.error = cached.error;
-                }
-                else {
-                    // Sub-tab has never been visited — clear the active slot so the
-                    // view-epic's `fetchState === 'Not-Started' || transactionIds.length
-                    // === 0` cache check falls through and triggers a fresh page-1
-                    // fetch for the new dataset. `scrollPosition` is reset to the top
-                    // so the incoming list isn't anchored to the outgoing sub-tab's
-                    // offset (different rows → previous offset is meaningless).
-                    autoCat.uiState.pageToken = null;
-                    autoCat.uiState.totalCount = {};
-                    autoCat.uiState.scrollPosition = {
-                        scrollTop: 0,
-                        scrollLeft: undefined,
-                    };
-                    autoCat.transactionIdsBySelectedPeriod = {};
-                    autoCat.fetchState = 'Not-Started';
-                    autoCat.error = undefined;
-                }
-                draft.selectedTransactionCategorizationCompletedSubTab = newSubTab;
-            },
-            prepare(newSubTab) {
-                return { payload: { newSubTab } };
-            },
-        },
-        updateTransactionCategorization: {
-            reducer(draft, action) {
-                const selectedTab = action.payload.selectedTab;
-                draft.transactionCategorizationView[selectedTab].saveStatus = {
-                    error: undefined,
-                    fetchState: 'In-Progress',
-                };
-            },
-            prepare(selectedTab, transactionIds, transactionSaveUpdates, cotTrackingByTransactionId, isUncategorizedExpenseCategoryEnabled) {
-                return {
-                    payload: {
-                        selectedTab,
-                        transactionIds,
-                        transactionSaveUpdates,
-                        cotTrackingByTransactionId,
-                        isUncategorizedExpenseCategoryEnabled,
-                    },
-                };
-            },
-        },
-        setAllItemsToCategoryClassInLocalDataForCategorization: {
-            reducer(draft, action) {
-                const { vendorId, customerId, selectedAccount, selectedClassBase, selectedProjectBase, transactions, transactionId, lineId, selectedTab, uncategorizedAccounts, isAccountingClassesEnabled, isUncategorizedExpenseCategoryEnabled, } = action.payload;
-                const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
-                    .transactionReviewLocalDataById, transactionId, undefined);
-                const existingAccount = transactionLocalData?.transactionReviewLocalData.lineItemById[lineId]
-                    .account;
-                if (transactionLocalData != null) {
-                    const newTransactionLocalData = {
-                        ...transactionLocalData.transactionReviewLocalData,
-                        lineItemById: {
-                            ...transactionLocalData.transactionReviewLocalData.lineItemById,
-                            [lineId]: {
-                                ...transactionLocalData.transactionReviewLocalData.lineItemById[lineId],
-                                account: selectedAccount,
-                                class: selectedClassBase,
-                                project: selectedProjectBase,
-                            },
-                        },
-                    };
-                    draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transactionId] = {
-                        transactionReviewLocalData: newTransactionLocalData,
-                        transactionId,
-                    };
-                    const selectedTransaction = transactions.find((transaction) => transaction.id === transactionId);
-                    const selectedCheckBoxTransactionIds = draft.transactionCategorizationView[selectedTab]
-                        .selectedCheckBoxTransactionIds;
-                    if (selectedTransaction != null &&
-                        shouldAutoSelectAndAdd(selectedTransaction, newTransactionLocalData, selectedCheckBoxTransactionIds, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled)) {
-                        draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
-                            ...selectedCheckBoxTransactionIds,
-                            transactionId,
-                        ];
-                    }
-                }
-                // Track dirty transaction IDs - always mark current transaction as dirty
-                const dirtyIds = [transactionId];
-                if (vendorId != null || customerId != null) {
-                    transactions.forEach((transaction) => {
-                        const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
-                            .transactionReviewLocalDataById, transaction.id, undefined);
-                        if (transactionLocalData != null) {
-                            const existingClassId = transactionLocalData.transactionReviewLocalData.lineItemById[lineId]?.class?.classId;
-                            const existingProjectId = transactionLocalData.transactionReviewLocalData.lineItemById[lineId]?.project?.projectId;
-                            const updatedItem = existingAccount?.accountId !== selectedAccount?.accountId
-                                ? 'category'
-                                : existingClassId !== selectedClassBase?.classId
-                                    ? 'class'
-                                    : existingProjectId !== selectedProjectBase?.projectId
-                                        ? 'project'
-                                        : 'class';
-                            const { localData, similarTransactionUpdated } = toSetAllLineItemsToCategoryClass(draft.transactionCategorizationView[selectedTab], transaction, transactionId, lineId, transactionLocalData.transactionReviewLocalData, updatedItem, uncategorizedAccounts, selectedTab, vendorId, customerId, selectedAccount, selectedClassBase, selectedProjectBase, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled);
-                            draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transaction.id] = {
-                                transactionId: transaction.id,
-                                transactionReviewLocalData: localData,
-                            };
-                            // Mark similar transaction as dirty only if it was actually updated
-                            if (similarTransactionUpdated) {
-                                dirtyIds.push(transaction.id);
-                            }
-                        }
-                    });
-                }
-                // Add all affected transaction IDs to dirty list
-                draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData = uniq([
-                    ...draft.transactionCategorizationView[selectedTab]
-                        .transactionIdsWithUnsavedData,
-                    ...dirtyIds,
-                ]);
-            },
-            prepare(selectedTab, transactionId, lineId, transactions, uncategorizedAccounts, vendorId, customerId, selectedAccount, selectedClassBase, lineEntity, recommendations, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled, selectedProjectBase) {
-                return {
-                    payload: {
-                        selectedTab,
-                        transactionId,
-                        lineId,
-                        transactions,
-                        vendorId,
-                        customerId,
-                        lineEntity,
-                        selectedAccount,
-                        selectedClassBase,
-                        selectedProjectBase,
-                        recommendations,
-                        uncategorizedAccounts,
-                        isAccountingClassesEnabled,
-                        isUncategorizedExpenseCategoryEnabled,
-                    },
-                };
-            },
-        },
-        setEntityRecommendationForLineIdsForCategorization: {
-            prepare(selectedTab, transactionId, transaction, lineIds, entity, amount, recommendationWithCOTByLineId, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled) {
-                return {
-                    payload: {
-                        selectedTab,
-                        transactionId,
-                        transaction,
-                        lineIds,
-                        entity,
-                        amount,
-                        recommendationWithCOTByLineId,
-                        uncategorizedAccounts,
-                        isAccountingClassesEnabled,
-                        isUncategorizedExpenseCategoryEnabled,
-                    },
-                };
-            },
-            reducer(draft, action) {
-                const { entity, transaction, transactionId, selectedTab, lineIds, uncategorizedAccounts, isAccountingClassesEnabled, isUncategorizedExpenseCategoryEnabled, } = action.payload;
-                const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
-                    .transactionReviewLocalDataById, transactionId.id, undefined);
-                if (transactionLocalData != null) {
-                    const newLocalData = setEntityRecommendationForLineIdInLocalData(draft.transactionCategorizationView[selectedTab], transaction, transactionLocalData.transactionReviewLocalData, entity, lineIds, uncategorizedAccounts, action.payload.recommendationWithCOTByLineId, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled);
-                    // Release the per-line fetch flag for every line this fetch
-                    // covered. Done in-place on the freshly returned local data
-                    // (the helper produces a new mutable object), before we write
-                    // it back to the draft.
-                    lineIds.forEach((lineId) => {
-                        const lineItem = newLocalData.lineItemById[lineId];
-                        if (lineItem != null) {
-                            newLocalData.lineItemById[lineId] = {
-                                ...lineItem,
-                                categoryClassRecommendationsFetchState: {
-                                    fetchState: 'Completed',
-                                    error: undefined,
-                                },
-                            };
-                        }
-                    });
-                    draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transaction.id] = {
-                        transactionId: transaction.id,
-                        transactionReviewLocalData: newLocalData,
-                    };
-                    // Mark transaction as dirty (autofill happened)
-                    if (!draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData.includes(transaction.id)) {
-                        draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData = [
-                            ...draft.transactionCategorizationView[selectedTab]
-                                .transactionIdsWithUnsavedData,
-                            transaction.id,
-                        ];
-                    }
-                }
-            },
-        },
-        // Start arm of the line-update recommendations fetch. Flips covered
-        // lines to In-Progress AND removes the transaction from
-        // selectedCheckBoxTransactionIds — the row is unchecked + disabled
-        // until either the success arm (recheck if limit allows) or the
-        // failure arm releases the per-line flag.
-        markCategoryClassRecommendationsInProgressForCategorization: {
-            reducer(draft, action) {
-                const { selectedTab, transactionId, lineIds } = action.payload;
-                const tab = draft.transactionCategorizationView[selectedTab];
-                const transactionLocalData = recordGet(tab.transactionReviewLocalDataById, transactionId.id, undefined);
-                if (transactionLocalData != null) {
-                    lineIds.forEach((lineId) => {
-                        const lineItem = transactionLocalData.transactionReviewLocalData.lineItemById[lineId];
-                        if (lineItem != null) {
-                            transactionLocalData.transactionReviewLocalData.lineItemById[lineId] = {
-                                ...lineItem,
-                                categoryClassRecommendationsFetchState: {
-                                    fetchState: 'In-Progress',
-                                    error: undefined,
-                                },
-                            };
-                        }
-                    });
-                }
-                // Uncheck on fetch start: the row's existing category/class are
-                // stale after a payee change, so we drop the auto-selection until
-                // fresh recommendations land.
-                if (tab.selectedCheckBoxTransactionIds.includes(transactionId.id)) {
-                    tab.selectedCheckBoxTransactionIds =
-                        tab.selectedCheckBoxTransactionIds.filter((id) => id !== transactionId.id);
-                }
-            },
-            prepare(selectedTab, transactionId, lineIds) {
-                return { payload: { selectedTab, transactionId, lineIds } };
-            },
-        },
-        // Completed arm. Used by the epic when the HTTP call succeeds but the
-        // server returned no per-line recommendations — we still need to
-        // release the In-Progress flag so the skeleton resolves. Successful
-        // responses with recommendations go through
-        // setEntityRecommendationForLineIdsForCategorization instead (which
-        // also flips the lines to Completed).
-        markCategoryClassRecommendationsCompletedForCategorization: {
-            reducer(draft, action) {
-                const { selectedTab, transactionId, lineIds } = action.payload;
-                const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
-                    .transactionReviewLocalDataById, transactionId.id, undefined);
-                if (transactionLocalData != null) {
-                    lineIds.forEach((lineId) => {
-                        const lineItem = transactionLocalData.transactionReviewLocalData.lineItemById[lineId];
-                        if (lineItem != null) {
-                            transactionLocalData.transactionReviewLocalData.lineItemById[lineId] = {
-                                ...lineItem,
-                                categoryClassRecommendationsFetchState: {
-                                    fetchState: 'Completed',
-                                    error: undefined,
-                                },
-                            };
-                        }
-                    });
-                }
-            },
-            prepare(selectedTab, transactionId, lineIds) {
-                return { payload: { selectedTab, transactionId, lineIds } };
-            },
-        },
-        // Failure arm. Flips covered lines to Error so the skeleton resolves
-        // and downstream UI can react to the failure. The transaction stays
-        // unchecked from the start-arm action.
-        markCategoryClassRecommendationsFailureForCategorization: {
-            reducer(draft, action) {
-                const { selectedTab, transactionId, lineIds, error } = action.payload;
-                const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
-                    .transactionReviewLocalDataById, transactionId.id, undefined);
-                if (transactionLocalData != null) {
-                    lineIds.forEach((lineId) => {
-                        const lineItem = transactionLocalData.transactionReviewLocalData.lineItemById[lineId];
-                        if (lineItem != null) {
-                            transactionLocalData.transactionReviewLocalData.lineItemById[lineId] = {
-                                ...lineItem,
-                                categoryClassRecommendationsFetchState: {
-                                    fetchState: 'Error',
-                                    error,
-                                },
-                            };
-                        }
-                    });
-                }
-            },
-            prepare(selectedTab, transactionId, lineIds, error) {
-                return { payload: { selectedTab, transactionId, lineIds, error } };
-            },
-        },
-        fetchTransactionCategorizationSuccess(draft, action) {
-            const { selectedTab, refreshViewInBackground } = action.payload;
-            if (draft.transactionCategorizationView[selectedTab].fetchState ===
-                'In-Progress' ||
-                refreshViewInBackground !== true) {
-                draft.transactionCategorizationView[selectedTab].fetchState =
-                    'Completed';
-                draft.transactionCategorizationView[selectedTab].error = undefined;
-            }
-            else {
-                draft.transactionCategorizationView[selectedTab].refreshStatus = {
-                    fetchState: 'Completed',
-                    error: undefined,
-                };
-            }
-        },
-        resetOtherTabsFetchState(draft, action) {
-            const { tabs, refreshViewInBackground } = action.payload;
-            tabs.forEach((tab) => {
-                if (draft.transactionCategorizationView[tab].fetchState ===
-                    'In-Progress' ||
-                    refreshViewInBackground !== true) {
-                    draft.transactionCategorizationView[tab].fetchState = 'Completed';
-                    draft.transactionCategorizationView[tab].error = undefined;
-                }
-                else {
-                    draft.transactionCategorizationView[tab].refreshStatus = {
-                        fetchState: 'Not-Started',
-                        error: undefined,
-                    };
-                }
-            });
-        },
-        fetchTransactionCategorizationFailure(draft, action) {
-            const { selectedTab, selectedPeriod } = action.payload;
-            draft.transactionCategorizationView[selectedTab].transactionIdsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)] =
-                [];
-            draft.transactionCategorizationView[selectedTab].fetchState = 'Error';
-            draft.transactionCategorizationView[selectedTab].error =
-                action.payload.status;
-        },
-        updateSelectedCustomerForTransaction(draft, action) {
-            const { transactionId, lineId, updatedCustomer, selectedTransaction, selectedTab, uncategorizedAccounts, isAccountingClassesEnabled, isUncategorizedExpenseCategoryEnabled, } = action.payload;
-            const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
-                .transactionReviewLocalDataById, transactionId, undefined);
-            if (transactionLocalData != null) {
-                let newTransactionLocalData = {
-                    ...transactionLocalData.transactionReviewLocalData,
-                };
-                if (!isVendorTransaction(selectedTransaction) &&
-                    updatedCustomer != null) {
-                    newTransactionLocalData = {
-                        ...newTransactionLocalData,
-                        lineItemById: {
-                            ...transactionLocalData.transactionReviewLocalData.lineItemById,
-                            [lineId]: {
-                                ...transactionLocalData.transactionReviewLocalData.lineItemById[lineId],
-                                customer: updatedCustomer,
-                                selectedEntityLine: action.payload.selectedEntity != null
-                                    ? action.payload.selectedEntity
-                                    : undefined,
-                            },
-                        },
-                    };
-                }
-                else {
-                    if (action.payload.selectedEntity != null) {
-                        newTransactionLocalData.selectedEntity =
-                            action.payload.selectedEntity;
-                    }
-                    newTransactionLocalData.customerUpdates =
-                        updatedCustomer != null && updatedCustomer.id != null
-                            ? {
-                                id: updatedCustomer.id,
-                                name: updatedCustomer.name,
-                                qboId: updatedCustomer.id,
-                            }
-                            : undefined;
-                    newTransactionLocalData.customer =
-                        updatedCustomer != null && updatedCustomer.id != null
-                            ? {
-                                id: updatedCustomer.id,
-                                name: updatedCustomer.name,
-                                logo: updatedCustomer.logo,
-                            }
-                            : undefined;
-                }
-                draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transactionId] = {
-                    transactionReviewLocalData: newTransactionLocalData,
-                    transactionId,
-                };
-                const selectedCheckBoxTransactionIds = draft.transactionCategorizationView[selectedTab]
-                    .selectedCheckBoxTransactionIds;
-                if (newTransactionLocalData.customer != null &&
-                    newTransactionLocalData.customer.id != null &&
-                    shouldAutoSelectAndAdd(selectedTransaction, newTransactionLocalData, selectedCheckBoxTransactionIds, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled)) {
-                    draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
-                        ...selectedCheckBoxTransactionIds,
-                        transactionId,
-                    ];
-                }
-                // Mark transaction as dirty (customer updated)
-                if (!draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData.includes(transactionId)) {
-                    draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData = [
-                        ...draft.transactionCategorizationView[selectedTab]
-                            .transactionIdsWithUnsavedData,
-                        transactionId,
-                    ];
-                }
-            }
-        },
-        updateSelectedVendorForTransaction(draft, action) {
-            const { transactionId, lineId, updatedVendor, selectedTransaction, selectedTab, uncategorizedAccounts, isAccountingClassesEnabled, isUncategorizedExpenseCategoryEnabled, } = action.payload;
-            const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
-                .transactionReviewLocalDataById, transactionId, undefined);
-            if (transactionLocalData != null) {
-                let newTransactionLocalData = {
-                    ...transactionLocalData.transactionReviewLocalData,
-                };
-                if (!isVendorTransaction(selectedTransaction) &&
-                    updatedVendor != null) {
-                    newTransactionLocalData = {
-                        ...newTransactionLocalData,
-                        lineItemById: {
-                            ...transactionLocalData.transactionReviewLocalData.lineItemById,
-                            [lineId]: {
-                                ...transactionLocalData.transactionReviewLocalData.lineItemById[lineId],
-                                vendor: updatedVendor,
-                                selectedEntityLine: action.payload.selectedEntity != null
-                                    ? action.payload.selectedEntity
-                                    : undefined,
-                            },
-                        },
-                    };
-                }
-                else {
-                    if (action.payload.selectedEntity != null) {
-                        newTransactionLocalData.selectedEntity =
-                            action.payload.selectedEntity;
-                    }
-                    newTransactionLocalData.vendorUpdates =
-                        updatedVendor != null && updatedVendor.id != null
-                            ? {
-                                id: updatedVendor.id,
-                                name: updatedVendor.name,
-                                qboId: updatedVendor.id,
-                            }
-                            : undefined;
-                    newTransactionLocalData.vendor =
-                        updatedVendor != null && updatedVendor.id != null
-                            ? {
-                                id: updatedVendor.id,
-                                name: updatedVendor.name,
-                                logo: updatedVendor.logo,
-                            }
-                            : undefined;
-                }
-                draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transactionId] = {
-                    transactionReviewLocalData: {
-                        ...newTransactionLocalData,
-                        tabSpecificLineItems: mergeTabSpecificLineItems(transactionLocalData.transactionReviewLocalData
-                            .tabSpecificLineItems, selectedTab, newTransactionLocalData.tabSpecificLineItems),
-                    },
-                    transactionId,
-                };
-                const selectedCheckBoxTransactionIds = draft.transactionCategorizationView[selectedTab]
-                    .selectedCheckBoxTransactionIds;
-                if (newTransactionLocalData.vendor != null &&
-                    newTransactionLocalData.vendor.id != null &&
-                    shouldAutoSelectAndAdd(selectedTransaction, newTransactionLocalData, selectedCheckBoxTransactionIds, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled)) {
-                    draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
-                        ...selectedCheckBoxTransactionIds,
-                        transactionId,
-                    ];
-                }
-                // Mark transaction as dirty (vendor updated)
-                if (!draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData.includes(transactionId)) {
-                    draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData = [
-                        ...draft.transactionCategorizationView[selectedTab]
-                            .transactionIdsWithUnsavedData,
-                        transactionId,
-                    ];
-                }
-            }
-        },
-        updateSelectedTransactionId(draft, action) {
-            const { selectedTab, transactionId, lineId } = action.payload;
-            draft.transactionCategorizationView[selectedTab].selectedTransactionId =
-                transactionId;
-            draft.transactionCategorizationView[selectedTab].selectedTransactionLineId = lineId;
-        },
-        updateTransactionCategorizationSaveStatus: {
-            reducer(draft, action) {
-                const selectedTab = action.payload.selectedTab;
-                draft.transactionCategorizationView[selectedTab].saveStatus = {
-                    fetchState: action.payload.fetchState,
-                    error: action.payload.error,
-                };
-            },
-            prepare(selectedTab, fetchState, error) {
-                return {
-                    payload: {
-                        selectedTab,
-                        fetchState,
-                        error,
-                    },
-                };
-            },
-        },
-        markTransactionAsNotMiscategorized: {
-            reducer(draft, action) {
-                const selectedTab = action.payload.selectedTab;
-                draft.transactionCategorizationView[selectedTab].markAsNotMiscategorizedStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-            },
-            prepare(selectedTab, transactionsInReview, isUncategorizedExpenseCategoryEnabled) {
-                return {
-                    payload: {
-                        selectedTab,
-                        transactionsInReview,
-                        isUncategorizedExpenseCategoryEnabled,
-                    },
-                };
-            },
-        },
-        updateStatusForTransactionNotMiscategorizedUpdateForCategorization: {
-            reducer(draft, action) {
-                const { selectedTab, selectedPeriod, uncheckTransactionIds, removeTransactionIdsFromSelectedPeriod, updateLineItemsByTransactionId, } = action.payload;
-                if (action.payload.fetchState === 'Completed') {
-                    const selectedCheckBoxTransactionIds = draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds.filter((id) => !uncheckTransactionIds.includes(id));
-                    draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
-                        ...selectedCheckBoxTransactionIds,
-                    ];
-                    const transactionIdsBySelectedPeriod = draft.transactionCategorizationView[selectedTab]
-                        .transactionIdsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)];
-                    if (transactionIdsBySelectedPeriod != null) {
-                        draft.transactionCategorizationView[selectedTab].transactionIdsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)] = transactionIdsBySelectedPeriod.filter((id) => !removeTransactionIdsFromSelectedPeriod.includes(id));
-                    }
-                    if (updateLineItemsByTransactionId != null) {
-                        Object.entries(updateLineItemsByTransactionId).forEach(([transactionId, lineIds]) => {
-                            if (lineIds.length > 0) {
-                                draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transactionId].transactionReviewLocalData.tabSpecificLineItems = {
-                                    ...draft.transactionCategorizationView[selectedTab]
-                                        .transactionReviewLocalDataById[transactionId]
-                                        .transactionReviewLocalData.tabSpecificLineItems,
-                                    [selectedTab]: [...lineIds],
-                                };
-                            }
-                            else {
-                                delete draft.transactionCategorizationView[selectedTab]
-                                    .transactionReviewLocalDataById[transactionId];
-                            }
-                        });
-                    }
-                    // Remove saved transaction IDs from dirty list
-                    draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData = draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData.filter((id) => !uncheckTransactionIds.includes(id));
-                }
-                draft.transactionCategorizationView[selectedTab].markAsNotMiscategorizedStatus = {
-                    fetchState: action.payload.fetchState,
-                    error: action.payload.error,
-                };
-            },
-            prepare(selectedTab, uncheckTransactionIds, removeTransactionIdsFromSelectedPeriod, selectedPeriod, fetchState, error, updateLineItemsByTransactionId) {
-                return {
-                    payload: {
-                        removeTransactionIdsFromSelectedPeriod,
-                        selectedPeriod,
-                        uncheckTransactionIds,
-                        selectedTab,
-                        fetchState,
-                        error,
-                        updateLineItemsByTransactionId,
-                    },
-                };
-            },
-        },
-        updateTotalCountForTransactionCategorization(draft, action) {
-            const { selectedTab, selectedPeriod, totalCount } = action.payload;
-            draft.transactionCategorizationView[selectedTab].uiState.totalCount[toMonthYearPeriodId(selectedPeriod)] = totalCount;
-        },
-        updateParentTotalCountForTab(draft, action) {
-            const { selectedTab, selectedPeriod, parentTotalCount } = action.payload;
-            draft.parentTotalCountByTab[selectedTab][toMonthYearPeriodId(selectedPeriod)] = parentTotalCount;
-        },
-        updateSelectedCheckboxTransactionIds(draft, action) {
-            const selectedTab = action.payload.selectedTab;
-            const transactionIds = action.payload.transactionIds;
-            draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [...transactionIds];
-        },
-        clearExpenseAutomationTransactionsViewPerTabView(draft, action) {
-            const selectedTab = action.payload;
-            draft.transactionCategorizationView[selectedTab] = {
-                ...initialTransactionTabViewState,
-            };
-            draft.parentTotalCountByTab[selectedTab] = {};
-            // The per-sub-tab snapshot cache lives at the slice root and is
-            // exclusively populated by the autoCategorized tab's sub-tab switching
-            // (see updateTransactionCategorizationCompletedSubTab). When that tab
-            // is reset, leaving stale snapshots behind would short-circuit the
-            // next sub-tab visit with phantom row IDs / page tokens that no longer
-            // correspond to anything in state — drop them in lockstep.
-            if (selectedTab === 'autoCategorized') {
-                draft.autoCategorizedSubTabCache = {};
-            }
-        },
-        clearExpenseAutomationTransactionsView(draft) {
-            Object.assign(draft, initialState);
-        },
-        updateTransactionCategorizationUploadReceiptState: {
-            reducer(draft, action) {
-                const { transactionId, fetchStatus, selectedTab } = action.payload;
-                draft.transactionCategorizationView[selectedTab].uploadReceiptStatusById[transactionId] = fetchStatus;
-            },
-            prepare(selectedTab, transactionId, fetchStatus) {
-                return { payload: { selectedTab, transactionId, fetchStatus } };
-            },
-        },
-        uploadTransactionCategorizationReceiptSuccess: {
-            reducer(draft, action) {
-                const { transactionPayload, selectedTab } = action.payload;
-                draft.transactionCategorizationView[selectedTab].uploadReceiptStatusById[transactionPayload.transaction_id] = {
-                    fetchState: 'Completed',
-                    error: undefined,
-                };
-            },
-            prepare(selectedTab, transactionPayload, updateType = 'merge') {
-                return { payload: { selectedTab, transactionPayload, updateType } };
-            },
-        },
-        syncTransactionCategorizationFromDetailSave: {
-            prepare(transactionId, updatedTransaction, pendingReviewLineIds, uncategorizedIncomeExpense, isUncategorizedExpenseCategoryEnabled) {
-                return {
-                    payload: {
-                        transactionId,
-                        updatedTransaction,
-                        pendingReviewLineIds,
-                        uncategorizedIncomeExpense,
-                        isUncategorizedExpenseCategoryEnabled,
-                    },
-                };
-            },
-            reducer(draft, action) {
-                const { transactionId, updatedTransaction, pendingReviewLineIds, uncategorizedIncomeExpense, isUncategorizedExpenseCategoryEnabled, } = action.payload;
-                const txnId = transactionId.id;
-                const reviewTabView = draft.transactionCategorizationView.review;
-                const autoTabView = draft.transactionCategorizationView.autoCategorized;
-                const existsInReview = reviewTabView.transactionReviewLocalDataById[txnId] != null;
-                const existsInAuto = autoTabView.transactionReviewLocalDataById[txnId] != null;
-                if (!existsInReview && !existsInAuto) {
-                    return;
-                }
-                // Auto tab: retain only lines still auto_reviewed or auto_categorized
-                if (existsInAuto) {
-                    filterAutoTabLineItems(autoTabView, txnId, updatedTransaction);
-                }
-                const allReviewed = pendingReviewLineIds.length === 0;
-                if (allReviewed) {
-                    if (existsInReview) {
-                        removeTransactionFromTabView(reviewTabView, txnId);
-                    }
-                    return;
-                }
-                // Partially reviewed: rebuild review tab local data with pending review lines
-                if (existsInReview) {
-                    const newLocalData = toTransactionDetailLocalData(updatedTransaction, 'review', pendingReviewLineIds, uncategorizedIncomeExpense, isUncategorizedExpenseCategoryEnabled);
-                    reviewTabView.transactionReviewLocalDataById[txnId] = {
-                        transactionId: txnId,
-                        transactionReviewLocalData: {
-                            ...newLocalData,
-                            sortedLineItems: updatedTransaction.lines?.map((l) => l.id) ?? [],
-                            tabSpecificLineItems: {
-                                review: pendingReviewLineIds,
-                            },
-                        },
-                    };
-                    reviewTabView.selectedCheckBoxTransactionIds =
-                        reviewTabView.selectedCheckBoxTransactionIds.filter((id) => id !== txnId);
-                    reviewTabView.transactionIdsWithUnsavedData =
-                        reviewTabView.transactionIdsWithUnsavedData.filter((id) => id !== txnId);
-                }
-            },
-        },
-        backgroundRefetchReviewTab: {
-            prepare(period, isUncategorizedExpenseCategoryEnabled) {
-                return {
-                    payload: {
-                        period,
-                        isUncategorizedExpenseCategoryEnabled,
-                    },
-                };
-            },
-            reducer(draft) {
-                draft.transactionCategorizationView.review.refreshStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-            },
-        },
-        removeTransactionFromAllTabs: {
-            prepare(transactionId) {
-                return { payload: { transactionId } };
-            },
-            reducer(draft, action) {
-                const { transactionId } = action.payload;
-                for (const tab of TRANSACTIONS_TABS) {
-                    removeTransactionFromTabView(draft.transactionCategorizationView[tab], transactionId);
-                }
-            },
-        },
-    },
-});
-export const { fetchTransactionCategorization, updateTransactionCategorizationUIState, updateTransactionFilters, initializeTransactionCategorizationViewLocalData, saveTransactionCategorizationLocalData, fetchTransactionCategorizationFailure, saveTransactionCategorization, updateTransactionCategorization, updateCurrentSelectedTransactionCategorizationTab, updateTransactionCategorizationCompletedSubTab, updateTransactionCategorizationSaveStatus, markTransactionAsNotMiscategorized, updateStatusForTransactionNotMiscategorizedUpdateForCategorization, updateSelectedVendorForTransaction, updateSelectedCustomerForTransaction, setAllItemsToCategoryClassInLocalDataForCategorization, updateTotalCountForTransactionCategorization, updateParentTotalCountForTab, fetchTransactionCategorizationSuccess, resetOtherTabsFetchState, fetchTransactionCategorizationView, updateSelectedCheckboxTransactionIds, clearExpenseAutomationTransactionsViewPerTabView, clearExpenseAutomationTransactionsView, setEntityRecommendationForLineIdsForCategorization, markCategoryClassRecommendationsInProgressForCategorization, markCategoryClassRecommendationsCompletedForCategorization, markCategoryClassRecommendationsFailureForCategorization, updateSelectedTransactionId, syncTransactionCategorizationFromDetailSave, backgroundRefetchReviewTab, removeTransactionFromAllTabs, updateTransactionCategorizationUploadReceiptState, uploadTransactionCategorizationReceiptSuccess, } = expenseAutomationTransactionsView.actions;
-export default expenseAutomationTransactionsView.reducer;