@zeniai/client-epic-state 5.1.20 → 5.1.21-betaRD2

package/lib/esm/view/expenseAutomationView/epics/transactionCategorization/fetchTransactionCategorizationViewEpic.js

@@ -7,6 +7,7 @@ import { fetchClassList } from '../../../classList/classListReducer';
 import { fetchOwnerList } from '../../../ownerList/ownerListReducer';
 import { fetchProjectList } from '../../../projectList/projectListReducer';
 import { fetchTransactionCategorization, fetchTransactionCategorizationView, } from '../../reducers/transactionsViewReducer';
+import { TRANSACTIONS_TABS } from '../../types/transactionsViewState';
 export const fetchTransactionCategorizationViewEpic = (actions$, state$) => actions$.pipe(filter(fetchTransactionCategorizationView.match), mergeMap((action) => {
     const { selectedTab, cacheOverride, keepExistingListItems, pageToken, period, refreshViewInBackground, searchString, resetListItems, isUncategorizedExpenseCategoryEnabled, } = action.payload;
     const updateActions = [];
@@ -16,8 +17,8 @@ export const fetchTransactionCategorizationViewEpic = (actions$, state$) => acti
         month: period.start.month,
         year: period.start.year,
     };
-    const transactionIds = transactionIdsBySelectedPeriod[toMonthYearPeriodId(monthYearPeriod)] ??
-        [];
+    const periodId = toMonthYearPeriodId(monthYearPeriod);
+    const transactionIds = transactionIdsBySelectedPeriod[periodId] ?? [];
     const accountList = state$.value.accountListState.byReportId['accountList'];
     if (accountList.hasValidState() === false &&
         accountList.fetchState === 'Not-Started') {
@@ -39,10 +40,36 @@ export const fetchTransactionCategorizationViewEpic = (actions$, state$) => acti
         vendorOwnerList.fetchState === 'Not-Started') {
         updateActions.push(fetchOwnerList());
     }
-    if (cacheOverride === true ||
+    if (searchString === '' ||
+        cacheOverride === true ||
         fetchState === 'Not-Started' ||
         transactionIds.length === 0) {
         updateActions.push(fetchTransactionCategorization(selectedTab, period, cacheOverride, keepExistingListItems, searchString, pageToken, refreshViewInBackground, resetListItems, isUncategorizedExpenseCategoryEnabled));
     }
+    // On the initial load of a tab (searchString undefined = non-search fetch),
+    // preload every other tab that hasn't been fetched yet for this period.
+    // This makes switching to the other tab instant instead of triggering a
+    // fresh fetch on click. refreshViewInBackground=true keeps it silent.
+    if (searchString === undefined) {
+        TRANSACTIONS_TABS.filter((tab) => tab !== selectedTab).forEach((otherTab) => {
+            const otherTabFetchState = expenseAutomationTransactionsViewState.transactionCategorizationView[otherTab].fetchState;
+            if (otherTabFetchState === 'Not-Started') {
+                updateActions.push(fetchTransactionCategorization(otherTab, period, false, false, undefined, undefined, true, undefined, isUncategorizedExpenseCategoryEnabled));
+            }
+        });
+    }
+    // When search changes (searchString defined, including empty string to
+    // clear), also update every other tab so all tabs always reflect the same
+    // search query. Skip if the other tab already has this search string to
+    // avoid redundant work on noop updates. On clear, restore from snapshot
+    // if available; otherwise issue a background fetch.
+    if (searchString !== undefined) {
+        TRANSACTIONS_TABS.filter((tab) => tab !== selectedTab).forEach((otherTab) => {
+            const otherTabSearchString = expenseAutomationTransactionsViewState.transactionCategorizationView[otherTab].uiState.searchString;
+            if (searchString !== otherTabSearchString) {
+                updateActions.push(fetchTransactionCategorization(otherTab, period, true, keepExistingListItems, searchString, undefined, true, true, isUncategorizedExpenseCategoryEnabled));
+            }
+        });
+    }
     return from(updateActions);
 }));

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

@@ -1,6 +1,7 @@
 import { createSlice } from '@reduxjs/toolkit';
 import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
 import { defaultVendorCurrency } from '../../../entity/vendor/vendorState';
+import { date } from '../../../zeniDayJS';
 import { toBalancesByMonthFromPayload, toVendorFluxAnalysisStatusFromPayload, } from '../helpers/helpers';
 export const initialState = {
     fluxAnalysisEntities: { operatingExpenses: [] },
@@ -31,6 +32,7 @@ export const initialState = {
     fetchState: 'Not-Started',
     error: undefined,
     currency: defaultVendorCurrency,
+    lastRefreshSuccessTime: undefined,
     totalBalancesAndVariance: undefined,
     hasValidState() {
         return this.fetchState == 'Completed';
@@ -99,7 +101,7 @@ const expenseAutomationFluxAnalysisView = createSlice({
             },
         },
         fetchFluxAnalysisViewSuccess(draft, action) {
-            const { expensesPayload, selectedPeriod, keepExistingListItems, fetchReimbursement, currency, totalsPayload, } = action.payload;
+            const { expensesPayload, selectedPeriod, keepExistingListItems, fetchReimbursement, currency, status, totalsPayload, } = action.payload;
             const periodId = toMonthYearPeriodId(selectedPeriod);
             const group = draft.groupsBySelectedPeriod[periodId];
             const groupToBeFetched = fetchReimbursement
@@ -109,6 +111,9 @@ const expenseAutomationFluxAnalysisView = createSlice({
             // Handle fetch completion
             handleFetchCompletion(draft, selectedPeriod, fetchReimbursement, groupToBeFetched);
             draft.fetchState = 'Completed';
+            if (status?.last_refresh_success_time != null) {
+                draft.lastRefreshSuccessTime = date(status.last_refresh_success_time);
+            }
             // Update flux analysis entities
             const allFluxAnalysisEntities = updateFluxAnalysisEntities(draft.fluxAnalysisEntities, expensesPayload, currency);
             // Update operating expense ids based on the "keepExistingListItems" flag

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

@@ -153,27 +153,39 @@ const expenseAutomationTransactionsView = createSlice({
                     draft.transactionCategorizationView[selectedTab].fetchState =
                         'In-Progress';
                     draft.transactionCategorizationView[selectedTab].error = undefined;
+                    // A foreground fetch supersedes any in-flight background preload.
+                    // Reset refreshStatus so a cancelled preload doesn't leave the
+                    // spinner stuck at In-Progress.
+                    draft.transactionCategorizationView[selectedTab].refreshStatus = {
+                        fetchState: 'Not-Started',
+                        error: undefined,
+                    };
                 }
                 draft.transactionCategorizationView[selectedTab].uiState.pageToken =
                     pageToken ?? null;
-                draft.transactionCategorizationView[selectedTab].uiState.searchString =
-                    searchString ?? '';
+                // Only overwrite when explicitly set; undefined means a non-search fetch
+                // (tab switch, period change) should preserve the existing search string.
+                if (searchString !== undefined) {
+                    draft.transactionCategorizationView[selectedTab].uiState.searchString =
+                        searchString;
+                }
                 draft.transactionCategorizationView[selectedTab].error = undefined;
+                const monthYearPeriod = {
+                    month: period.start.month,
+                    year: period.start.year,
+                };
+                const periodId = toMonthYearPeriodId(monthYearPeriod);
+                const transactionIdsBySelectedPeriod = draft.transactionCategorizationView[selectedTab]
+                    .transactionIdsBySelectedPeriod[periodId] ?? [];
                 // 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].transactionIdsBySelectedPeriod[periodId] = [];
                     draft.transactionCategorizationView[selectedTab].refreshStatus = {
                         fetchState: 'Not-Started',
                         error: undefined,
@@ -305,10 +317,12 @@ const expenseAutomationTransactionsView = createSlice({
             }
         },
         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;
+            const { filters } = action.payload;
+            // Filters are tab-agnostic (payee/category/class/amount), so apply to
+            // all tabs so switching tabs after filtering shows consistent results.
+            TRANSACTIONS_TABS.forEach((tab) => {
+                draft.transactionCategorizationView[tab].filters = filters;
+            });
         },
         saveTransactionCategorization: {
             prepare(selectedTab, transactionIds, cotTrackingByTransactionId, isUncategorizedExpenseCategoryEnabled) {
@@ -660,18 +674,24 @@ const expenseAutomationTransactionsView = createSlice({
         resetOtherTabsFetchState(draft, action) {
             const { tabs, refreshViewInBackground } = action.payload;
             tabs.forEach((tab) => {
-                if (draft.transactionCategorizationView[tab].fetchState ===
-                    'In-Progress' ||
-                    refreshViewInBackground !== true) {
+                const tabFetchState = draft.transactionCategorizationView[tab].fetchState;
+                if (refreshViewInBackground !== true) {
+                    // Foreground fetch completed: mark other tabs as Completed.
                     draft.transactionCategorizationView[tab].fetchState = 'Completed';
                     draft.transactionCategorizationView[tab].error = undefined;
                 }
-                else {
+                else if (tabFetchState !== 'In-Progress') {
+                    // Background fetch completed: reset the other tab's refreshStatus,
+                    // but only when it is not mid-load. During a dual-search the active
+                    // tab has its own foreground fetch in flight — clobbering its
+                    // fetchState here would drop the skeleton and show an empty list.
                     draft.transactionCategorizationView[tab].refreshStatus = {
                         fetchState: 'Not-Started',
                         error: undefined,
                     };
                 }
+                // If tabFetchState === 'In-Progress' and refreshViewInBackground === true,
+                // leave the other tab's state untouched — it has its own active fetch.
             });
         },
         fetchTransactionCategorizationFailure(draft, action) {

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

@@ -8,7 +8,7 @@ import { getVendorByVendorId } from '../../../entity/vendor/vendorSelector';
 import { getAllSteps } from '../selectorTypes/expenseAutomationViewSelectorTypes';
 export function getExpenseAutomationFluxAnalysisView(state) {
     const { expenseAutomationFluxAnalysisViewState, monthEndCloseChecksState, monthEndCloseChecksViewState, } = state;
-    const { fetchState, error, refreshStatus, uiState, reviewOperatingExpenseIdsByPeriod, selectedSectionIdsByPeriod, groupsBySelectedPeriod, fluxAnalysisEntities, bulkReviewStatus, currency, totalBalancesAndVariance, } = expenseAutomationFluxAnalysisViewState;
+    const { fetchState, error, lastRefreshSuccessTime, refreshStatus, uiState, reviewOperatingExpenseIdsByPeriod, selectedSectionIdsByPeriod, groupsBySelectedPeriod, fluxAnalysisEntities, bulkReviewStatus, currency, totalBalancesAndVariance, } = expenseAutomationFluxAnalysisViewState;
     const fetchStateAndError = {
         fetchState,
         error,
@@ -110,6 +110,7 @@ export function getExpenseAutomationFluxAnalysisView(state) {
         refreshStatus,
         currency,
         completionStatus,
+        lastRefreshSuccessTime,
     };
 }
 // Helper function to transform operating expense to vendor view

package/lib/esm/view/opExByVendor/opExByVendorReducer.js

@@ -22,6 +22,10 @@ export const initialState = {
             error: undefined,
         },
     },
+    refreshStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
     summaryFetchState: {
         fetchState: 'Not-Started',
         error: undefined,
@@ -259,12 +263,32 @@ const opexByVendor = createSlice({
                 [timeframe]: [],
             };
         },
+        refreshOpExByVendorReport(draft) {
+            draft.refreshStatus = { fetchState: 'In-Progress', error: undefined };
+        },
+        refreshOpExByVendorReportSuccess(draft, action) {
+            draft.refreshStatus = { fetchState: 'Completed', error: undefined };
+            if (action.payload.lastRefreshSuccessTime != null) {
+                draft.lastRefreshSuccessTime = action.payload.lastRefreshSuccessTime;
+            }
+        },
+        refreshOpExByVendorReportFailure: {
+            prepare(error) {
+                return { payload: { error } };
+            },
+            reducer(draft, action) {
+                draft.refreshStatus = {
+                    fetchState: 'Error',
+                    error: action.payload.error,
+                };
+            },
+        },
         clearOpExByVendor(draft) {
             Object.assign(draft, initialState);
         },
     },
 });
-export const { fetchOpExByVendor, updateOpExByVendorReportGenerated, fetchOpExByVendorReportForTimeframe, updateOpExByVendorReportFailureForTimeframe, updateOpExByVendorReportSuccessForTimeframe, fetchOpExByVendorReportSummary, updateOpExByVendorReportSummaryFailure, updateOpExByVendorReportSummarySuccess, updateOpExByVendorTimeFrame, updateOpExByVendorUIState, clearOpExByVendor, updateOpExByVendorAdditionalBalancesSelection, updateOpExByVendorSort, updateOpExByVendorSortOrSearchInProgress, updateOpExByVendorPageFetchInProgress, updateOpExByVendorDownloadState, clearOpExByVendorSearch, updateOpExByVendorPageLimit, updateOpExByVendorSearchString, } = opexByVendor.actions;
+export const { fetchOpExByVendor, updateOpExByVendorReportGenerated, fetchOpExByVendorReportForTimeframe, updateOpExByVendorReportFailureForTimeframe, updateOpExByVendorReportSuccessForTimeframe, fetchOpExByVendorReportSummary, updateOpExByVendorReportSummaryFailure, updateOpExByVendorReportSummarySuccess, updateOpExByVendorTimeFrame, updateOpExByVendorUIState, clearOpExByVendor, updateOpExByVendorAdditionalBalancesSelection, updateOpExByVendorSort, updateOpExByVendorSortOrSearchInProgress, updateOpExByVendorPageFetchInProgress, updateOpExByVendorDownloadState, clearOpExByVendorSearch, updateOpExByVendorPageLimit, updateOpExByVendorSearchString, refreshOpExByVendorReport, refreshOpExByVendorReportSuccess, refreshOpExByVendorReportFailure, } = opexByVendor.actions;
 export default opexByVendor.reducer;
 const doUpdateOpexByVendorReport = (draft, timeframe, reportPayload, queryProps) => {
     if (reportPayload.status.is_report_generated == null) {
@@ -317,10 +341,9 @@ const doUpdateOpexByVendorReportSummary = (draft, reportPayload) => {
         const report = mapReportPayloadToReport(reportPayload);
         draft.firstMonthOfFY = report.firstMonthOfFY;
         draft.bookCloseDate = report.bookCloseDate;
-        draft.lastRefreshSuccessTime =
-            reportPayload.status.last_refresh_success_time != null
-                ? date(reportPayload.status.last_refresh_success_time)
-                : undefined;
+        if (reportPayload.status.last_refresh_success_time != null) {
+            draft.lastRefreshSuccessTime = date(reportPayload.status.last_refresh_success_time);
+        }
         draft.totalOpexByVendor = combineCOABalanceGrouped(mapCOABalanceGroupedPayloadV2ToCOABalanceGrouped(reportPayload.operating_expenses, reportPayload.currency, 'month'), mapCOABalanceGroupedPayloadV2ToCOABalanceGrouped(reportPayload.operating_expenses, reportPayload.currency, 'quarter'));
         draft.summaryOpexByVendorKey = mapVendorSummaryBalances(reportPayload.operating_expenses, reportPayload.currency);
     }

package/lib/esm/view/opExByVendor/opExByVendorSelector.js

@@ -67,6 +67,7 @@ export const getOpExByVendorReport = createSelector((state) => state.opExByVendo
         filter,
         isReportGenerated: opExByVendorState.opExByVendorReportGenerated,
         lastRefreshSuccessTime: opExByVendorState.lastRefreshSuccessTime,
+        refreshStatus: opExByVendorState.refreshStatus,
         opexBalances,
         summaryBalances,
         allTimeframeTicks,

package/lib/esm/view/opExByVendor/refreshOpExByVendorReportEpic.js

@@ -0,0 +1,21 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus } from '../../responsePayload';
+import { date } from '../../zeniDayJS';
+import { refreshOpExByVendorReport, refreshOpExByVendorReportFailure, refreshOpExByVendorReportSuccess, } from './opExByVendorReducer';
+export const refreshOpExByVendorReportEpic = (actions$, _state, zeniAPI) => actions$.pipe(filter(refreshOpExByVendorReport.match), switchMap(() => {
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/reports/operating-expenses-by-vendor/refresh`)
+        .pipe(mergeMap((response) => {
+        if (response.status.code >= 200 && response.status.code < 300) {
+            const lastRefreshSuccessTime = response.status.last_refresh_success_time != null
+                ? date(response.status.last_refresh_success_time)
+                : undefined;
+            return of(refreshOpExByVendorReportSuccess({ lastRefreshSuccessTime }));
+        }
+        else {
+            return of(refreshOpExByVendorReportFailure(response.status));
+        }
+    }), catchError((error) => of(refreshOpExByVendorReportFailure(createZeniAPIStatus('Unexpected error', 'Refresh OpEx by Vendor REST API call errored out: ' +
+        JSON.stringify(error))))));
+}));

package/lib/index.d.ts

@@ -349,7 +349,7 @@ import { fetchOpEx, fetchOpExWithForecast, updateOpExCOABalancesRange, updateOpE
 import { getOperatingExpensesForHighlightedRange, getOperatingExpensesForSelectedRange, getOperatingExpensesReport, getOperatingExpensesReportFetchState, getOperatingExpensesUIState } from './view/opEx/opExSelector';
 import { OpExReport, OpExUIStateSelectorView } from './view/opEx/opExSelectorTypes';
 import { OpExState, OpExUIState } from './view/opEx/opExState';
-import { clearOpExByVendorSearch, fetchOpExByVendor, fetchOpExByVendorReportForTimeframe, updateOpExByVendorAdditionalBalancesSelection, updateOpExByVendorDownloadState, updateOpExByVendorPageFetchInProgress, updateOpExByVendorPageLimit, updateOpExByVendorSearchString, updateOpExByVendorSort, updateOpExByVendorSortOrSearchInProgress, updateOpExByVendorTimeFrame, updateOpExByVendorUIState } from './view/opExByVendor/opExByVendorReducer';
+import { clearOpExByVendorSearch, fetchOpExByVendor, fetchOpExByVendorReportForTimeframe, refreshOpExByVendorReport, updateOpExByVendorAdditionalBalancesSelection, updateOpExByVendorDownloadState, updateOpExByVendorPageFetchInProgress, updateOpExByVendorPageLimit, updateOpExByVendorSearchString, updateOpExByVendorSort, updateOpExByVendorSortOrSearchInProgress, updateOpExByVendorTimeFrame, updateOpExByVendorUIState } from './view/opExByVendor/opExByVendorReducer';
 import { OpExBalancesByVendor, OpExByVendorReport, OpExSummaryBalances, OpExVendorAndBalance, OpexVendorTimeframeKey, getOpExByVendorReport, getOpExByVendorUIState, getOpexVendorTimeframeKey, isOpexByVendorIDNotSpecifiedVendor } from './view/opExByVendor/opExByVendorSelector';
 import { OpExByVendorState, OpexByVendorSortKey, OpexByVendorUIState, toOpexByVendorSortKeyType } from './view/opExByVendor/opExByVendorState';
 import { fetchOpExClassesView, updateAccountViewMode as updateOpExAccountViewMode, updateClassesToFilterOut as updateOpExClassesToFilterOut, updateOpExClassesViewUIState } from './view/opExClassesView/opExClassesViewReducer';
@@ -702,7 +702,7 @@ export { CardBalanceState, getCardBalance, CardBalanceReport, fetchCardBalance,
 export { CashBalanceState, getCashBalance, CashBalanceReport, fetchCashBalance };
 export { fetchBillPayCard, fetchReimbursementCard };
 export { fetchOpEx, updateOpExCOABalancesRange, updateOpExDownloadState, updateOpExUIState, getOperatingExpensesReportFetchState, getOperatingExpensesReport, getOperatingExpensesUIState, getOperatingExpensesForSelectedRange, getOperatingExpensesForHighlightedRange, OpExReport, OpExState, OpExUIState, OpExUIStateSelectorView, fetchOpExWithForecast, };
-export { fetchOpExByVendor, fetchOpExByVendorReportForTimeframe, updateOpExByVendorTimeFrame, updateOpExByVendorUIState, OpExByVendorState, OpexByVendorSortKey, OpexByVendorUIState, OpExByVendorReport, getOpExByVendorReport, getOpExByVendorUIState, OpExBalancesByVendor, updateOpExByVendorAdditionalBalancesSelection, updateOpExByVendorSearchString, OpExSummaryBalances, updateOpExByVendorSort, updateOpExByVendorPageFetchInProgress, updateOpExByVendorSortOrSearchInProgress, updateOpExByVendorDownloadState, clearOpExByVendorSearch, updateOpExByVendorPageLimit, toOpexByVendorSortKeyType, OpExVendorAndBalance, OpexVendorTimeframeKey, getOpexVendorTimeframeKey, isOpexByVendorIDNotSpecifiedVendor, };
+export { fetchOpExByVendor, fetchOpExByVendorReportForTimeframe, refreshOpExByVendorReport, updateOpExByVendorTimeFrame, updateOpExByVendorUIState, OpExByVendorState, OpexByVendorSortKey, OpexByVendorUIState, OpExByVendorReport, getOpExByVendorReport, getOpExByVendorUIState, OpExBalancesByVendor, updateOpExByVendorAdditionalBalancesSelection, updateOpExByVendorSearchString, OpExSummaryBalances, updateOpExByVendorSort, updateOpExByVendorPageFetchInProgress, updateOpExByVendorSortOrSearchInProgress, updateOpExByVendorDownloadState, clearOpExByVendorSearch, updateOpExByVendorPageLimit, toOpexByVendorSortKeyType, OpExVendorAndBalance, OpexVendorTimeframeKey, getOpexVendorTimeframeKey, isOpexByVendorIDNotSpecifiedVendor, };
 export { fetchOpExClassesView, updateOpExAccountViewMode, updateOpExClassesToFilterOut, updateOpExClassesViewUIState, getOpExClassesView, getOpExClassesViewForHighlightedRange, getOpExClassesViewForSelectedRange, OpExClassesViewReport, isOpExClassesViewSectionID, isOpExClassesViewCalculatedSectionID, OpExClassesViewSectionID, OpExClassesViewCalculatedSectionID, };
 export { fetchNetBurnOrIncomeClassesView, updateNetBurnOrIncomeAccountViewMode, updateNetBurnOrIncomeClassesToFilterOut, updateNetBurnOrIncomeClassesViewUIState, getNetBurnOrIncomeClassesView, getNetBurnOrIncomeClassesViewForHighlightedRange, getNetBurnOrIncomeClassesViewForSelectedRange, NetBurnOrIncomeClassesViewReport, isNetBurnOrIncomeClassesViewSectionID, isNetBurnOrIncomeClassesViewCalculatedSectionID, NetBurnOrIncomeClassesViewCalculatedSectionID, NetBurnOrIncomeClassesViewSectionID, };
 export { fetchNetBurnOrIncome, updateNetBurnOrIncomeUIState, fetchNetBurnOrIncomeWithForecast, NetBurnOrIncomeState, NetBurnOrIncomeUIState, NetBurnOrIncomeReport, NetBurnOrIncomeCalculatedSectionID, NetBurnOrIncomeSectionID, updateNetBurnOrIncomeCOABalancesRange, updateNetBurnOrIncomeDownloadState, NetBurnOrIncomeUIStateSelectorView, getNetBurnOrIncomeReport, getNetBurnOrIncomeForSelectedRange, getNetBurnOrIncomeForHighlightedRange, getNetBurnOrIncomeUIState, getNetBurnOrIncomeReportFetchState, isNetBurnOrIncomeReportViewCalculatedSectionID, isNetBurnOrIncomeReportViewSectionID, };