@zeniai/client-epic-state 5.1.18-betaDI1 → 5.1.18-betaDI10

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

@@ -0,0 +1,1058 @@
+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;