@zeniai/client-epic-state 4.15.16 → 4.15.17

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

@@ -0,0 +1,375 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSaveReconciliationReviewFetchStatus = exports.saveReconciliationReview = exports.updateReviewTabLocalData = exports.initializeReconciliationReviewTabLocalData = exports.updateReviewTabSortState = exports.updateSelectedDrawerAccountId = exports.clearExpenseAutomationReconciliationView = exports.initialiseLocalDataForSelectedAccountId = exports.updateBalancesLocalData = exports.updateSelectedTab = exports.saveReconciliationDetailSuccess = exports.updateReconcileTabListScrollState = exports.updateReconcileTabListSortState = exports.updateReconcileTabLocalData = exports.setConnectionInProgressForAccount = exports.updateSelectedAccountId = exports.saveReconciliationDetailFailure = exports.saveReconciliationDetail = exports.fetchReconciliationSuccess = exports.fetchReconciliationFailure = exports.fetchReconciliation = exports.initialState = exports.initialActionFetchState = exports.initialReconciliationTabsState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
+const accountReconState_1 = require("../../../entity/accountRecon/accountReconState");
+// Initial state
+exports.initialReconciliationTabsState = {
+    balances: {
+        clearedBalance: { amount: 0, currencyCode: 'USD', currencySymbol: '$' },
+        variance: { amount: 0, currencyCode: 'USD', currencySymbol: '$' },
+        variancePercentage: 0,
+        deposits: {
+            count: 0,
+            totalAmount: { amount: 0, currencyCode: 'USD', currencySymbol: '$' },
+        },
+        payments: {
+            count: 0,
+            totalAmount: { amount: 0, currencyCode: 'USD', currencySymbol: '$' },
+        },
+    },
+    reconcile: {
+        localData: {
+            selectedTransactionIds: [],
+        },
+        uiState: {
+            scrollYOffset: undefined,
+            sortKey: 'date',
+            sortOrder: 'ascending',
+        },
+    },
+    review: {
+        localData: {},
+        uiState: {
+            scrollPosition: undefined,
+            sortKey: 'date',
+            sortOrder: 'descending',
+        },
+    },
+};
+exports.initialActionFetchState = {
+    excludeFetchById: {},
+    reconcileFetch: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    saveForLaterFetch: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    saveReconciliationReviewFetch: {},
+};
+exports.initialState = {
+    accountReconciliationRecordsBySelectedPeriod: {},
+    accountConnectionStatusByAccountID: {},
+    fetchState: 'Not-Started',
+    error: undefined,
+    selectedTab: 'review',
+    reconTabsState: exports.initialReconciliationTabsState,
+    refreshStatus: { fetchState: 'Not-Started', error: undefined },
+    actionFetchState: exports.initialActionFetchState,
+    selectedAccountId: undefined,
+};
+// Create slice with reducers
+const expenseAutomationReconciliationView = (0, toolkit_1.createSlice)({
+    name: 'expenseAutomationReconciliationView',
+    initialState: exports.initialState,
+    reducers: {
+        fetchReconciliation: {
+            reducer(draft, action) {
+                if (action.payload.accountId == null) {
+                    if (action.payload.refreshViewInBackground === true) {
+                        draft.refreshStatus = { fetchState: 'In-Progress', error: undefined };
+                    }
+                    else {
+                        draft.fetchState = 'In-Progress';
+                        draft.error = undefined;
+                    }
+                }
+                else {
+                    // select the account for which we are fetching
+                    draft.selectedAccountId = action.payload.accountId;
+                    const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(action.payload.selectedPeriod)];
+                    const { transactionFetchState } = accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId];
+                    if (transactionFetchState.fetchState !== 'Completed' ||
+                        action.payload.cacheOverride === true) {
+                        const data = accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId];
+                        if (action.payload.refreshViewInBackground === true) {
+                            accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId] = Object.assign(Object.assign({}, data), { refreshStatus: {
+                                    fetchState: 'In-Progress',
+                                    error: undefined,
+                                }, accountId: action.payload.accountId, reconciliationId: undefined });
+                        }
+                        else {
+                            accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId] = Object.assign(Object.assign({}, data), { transactionFetchState: {
+                                    fetchState: 'In-Progress',
+                                    error: undefined,
+                                }, accountId: action.payload.accountId, reconciliationId: undefined });
+                        }
+                    }
+                }
+            },
+            prepare(selectedPeriod, accountId, cacheOverride = false, refreshViewInBackground = false) {
+                return {
+                    payload: {
+                        selectedPeriod,
+                        accountId,
+                        cacheOverride,
+                        refreshViewInBackground,
+                    },
+                };
+            },
+        },
+        fetchReconciliationSuccess: {
+            reducer(draft, action) {
+                if (action.payload.accountId == null) {
+                    updateAllReconciliation(draft, action.payload.selectedPeriod, action.payload.reconciliation.reconciliation, action.payload.refreshViewInBackground);
+                }
+                else if (action.payload.reconciliation.reconciliation.length > 0) {
+                    updateReconciliationByAccountID(draft, action.payload.selectedPeriod, action.payload.accountId, action.payload.reconciliation.reconciliation[0], action.payload.refreshViewInBackground);
+                }
+            },
+            prepare(selectedPeriod, reconciliation, refreshViewInBackground = false, accountId, reconciliationId) {
+                return {
+                    payload: {
+                        selectedPeriod,
+                        accountId,
+                        refreshViewInBackground,
+                        reconciliation,
+                        reconciliationId,
+                    },
+                };
+            },
+        },
+        fetchReconciliationFailure: (draft, action) => {
+            if (action.payload.accountId == null) {
+                if (action.payload.refreshViewInBackground === true) {
+                    draft.refreshStatus = {
+                        fetchState: 'Error',
+                        error: action.payload.error,
+                    };
+                }
+                else {
+                    draft.error = action.payload.error;
+                    draft.fetchState = 'Error';
+                }
+            }
+            else {
+                const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(action.payload.selectedPeriod)];
+                if (action.payload.refreshViewInBackground === true) {
+                    accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId].refreshStatus.error = action.payload.error;
+                    accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId].refreshStatus.fetchState = 'Error';
+                }
+                else {
+                    accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId].transactionFetchState.error = action.payload.error;
+                    accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId].transactionFetchState.fetchState = 'Error';
+                }
+            }
+        },
+        saveReconciliationDetail: (draft, action) => {
+            const { reconcileAction } = action.payload;
+            if (reconcileAction === 'reconcile') {
+                draft.actionFetchState.reconcileFetch = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            }
+            else if (reconcileAction === 'save_reconcile_for_later') {
+                draft.actionFetchState.saveForLaterFetch = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            }
+            else if (reconcileAction === 'exclude') {
+                const excludeTransactionId = action.payload.excludeTransactionId;
+                const excludeFetchStates = draft.actionFetchState.excludeFetchById;
+                draft.actionFetchState.excludeFetchById = Object.assign(Object.assign({}, excludeFetchStates), { [excludeTransactionId]: {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    } });
+            }
+        },
+        saveReconciliationDetailFailure: (draft, action) => {
+            const { reconcileAction } = action.payload.fetchStateByAction;
+            const { error } = action.payload;
+            if (reconcileAction === 'reconcile') {
+                draft.actionFetchState.reconcileFetch = {
+                    fetchState: 'Error',
+                    error: error,
+                };
+            }
+            else if (reconcileAction === 'save_reconcile_for_later') {
+                draft.actionFetchState.saveForLaterFetch = {
+                    fetchState: 'Error',
+                    error: error,
+                };
+            }
+            else if (reconcileAction === 'exclude') {
+                const excludeTransactionId = action.payload.fetchStateByAction.excludeTransactionId;
+                const excludeFetchStates = draft.actionFetchState.excludeFetchById;
+                draft.actionFetchState.excludeFetchById = Object.assign(Object.assign({}, excludeFetchStates), { [excludeTransactionId]: {
+                        fetchState: 'Error',
+                        error: error,
+                    } });
+            }
+        },
+        saveReconciliationDetailSuccess: (draft, action) => {
+            const { reconcileAction } = action.payload;
+            if (reconcileAction === 'reconcile') {
+                draft.actionFetchState.reconcileFetch = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+            }
+            else if (reconcileAction === 'save_reconcile_for_later') {
+                draft.actionFetchState.saveForLaterFetch = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+            }
+            else if (reconcileAction === 'exclude') {
+                const excludeTransactionId = action.payload.excludeTransactionId;
+                const excludeFetchStates = draft.actionFetchState.excludeFetchById;
+                draft.actionFetchState.excludeFetchById = Object.assign(Object.assign({}, excludeFetchStates), { [excludeTransactionId]: {
+                        fetchState: 'Completed',
+                        error: undefined,
+                    } });
+            }
+        },
+        updateReconcileTabLocalData: (draft, action) => {
+            const { selectedTransactionIds } = action.payload;
+            draft.reconTabsState.reconcile.localData.selectedTransactionIds =
+                selectedTransactionIds;
+        },
+        updateBalancesLocalData: (draft, action) => {
+            const { clearedBalance, variance, payments, deposits, variancePercentage } = action.payload;
+            draft.reconTabsState.balances = {
+                clearedBalance,
+                variance,
+                variancePercentage,
+                payments: payments,
+                deposits: deposits,
+            };
+        },
+        updateSelectedAccountId: (draft, action) => {
+            draft.selectedAccountId = action.payload.selectedAccountId;
+        },
+        updateSelectedDrawerAccountId: (draft, action) => {
+            draft.selectedDrawerAccountId = action.payload.selectedDrawerAccountId;
+        },
+        initialiseLocalDataForSelectedAccountId: () => { },
+        updateSelectedTab: (draft, action) => {
+            const { selectedTab } = action.payload;
+            draft.selectedTab = selectedTab;
+        },
+        updateReconcileTabListSortState: (draft, action) => {
+            draft.reconTabsState.reconcile.uiState = Object.assign(Object.assign({}, draft.reconTabsState.reconcile.uiState), { sortOrder: action.payload.sortOrder, sortKey: action.payload.sortKey });
+        },
+        updateReviewTabSortState: (draft, action) => {
+            draft.reconTabsState.review.uiState = Object.assign(Object.assign({}, draft.reconTabsState.review.uiState), { sortOrder: action.payload.sortOrder, sortKey: action.payload.sortKey });
+        },
+        updateReconcileTabListScrollState: (draft, action) => {
+            draft.reconTabsState.reconcile.uiState = Object.assign(Object.assign({}, draft.reconTabsState.reconcile.uiState), { scrollYOffset: action.payload.scrollYOffset });
+        },
+        updateReviewTabLocalData(draft, action) {
+            const { data, transactionId } = action.payload;
+            draft.reconTabsState.review.localData = Object.assign(Object.assign({}, draft.reconTabsState.review.localData), { [transactionId]: data });
+        },
+        saveReconciliationReview: {
+            reducer(draft, action) {
+                const { transactionId } = action.payload;
+                draft.actionFetchState.saveReconciliationReviewFetch[transactionId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(transactionId) {
+                return {
+                    payload: {
+                        transactionId,
+                    },
+                };
+            },
+        },
+        updateSaveReconciliationReviewFetchStatus: (draft, action) => {
+            const { transactionId, error, fetchState } = action.payload;
+            draft.actionFetchState.saveReconciliationReviewFetch[transactionId] = {
+                fetchState: fetchState,
+                error,
+            };
+        },
+        initializeReconciliationReviewTabLocalData: {
+            reducer(draft, action) {
+                draft.reconTabsState.review.localData = action.payload.localData;
+            },
+            prepare(localData) {
+                return {
+                    payload: { localData },
+                };
+            },
+        },
+        setConnectionInProgressForAccount: (draft, action) => {
+            if (draft.accountConnectionStatusByAccountID[action.payload.accountId] ==
+                null) {
+                console.error(`Account ${action.payload.accountId} not found to set connection in progress`);
+            }
+            else {
+                draft.accountConnectionStatusByAccountID[action.payload.accountId] = Object.assign(Object.assign({}, draft.accountConnectionStatusByAccountID[action.payload.accountId]), { connectionInProgress: action.payload.connectionInProgress });
+            }
+        },
+        clearExpenseAutomationReconciliationView: (draft) => {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+// Export actions
+_a = expenseAutomationReconciliationView.actions, exports.fetchReconciliation = _a.fetchReconciliation, exports.fetchReconciliationFailure = _a.fetchReconciliationFailure, exports.fetchReconciliationSuccess = _a.fetchReconciliationSuccess, exports.saveReconciliationDetail = _a.saveReconciliationDetail, exports.saveReconciliationDetailFailure = _a.saveReconciliationDetailFailure, exports.updateSelectedAccountId = _a.updateSelectedAccountId, exports.setConnectionInProgressForAccount = _a.setConnectionInProgressForAccount, exports.updateReconcileTabLocalData = _a.updateReconcileTabLocalData, exports.updateReconcileTabListSortState = _a.updateReconcileTabListSortState, exports.updateReconcileTabListScrollState = _a.updateReconcileTabListScrollState, exports.saveReconciliationDetailSuccess = _a.saveReconciliationDetailSuccess, exports.updateSelectedTab = _a.updateSelectedTab, exports.updateBalancesLocalData = _a.updateBalancesLocalData, exports.initialiseLocalDataForSelectedAccountId = _a.initialiseLocalDataForSelectedAccountId, exports.clearExpenseAutomationReconciliationView = _a.clearExpenseAutomationReconciliationView, exports.updateSelectedDrawerAccountId = _a.updateSelectedDrawerAccountId, exports.updateReviewTabSortState = _a.updateReviewTabSortState, exports.initializeReconciliationReviewTabLocalData = _a.initializeReconciliationReviewTabLocalData, exports.updateReviewTabLocalData = _a.updateReviewTabLocalData, exports.saveReconciliationReview = _a.saveReconciliationReview, exports.updateSaveReconciliationReviewFetchStatus = _a.updateSaveReconciliationReviewFetchStatus;
+// Export reducer
+exports.default = expenseAutomationReconciliationView.reducer;
+function updateAllReconciliation(draft, selectedPeriod, reconciliationData, refreshViewInBackground) {
+    draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = {
+        accountIDs: [],
+        reconciliationByAccountID: {},
+    };
+    const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)];
+    reconciliationData.forEach((reconciliation) => {
+        var _a;
+        const oldConnectionStatus = draft.accountConnectionStatusByAccountID[reconciliation.account_id];
+        if (oldConnectionStatus == null) {
+            draft.accountConnectionStatusByAccountID[reconciliation.account_id] = {
+                status: (0, accountReconState_1.toBankStatusCodeType)(reconciliation.bank_status.code),
+                connectionInProgress: false,
+            };
+        }
+        else {
+            draft.accountConnectionStatusByAccountID[reconciliation.account_id] = {
+                status: (0, accountReconState_1.toBankStatusCodeType)(reconciliation.bank_status.code),
+                connectionInProgress: !(reconciliation.bank_status.code === 'connected' &&
+                    oldConnectionStatus.connectionInProgress === true),
+            };
+        }
+        accountReconciliationRecords.reconciliationByAccountID[reconciliation.account_id] = {
+            accountId: reconciliation.account_id,
+            reconciliationId: (_a = reconciliation.reconciliation_id) !== null && _a !== void 0 ? _a : undefined,
+            transactionFetchState: { fetchState: 'Not-Started', error: undefined },
+            refreshStatus: { fetchState: 'Not-Started', error: undefined },
+        };
+        accountReconciliationRecords.accountIDs.push(reconciliation.account_id);
+    });
+    if (refreshViewInBackground === true) {
+        draft.refreshStatus = {
+            fetchState: 'Completed',
+            error: undefined,
+        };
+    }
+    else {
+        draft.fetchState = 'Completed';
+        draft.error = undefined;
+    }
+}
+function updateReconciliationByAccountID(draft, selectedPeriod, accountId, reconciliationData, refreshViewInBackground) {
+    var _a, _b;
+    const oldRecord = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)].reconciliationByAccountID[accountId];
+    draft.accountConnectionStatusByAccountID[accountId] = {
+        status: (0, accountReconState_1.toBankStatusCodeType)(reconciliationData.bank_status.code),
+        connectionInProgress: false,
+    };
+    if (refreshViewInBackground === true) {
+        draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)].reconciliationByAccountID[accountId] = Object.assign(Object.assign({}, oldRecord), { reconciliationId: (_a = reconciliationData.reconciliation_id) !== null && _a !== void 0 ? _a : undefined, refreshStatus: { fetchState: 'Completed', error: undefined } });
+    }
+    else {
+        draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)].reconciliationByAccountID[accountId] = Object.assign(Object.assign({}, oldRecord), { reconciliationId: (_b = reconciliationData.reconciliation_id) !== null && _b !== void 0 ? _b : undefined, transactionFetchState: { fetchState: 'Completed', error: undefined } });
+    }
+}

package/lib/view/expenseAutomationView/selectorTypes/expenseAutomationViewSelectorTypes.d.ts

@@ -9,6 +9,7 @@ import { TransactionsTab } from '../types/transactionsViewState';
 import { ExpenseAutomationFluxAnalysisViewSelector } from './fluxAnalysisViewSelectorTypes';
 import { ExpenseAutomationJESchedulesViewSelector } from './jeSchedulesSelectorTypes';
 import { ExpenseAutomationMissingReceiptsViewSelector } from './missingReceiptsSelectorTypes';
+import { ExpenseAutomationReconciliationViewSelector } from './reconciliationViewSelectorTypes';
 import { ExpenseAutomationTransactionViewSelector } from './transactionsViewSelectorTypes';
 export interface ExpenseAutomationStepDetails {
     step: ExpenseAutomationViewType;
@@ -29,6 +30,7 @@ export interface ExpenseAutomationViewSelector extends SelectorView {
     jeSchedules: ExpenseAutomationJESchedulesViewSelector;
     missingReceipts: ExpenseAutomationMissingReceiptsViewSelector;
     fluxAnalysis: ExpenseAutomationFluxAnalysisViewSelector;
+    reconciliation: ExpenseAutomationReconciliationViewSelector;
     monthEndInsights?: CompanyMonthEndReportSelectorView;
     saveStatus: FetchStateAndError;
     updateStatus: FetchStateAndError;

package/lib/view/expenseAutomationView/selectorTypes/expenseAutomationViewSelectorTypes.js

@@ -19,7 +19,7 @@ const getAllSteps = (monthEndCloseChecksState, monthYearId, tenantId, auditSumma
                         isPrevDisabled: false,
                         isNextDisabled: false,
                     };
-                case 'account_recon':
+                case 'reconciliation':
                 case 'je_schedules':
                 case 'missing_receipts':
                 case 'flux_analysis':

package/lib/view/expenseAutomationView/selectorTypes/reconciliationViewSelectorTypes.d.ts

@@ -0,0 +1,50 @@
+import { NestedAccountHierarchyForReport } from '../../../commonStateTypes/accountView/nestedAccountID';
+import { Amount } from '../../../commonStateTypes/amount';
+import { NestedClassHierarchyForReport } from '../../../commonStateTypes/classesView/nestedClassID';
+import { CompletionStatusType, FetchStateAndError, ID } from '../../../commonStateTypes/common';
+import { MonthYearPeriod } from '../../../commonStateTypes/timePeriod';
+import { AccountBase } from '../../../entity/account/accountState';
+import { AccountReconciliationEntity } from '../../../entity/accountRecon/accountReconSelector';
+import { BankStatusCodeType } from '../../../entity/accountRecon/accountReconState';
+import { ClassBase } from '../../../entity/class/classState';
+import { PlaidConnectionDetails } from '../../spendManagement/plaidAccount/plaidAccountViewState';
+import { ActionFetchStates, ReconciliationTabsState, ReconciliationViewTabType } from '../types/reconciliationViewState';
+export declare const ALL_ACCOUNT_RECON_SECTION_IDS: readonly ["assets", "liabilities"];
+declare const toAccountReconSectionID: (v: string) => "assets" | "liabilities";
+export type AccountReconSectionID = ReturnType<typeof toAccountReconSectionID>;
+export interface ExpenseAutomationReconciliationViewSelector {
+    fetchStatus: FetchStateAndError;
+    refreshStatus: FetchStateAndError;
+    completionStatus: CompletionStatusType;
+    selectedTab: ReconciliationViewTabType;
+    monthYearPeriod: MonthYearPeriod;
+    plaidConnectionDetails: PlaidConnectionDetails;
+    accountReconciliationBySectionID: Record<AccountReconSectionID, AccountReconciliationBySection>;
+    accountReconciliationsByAccountID: Record<ID, AccountReconciliationByAccount>;
+    reconciliationTabsState: ReconciliationTabsState;
+    selectedAccountId?: ID;
+    selectedReconAccount?: AccountReconciliationByAccount;
+    selectedDrawerAccountId?: ID;
+    actionFetchStates: ActionFetchStates;
+    accountListNestedAccountHierarchy: NestedAccountHierarchyForReport[];
+    classListNestedAccountHierarchy: NestedClassHierarchyForReport[];
+    allAccountList: AccountBase[];
+    allClassList: ClassBase[];
+}
+export interface AccountReconciliationBySection {
+    sectionId: AccountReconSectionID;
+    accountIDs: ID[];
+    totalBankBalance?: Amount;
+    totalClearedBalance?: Amount;
+    totalReconciledBalance?: Amount;
+    totalVariance?: Amount;
+    totalVariancePercentage?: number;
+}
+export interface AccountReconciliationByAccount {
+    accountConnectionStatus: BankStatusCodeType;
+    connectionInProgress: boolean;
+    accountReconEntity: AccountReconciliationEntity;
+    transactionFetchState: FetchStateAndError;
+    refreshStatus: FetchStateAndError;
+}
+export {};

package/lib/view/expenseAutomationView/selectorTypes/reconciliationViewSelectorTypes.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_ACCOUNT_RECON_SECTION_IDS = void 0;
+const stringToUnion_1 = require("../../../commonStateTypes/stringToUnion");
+exports.ALL_ACCOUNT_RECON_SECTION_IDS = ['assets', 'liabilities'];
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const toAccountReconSectionID = (v) => (0, stringToUnion_1.stringToUnion)(v, exports.ALL_ACCOUNT_RECON_SECTION_IDS);

package/lib/view/expenseAutomationView/selectors/reconciliationViewSelector.d.ts

@@ -0,0 +1,5 @@
+import { ReportIDPlusForecastID } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { RootState } from '../../../reducer';
+import { ExpenseAutomationReconciliationViewSelector } from '../selectorTypes/reconciliationViewSelectorTypes';
+export declare const getExpenseAutomationReconciliationView: (state: RootState) => ExpenseAutomationReconciliationViewSelector;
+export declare const isAccountReconReport: (reportId: ReportIDPlusForecastID) => boolean;