@zeniai/client-epic-state 4.20.3-betaSS12 → 4.20.3-betaSS14

package/lib/view/reportsResync/reportsResyncReducer.d.ts

@@ -2,8 +2,8 @@ import { ReportID } from '../../commonStateTypes/viewAndReport/viewAndReport';
 import { ZeniAPIStatus } from '../../responsePayload';
 import { ReportsResyncState } from './reportsResyncState';
 export declare const initialReportsResyncState: ReportsResyncState;
-export declare const initiateReportsResync: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[reportIdToResync: "cash_balance" | "card_balance" | "expense_automation_card" | "operating_expenses" | "operating_expenses_by_classes" | "revenue" | "revenue_by_classes" | "net_burn_or_income" | "net_burn_or_income_story_card" | "net_burn_or_income_by_classes" | "cash_position" | "top_expenses" | "profit_and_loss" | "profit_and_loss_by_classes" | "balance_sheet" | "cash_flow" | "dashboard" | "finance_statement" | "transaction_list_of_account" | "transaction_list_missing_receipt" | "transaction_list_of_account_by_class" | "transaction_detail" | "cash_in_cash_out" | "insights_dashboard" | "company_details" | "class_list" | "account_list" | "account_list_by_type" | "vendor" | "task_card" | "bill_pay" | "reimbursement" | "bill_pay_card" | "reimbursement_card" | "bill_pay_promo_card" | "zeni_accounts" | "zeni_accounts_promo_card" | "zeni_treasury" | "charge_cards" | "other_connection" | "reimbursement_promo_card" | "onboarding" | "operating_expenses_by_vendor" | "operating_expenses_by_vendor_summary" | "vendors_tab" | "accounts_payable_aging" | "accounts_receivable_aging" | "vendor_global_review" | "prepaid_expenses" | "fixed_assets" | "notification" | "rewards_card" | "billing" | "flux_analysis_operating_expense" | "account_reconciliation" | "zeni_credit_promo_card" | "treasury_promo_card"], {
-    reportIdToResync: "cash_balance" | "card_balance" | "expense_automation_card" | "operating_expenses" | "operating_expenses_by_classes" | "revenue" | "revenue_by_classes" | "net_burn_or_income" | "net_burn_or_income_story_card" | "net_burn_or_income_by_classes" | "cash_position" | "top_expenses" | "profit_and_loss" | "profit_and_loss_by_classes" | "balance_sheet" | "cash_flow" | "dashboard" | "finance_statement" | "transaction_list_of_account" | "transaction_list_missing_receipt" | "transaction_list_of_account_by_class" | "transaction_detail" | "cash_in_cash_out" | "insights_dashboard" | "company_details" | "class_list" | "account_list" | "account_list_by_type" | "vendor" | "task_card" | "bill_pay" | "reimbursement" | "bill_pay_card" | "reimbursement_card" | "bill_pay_promo_card" | "zeni_accounts" | "zeni_accounts_promo_card" | "zeni_treasury" | "charge_cards" | "other_connection" | "reimbursement_promo_card" | "onboarding" | "operating_expenses_by_vendor" | "operating_expenses_by_vendor_summary" | "vendors_tab" | "accounts_payable_aging" | "accounts_receivable_aging" | "vendor_global_review" | "prepaid_expenses" | "fixed_assets" | "notification" | "rewards_card" | "billing" | "flux_analysis_operating_expense" | "account_reconciliation" | "zeni_credit_promo_card" | "treasury_promo_card";
+export declare const initiateReportsResync: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[reportIdToResync: "cash_balance" | "card_balance" | "expense_automation_card" | "operating_expenses" | "operating_expenses_by_classes" | "revenue" | "revenue_by_classes" | "net_burn_or_income" | "net_burn_or_income_story_card" | "net_burn_or_income_by_classes" | "cash_position" | "top_expenses" | "profit_and_loss" | "profit_and_loss_by_classes" | "profit_and_loss_by_projects" | "balance_sheet" | "cash_flow" | "dashboard" | "finance_statement" | "transaction_list_of_account" | "transaction_list_missing_receipt" | "transaction_list_of_account_by_class" | "transaction_detail" | "cash_in_cash_out" | "insights_dashboard" | "company_details" | "class_list" | "account_list" | "account_list_by_type" | "vendor" | "task_card" | "bill_pay" | "reimbursement" | "bill_pay_card" | "reimbursement_card" | "bill_pay_promo_card" | "zeni_accounts" | "zeni_accounts_promo_card" | "zeni_treasury" | "charge_cards" | "other_connection" | "reimbursement_promo_card" | "onboarding" | "operating_expenses_by_vendor" | "operating_expenses_by_vendor_summary" | "vendors_tab" | "accounts_payable_aging" | "accounts_receivable_aging" | "vendor_global_review" | "prepaid_expenses" | "fixed_assets" | "notification" | "rewards_card" | "billing" | "flux_analysis_operating_expense" | "account_reconciliation" | "zeni_credit_promo_card" | "treasury_promo_card" | "excluded_account_reconciliation"], {
+    reportIdToResync: "cash_balance" | "card_balance" | "expense_automation_card" | "operating_expenses" | "operating_expenses_by_classes" | "revenue" | "revenue_by_classes" | "net_burn_or_income" | "net_burn_or_income_story_card" | "net_burn_or_income_by_classes" | "cash_position" | "top_expenses" | "profit_and_loss" | "profit_and_loss_by_classes" | "profit_and_loss_by_projects" | "balance_sheet" | "cash_flow" | "dashboard" | "finance_statement" | "transaction_list_of_account" | "transaction_list_missing_receipt" | "transaction_list_of_account_by_class" | "transaction_detail" | "cash_in_cash_out" | "insights_dashboard" | "company_details" | "class_list" | "account_list" | "account_list_by_type" | "vendor" | "task_card" | "bill_pay" | "reimbursement" | "bill_pay_card" | "reimbursement_card" | "bill_pay_promo_card" | "zeni_accounts" | "zeni_accounts_promo_card" | "zeni_treasury" | "charge_cards" | "other_connection" | "reimbursement_promo_card" | "onboarding" | "operating_expenses_by_vendor" | "operating_expenses_by_vendor_summary" | "vendors_tab" | "accounts_payable_aging" | "accounts_receivable_aging" | "vendor_global_review" | "prepaid_expenses" | "fixed_assets" | "notification" | "rewards_card" | "billing" | "flux_analysis_operating_expense" | "account_reconciliation" | "zeni_credit_promo_card" | "treasury_promo_card" | "excluded_account_reconciliation";
 }, "initiateReportsResync/initiateReportsResync", never, never>, initiateReportsClassViewRefetching: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     reportIdToResync: ReportID;
 }, "initiateReportsResync/initiateReportsClassViewRefetching">, reportsResyncSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{

package/lib/view/reviewCompanyView/reviewCompanyViewState.d.ts

@@ -3,7 +3,7 @@ import { SortOrder } from '../../commonStateTypes/selectorTypes/sortOrderTypes';
 import { OnboardingInfo } from '../../entity/company/companyStateTypes';
 import { ZeniDate } from '../../zeniDayJS';
 import { AuditSummaryPayload, ReviewCompanyPayload } from './reviewCompanyPayload';
-export declare const toReviewColumnKeyType: (v: string) => "uncategorized" | "companyName" | "auditScore" | "miscategorized" | "notes" | "warnings" | "vendorReview" | "reviewVendor";
+export declare const toReviewColumnKeyType: (v: string) => "companyName" | "notes" | "uncategorized" | "auditScore" | "miscategorized" | "warnings" | "vendorReview" | "reviewVendor";
 export type ReviewCompanyColumnKey = ReturnType<typeof toReviewColumnKeyType>;
 export type ReviewTransactionsType = 'income' | 'expense';
 export interface AuditSummary {

package/lib/view/scheduleView/scheduleListView/scheduleListTypes.d.ts

@@ -7,7 +7,7 @@ export declare const getScheduleListKey: (selectedCategory: ID, selectedTimefram
 export type ScheduleListKey = ReturnType<typeof getScheduleListKey>;
 export declare const toScheduleSubTabType: (v: string) => "completed" | "new" | "ongoing" | "all";
 export type ScheduleSubTabType = ReturnType<typeof toScheduleSubTabType>;
-declare const toScheduleSortKeyType: (v: string) => "months" | "amount" | "vendor" | "status" | "user" | "createTime" | "class" | "memo" | "balanceAsOfToday" | "transactionDate" | "transactionType" | "assetId" | "accruedExpenseCategory" | "scheduleCategory" | "expenseCategory" | "accumulatedDepreciationCategory" | "startMonth" | "endMonth";
+declare const toScheduleSortKeyType: (v: string) => "months" | "amount" | "vendor" | "status" | "user" | "createTime" | "class" | "memo" | "balanceAsOfToday" | "transactionDate" | "transactionType" | "assetId" | "scheduleCategory" | "startMonth" | "accruedExpenseCategory" | "expenseCategory" | "accumulatedDepreciationCategory" | "endMonth";
 export declare type ScheduleListSortKey = ReturnType<typeof toScheduleSortKeyType>;
 export interface DownloadJEScheduleTabOptions {
     categoryId: ID;

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;