@zeniai/client-epic-state 5.0.70 → 5.0.71-betaAK1

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

@@ -4,6 +4,7 @@ import uniq from 'lodash/uniq';
 import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
 import { isVendorTransaction } from '../../../entity/transaction/stateTypes/vendorTransaction';
 import { MAX_SELECTION_LIMIT, checkIfAllLineItemsAreCategoryClassFilled, filterAutoTabLineItems, mergeTabSpecificLineItems, removeTransactionFromTabView, setEntityRecommendationForLineIdInLocalData, toSetAllLineItemsToCategoryClass, toTransactionDetailLocalData, } from '../helpers/transactionCategorizationLocalDataHelper';
+import { DEFAULT_COMPLETED_SUB_TAB, } from '../types/completedSubTab';
 export const initialTransactionTabViewState = {
     saveStatus: {
         fetchState: 'Not-Started',
@@ -41,12 +42,74 @@ export const initialTransactionTabViewState = {
     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,
@@ -260,6 +323,55 @@ const expenseAutomationTransactionsView = createSlice({
                 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;
@@ -697,6 +809,10 @@ const expenseAutomationTransactionsView = createSlice({
             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;
@@ -707,6 +823,16 @@ const expenseAutomationTransactionsView = createSlice({
             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);
@@ -803,5 +929,5 @@ const expenseAutomationTransactionsView = createSlice({
         },
     },
 });
-export const { fetchTransactionCategorization, updateTransactionCategorizationUIState, initializeTransactionCategorizationViewLocalData, saveTransactionCategorizationLocalData, fetchTransactionCategorizationFailure, saveTransactionCategorization, updateTransactionCategorization, updateCurrentSelectedTransactionCategorizationTab, updateTransactionCategorizationSaveStatus, markTransactionAsNotMiscategorized, updateStatusForTransactionNotMiscategorizedUpdateForCategorization, updateSelectedVendorForTransaction, updateSelectedCustomerForTransaction, setAllItemsToCategoryClassInLocalDataForCategorization, updateTotalCountForTransactionCategorization, fetchTransactionCategorizationSuccess, resetOtherTabsFetchState, fetchTransactionCategorizationView, updateSelectedCheckboxTransactionIds, clearExpenseAutomationTransactionsViewPerTabView, clearExpenseAutomationTransactionsView, setEntityRecommendationForLineIdsForCategorization, updateSelectedTransactionId, syncTransactionCategorizationFromDetailSave, backgroundRefetchReviewTab, updateTransactionCategorizationUploadReceiptState, uploadTransactionCategorizationReceiptSuccess, } = expenseAutomationTransactionsView.actions;
+export const { fetchTransactionCategorization, updateTransactionCategorizationUIState, initializeTransactionCategorizationViewLocalData, saveTransactionCategorizationLocalData, fetchTransactionCategorizationFailure, saveTransactionCategorization, updateTransactionCategorization, updateCurrentSelectedTransactionCategorizationTab, updateTransactionCategorizationCompletedSubTab, updateTransactionCategorizationSaveStatus, markTransactionAsNotMiscategorized, updateStatusForTransactionNotMiscategorizedUpdateForCategorization, updateSelectedVendorForTransaction, updateSelectedCustomerForTransaction, setAllItemsToCategoryClassInLocalDataForCategorization, updateTotalCountForTransactionCategorization, updateParentTotalCountForTab, fetchTransactionCategorizationSuccess, resetOtherTabsFetchState, fetchTransactionCategorizationView, updateSelectedCheckboxTransactionIds, clearExpenseAutomationTransactionsViewPerTabView, clearExpenseAutomationTransactionsView, setEntityRecommendationForLineIdsForCategorization, updateSelectedTransactionId, syncTransactionCategorizationFromDetailSave, backgroundRefetchReviewTab, updateTransactionCategorizationUploadReceiptState, uploadTransactionCategorizationReceiptSuccess, } = expenseAutomationTransactionsView.actions;
 export default expenseAutomationTransactionsView.reducer;

package/lib/esm/view/expenseAutomationView/selectors/transactionCategorizationSelector.js

@@ -10,7 +10,7 @@ import { getProjectList } from '../../projectList/projectListSelector';
 import { getAllSteps } from '../selectorTypes/expenseAutomationViewSelectorTypes';
 export function getExpenseAutomationTransactionView(state) {
     const { accountState, classState, classListState, accountListState, expenseAutomationTransactionsViewState, expenseAutomationViewState, projectState, projectListState, transactionState, monthEndCloseChecksState, monthEndCloseChecksViewState, } = state;
-    const { selectedTransactionCategorizationTab } = expenseAutomationTransactionsViewState;
+    const { selectedTransactionCategorizationCompletedSubTab, selectedTransactionCategorizationTab, } = expenseAutomationTransactionsViewState;
     const { uiState, refreshStatus, saveStatus, markAsNotMiscategorizedStatus, transactionIdsBySelectedPeriod, transactionReviewLocalDataById, selectedCheckBoxTransactionIds, transactionIdsWithUnsavedData, uploadReceiptStatusById, selectedTransactionId, selectedTransactionLineId, } = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTransactionCategorizationTab];
     const uncategorizedIncomeExpense = getUncategorizedAccounts(accountState, accountListState, 'accountList');
     const accountList = getAccountList(accountState, accountListState, 'accountList');
@@ -63,10 +63,27 @@ export function getExpenseAutomationTransactionView(state) {
         .uiState.totalCount;
     const totalCountByAutoCat = expenseAutomationTransactionsViewState.transactionCategorizationView
         .autoCategorized.uiState.totalCount;
+    // Per-(sub-)tab counts powering pagination, in-list "showing X of Y", and
+    // any save/refresh round-trips. Sourced from `uiState.totalCount` which
+    // mirrors the response's `total_count` for whatever tab/sub-tab the user is
+    // viewing (e.g. only the Manual sub-tab rows for Completed → Manual).
     const totalCountByTab = {
         review: monthYearPeriodId != null ? totalCountByReview[monthYearPeriodId] : 0,
         autoCategorized: monthYearPeriodId != null ? totalCountByAutoCat[monthYearPeriodId] : 0,
     };
+    // Parent-tab badge counts. Sourced from `parent_tab_total_count` in the
+    // listing response and used exclusively by the navbar / tab strip badges.
+    // Independent of which Completed sub-tab is active so the badge stays
+    // stable across sub-tab switches.
+    const parentTotalCountByTab = expenseAutomationTransactionsViewState.parentTotalCountByTab;
+    const parentTabTotalCountByTab = {
+        review: monthYearPeriodId != null
+            ? (parentTotalCountByTab.review[monthYearPeriodId] ?? 0)
+            : 0,
+        autoCategorized: monthYearPeriodId != null
+            ? (parentTotalCountByTab.autoCategorized[monthYearPeriodId] ?? 0)
+            : 0,
+    };
     const fetchStateByTab = {
         review: {
             fetchState: expenseAutomationTransactionsViewState.transactionCategorizationView
@@ -108,9 +125,11 @@ export function getExpenseAutomationTransactionView(state) {
         markAsNotMiscategorizedStatus,
         completionStatus,
         totalCountByTab,
+        parentTabTotalCountByTab,
         fetchStateByTransactionTabs: fetchStateByTab,
         uploadReceiptStatusById,
         selectedTransactionId,
         selectedTransactionLineId,
+        selectedTransactionCategorizationCompletedSubTab,
     };
 }

package/lib/esm/view/expenseAutomationView/types/completedSubTab.js

@@ -0,0 +1,17 @@
+import { stringToUnion } from '../../../commonStateTypes/stringToUnion';
+/**
+ * Sub-tabs that can appear under any "Completed" tab in the Expense Automation
+ * surface (Transaction Categorization Completed and Missing Receipts Completed
+ * both use this exact union). Forwarded verbatim to listing APIs as `sub_tab`
+ * / `match_type`. `'all'` preserves parent-tab semantics on the backend.
+ */
+const COMPLETED_SUB_TABS = ['all', 'ai_accountant', 'manual'];
+export const toCompletedSubTab = (v) => stringToUnion(v.trim().toLowerCase(), COMPLETED_SUB_TABS);
+/**
+ * "No sub-tab filter" sentinel — single source of truth for the default
+ * value of {@link CompletedSubTab}. Use this constant in initial slice
+ * state and at any call site that needs to fall back to the parent-tab
+ * listing semantics (review tab requests, manual-search overrides, etc.)
+ * so a future rename of the union doesn't require chasing literals.
+ */
+export const DEFAULT_COMPLETED_SUB_TAB = 'all';

package/lib/esm/view/expenseAutomationView/types/missingReceiptsViewState.js

@@ -39,8 +39,6 @@ const BULK_UPLOAD_RESULTS_TABS = ['completed', 'unmatched'];
 export const toBulkUploadResultsTab = (v) => stringToUnion(v.trim().toLowerCase(), BULK_UPLOAD_RESULTS_TABS);
 const MISSING_RECEIPTS_TABS = ['missing', 'completed', 'unmatched'];
 export const toMissingReceiptsTab = (v) => stringToUnion(v.trim().toLowerCase(), MISSING_RECEIPTS_TABS);
-const COMPLETED_SUB_TABS = ['all', 'ai_accountant', 'manual'];
-export const toCompletedSubTab = (v) => stringToUnion(v.trim().toLowerCase(), COMPLETED_SUB_TABS);
 const MATCH_SOURCES = ['ai', 'manual'];
 export const toMatchSource = (v) => stringToUnion(v.trim().toLowerCase(), MATCH_SOURCES);
 const BULK_UPLOAD_SORT_KEYS = [

package/lib/esm/view/financeStatement/financeStatementSelector.js

@@ -2,6 +2,7 @@ import { createSelector } from '@reduxjs/toolkit';
 import { stripCompareAdditionalBalanceTypes } from '../../commonStateTypes/coaBalance/coaBalanceType';
 import { newBalancesFilter, newBalancesFilterForDateRange, } from '../../commonStateTypes/coaBalance/coaBalancesFilter';
 import { newBalancesFilterClassesView } from '../../commonStateTypes/coaBalance/coaBalancesFilterClassesView';
+import { newBalancesFilterProjectView } from '../../commonStateTypes/coaBalance/coaBalancesFilterProjectView';
 import { getNumberOfPeriods, } from '../../commonStateTypes/dataAvailable';
 import { reduceAnyCompletedFetchState } from '../../commonStateTypes/reduceFetchState';
 import { toTimeframeTick, } from '../../commonStateTypes/timeframeTick';
@@ -9,7 +10,6 @@ import { extractThisPeriod } from '../../commonStateTypes/viewAndReport/thisPeri
 import { getBalanceSheet } from '../balanceSheet/balanceSheetSelector';
 import { getCashFlow } from '../cashFlow/cashFlowSelector';
 import { getProfitAndLossReport, } from '../profitAndLoss/profitAndLossSelector';
-import { newBalancesFilterProjectView } from '../../commonStateTypes/coaBalance/coaBalancesFilterProjectView';
 import { getProfitAndLossClassesHorizontalView } from '../profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelector';
 import { getProfitAndLossClassesView } from '../profitAndLossClassesView/profitAndLossClassesViewSelector';
 import { getProfitAndLossProjectView } from '../profitAndLossProjectView/profitAndLossProjectViewSelector';

package/lib/esm/view/spendManagement/cashManagement/cashManagementOverview/cashManagementOverviewPayload.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/view/spendManagement/cashManagement/cashManagementOverview/cashManagementOverviewReducer.js

@@ -0,0 +1,82 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { initialCashManagementBannerState, initialUpcomingPaymentEventsListState, } from './cashManagementOverviewState';
+export const initialState = {
+    banner: initialCashManagementBannerState,
+    upcomingPaymentEvents: initialUpcomingPaymentEventsListState,
+    fetchState: 'Not-Started',
+    error: undefined,
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+const cashManagementOverview = createSlice({
+    name: 'cashManagementOverview',
+    initialState,
+    reducers: {
+        fetchCashManagementOverviewPage: {
+            reducer() { },
+            prepare(cacheOverride) {
+                return { payload: { cacheOverride } };
+            },
+        },
+        fetchUpcomingPaymentEvents(draft) {
+            draft.upcomingPaymentEvents = {
+                ...draft.upcomingPaymentEvents,
+                fetchState: 'In-Progress',
+                error: undefined,
+            };
+        },
+        updateUpcomingPaymentEventsList(draft, action) {
+            const { data } = action.payload;
+            const eventIds = [];
+            data.events.forEach((payload) => {
+                if (payload.id != null) {
+                    eventIds.push(payload.id);
+                }
+            });
+            draft.upcomingPaymentEvents = {
+                fetchState: 'Completed',
+                error: undefined,
+                billStages: (data.bill_stages ?? []),
+                eventIds,
+                horizonDays: data.horizon_days,
+                reimbursementStages: (data.reimbursement_stages ??
+                    []),
+                tenantNamespace: data.tenant_namespace,
+            };
+        },
+        updateUpcomingPaymentEventsListFetchStatus(draft, action) {
+            draft.upcomingPaymentEvents = {
+                ...draft.upcomingPaymentEvents,
+                fetchState: action.payload.fetchState,
+                error: action.payload.error,
+            };
+        },
+        fetchCashManagementBanner(draft) {
+            draft.banner = {
+                ...initialCashManagementBannerState,
+                fetchState: 'In-Progress',
+                error: undefined,
+            };
+        },
+        updateCashManagementBanner(draft, action) {
+            draft.banner = {
+                fetchState: 'Completed',
+                error: undefined,
+                data: action.payload.data,
+            };
+        },
+        updateCashManagementBannerFetchStatus(draft, action) {
+            draft.banner = {
+                ...draft.banner,
+                fetchState: action.payload.fetchState,
+                error: action.payload.error,
+            };
+        },
+        clearCashManagementOverview(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { fetchCashManagementOverviewPage, fetchUpcomingPaymentEvents, updateUpcomingPaymentEventsList, updateUpcomingPaymentEventsListFetchStatus, fetchCashManagementBanner, updateCashManagementBanner, updateCashManagementBannerFetchStatus, clearCashManagementOverview, } = cashManagementOverview.actions;
+export default cashManagementOverview.reducer;

package/lib/esm/view/spendManagement/cashManagement/cashManagementOverview/cashManagementOverviewSelector.js

@@ -0,0 +1,93 @@
+import { zeroAmount } from '../../../../commonStateTypes/amount';
+import { reduceAllFetchState } from '../../../../commonStateTypes/reduceFetchState';
+import { getUpcomingPaymentEventsByIds } from '../../../../entity/upcomingPaymentEvent/upcomingPaymentEventSelector';
+export const getCashManagementOverviewBanner = (state) => {
+    const { banner } = state.cashManagementOverviewState;
+    return {
+        fetchState: banner.fetchState,
+        error: banner.error,
+        data: banner.data,
+        version: 0,
+    };
+};
+export const getCashManagementOverview = (state) => {
+    const { cashManagementOverviewState, depositAccountListState, depositAccountState, paymentAccountListState, paymentAccountState, treasuryDetailState, } = state;
+    const outflowEventsFetchState = {
+        fetchState: cashManagementOverviewState.upcomingPaymentEvents.fetchState,
+        error: cashManagementOverviewState.upcomingPaymentEvents.error,
+    };
+    const bannerFetchState = {
+        fetchState: cashManagementOverviewState.banner.fetchState,
+        error: cashManagementOverviewState.banner.error,
+    };
+    const aggregate = reduceAllFetchState([
+        {
+            fetchState: paymentAccountListState.fetchState,
+            error: paymentAccountListState.error,
+        },
+        {
+            fetchState: depositAccountListState.fetchState,
+            error: depositAccountListState.error,
+        },
+        {
+            fetchState: treasuryDetailState.fetchState,
+            error: treasuryDetailState.error,
+        },
+        outflowEventsFetchState,
+        bannerFetchState,
+    ]);
+    const treasuryBalance = treasuryDetailState.accountSummary?.totalBalance ?? zeroAmount();
+    const cashBalance = sumCashBalances(paymentAccountListState.paymentAccountIds, paymentAccountState, depositAccountListState.accountIds, depositAccountState);
+    const totalCash = addAmounts(treasuryBalance, cashBalance);
+    return {
+        bannerFetchState,
+        cashBalance,
+        horizonDays: cashManagementOverviewState.upcomingPaymentEvents.horizonDays,
+        outflowEvents: getUpcomingPaymentEventsByIds(state.upcomingPaymentEventState, cashManagementOverviewState.upcomingPaymentEvents.eventIds),
+        outflowEventsFetchState,
+        totalCash,
+        treasuryBalance,
+        fetchState: aggregate.fetchState,
+        error: aggregate.error,
+        version: 0,
+    };
+};
+const isZeroAmount = (a) => a.amount === 0 && a.currencyCode === 'USD' && a.currencySymbol === '$';
+/**
+ * Adds two Amounts. Currencies must match (the seeded zeroAmount() counts as
+ * "no currency yet" and adopts `b`'s currency). Mismatches return `a`
+ * unchanged and warn — mixing currencies in a total is a bug, not silent
+ * conversion.
+ */
+const addAmounts = (a, b) => {
+    if (isZeroAmount(a)) {
+        return { ...b };
+    }
+    if (a.currencyCode !== b.currencyCode ||
+        a.currencySymbol !== b.currencySymbol) {
+        console.warn(`cashManagementOverview: skipping balance with mismatched currency. Expected ${a.currencyCode} (${a.currencySymbol}), got ${b.currencyCode} (${b.currencySymbol}).`);
+        return a;
+    }
+    return {
+        amount: a.amount + b.amount,
+        currencyCode: a.currencyCode,
+        currencySymbol: a.currencySymbol,
+    };
+};
+const sumCashBalances = (paymentAccountIds, paymentAccountState, depositAccountIds, depositAccountState) => {
+    let total = zeroAmount();
+    paymentAccountIds.forEach((id) => {
+        const balance = paymentAccountState.paymentAccountByID[id]?.balances
+            ?.available;
+        if (balance != null) {
+            total = addAmounts(total, balance);
+        }
+    });
+    depositAccountIds.forEach((id) => {
+        const balance = depositAccountState.depositAccountByID[id]?.accountBalance?.available;
+        if (balance != null) {
+            total = addAmounts(total, balance);
+        }
+    });
+    return total;
+};

package/lib/esm/view/spendManagement/cashManagement/cashManagementOverview/cashManagementOverviewState.js

@@ -0,0 +1,14 @@
+export const initialCashManagementBannerState = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    data: undefined,
+};
+export const initialUpcomingPaymentEventsListState = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    billStages: [],
+    eventIds: [],
+    horizonDays: 0,
+    reimbursementStages: [],
+    tenantNamespace: undefined,
+};

package/lib/esm/view/spendManagement/cashManagement/cashManagementOverview/epics/fetchCashManagementBannerEpic.js

@@ -0,0 +1,6 @@
+import { EMPTY } from 'rxjs';
+import { filter, mergeMap } from 'rxjs/operators';
+import { fetchCashManagementBanner, } from '../cashManagementOverviewReducer';
+// TODO: replace EMPTY with an actual API call once the banner endpoint is finalized.
+// Figma: https://www.figma.com/design/FUg2pv7edRAidx9X56VnZT/Cash-Management?node-id=2265-63443
+export const fetchCashManagementBannerEpic = (actions$) => actions$.pipe(filter(fetchCashManagementBanner.match), mergeMap(() => EMPTY));

package/lib/esm/view/spendManagement/cashManagement/cashManagementOverview/epics/fetchCashManagementOverviewPageEpic.js

@@ -0,0 +1,42 @@
+import { concat, from } from 'rxjs';
+import { filter, mergeMap } from 'rxjs/operators';
+import { fetchAutoTransferRules } from '../../../autotransferRules/autoTransferRulesReducer';
+import { fetchTreasuryOverviewDetail } from '../../../treasury/treasuryList/treasuryDetailReducer';
+import { fetchZeniAccountList } from '../../../zeniAccounts/zeniAccountList/zeniAccountListReducer';
+import { fetchCashManagementBanner, fetchCashManagementOverviewPage, fetchUpcomingPaymentEvents, } from '../cashManagementOverviewReducer';
+export const fetchCashManagementOverviewPageEpic = (actions$, state$) => actions$.pipe(filter(fetchCashManagementOverviewPage.match), mergeMap((action) => {
+    const { cacheOverride } = action.payload;
+    const state = state$.value;
+    const pageActions = [];
+    if (cacheOverride === true) {
+        pageActions.push(fetchTreasuryOverviewDetail(true));
+        pageActions.push(fetchZeniAccountList(true));
+        pageActions.push(fetchUpcomingPaymentEvents());
+        pageActions.push(fetchCashManagementBanner());
+        pageActions.push(fetchAutoTransferRules(true));
+    }
+    else {
+        const treasuryDetailState = state.treasuryDetailState;
+        if (treasuryDetailState.hasValidState() === false &&
+            treasuryDetailState.fetchState !== 'In-Progress') {
+            pageActions.push(fetchTreasuryOverviewDetail(false));
+        }
+        pageActions.push(fetchZeniAccountList(false));
+        const upcomingEvents = state.cashManagementOverviewState.upcomingPaymentEvents;
+        if (upcomingEvents.fetchState !== 'Completed' &&
+            upcomingEvents.fetchState !== 'In-Progress') {
+            pageActions.push(fetchUpcomingPaymentEvents());
+        }
+        const banner = state.cashManagementOverviewState.banner;
+        if (banner.fetchState !== 'Completed' &&
+            banner.fetchState !== 'In-Progress') {
+            pageActions.push(fetchCashManagementBanner());
+        }
+        const autoTransferRules = state.autotransferRulesState;
+        if (autoTransferRules.fetchState !== 'Completed' &&
+            autoTransferRules.fetchState !== 'In-Progress') {
+            pageActions.push(fetchAutoTransferRules(false));
+        }
+    }
+    return concat(from(pageActions));
+}));

package/lib/esm/view/spendManagement/cashManagement/cashManagementOverview/epics/fetchUpcomingPaymentEventsEpic.js

@@ -0,0 +1,22 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../../responsePayload';
+import { updateUpcomingPaymentEvents } from '../../../../../entity/upcomingPaymentEvent/upcomingPaymentEventReducer';
+import { fetchUpcomingPaymentEvents, updateUpcomingPaymentEventsList, updateUpcomingPaymentEventsListFetchStatus, } from '../cashManagementOverviewReducer';
+export const fetchUpcomingPaymentEventsEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchUpcomingPaymentEvents.match), switchMap(() => zeniAPI
+    .getJSON(
+// TODO: drop /rajat/ once the prod endpoint lands. `${zeniAPI.apiEndPoints.spendManagementMicroServiceBaseUrl}/1.0/upcoming-payment-events`
+`https://dev.api.zeni.ai/version/spend-management/rajat/1.0/upcoming-payment-events`)
+    .pipe(mergeMap((response) => {
+    if (isSuccessResponse(response) && response.data != null) {
+        return of(updateUpcomingPaymentEvents(response.data.events), updateUpcomingPaymentEventsList({ data: response.data }));
+    }
+    return of(updateUpcomingPaymentEventsListFetchStatus({
+        fetchState: 'Error',
+        error: response.status,
+    }));
+}), catchError((error) => of(updateUpcomingPaymentEventsListFetchStatus({
+    fetchState: 'Error',
+    error: createZeniAPIStatus('Unexpected Error', 'Fetch upcoming payment events REST API call errored out' +
+        JSON.stringify(error)),
+}))))));

package/lib/esm/view/spendManagement/chargeCards/cashbackDetail/cashbackDetailReducer.js

@@ -1,6 +1,7 @@
 import { createSlice } from '@reduxjs/toolkit';
 import { mapCurrencyPayloadToCurrency } from '../../../../commonPayloadTypes/v2/viewAndReportPayloadv2';
 import { toAmount } from '../../../../commonStateTypes/amount';
+import { createCacheOverrideFetchReducer } from '../../../../commonStateTypes/cacheOverrideFetchReducer';
 import { initialCashbackAnalytics, } from './cashbackDetailState';
 export const initialState = {
     fetchState: 'Not-Started',
@@ -27,10 +28,10 @@ const cashbackDetail = createSlice({
     name: 'cashbackDetail',
     initialState,
     reducers: {
-        fetchCashbackDetail(draft) {
+        fetchCashbackDetail: createCacheOverrideFetchReducer((draft) => {
             draft.fetchState = 'In-Progress';
             draft.error = undefined;
-        },
+        }),
         updateCashbackDetail(draft, action) {
             draft.cashbackByPeriod = toCashbackByPeriod(action.payload);
             draft.cashbackSummary = toCashbackSummary(action.payload);

package/lib/esm/view/spendManagement/chargeCards/chargeCardConfig/chargeCardConfigReducer.js

@@ -1,5 +1,6 @@
 import { createSlice } from '@reduxjs/toolkit';
 import { toAmount } from '../../../../commonStateTypes/amount';
+import { createCacheOverrideFetchReducer } from '../../../../commonStateTypes/cacheOverrideFetchReducer';
 import { toCreditLimitFrequencyCodeType } from '../../../../entity/chargeCard/chargeCard';
 import { toCreditTerm, toRePaymentInfo, } from './chargeCardConfigPayload';
 export const initialState = {
@@ -30,10 +31,10 @@ const chargeCardConfig = createSlice({
     name: 'chargeCardConfig',
     initialState,
     reducers: {
-        fetchChargeCardConfig(draft) {
+        fetchChargeCardConfig: createCacheOverrideFetchReducer((draft) => {
             draft.fetchState = 'In-Progress';
             draft.error = undefined;
-        },
+        }),
         updateChargeCardConfig(draft, action) {
             const { payload } = action;
             draft.creditLimitFrequency =