@zeniai/client-epic-state 4.19.85 → 4.19.86-betaNB1

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

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.backgroundRefetchReviewTab = exports.syncTransactionCategorizationFromDetailSave = exports.updateSelectedTransactionId = exports.setEntityRecommendationForLineIdsForCategorization = exports.clearExpenseAutomationTransactionsView = exports.clearExpenseAutomationTransactionsViewPerTabView = exports.updateSelectedCheckboxTransactionIds = exports.fetchTransactionCategorizationView = exports.resetOtherTabsFetchState = exports.fetchTransactionCategorizationSuccess = exports.updateTotalCountForTransactionCategorization = exports.setAllItemsToCategoryClassInLocalDataForCategorization = exports.updateSelectedCustomerForTransaction = exports.updateSelectedVendorForTransaction = exports.updateStatusForTransactionNotMiscategorizedUpdateForCategorization = exports.markTransactionAsNotMiscategorized = exports.updateTransactionCategorizationSaveStatus = exports.updateCurrentSelectedTransactionCategorizationTab = exports.updateTransactionCategorization = exports.saveTransactionCategorization = exports.fetchTransactionCategorizationFailure = exports.saveTransactionCategorizationLocalData = exports.initializeTransactionCategorizationViewLocalData = exports.updateTransactionCategorizationUIState = exports.fetchTransactionCategorization = exports.initialState = exports.initialTransactionTabViewState = void 0;
+exports.uploadTransactionCategorizationReceiptSuccess = exports.updateTransactionCategorizationUploadReceiptState = exports.backgroundRefetchReviewTab = exports.syncTransactionCategorizationFromDetailSave = exports.updateSelectedTransactionId = exports.setEntityRecommendationForLineIdsForCategorization = exports.clearExpenseAutomationTransactionsView = exports.clearExpenseAutomationTransactionsViewPerTabView = exports.updateSelectedCheckboxTransactionIds = exports.fetchTransactionCategorizationView = exports.resetOtherTabsFetchState = exports.fetchTransactionCategorizationSuccess = exports.updateTotalCountForTransactionCategorization = exports.setAllItemsToCategoryClassInLocalDataForCategorization = exports.updateSelectedCustomerForTransaction = exports.updateSelectedVendorForTransaction = exports.updateStatusForTransactionNotMiscategorizedUpdateForCategorization = exports.markTransactionAsNotMiscategorized = exports.updateTransactionCategorizationSaveStatus = exports.updateCurrentSelectedTransactionCategorizationTab = exports.updateTransactionCategorization = exports.saveTransactionCategorization = exports.fetchTransactionCategorizationFailure = exports.saveTransactionCategorizationLocalData = exports.initializeTransactionCategorizationViewLocalData = exports.updateTransactionCategorizationUIState = exports.fetchTransactionCategorization = exports.initialState = exports.initialTransactionTabViewState = void 0;
 const toolkit_1 = require("@reduxjs/toolkit");
 const get_1 = __importDefault(require("lodash/get"));
 const uniq_1 = __importDefault(require("lodash/uniq"));
@@ -43,6 +43,7 @@ exports.initialTransactionTabViewState = {
     transactionIdsBySelectedPeriod: {},
     selectedCheckBoxTransactionIds: [],
     transactionIdsWithUnsavedData: [],
+    uploadReceiptStatusById: {},
     selectedTransactionId: undefined,
     selectedTransactionLineId: undefined,
 };
@@ -706,6 +707,24 @@ const expenseAutomationTransactionsView = (0, toolkit_1.createSlice)({
         clearExpenseAutomationTransactionsView(draft) {
             Object.assign(draft, exports.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 {
@@ -777,5 +796,5 @@ const expenseAutomationTransactionsView = (0, toolkit_1.createSlice)({
         },
     },
 });
-_a = expenseAutomationTransactionsView.actions, exports.fetchTransactionCategorization = _a.fetchTransactionCategorization, exports.updateTransactionCategorizationUIState = _a.updateTransactionCategorizationUIState, exports.initializeTransactionCategorizationViewLocalData = _a.initializeTransactionCategorizationViewLocalData, exports.saveTransactionCategorizationLocalData = _a.saveTransactionCategorizationLocalData, exports.fetchTransactionCategorizationFailure = _a.fetchTransactionCategorizationFailure, exports.saveTransactionCategorization = _a.saveTransactionCategorization, exports.updateTransactionCategorization = _a.updateTransactionCategorization, exports.updateCurrentSelectedTransactionCategorizationTab = _a.updateCurrentSelectedTransactionCategorizationTab, exports.updateTransactionCategorizationSaveStatus = _a.updateTransactionCategorizationSaveStatus, exports.markTransactionAsNotMiscategorized = _a.markTransactionAsNotMiscategorized, exports.updateStatusForTransactionNotMiscategorizedUpdateForCategorization = _a.updateStatusForTransactionNotMiscategorizedUpdateForCategorization, exports.updateSelectedVendorForTransaction = _a.updateSelectedVendorForTransaction, exports.updateSelectedCustomerForTransaction = _a.updateSelectedCustomerForTransaction, exports.setAllItemsToCategoryClassInLocalDataForCategorization = _a.setAllItemsToCategoryClassInLocalDataForCategorization, exports.updateTotalCountForTransactionCategorization = _a.updateTotalCountForTransactionCategorization, exports.fetchTransactionCategorizationSuccess = _a.fetchTransactionCategorizationSuccess, exports.resetOtherTabsFetchState = _a.resetOtherTabsFetchState, exports.fetchTransactionCategorizationView = _a.fetchTransactionCategorizationView, exports.updateSelectedCheckboxTransactionIds = _a.updateSelectedCheckboxTransactionIds, exports.clearExpenseAutomationTransactionsViewPerTabView = _a.clearExpenseAutomationTransactionsViewPerTabView, exports.clearExpenseAutomationTransactionsView = _a.clearExpenseAutomationTransactionsView, exports.setEntityRecommendationForLineIdsForCategorization = _a.setEntityRecommendationForLineIdsForCategorization, exports.updateSelectedTransactionId = _a.updateSelectedTransactionId, exports.syncTransactionCategorizationFromDetailSave = _a.syncTransactionCategorizationFromDetailSave, exports.backgroundRefetchReviewTab = _a.backgroundRefetchReviewTab;
+_a = expenseAutomationTransactionsView.actions, exports.fetchTransactionCategorization = _a.fetchTransactionCategorization, exports.updateTransactionCategorizationUIState = _a.updateTransactionCategorizationUIState, exports.initializeTransactionCategorizationViewLocalData = _a.initializeTransactionCategorizationViewLocalData, exports.saveTransactionCategorizationLocalData = _a.saveTransactionCategorizationLocalData, exports.fetchTransactionCategorizationFailure = _a.fetchTransactionCategorizationFailure, exports.saveTransactionCategorization = _a.saveTransactionCategorization, exports.updateTransactionCategorization = _a.updateTransactionCategorization, exports.updateCurrentSelectedTransactionCategorizationTab = _a.updateCurrentSelectedTransactionCategorizationTab, exports.updateTransactionCategorizationSaveStatus = _a.updateTransactionCategorizationSaveStatus, exports.markTransactionAsNotMiscategorized = _a.markTransactionAsNotMiscategorized, exports.updateStatusForTransactionNotMiscategorizedUpdateForCategorization = _a.updateStatusForTransactionNotMiscategorizedUpdateForCategorization, exports.updateSelectedVendorForTransaction = _a.updateSelectedVendorForTransaction, exports.updateSelectedCustomerForTransaction = _a.updateSelectedCustomerForTransaction, exports.setAllItemsToCategoryClassInLocalDataForCategorization = _a.setAllItemsToCategoryClassInLocalDataForCategorization, exports.updateTotalCountForTransactionCategorization = _a.updateTotalCountForTransactionCategorization, exports.fetchTransactionCategorizationSuccess = _a.fetchTransactionCategorizationSuccess, exports.resetOtherTabsFetchState = _a.resetOtherTabsFetchState, exports.fetchTransactionCategorizationView = _a.fetchTransactionCategorizationView, exports.updateSelectedCheckboxTransactionIds = _a.updateSelectedCheckboxTransactionIds, exports.clearExpenseAutomationTransactionsViewPerTabView = _a.clearExpenseAutomationTransactionsViewPerTabView, exports.clearExpenseAutomationTransactionsView = _a.clearExpenseAutomationTransactionsView, exports.setEntityRecommendationForLineIdsForCategorization = _a.setEntityRecommendationForLineIdsForCategorization, exports.updateSelectedTransactionId = _a.updateSelectedTransactionId, exports.syncTransactionCategorizationFromDetailSave = _a.syncTransactionCategorizationFromDetailSave, exports.backgroundRefetchReviewTab = _a.backgroundRefetchReviewTab, exports.updateTransactionCategorizationUploadReceiptState = _a.updateTransactionCategorizationUploadReceiptState, exports.uploadTransactionCategorizationReceiptSuccess = _a.uploadTransactionCategorizationReceiptSuccess;
 exports.default = expenseAutomationTransactionsView.reducer;

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

@@ -28,6 +28,7 @@ export interface ExpenseAutomationTransactionViewSelector extends SelectorView {
     transactions: SupportedTransactionWithCOT[];
     uiState: TransactionsViewUIState;
     uncategorizedAccounts: UncategorizedAccounts;
+    uploadReceiptStatusById: Record<ID, FetchStateAndError>;
     selectedTransactionId?: ID;
     selectedTransactionLineId?: ID;
 }

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

@@ -16,7 +16,7 @@ const expenseAutomationViewSelectorTypes_1 = require("../selectorTypes/expenseAu
 function getExpenseAutomationTransactionView(state) {
     const { accountState, classState, classListState, accountListState, expenseAutomationTransactionsViewState, expenseAutomationViewState, transactionState, monthEndCloseChecksState, } = state;
     const { selectedTransactionCategorizationTab } = expenseAutomationTransactionsViewState;
-    const { uiState, refreshStatus, saveStatus, markAsNotMiscategorizedStatus, transactionIdsBySelectedPeriod, transactionReviewLocalDataById, selectedCheckBoxTransactionIds, transactionIdsWithUnsavedData, selectedTransactionId, selectedTransactionLineId, } = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTransactionCategorizationTab];
+    const { uiState, refreshStatus, saveStatus, markAsNotMiscategorizedStatus, transactionIdsBySelectedPeriod, transactionReviewLocalDataById, selectedCheckBoxTransactionIds, transactionIdsWithUnsavedData, uploadReceiptStatusById, selectedTransactionId, selectedTransactionLineId, } = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTransactionCategorizationTab];
     const uncategorizedIncomeExpense = (0, accountListSelector_1.getUncategorizedAccounts)(accountState, accountListState, 'accountList');
     const accountList = (0, accountListSelector_1.getAccountList)(accountState, accountListState, 'accountList');
     const classList = (0, classListSelector_1.getClassList)(classState, classListState);
@@ -100,6 +100,7 @@ function getExpenseAutomationTransactionView(state) {
         completionStatus,
         totalCountByTab,
         fetchStateByTransactionTabs: fetchStateByTab,
+        uploadReceiptStatusById,
         selectedTransactionId,
         selectedTransactionLineId,
     };

package/lib/view/expenseAutomationView/types/transactionsViewState.d.ts

@@ -15,7 +15,7 @@ import { VendorBase } from '../../../entity/vendor/vendorState';
 import { ZeniDate } from '../../../zeniDayJS';
 import { EntityRecommendationKey } from '../../recommendation/recommendationState';
 import { TransactionDetailKey } from '../../transactionDetail/transactionDetailState';
-export declare const toTransactionsSortKey: (v: string) => "date" | "amount" | "vendor" | "category" | "class" | "memo" | "transaction_type";
+export declare const toTransactionsSortKey: (v: string) => "date" | "amount" | "vendor" | "category" | "class" | "payment_account" | "transaction_type" | "memo_and_receipt";
 export type TransactionsSortKey = ReturnType<typeof toTransactionsSortKey>;
 export declare const TRANSACTIONS_TABS: readonly ["review", "autoCategorized"];
 export declare const toTransactionsTabKey: (v: string) => "review" | "autoCategorized";
@@ -97,6 +97,7 @@ export interface TransactionsTabViewState extends FetchedState {
     transactionIdsWithUnsavedData: ID[];
     transactionReviewLocalDataById: Record<ID | TransactionDetailKey, SupportedTransactionCategorization>;
     uiState: TransactionsViewUIState;
+    uploadReceiptStatusById: Record<ID, FetchStateAndError>;
     selectedTransactionId?: ID;
     selectedTransactionLineId?: ID;
 }

package/lib/view/expenseAutomationView/types/transactionsViewState.js

@@ -7,10 +7,11 @@ const TRANSACTIONS_SORT_KEYS = [
     'vendor',
     'amount',
     'transaction_type',
+    'payment_account',
     'date',
     'category',
     'class',
-    'memo',
+    'memo_and_receipt',
 ];
 const toTransactionsSortKey = (v) => (0, stringToUnion_1.stringToUnion)(v, TRANSACTIONS_SORT_KEYS);
 exports.toTransactionsSortKey = toTransactionsSortKey;

package/lib/view/spendManagement/autotransferRules/autoTransferRulesPayload.d.ts

@@ -0,0 +1,75 @@
+import { Amount } from '../../../commonStateTypes/amount';
+import { ZeniAPIResponse } from '../../../responsePayload';
+import { ZeniDate } from '../../../zeniDayJS';
+import { FundingAccount } from '../commonSetup/setupViewSelector';
+import { TreasuryAccount } from '../treasury/treasuryTransferMoney/treasuryTransferMoneyState';
+import { AutoTransferRule } from './autoTransferRulesState';
+export type AutoTransferRuleType = 'minimum_balance' | 'recurring' | 'percentage_of_balance';
+export type AutoTransferRuleFrequency = 'daily' | 'weekly' | 'monthly';
+export interface DestinationBankAccountMetadataPayload {
+    account_id: string;
+    account_type: string;
+    percentage: number;
+}
+export interface AutoTransferRulePayload {
+    amount: number;
+    auto_transfer_rule_id: string;
+    create_time: string;
+    created_by_user_id: string;
+    currency_code: string;
+    currency_symbol: string;
+    destination_bank_account_id: string | null;
+    destination_bank_account_metadata: DestinationBankAccountMetadataPayload[] | null;
+    destination_bank_account_type: string;
+    frequency: AutoTransferRuleFrequency;
+    is_active: boolean;
+    is_deleted: boolean;
+    last_run_time: string | null;
+    last_run_transaction_metadata: unknown | null;
+    next_transfer_date: string;
+    rule_type: AutoTransferRuleType;
+    source_bank_account_id: string;
+    source_bank_account_type: string;
+    update_time: string;
+}
+interface AutoTransferRulesPayload {
+    auto_transfer_rules: AutoTransferRulePayload[];
+}
+export type FetchAutoTransferRulesResponse = ZeniAPIResponse<AutoTransferRulesPayload>;
+export interface AutoTransferRuleRequestBody {
+    amount?: number;
+    currency_code?: string;
+    currency_symbol?: string;
+    destination_bank_account_id?: string;
+    destination_bank_account_metadata?: DestinationBankAccountMetadataPayload[];
+    destination_bank_account_type?: string;
+    first_transfer_date?: string;
+    frequency?: AutoTransferRuleFrequency;
+    is_active?: boolean;
+    next_transfer_date?: string;
+    rule_type?: AutoTransferRuleType;
+    source_bank_account_id?: string;
+    source_bank_account_type?: string;
+}
+export interface AutoTransferRuleLocalData {
+    amount?: Amount;
+    destinationAccount?: FundingAccount | TreasuryAccount;
+    destinationAccountWithPercentAllocation?: {
+        account: FundingAccount | TreasuryAccount;
+        percentage: number;
+    }[];
+    firstTransferDate?: ZeniDate;
+    frequency?: AutoTransferRuleFrequency;
+    ruleType?: AutoTransferRuleType;
+    sourceAccount?: FundingAccount | TreasuryAccount;
+}
+interface CreateAutoTransferRulesPayload {
+    auto_transfer_rule: AutoTransferRulePayload;
+}
+export type CreateAutoTransferRulesResponse = ZeniAPIResponse<CreateAutoTransferRulesPayload>;
+interface DeleteAutoTransferRulePayload {
+    message: string;
+}
+export type DeleteAutoTransferRuleResponse = ZeniAPIResponse<DeleteAutoTransferRulePayload>;
+export declare const mapPayloadToAutoTransferRule: (payload: AutoTransferRulePayload) => AutoTransferRule;
+export {};

package/lib/view/spendManagement/autotransferRules/autoTransferRulesPayload.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapPayloadToAutoTransferRule = void 0;
+const zeniDayJS_1 = require("../../../zeniDayJS");
+const mapPayloadToAutoTransferRule = (payload) => ({
+    amount: payload.amount,
+    autoTransferRuleId: payload.auto_transfer_rule_id,
+    createTime: payload.create_time != null ? (0, zeniDayJS_1.date)(payload.create_time) : undefined,
+    currencyCode: payload.currency_code,
+    currencySymbol: payload.currency_symbol ?? '$',
+    destinationBankAccountId: payload.destination_bank_account_id,
+    destinationBankAccountMetadata: payload.destination_bank_account_metadata?.map((m) => ({
+        accountId: m.account_id,
+        accountType: m.account_type,
+        percentage: m.percentage,
+    })) ?? undefined,
+    destinationBankAccountType: payload.destination_bank_account_type ?? undefined,
+    frequency: payload.frequency,
+    isActive: payload.is_active,
+    isDeleted: payload.is_deleted,
+    lastRunTime: payload.last_run_time,
+    nextTransferDate: payload.next_transfer_date != null
+        ? (0, zeniDayJS_1.date)(payload.next_transfer_date)
+        : undefined,
+    ruleType: payload.rule_type,
+    sourceBankAccountId: payload.source_bank_account_id,
+    sourceBankAccountType: payload.source_bank_account_type,
+    updateTime: payload.update_time != null ? (0, zeniDayJS_1.date)(payload.update_time) : undefined,
+});
+exports.mapPayloadToAutoTransferRule = mapPayloadToAutoTransferRule;

package/lib/view/spendManagement/autotransferRules/autoTransferRulesReducer.d.ts

@@ -0,0 +1,50 @@
+import { FetchState, ID } from '../../../commonStateTypes/common';
+import { ZeniAPIStatus } from '../../../responsePayload';
+import { HistoricEventPayload } from '../commonHistoryView/commonHistoryPayload';
+import { ReviewTransferMoneyPayload } from '../zeniAccounts/transferDetail/transferDetailPayload';
+import { AutoTransferRuleLocalData } from './autoTransferRulesPayload';
+import { AutoTransferRule, AutoTransferRulesState } from './autoTransferRulesState';
+export declare const initialState: AutoTransferRulesState;
+export declare const fetchAutoTransferRules: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[cacheOverride?: any], {
+    cacheOverride: any;
+}, "autotransferRules/fetchAutoTransferRules", never, never>, updateAutoTransferRules: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    rules: AutoTransferRule[];
+}, "autotransferRules/updateAutoTransferRules">, updateAutoTransferRulesFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    error?: ZeniAPIStatus;
+}, "autotransferRules/updateAutoTransferRulesFailure">, fetchAutoTransferReviewDetail: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"autotransferRules/fetchAutoTransferReviewDetail">, updateAutoTransferReviewDetail: import("@reduxjs/toolkit").ActionCreatorWithPayload<ReviewTransferMoneyPayload, "autotransferRules/updateAutoTransferReviewDetail">, updateAutoTransferReviewDetailFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "autotransferRules/updateAutoTransferReviewDetailFailure">, clearAutoTransferReviewDetail: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"autotransferRules/clearAutoTransferReviewDetail">, createAutoTransferRule: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"autotransferRules/createAutoTransferRule">, createAutoTransferRuleSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    rule: AutoTransferRule;
+}, "autotransferRules/createAutoTransferRuleSuccess">, createAutoTransferRuleFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    error?: ZeniAPIStatus;
+}, "autotransferRules/createAutoTransferRuleFailure">, updateAutoTransferRule: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[ruleId: string, pauseRule?: boolean | undefined, resumeRule?: boolean | undefined], {
+    ruleId: string;
+    pauseRule: boolean | undefined;
+    resumeRule: boolean | undefined;
+}, "autotransferRules/updateAutoTransferRule", never, never>, updateAutoTransferRuleSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    rule: AutoTransferRule;
+}, "autotransferRules/updateAutoTransferRuleSuccess">, updateAutoTransferRuleFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    ruleId: ID;
+    error?: ZeniAPIStatus;
+}, "autotransferRules/updateAutoTransferRuleFailure">, deleteAutoTransferRule: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[ruleId: string], {
+    ruleId: string;
+}, "autotransferRules/deleteAutoTransferRule", never, never>, deleteAutoTransferRuleSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    ruleId: ID;
+}, "autotransferRules/deleteAutoTransferRuleSuccess">, deleteAutoTransferRuleFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    ruleId: ID;
+    error?: ZeniAPIStatus;
+}, "autotransferRules/deleteAutoTransferRuleFailure">, fetchAutoTransferRuleHistory: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[ruleId: string, cacheOverride?: any], {
+    ruleId: string;
+    cacheOverride: any;
+}, "autotransferRules/fetchAutoTransferRuleHistory", never, never>, updateAutoTransferRuleHistory: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    historicEventsPayload: HistoricEventPayload[];
+    ruleId: ID;
+}, "autotransferRules/updateAutoTransferRuleHistory">, updateAutoTransferRuleHistoryFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    ruleId: ID;
+    error?: ZeniAPIStatus;
+}, "autotransferRules/updateAutoTransferRuleHistoryFetchStatus">, updateRuleLocalData: import("@reduxjs/toolkit").ActionCreatorWithPayload<AutoTransferRuleLocalData, "autotransferRules/updateRuleLocalData">, clearRuleUpdateLocalData: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"autotransferRules/clearRuleUpdateLocalData">, clearAutoTransferRules: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"autotransferRules/clearAutoTransferRules">;
+declare const _default: import("redux").Reducer<AutoTransferRulesState>;
+export default _default;

package/lib/view/spendManagement/autotransferRules/autoTransferRulesReducer.js

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearAutoTransferRules = exports.clearRuleUpdateLocalData = exports.updateRuleLocalData = exports.updateAutoTransferRuleHistoryFetchStatus = exports.updateAutoTransferRuleHistory = exports.fetchAutoTransferRuleHistory = exports.deleteAutoTransferRuleFailure = exports.deleteAutoTransferRuleSuccess = exports.deleteAutoTransferRule = exports.updateAutoTransferRuleFailure = exports.updateAutoTransferRuleSuccess = exports.updateAutoTransferRule = exports.createAutoTransferRuleFailure = exports.createAutoTransferRuleSuccess = exports.createAutoTransferRule = exports.clearAutoTransferReviewDetail = exports.updateAutoTransferReviewDetailFailure = exports.updateAutoTransferReviewDetail = exports.fetchAutoTransferReviewDetail = exports.updateAutoTransferRulesFailure = exports.updateAutoTransferRules = exports.fetchAutoTransferRules = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const get_1 = __importDefault(require("lodash/get"));
+const commonHistory_1 = require("../commonHistoryView/commonHistory");
+const commonHistoryPayload_1 = require("../commonHistoryView/commonHistoryPayload");
+const transferDetailPayload_1 = require("../zeniAccounts/transferDetail/transferDetailPayload");
+exports.initialState = {
+    autoTransferReviewDetail: {
+        reviewTransferMoney: {
+            isShowDailyAchLimitWarning: false,
+            dailyAchDebitLimit: {
+                amount: 0,
+                currencyCode: 'USD',
+                currencySymbol: '$',
+            },
+            transferSchedules: [],
+        },
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    historyByRuleId: {},
+    ruleDeleteStatusById: {},
+    ruleUpdateLocalData: {},
+    ruleUpdateStatusById: {},
+    rules: [],
+    fetchState: 'Not-Started',
+    error: undefined,
+    createRuleFetchState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    hasValidState() {
+        return this.fetchState === 'Completed';
+    },
+};
+const autotransferRules = (0, toolkit_1.createSlice)({
+    name: 'autotransferRules',
+    initialState: exports.initialState,
+    reducers: {
+        fetchAutoTransferRules: {
+            reducer(draft) {
+                draft.fetchState = 'In-Progress';
+            },
+            prepare(cacheOverride = false) {
+                return {
+                    payload: {
+                        cacheOverride,
+                    },
+                };
+            },
+        },
+        updateAutoTransferRules(draft, action) {
+            draft.rules = action.payload.rules;
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+        },
+        updateAutoTransferRulesFailure(draft, action) {
+            draft.fetchState = action.payload.fetchState;
+            draft.error = action.payload.error;
+        },
+        updateRuleLocalData(draft, action) {
+            draft.ruleUpdateLocalData = {
+                ...draft.ruleUpdateLocalData,
+                ...action.payload,
+            };
+        },
+        clearRuleUpdateLocalData(draft) {
+            draft.ruleUpdateLocalData = {};
+        },
+        fetchAutoTransferReviewDetail(draft) {
+            draft.autoTransferReviewDetail.fetchState = 'In-Progress';
+            draft.autoTransferReviewDetail.error = undefined;
+        },
+        updateAutoTransferReviewDetail(draft, action) {
+            draft.autoTransferReviewDetail.fetchState = 'Completed';
+            draft.autoTransferReviewDetail.error = undefined;
+            draft.autoTransferReviewDetail.reviewTransferMoney =
+                (0, transferDetailPayload_1.mapReviewTransferMoneyPayloadToReviewTransferMoney)(action.payload);
+        },
+        updateAutoTransferReviewDetailFailure(draft, action) {
+            draft.autoTransferReviewDetail.fetchState = 'Error';
+            draft.autoTransferReviewDetail.error = action.payload;
+        },
+        clearAutoTransferReviewDetail(draft) {
+            draft.autoTransferReviewDetail = exports.initialState.autoTransferReviewDetail;
+        },
+        createAutoTransferRule(draft) {
+            draft.createRuleFetchState = {
+                fetchState: 'In-Progress',
+                error: undefined,
+            };
+        },
+        createAutoTransferRuleSuccess(draft, action) {
+            draft.rules = [...draft.rules, action.payload.rule];
+            draft.createRuleFetchState = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        createAutoTransferRuleFailure(draft, action) {
+            draft.createRuleFetchState = {
+                fetchState: action.payload.fetchState,
+                error: action.payload.error,
+            };
+        },
+        updateAutoTransferRule: {
+            reducer(draft, action) {
+                draft.ruleUpdateStatusById[action.payload.ruleId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(ruleId, pauseRule, resumeRule) {
+                return { payload: { ruleId, pauseRule, resumeRule } };
+            },
+        },
+        updateAutoTransferRuleSuccess(draft, action) {
+            const updatedRule = action.payload.rule;
+            draft.rules = draft.rules.map((rule) => rule.autoTransferRuleId === updatedRule.autoTransferRuleId
+                ? updatedRule
+                : rule);
+            draft.ruleUpdateStatusById[updatedRule.autoTransferRuleId] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        updateAutoTransferRuleFailure(draft, action) {
+            draft.ruleUpdateStatusById[action.payload.ruleId] = {
+                fetchState: action.payload.fetchState,
+                error: action.payload.error,
+            };
+        },
+        deleteAutoTransferRule: {
+            reducer(draft, action) {
+                draft.ruleDeleteStatusById[action.payload.ruleId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(ruleId) {
+                return { payload: { ruleId } };
+            },
+        },
+        deleteAutoTransferRuleSuccess(draft, action) {
+            const { ruleId } = action.payload;
+            draft.rules = draft.rules.filter((rule) => rule.autoTransferRuleId !== ruleId);
+            draft.ruleDeleteStatusById[ruleId] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        deleteAutoTransferRuleFailure(draft, action) {
+            draft.ruleDeleteStatusById[action.payload.ruleId] = {
+                fetchState: action.payload.fetchState,
+                error: action.payload.error,
+            };
+        },
+        fetchAutoTransferRuleHistory: {
+            reducer(draft, action) {
+                const { ruleId, cacheOverride } = action.payload;
+                const detail = (0, get_1.default)(draft.historyByRuleId, ruleId, undefined);
+                if (cacheOverride === true ||
+                    detail == null ||
+                    detail.fetchState !== 'In-Progress') {
+                    draft.historyByRuleId[ruleId] = {
+                        ...commonHistory_1.initialCommonHistory,
+                    };
+                }
+            },
+            prepare(ruleId, cacheOverride = true) {
+                return {
+                    payload: { ruleId, cacheOverride },
+                };
+            },
+        },
+        updateAutoTransferRuleHistory(draft, action) {
+            const { ruleId, historicEventsPayload } = action.payload;
+            const historicEvents = historicEventsPayload.map((historicEventPayload) => (0, commonHistoryPayload_1.toHistoricEvent)(historicEventPayload));
+            draft.historyByRuleId[ruleId] = {
+                ...commonHistory_1.initialCommonHistory,
+                fetchState: 'Completed',
+                error: undefined,
+                historicEvents,
+            };
+        },
+        updateAutoTransferRuleHistoryFetchStatus(draft, action) {
+            const { ruleId, fetchState, error } = action.payload;
+            const detail = (0, get_1.default)(draft.historyByRuleId, ruleId, undefined);
+            if (detail != null) {
+                detail.fetchState = fetchState;
+                detail.error = error;
+            }
+        },
+        clearAutoTransferRules(draft) {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+_a = autotransferRules.actions, exports.fetchAutoTransferRules = _a.fetchAutoTransferRules, exports.updateAutoTransferRules = _a.updateAutoTransferRules, exports.updateAutoTransferRulesFailure = _a.updateAutoTransferRulesFailure, exports.fetchAutoTransferReviewDetail = _a.fetchAutoTransferReviewDetail, exports.updateAutoTransferReviewDetail = _a.updateAutoTransferReviewDetail, exports.updateAutoTransferReviewDetailFailure = _a.updateAutoTransferReviewDetailFailure, exports.clearAutoTransferReviewDetail = _a.clearAutoTransferReviewDetail, exports.createAutoTransferRule = _a.createAutoTransferRule, exports.createAutoTransferRuleSuccess = _a.createAutoTransferRuleSuccess, exports.createAutoTransferRuleFailure = _a.createAutoTransferRuleFailure, exports.updateAutoTransferRule = _a.updateAutoTransferRule, exports.updateAutoTransferRuleSuccess = _a.updateAutoTransferRuleSuccess, exports.updateAutoTransferRuleFailure = _a.updateAutoTransferRuleFailure, exports.deleteAutoTransferRule = _a.deleteAutoTransferRule, exports.deleteAutoTransferRuleSuccess = _a.deleteAutoTransferRuleSuccess, exports.deleteAutoTransferRuleFailure = _a.deleteAutoTransferRuleFailure, exports.fetchAutoTransferRuleHistory = _a.fetchAutoTransferRuleHistory, exports.updateAutoTransferRuleHistory = _a.updateAutoTransferRuleHistory, exports.updateAutoTransferRuleHistoryFetchStatus = _a.updateAutoTransferRuleHistoryFetchStatus, exports.updateRuleLocalData = _a.updateRuleLocalData, exports.clearRuleUpdateLocalData = _a.clearRuleUpdateLocalData, exports.clearAutoTransferRules = _a.clearAutoTransferRules;
+exports.default = autotransferRules.reducer;

package/lib/view/spendManagement/autotransferRules/autoTransferRulesSelector.d.ts

@@ -0,0 +1,24 @@
+import { FetchState, FetchStateAndError, ID } from '../../../commonStateTypes/common';
+import { SelectorView } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { RootState } from '../../../reducer';
+import { CommonHistoryView } from '../commonHistoryView/commonHistory';
+import { FundingAccount } from '../commonSetup/setupViewSelector';
+import { TreasuryAccount } from '../treasury/treasuryTransferMoney/treasuryTransferMoneyState';
+import { ReviewTransferDetail } from '../zeniAccounts/transferDetail/transferDetailState';
+import { AutoTransferRuleLocalData } from './autoTransferRulesPayload';
+import { AutoTransferRule } from './autoTransferRulesState';
+export interface AutoTransferRulesSelectorView extends SelectorView {
+    autoTransferReviewDetail: ReviewTransferDetail;
+    createRuleFetchState: FetchStateAndError;
+    ruleDeleteStatusById: Record<ID, FetchStateAndError>;
+    rules: AutoTransferRule[];
+    ruleUpdateLocalData: AutoTransferRuleLocalData;
+    ruleUpdateStatusById: Record<ID, FetchStateAndError>;
+    transferMoneyParties: FundingAccount[];
+    transferMoneyPartiesFetchState: FetchState;
+    treasuryAccount: TreasuryAccount;
+    ruleHistory?: Record<string, CommonHistoryView>;
+}
+export declare const getAutoTransferRules: (state: RootState) => AutoTransferRulesSelectorView;
+export declare const getAutoTransferRuleById: (state: RootState, ruleId: ID) => AutoTransferRule | undefined;
+export declare const getAutoTransferRuleHistory: (state: RootState, ruleId: ID) => CommonHistoryView | undefined;

package/lib/view/spendManagement/autotransferRules/autoTransferRulesSelector.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAutoTransferRuleHistory = exports.getAutoTransferRuleById = exports.getAutoTransferRules = void 0;
+const get_1 = __importDefault(require("lodash/get"));
+const reduceFetchState_1 = require("../../../commonStateTypes/reduceFetchState");
+const setupViewSelector_1 = require("../commonSetup/setupViewSelector");
+const depositAccountListSelector_1 = require("../zeniAccounts/depositAccountList/depositAccountListSelector");
+const paymentAccountListSelector_1 = require("../zeniAccounts/paymentAccountList/paymentAccountListSelector");
+const getAutoTransferRules = (state) => {
+    const { autotransferRulesState, depositAccountState, paymentAccountState, depositAccountListState, paymentAccountListState, treasuryDetailState, } = state;
+    const { rules, error, historyByRuleId, ruleUpdateLocalData, ruleUpdateStatusById, ruleDeleteStatusById, createRuleFetchState, autoTransferReviewDetail, } = autotransferRulesState;
+    const depositAccountsView = (0, depositAccountListSelector_1.getAllDepositAccounts)(depositAccountState, depositAccountListState);
+    const paymentAccountsView = (0, paymentAccountListSelector_1.getAllPaymentAccounts)(paymentAccountState, paymentAccountListState);
+    let transferMoneyParties = [];
+    const transferMoneyPartiesFetchState = (0, reduceFetchState_1.reduceAllFetchState)([
+        depositAccountsView,
+        paymentAccountsView,
+    ]).fetchState;
+    const fetchState = (0, reduceFetchState_1.reduceAllFetchState)([
+        autotransferRulesState,
+        depositAccountsView,
+        paymentAccountsView,
+    ]).fetchState;
+    if (depositAccountsView.fetchState === 'Completed' &&
+        paymentAccountsView.fetchState === 'Completed') {
+        transferMoneyParties = (0, setupViewSelector_1.getAllFundingAccounts)(depositAccountsView.depositAccounts, paymentAccountsView.paymentAccounts, paymentAccountListState.paymentAccountBalanceFetchStatus);
+    }
+    const treasuryAccount = {
+        accType: 'treasuryAccount',
+        label: 'Treasury',
+        id: 'treasury',
+        balance: treasuryDetailState.accountSummary?.availableBalance,
+    };
+    return {
+        autoTransferReviewDetail,
+        rules,
+        ruleUpdateLocalData,
+        ruleUpdateStatusById,
+        ruleDeleteStatusById,
+        ruleHistory: historyByRuleId,
+        treasuryAccount,
+        transferMoneyParties,
+        transferMoneyPartiesFetchState,
+        createRuleFetchState,
+        fetchState,
+        error,
+        version: 0,
+    };
+};
+exports.getAutoTransferRules = getAutoTransferRules;
+const getAutoTransferRuleById = (state, ruleId) => {
+    return state.autotransferRulesState.rules.find((rule) => rule.autoTransferRuleId === ruleId);
+};
+exports.getAutoTransferRuleById = getAutoTransferRuleById;
+const getAutoTransferRuleHistory = (state, ruleId) => {
+    return (0, get_1.default)(state.autotransferRulesState.historyByRuleId, ruleId, undefined);
+};
+exports.getAutoTransferRuleHistory = getAutoTransferRuleHistory;

package/lib/view/spendManagement/autotransferRules/autoTransferRulesState.d.ts

@@ -0,0 +1,38 @@
+import { FetchStateAndError, FetchedState, ID } from '../../../commonStateTypes/common';
+import { ZeniDate } from '../../../zeniDayJS';
+import { CommonHistoryView } from '../commonHistoryView/commonHistory';
+import { ReviewTransferDetail } from '../zeniAccounts/transferDetail/transferDetailState';
+import { AutoTransferRuleFrequency, AutoTransferRuleLocalData, AutoTransferRuleType } from './autoTransferRulesPayload';
+export interface AutoTransferRule {
+    amount: number;
+    autoTransferRuleId: ID;
+    currencyCode: string;
+    currencySymbol: string;
+    destinationBankAccountId: string | null;
+    frequency: AutoTransferRuleFrequency;
+    isActive: boolean;
+    isDeleted: boolean;
+    lastRunTime: string | null;
+    ruleType: AutoTransferRuleType;
+    sourceBankAccountId: string;
+    sourceBankAccountType: string;
+    createTime?: ZeniDate;
+    destinationBankAccountMetadata?: DestinationBankAccountMetadata[];
+    destinationBankAccountType?: string;
+    nextTransferDate?: ZeniDate;
+    updateTime?: ZeniDate;
+}
+export interface DestinationBankAccountMetadata {
+    accountId: string;
+    accountType: string;
+    percentage: number;
+}
+export interface AutoTransferRulesState extends FetchedState {
+    autoTransferReviewDetail: ReviewTransferDetail;
+    createRuleFetchState: FetchStateAndError;
+    historyByRuleId: Record<ID, CommonHistoryView>;
+    ruleDeleteStatusById: Record<ID, FetchStateAndError>;
+    rules: AutoTransferRule[];
+    ruleUpdateLocalData: AutoTransferRuleLocalData;
+    ruleUpdateStatusById: Record<ID, FetchStateAndError>;
+}

package/lib/view/spendManagement/autotransferRules/autoTransferRulesState.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/view/spendManagement/autotransferRules/epics/createAutoTransferRuleEpic.d.ts

@@ -0,0 +1,12 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { RootState } from '../../../../reducer';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { AccType, AccountTypeSubConfigCodeKeyType } from '../../billPay/billPayConfig/billPayConfigState';
+import { AutoTransferRuleLocalData, AutoTransferRuleRequestBody } from '../autoTransferRulesPayload';
+import { createAutoTransferRule, createAutoTransferRuleFailure, createAutoTransferRuleSuccess } from '../autoTransferRulesReducer';
+export type ActionType = ReturnType<typeof createAutoTransferRule> | ReturnType<typeof createAutoTransferRuleSuccess> | ReturnType<typeof createAutoTransferRuleFailure> | ReturnType<typeof openSnackbar>;
+export declare const createAutoTransferRuleEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;
+export declare function mapAutoTransferRuleLocalDataToPayload(localData: AutoTransferRuleLocalData, pauseRule?: boolean, resumeRule?: boolean): AutoTransferRuleRequestBody;
+export declare const accountTypeSubConfigCodeToAccType: (code?: AccountTypeSubConfigCodeKeyType | "treasuryAccount") => AccType | "treasury_account" | undefined;