@zeniai/client-epic-state 4.17.45 → 4.17.46

package/lib/view/spendManagement/treasury/treasurySetUp/treasurySetupViewReducer.js

@@ -0,0 +1,264 @@
+"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.updateFundAllocationLocalData = exports.fetchPortfolioAllocationFailure = exports.fetchPortfolioAllocationSuccess = exports.fetchPortfolioAllocation = exports.updatePortfolioAllocationFailure = exports.updatePortfolioAllocationSuccess = exports.updatePortfolioAllocation = exports.updateTreasuryFundsFailure = exports.updateTreasuryFundsSuccess = exports.clearTreasurySetupView = exports.acceptTreasuryTermsFailure = exports.acceptTreasuryTermsSuccess = exports.acceptTreasuryTerms = exports.fetchTreasurySetupViewFailure = exports.fetchTreasurySetupViewSuccess = exports.fetchTreasurySetupView = exports.fetchTreasuryFunds = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const zeniDayJS_1 = require("../../../../zeniDayJS");
+exports.initialState = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    isRefreshingViewInBackground: false,
+    treasuryTermsDetails: undefined,
+    treasuryFundsDetails: {
+        fundsDetails: [],
+        fundAllocationOptions: [],
+        fetchStatus: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+    },
+    fundAllocationLocalData: {
+        allocation: {},
+        riskLevel: 'Recommended',
+        optionIndex: 0,
+    },
+    currentAllocation: {
+        fetchStatus: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+        allocation: undefined,
+    },
+    portfolioAllocationUpdateStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    hasValidState() {
+        return this.fetchState === 'Completed';
+    },
+};
+const treasurySetupView = (0, toolkit_1.createSlice)({
+    name: 'treasurySetupView',
+    initialState: exports.initialState,
+    reducers: {
+        fetchTreasuryFunds(draft) {
+            draft.treasuryFundsDetails = Object.assign(Object.assign({}, draft.treasuryFundsDetails), { fundsDetails: [], fundAllocationOptions: [], fetchStatus: {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                } });
+        },
+        updateTreasuryFundsSuccess(draft, action) {
+            const fundAllocationOptions = action.payload.allocation_percentage_to_risk.map((option, index) => ({
+                allocation: option.allocation,
+                riskLevel: option.risk_level,
+                optionIndex: index,
+            }));
+            draft.treasuryFundsDetails = {
+                fundsDetails: mapTreasuryFundsPayloadToFundData(action.payload),
+                fundAllocationOptions,
+                fetchStatus: { fetchState: 'Completed', error: undefined },
+            };
+            // If currentAllocation already exists, populate fundAllocationLocalData with matching option
+            if (draft.currentAllocation.allocation) {
+                const matchingOption = fundAllocationOptions.find((option) => (0, isEqual_1.default)(option.allocation, draft.currentAllocation.allocation));
+                if (matchingOption) {
+                    draft.fundAllocationLocalData = {
+                        allocation: matchingOption.allocation,
+                        riskLevel: matchingOption.riskLevel,
+                        optionIndex: matchingOption.optionIndex,
+                    };
+                }
+            }
+            else {
+                // If no currentAllocation, default to "Recommended" risk level option
+                const recommendedOption = fundAllocationOptions.find((option) => option.riskLevel === 'Recommended');
+                if (recommendedOption) {
+                    draft.fundAllocationLocalData = {
+                        allocation: recommendedOption.allocation,
+                        riskLevel: recommendedOption.riskLevel,
+                        optionIndex: recommendedOption.optionIndex,
+                    };
+                }
+            }
+        },
+        updateTreasuryFundsFailure(draft, action) {
+            draft.treasuryFundsDetails = {
+                fundsDetails: [],
+                fundAllocationOptions: [],
+                fetchStatus: {
+                    fetchState: 'Error',
+                    error: action.payload.error,
+                },
+            };
+        },
+        fetchTreasurySetupView: {
+            reducer(draft, action) {
+                const { refreshViewInBackground } = action.payload;
+                draft.isRefreshingViewInBackground = refreshViewInBackground;
+                if (!refreshViewInBackground) {
+                    draft.fetchState = 'In-Progress';
+                    draft.error = undefined;
+                }
+            },
+            prepare(companyId, cacheOverride = false, refreshViewInBackground = false) {
+                return {
+                    payload: { companyId, cacheOverride, refreshViewInBackground },
+                };
+            },
+        },
+        fetchTreasurySetupViewSuccess(draft) {
+            draft.isRefreshingViewInBackground = false;
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+        },
+        fetchTreasurySetupViewFailure: {
+            reducer(draft, action) {
+                draft.isRefreshingViewInBackground = false;
+                draft.fetchState = 'Error';
+                draft.error = action.payload;
+            },
+            prepare(error) {
+                return {
+                    payload: error,
+                };
+            },
+        },
+        acceptTreasuryTerms: {
+            reducer(draft) {
+                draft.treasuryTermsDetails = Object.assign({}, draft.treasuryTermsDetails, {
+                    fetchStatus: {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    },
+                });
+            },
+            prepare(companyId) {
+                return { payload: { companyId } };
+            },
+        },
+        acceptTreasuryTermsSuccess(draft) {
+            draft.treasuryTermsDetails = Object.assign({}, draft.treasuryTermsDetails, {
+                fetchStatus: {
+                    fetchState: 'Completed',
+                    error: undefined,
+                },
+            });
+        },
+        acceptTreasuryTermsFailure: {
+            reducer(draft, action) {
+                draft.treasuryTermsDetails = Object.assign({}, draft.treasuryTermsDetails, {
+                    fetchStatus: {
+                        fetchState: 'Error',
+                        error: action.payload,
+                    },
+                });
+            },
+            prepare(error) {
+                return {
+                    payload: error,
+                };
+            },
+        },
+        updatePortfolioAllocation: {
+            reducer(draft) {
+                draft.portfolioAllocationUpdateStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(isEdit) {
+                return {
+                    payload: { isEdit },
+                };
+            },
+        },
+        updatePortfolioAllocationSuccess(draft) {
+            draft.portfolioAllocationUpdateStatus = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        updatePortfolioAllocationFailure: {
+            reducer(draft, action) {
+                draft.portfolioAllocationUpdateStatus = {
+                    fetchState: 'Error',
+                    error: action.payload,
+                };
+            },
+            prepare(error) {
+                return {
+                    payload: error,
+                };
+            },
+        },
+        fetchPortfolioAllocation(draft) {
+            draft.currentAllocation = {
+                fetchStatus: {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                },
+                allocation: undefined,
+            };
+        },
+        fetchPortfolioAllocationSuccess(draft, action) {
+            draft.currentAllocation = Object.assign({ fetchStatus: {
+                    fetchState: 'Completed',
+                    error: undefined,
+                } }, (Object.keys(action.payload.allocation_percentages).length > 0 && {
+                allocation: action.payload.allocation_percentages,
+            }));
+            //populate the fund allocation local data with current allocation
+            const option = draft.treasuryFundsDetails.fundAllocationOptions.find((option) => (0, isEqual_1.default)(option.allocation, action.payload.allocation_percentages));
+            if (option) {
+                draft.fundAllocationLocalData = {
+                    allocation: option.allocation,
+                    riskLevel: option.riskLevel,
+                    optionIndex: option.optionIndex,
+                };
+            }
+        },
+        fetchPortfolioAllocationFailure(draft, action) {
+            draft.currentAllocation = {
+                fetchStatus: {
+                    fetchState: 'Error',
+                    error: action.payload,
+                },
+                allocation: undefined,
+            };
+        },
+        updateFundAllocationLocalData(draft, action) {
+            draft.fundAllocationLocalData = action.payload;
+        },
+        clearTreasurySetupView(draft) {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+_a = treasurySetupView.actions, exports.fetchTreasuryFunds = _a.fetchTreasuryFunds, exports.fetchTreasurySetupView = _a.fetchTreasurySetupView, exports.fetchTreasurySetupViewSuccess = _a.fetchTreasurySetupViewSuccess, exports.fetchTreasurySetupViewFailure = _a.fetchTreasurySetupViewFailure, exports.acceptTreasuryTerms = _a.acceptTreasuryTerms, exports.acceptTreasuryTermsSuccess = _a.acceptTreasuryTermsSuccess, exports.acceptTreasuryTermsFailure = _a.acceptTreasuryTermsFailure, exports.clearTreasurySetupView = _a.clearTreasurySetupView, exports.updateTreasuryFundsSuccess = _a.updateTreasuryFundsSuccess, exports.updateTreasuryFundsFailure = _a.updateTreasuryFundsFailure, exports.updatePortfolioAllocation = _a.updatePortfolioAllocation, exports.updatePortfolioAllocationSuccess = _a.updatePortfolioAllocationSuccess, exports.updatePortfolioAllocationFailure = _a.updatePortfolioAllocationFailure, exports.fetchPortfolioAllocation = _a.fetchPortfolioAllocation, exports.fetchPortfolioAllocationSuccess = _a.fetchPortfolioAllocationSuccess, exports.fetchPortfolioAllocationFailure = _a.fetchPortfolioAllocationFailure, exports.updateFundAllocationLocalData = _a.updateFundAllocationLocalData;
+exports.default = treasurySetupView.reducer;
+function mapTreasuryFundsPayloadToFundData(fundsPayload) {
+    return fundsPayload.funds.map((fund) => ({
+        fundCode: fund.fund_code,
+        fundName: fund.fund_name,
+        fundCompanyName: fund.fund_company_name,
+        fundType: fund.fund_type,
+        description: fund.description,
+        liquidityTimeline: fund.liquidity_timeline,
+        yield: fund.percentage_yield,
+        fundSize: fund.fund_size,
+        currencySymbol: fund.currency_symbol,
+        maturity: fund.maturity,
+        expenseRatio: fund.expense_ratio,
+        riskRating: fund.risk_rating,
+        compositions: fund.compositions.map((composition) => ({
+            percentage: composition.percentage,
+            investedIn: composition.invested_in,
+        })),
+        url: fund.url,
+        asOfDate: (0, zeniDayJS_1.date)(fund.as_of_date),
+    }));
+}

package/lib/view/spendManagement/treasury/treasurySetUp/treasurySetupViewSelector.d.ts

@@ -0,0 +1,24 @@
+import { FetchStateAndError, ID } from '../../../../commonStateTypes/common';
+import { SelectorView } from '../../../../commonStateTypes/viewAndReport/viewAndReport';
+import { CompanyTreasuryInfo } from '../../../../entity/company/companyStateTypes';
+import { RootState } from '../../../../reducer';
+import { BusinessVerificationDetails, CompanyOfficersDetails, SetupView } from '../../commonSetup/setupViewSelector';
+import { FundAllocationOption, FundData } from './treasurySetupViewState';
+export interface TreasurySetupView extends SetupView, SelectorView {
+    fundsData: FundData[];
+    fundAllocationOptions: FundAllocationOption[];
+    isRefreshingViewInBackground: boolean;
+    fundAllocationLocalData: FundAllocationOption;
+    portfolioAllocationUpdateStatus: FetchStateAndError;
+    companyTreasuryInfo?: CompanyTreasuryInfo;
+    treasuryTermsDetails?: {
+        fetchStatus: FetchStateAndError;
+    };
+    selectedCompanyOfficer?: CompanyOfficersDetails;
+    currentAllocation?: Record<string, number>;
+}
+export interface TreasuryBusinessVerificationDetails extends BusinessVerificationDetails, SelectorView {
+    isRefreshingViewInBackground: boolean;
+}
+export declare function getTreasurySetupViewDetails(state: RootState, companyId: ID): TreasurySetupView;
+export declare function getTreasuryBusinessVerificationDetails(state: RootState, companyId: ID): TreasuryBusinessVerificationDetails;

package/lib/view/spendManagement/treasury/treasurySetUp/treasurySetupViewSelector.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTreasurySetupViewDetails = getTreasurySetupViewDetails;
+exports.getTreasuryBusinessVerificationDetails = getTreasuryBusinessVerificationDetails;
+const reduceFetchState_1 = require("../../../../commonStateTypes/reduceFetchState");
+const getCompanyView_1 = require("../../../companyView/selectorHelpers/getCompanyView");
+const setupViewSelector_1 = require("../../commonSetup/setupViewSelector");
+const helpers_1 = require("../../helpers");
+function getTreasurySetupViewDetails(state, companyId) {
+    const treasurySetupViewDetails = (0, setupViewSelector_1.getCommonSetupViewDetails)(state, companyId, 'zeni_treasury', 'treasury_setup');
+    const companyView = (0, getCompanyView_1.getCompanyView)(state, companyId, []);
+    const companyTreasuryInfo = companyView === null || companyView === void 0 ? void 0 : companyView.company.company.companyTreasuryInfo;
+    const { treasurySetupViewState, setupViewState } = state;
+    const { treasuryTermsDetails, isRefreshingViewInBackground, treasuryFundsDetails, } = treasurySetupViewState;
+    const { updateStatus } = setupViewState;
+    const businessVerificationDetails = getTreasuryBusinessVerificationDetails(state, companyId);
+    const selectedCompanyOfficer = (0, helpers_1.getSelectedCompanyOfficer)(businessVerificationDetails);
+    const reducedFetchState = (0, reduceFetchState_1.reduceFetchState)([
+        treasurySetupViewState,
+        treasurySetupViewState.treasuryFundsDetails.fetchStatus,
+        treasurySetupViewState.currentAllocation.fetchStatus,
+    ]);
+    return Object.assign(Object.assign({}, treasurySetupViewDetails), { treasuryTermsDetails,
+        companyTreasuryInfo, version: 1, fetchState: reducedFetchState.fetchState, error: reducedFetchState.error, updateStatus,
+        selectedCompanyOfficer,
+        isRefreshingViewInBackground, fundsData: treasuryFundsDetails.fundsDetails, fundAllocationOptions: treasuryFundsDetails.fundAllocationOptions, fundAllocationLocalData: treasurySetupViewState.fundAllocationLocalData, currentAllocation: treasurySetupViewState.currentAllocation.allocation, portfolioAllocationUpdateStatus: treasurySetupViewState.portfolioAllocationUpdateStatus });
+}
+function getTreasuryBusinessVerificationDetails(state, companyId) {
+    const treasuryBusinessVerificationDetails = (0, setupViewSelector_1.getBusinessVerificationDetails)(state, companyId);
+    const { treasurySetupViewState } = state;
+    const { isRefreshingViewInBackground, fetchState, error } = treasurySetupViewState;
+    return Object.assign(Object.assign({}, treasuryBusinessVerificationDetails), { version: 1, fetchState,
+        error,
+        isRefreshingViewInBackground });
+}

package/lib/view/spendManagement/treasury/treasurySetUp/treasurySetupViewState.d.ts

@@ -0,0 +1,47 @@
+import { FetchStateAndError, FetchedState } from '../../../../commonStateTypes/common';
+import { ZeniDate } from '../../../../zeniDayJS';
+import { SetupViewLocalData } from '../../commonSetup/setupViewState';
+export type TreasurySetupViewLocalData = SetupViewLocalData;
+export interface TreasurySetupViewState extends FetchedState {
+    isRefreshingViewInBackground: boolean;
+    currentAllocation: {
+        fetchStatus: FetchStateAndError;
+        allocation?: Record<string, number>;
+    };
+    treasuryFundsDetails: {
+        fundsDetails: FundData[];
+        fundAllocationOptions: FundAllocationOption[];
+        fetchStatus: FetchStateAndError;
+    };
+    portfolioAllocationUpdateStatus: FetchStateAndError;
+    fundAllocationLocalData: FundAllocationOption;
+    treasuryTermsDetails?: {
+        fetchStatus: FetchStateAndError;
+    };
+}
+export interface FundAllocationOption {
+    allocation: Record<string, number>;
+    riskLevel: string;
+    optionIndex: number;
+}
+export interface FundData {
+    fundCode: string;
+    fundName: string;
+    fundCompanyName: string;
+    fundType: string;
+    description: string;
+    liquidityTimeline: string;
+    yield: string;
+    fundSize: string;
+    currencySymbol: string;
+    maturity: string;
+    expenseRatio: string;
+    riskRating: string;
+    compositions: FundComposition[];
+    url: string;
+    asOfDate: ZeniDate;
+}
+export interface FundComposition {
+    percentage: string;
+    investedIn: string;
+}

package/lib/view/spendManagement/treasury/treasurySetUp/treasurySetupViewState.js

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

package/lib/view/spendManagement/treasury/treasuryStatementList/fetchTreasuryStatementListEpic.d.ts

@@ -0,0 +1,7 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../../reducer';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { fetchTreasuryStatementList, updateTreasuryStatementList, updateTreasuryStatementListFetchStatus } from './treasuryStatementListReducer';
+export type ActionType = ReturnType<typeof fetchTreasuryStatementList> | ReturnType<typeof updateTreasuryStatementList> | ReturnType<typeof updateTreasuryStatementListFetchStatus>;
+export declare const fetchTreasuryStatementListEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/spendManagement/treasury/treasuryStatementList/fetchTreasuryStatementListEpic.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTreasuryStatementListEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../../responsePayload");
+const treasuryStatementListReducer_1 = require("./treasuryStatementListReducer");
+const fetchTreasuryStatementListEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(treasuryStatementListReducer_1.fetchTreasuryStatementList.match), (0, operators_1.mergeMap)((action) => {
+    const { cacheOverride } = action.payload;
+    const currentFetchState = state$.value.treasuryStatementListState.fetchState;
+    if (cacheOverride === true || currentFetchState !== 'Completed') {
+        const apiEndpoint = `${zeniAPI.apiEndPoints.bankingMicroServiceBaseUrl}/1.0/treasury-account/statements`;
+        return zeniAPI
+            .getJSON(apiEndpoint)
+            .pipe((0, operators_1.mergeMap)((response) => {
+            var _a, _b;
+            if ((0, responsePayload_1.isSuccessResponse)(response)) {
+                return (0, rxjs_1.of)((0, treasuryStatementListReducer_1.updateTreasuryStatementList)({
+                    data: (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.statements) !== null && _b !== void 0 ? _b : [],
+                }));
+            }
+            else {
+                return (0, rxjs_1.of)((0, treasuryStatementListReducer_1.updateTreasuryStatementListFetchStatus)({
+                    fetchState: 'Error',
+                    error: response.status,
+                }));
+            }
+        }), (0, operators_1.catchError)((error) => {
+            return (0, rxjs_1.of)((0, treasuryStatementListReducer_1.updateTreasuryStatementListFetchStatus)({
+                fetchState: 'Error',
+                error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch treasury Account statement REST API call errored out ' +
+                    JSON.stringify(error)),
+            }));
+        }));
+    }
+    // Otherwise, just update fetch status to completed
+    return (0, rxjs_1.of)((0, treasuryStatementListReducer_1.updateTreasuryStatementListFetchStatus)({
+        fetchState: 'Completed',
+        error: undefined,
+    }));
+}));
+exports.fetchTreasuryStatementListEpic = fetchTreasuryStatementListEpic;

package/lib/view/spendManagement/treasury/treasuryStatementList/treasuryStatementList.d.ts

@@ -0,0 +1,10 @@
+import { FetchedState, ID } from '../../../../commonStateTypes/common';
+import { MonthYearPeriod } from '../../../../commonStateTypes/timePeriod';
+export interface TreasuryStatementListState extends FetchedState {
+    statements: Statement[];
+}
+export interface Statement {
+    id: ID;
+    title: MonthYearPeriod;
+}
+export declare const initialStatements: TreasuryStatementListState;

package/lib/view/spendManagement/treasury/treasuryStatementList/treasuryStatementList.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialStatements = void 0;
+exports.initialStatements = {
+    statements: [],
+    fetchState: 'Not-Started',
+    error: undefined,
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};

package/lib/view/spendManagement/treasury/treasuryStatementList/treasuryStatementListPayload.d.ts

@@ -0,0 +1,10 @@
+import { ZeniAPIResponse } from '../../../../responsePayload';
+export interface StatementPayload {
+    statement_id: string;
+    period: string;
+}
+interface FetchTreasuryStatementPayload {
+    statements: StatementPayload[];
+}
+export type FetchTreasuryStatementResponse = ZeniAPIResponse<FetchTreasuryStatementPayload>;
+export {};

package/lib/view/spendManagement/treasury/treasuryStatementList/treasuryStatementListPayload.js

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

package/lib/view/spendManagement/treasury/treasuryStatementList/treasuryStatementListReducer.d.ts

@@ -0,0 +1,15 @@
+import { FetchState } from '../../../../commonStateTypes/common';
+import { ZeniAPIStatus } from '../../../../responsePayload';
+import { TreasuryStatementListState } from './treasuryStatementList';
+import { StatementPayload } from './treasuryStatementListPayload';
+export declare const initialState: TreasuryStatementListState;
+export declare const fetchTreasuryStatementList: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[cacheOverride?: any], {
+    cacheOverride: any;
+}, "treasuryStatementList/fetchTreasuryStatementList", never, never>, updateTreasuryStatementList: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    data: StatementPayload[];
+}, "treasuryStatementList/updateTreasuryStatementList">, updateTreasuryStatementListFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    error?: ZeniAPIStatus;
+}, "treasuryStatementList/updateTreasuryStatementListFetchStatus">, clearTreasuryStatementList: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"treasuryStatementList/clearTreasuryStatementList">;
+declare const _default: import("redux").Reducer<TreasuryStatementListState>;
+export default _default;

package/lib/view/spendManagement/treasury/treasuryStatementList/treasuryStatementListReducer.js

@@ -0,0 +1,57 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearTreasuryStatementList = exports.updateTreasuryStatementListFetchStatus = exports.updateTreasuryStatementList = exports.fetchTreasuryStatementList = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+exports.initialState = {
+    statements: [],
+    fetchState: 'Not-Started',
+    error: undefined,
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+const treasuryStatementList = (0, toolkit_1.createSlice)({
+    name: 'treasuryStatementList',
+    initialState: exports.initialState,
+    reducers: {
+        fetchTreasuryStatementList: {
+            reducer(draft) {
+                draft.fetchState = 'In-Progress';
+            },
+            prepare(cacheOverride = false) {
+                return {
+                    payload: {
+                        cacheOverride,
+                    },
+                };
+            },
+        },
+        updateTreasuryStatementList(draft, action) {
+            const { data } = action.payload;
+            const statements = data.map((payload) => {
+                const s = payload.period.split('-');
+                return {
+                    id: payload.statement_id,
+                    title: {
+                        year: parseInt(s[0]),
+                        month: parseInt(s[1]),
+                    },
+                };
+            });
+            draft.statements = statements;
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+        },
+        updateTreasuryStatementListFetchStatus(draft, action) {
+            const { fetchState, error } = action.payload;
+            draft.fetchState = fetchState;
+            draft.error = error;
+        },
+        clearTreasuryStatementList(draft) {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+_a = treasuryStatementList.actions, exports.fetchTreasuryStatementList = _a.fetchTreasuryStatementList, exports.updateTreasuryStatementList = _a.updateTreasuryStatementList, exports.updateTreasuryStatementListFetchStatus = _a.updateTreasuryStatementListFetchStatus, exports.clearTreasuryStatementList = _a.clearTreasuryStatementList;
+exports.default = treasuryStatementList.reducer;

package/lib/view/spendManagement/treasury/treasuryStatementList/treasuryStatementListSelector.d.ts

@@ -0,0 +1,7 @@
+import { SelectorView } from '../../../../commonStateTypes/viewAndReport/viewAndReport';
+import { RootState } from '../../../../reducer';
+import { Statement } from './treasuryStatementList';
+export interface TreasuryStatementsSelectorView extends SelectorView {
+    statements: Statement[];
+}
+export declare const getTreasuryStatements: (state: RootState) => TreasuryStatementsSelectorView;

package/lib/view/spendManagement/treasury/treasuryStatementList/treasuryStatementListSelector.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTreasuryStatements = void 0;
+const getTreasuryStatements = (state) => {
+    var _a;
+    const { treasuryStatementListState } = state;
+    const fetchStateAndError = {
+        fetchState: treasuryStatementListState.fetchState,
+        error: treasuryStatementListState.error,
+    };
+    return {
+        statements: (_a = treasuryStatementListState.statements) !== null && _a !== void 0 ? _a : [],
+        fetchState: fetchStateAndError.fetchState,
+        error: fetchStateAndError.error,
+        version: 0,
+    };
+};
+exports.getTreasuryStatements = getTreasuryStatements;

package/lib/view/spendManagement/treasury/treasuryTransferMoney/treasuryTransferMoneyEpic.d.ts

@@ -0,0 +1,9 @@
+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 { updateTreasuryTransactionList } from '../treasuryList/treasuryDetailReducer';
+import { executeTreasuryTransferMoney, treasuryTransferMoneySuccessOrFailure } from './treasuryTransferMoneyReducer';
+export type ActionType = ReturnType<typeof executeTreasuryTransferMoney> | ReturnType<typeof treasuryTransferMoneySuccessOrFailure> | ReturnType<typeof updateTreasuryTransactionList> | ReturnType<typeof openSnackbar>;
+export declare const treasuryTransferMoneyEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;