@zeniai/client-epic-state 5.1.7 → 5.1.8-betaAS1

package/lib/esm/view/spendManagement/billPay/internationalWireVerification/internationalWireVerificationSubmitPayload.js

@@ -0,0 +1,154 @@
+import { InternationalWireVerificationBooleanWithSubfieldsFieldNames, InternationalWireVerificationFormFieldNames, InternationalWireVerificationSubfieldNames, } from './internationalWireVerificationFieldConstants';
+export const IntlWireVerificationLocalDataSuffix = {
+    documentOption: '_option',
+    documentBack: '_back',
+    nameFirst: '_first_name',
+    nameLast: '_last_name',
+};
+const MULTI_OPTION_FILE_FIELD_NAMES = new Set([
+    InternationalWireVerificationFormFieldNames.businessOwnership,
+    InternationalWireVerificationFormFieldNames.companyProofOfAddress,
+    InternationalWireVerificationFormFieldNames.companyOfficerProofOfAddress,
+]);
+const BOOLEAN_WITH_SUBFIELDS_FIELD_NAMES = new Set([
+    InternationalWireVerificationBooleanWithSubfieldsFieldNames.stakeHolder,
+    InternationalWireVerificationBooleanWithSubfieldsFieldNames.controllingPerson,
+]);
+const FILE_SUBFIELD_NAMES = new Set([
+    InternationalWireVerificationSubfieldNames.proofOfIdentity,
+    InternationalWireVerificationSubfieldNames.proofOfAddress,
+]);
+const isInternalLocalDataKey = (key) => key.endsWith(IntlWireVerificationLocalDataSuffix.documentOption) ||
+    key.endsWith(IntlWireVerificationLocalDataSuffix.documentBack) ||
+    key.endsWith(IntlWireVerificationLocalDataSuffix.nameFirst) ||
+    key.endsWith(IntlWireVerificationLocalDataSuffix.nameLast);
+const isPersonSubfieldKey = (key) => key.startsWith(`${InternationalWireVerificationBooleanWithSubfieldsFieldNames.stakeHolder}_`) ||
+    key.startsWith(`${InternationalWireVerificationBooleanWithSubfieldsFieldNames.controllingPerson}_`);
+const toFileOptionPayloads = (localData, baseKey) => {
+    const option = localData[`${baseKey}${IntlWireVerificationLocalDataSuffix.documentOption}`];
+    if (typeof option !== 'string' || option.length === 0) {
+        return undefined;
+    }
+    const payloads = [];
+    const frontFileId = localData[baseKey];
+    if (typeof frontFileId === 'string' && frontFileId.length > 0) {
+        payloads.push({ file_id: frontFileId, option });
+    }
+    const backFileId = localData[`${baseKey}${IntlWireVerificationLocalDataSuffix.documentBack}`];
+    if (typeof backFileId === 'string' && backFileId.length > 0) {
+        payloads.push({ file_id: backFileId, option });
+    }
+    return payloads.length > 0 ? payloads : undefined;
+};
+const buildPersonPayload = (localData, keyPrefix) => {
+    const person = {};
+    const nameBaseKey = `${keyPrefix}_${InternationalWireVerificationSubfieldNames.name}`;
+    const firstName = localData[`${nameBaseKey}${IntlWireVerificationLocalDataSuffix.nameFirst}`];
+    const lastName = localData[`${nameBaseKey}${IntlWireVerificationLocalDataSuffix.nameLast}`];
+    if (typeof firstName === 'string' || typeof lastName === 'string') {
+        person.name = {
+            first_name: typeof firstName === 'string' ? firstName : '',
+            last_name: typeof lastName === 'string' ? lastName : '',
+        };
+    }
+    const assignStringField = (subfieldName, assign) => {
+        const value = localData[`${keyPrefix}_${subfieldName}`];
+        if (typeof value === 'string' && value.length > 0) {
+            assign(value);
+        }
+    };
+    assignStringField(InternationalWireVerificationSubfieldNames.nationality, (value) => {
+        person.nationality = value;
+    });
+    assignStringField(InternationalWireVerificationSubfieldNames.email, (value) => {
+        person.email = value;
+    });
+    assignStringField(InternationalWireVerificationSubfieldNames.companyRole, (value) => {
+        person.company_role = value;
+    });
+    assignStringField(InternationalWireVerificationSubfieldNames.ssn, (value) => {
+        person.ssn = value;
+    });
+    assignStringField(InternationalWireVerificationSubfieldNames.dateOfBirth, (value) => {
+        person.date_of_birth = value;
+    });
+    const ownershipValue = localData[`${keyPrefix}_${InternationalWireVerificationSubfieldNames.ownershipPercentage}`];
+    if (ownershipValue != null && ownershipValue !== '') {
+        person.ownership_percentage = Number(ownershipValue);
+    }
+    FILE_SUBFIELD_NAMES.forEach((subfieldName) => {
+        const filePayloads = toFileOptionPayloads(localData, `${keyPrefix}_${subfieldName}`);
+        if (filePayloads != null) {
+            if (subfieldName ===
+                InternationalWireVerificationSubfieldNames.proofOfIdentity) {
+                person.proof_of_identity = filePayloads;
+            }
+            else {
+                person.proof_of_address = filePayloads;
+            }
+        }
+    });
+    return person;
+};
+const getStakeHolderOwnerIndices = (localData) => {
+    const stakeHolderPrefix = `${InternationalWireVerificationBooleanWithSubfieldsFieldNames.stakeHolder}_`;
+    const indices = new Set();
+    Object.keys(localData).forEach((key) => {
+        const match = key.match(/^stake_holder_(\d+)_/);
+        if (match != null) {
+            indices.add(Number.parseInt(match[1], 10));
+        }
+    });
+    if (indices.size === 0) {
+        const hasUnindexedStakeHolderData = Object.keys(localData).some((key) => key.startsWith(stakeHolderPrefix) &&
+            !/^stake_holder_(true|false)$/.test(key));
+        if (hasUnindexedStakeHolderData) {
+            indices.add(0);
+        }
+    }
+    return Array.from(indices).sort((a, b) => a - b);
+};
+const hasPersonPayloadData = (person) => Object.keys(person).length > 0;
+export const toIntlWireVerificationFormDetails = (localData) => {
+    const formDetails = {};
+    Object.entries(localData).forEach(([key, value]) => {
+        if (BOOLEAN_WITH_SUBFIELDS_FIELD_NAMES.has(key) ||
+            isInternalLocalDataKey(key) ||
+            isPersonSubfieldKey(key)) {
+            return;
+        }
+        if (MULTI_OPTION_FILE_FIELD_NAMES.has(key)) {
+            const filePayloads = toFileOptionPayloads(localData, key);
+            if (filePayloads != null) {
+                formDetails[key] = filePayloads;
+            }
+            return;
+        }
+        if (value == null || value === '') {
+            return;
+        }
+        formDetails[key] = value;
+    });
+    const stakeHolderSelection = localData[InternationalWireVerificationBooleanWithSubfieldsFieldNames.stakeHolder];
+    if (stakeHolderSelection === 'true') {
+        formDetails[InternationalWireVerificationBooleanWithSubfieldsFieldNames.stakeHolder] = getStakeHolderOwnerIndices(localData)
+            .map((ownerIndex) => buildPersonPayload(localData, `${InternationalWireVerificationBooleanWithSubfieldsFieldNames.stakeHolder}_${ownerIndex}`))
+            .filter(hasPersonPayloadData);
+    }
+    else if (stakeHolderSelection === 'false') {
+        formDetails[InternationalWireVerificationBooleanWithSubfieldsFieldNames.stakeHolder] = [];
+    }
+    const controllingPersonSelection = localData[InternationalWireVerificationBooleanWithSubfieldsFieldNames
+        .controllingPerson];
+    if (controllingPersonSelection === 'false') {
+        const controllingPerson = buildPersonPayload(localData, InternationalWireVerificationBooleanWithSubfieldsFieldNames.controllingPerson);
+        if (hasPersonPayloadData(controllingPerson)) {
+            formDetails[InternationalWireVerificationBooleanWithSubfieldsFieldNames.controllingPerson] = controllingPerson;
+        }
+    }
+    return formDetails;
+};
+export const toIntlWireVerificationSubmitPayload = (localData) => ({
+    is_applicant_declaration: true,
+    form_details: toIntlWireVerificationFormDetails(localData),
+});

package/lib/esm/view/spendManagement/cashManagement/autoSweepFlow/autoSweepFlowPayload.js

@@ -0,0 +1,29 @@
+import { toAmount } from '../../../../commonStateTypes/amount';
+import { date } from '../../../../zeniDayJS';
+import { toAutoSweepFrequency, } from './autoSweepFlowState';
+export const toSaveAutoSweepSettingsBody = (state) => ({
+    frequency: state.frequency,
+    memo: state.memo,
+    minimum_buffer_usd: state.bufferAmount.amount,
+});
+/**
+ * Map a `GET /cash-management/settings` payload into the slice's writable
+ * fields. Defensive on the frequency (string-from-the-wire → union via
+ * `toAutoSweepFrequency`, falling back to `'weekly'` if the server returns
+ * something we don't model yet). Only the source account *id* is stored
+ * here — the full deposit-account payload is published to the entity bucket
+ * by the fetch epic.
+ */
+export const toAutoSweepFlowStatePatch = (payload) => {
+    const currencyCode = payload.source_bank_account.balances?.currency_code;
+    const currencySymbol = payload.source_bank_account.balances?.currency_symbol;
+    return {
+        bufferAmount: toAmount(payload.minimum_buffer_usd, currencyCode ?? 'USD', currencySymbol ?? '$'),
+        frequency: toAutoSweepFrequency(payload.frequency) ?? 'weekly',
+        nextTransferDate: payload.next_run_date != null && payload.next_run_date !== ''
+            ? date(payload.next_run_date)
+            : undefined,
+        primaryFundingAccountId: payload.source_bank_account.deposit_account_id ?? undefined,
+        settingsId: payload.cash_management_settings_id ?? undefined,
+    };
+};

package/lib/esm/view/spendManagement/cashManagement/autoSweepFlow/autoSweepFlowReducer.js

@@ -0,0 +1,78 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { toAutoSweepFlowStatePatch, } from './autoSweepFlowPayload';
+import { initialAutoSweepFlowState, } from './autoSweepFlowState';
+export const initialState = initialAutoSweepFlowState;
+const autoSweepFlow = createSlice({
+    name: 'autoSweepFlow',
+    initialState,
+    reducers: {
+        /**
+         * Kicks off `GET /cash-management/settings`. Flips the top-level
+         * fetchState to `In-Progress`; the fetch epic picks this up.
+         */
+        fetchCashManagementSettings(draft) {
+            draft.fetchState = 'In-Progress';
+            draft.error = undefined;
+        },
+        /**
+         * Hydrates the form fields with the server-side settings (and stashes
+         * the settings id for subsequent saves). Marks the GET as `Completed`.
+         */
+        updateCashManagementSettings(draft, action) {
+            const patch = toAutoSweepFlowStatePatch(action.payload.data);
+            draft.bufferAmount = patch.bufferAmount;
+            draft.frequency = patch.frequency;
+            draft.nextTransferDate = patch.nextTransferDate;
+            draft.primaryFundingAccountId = patch.primaryFundingAccountId;
+            draft.settingsId = patch.settingsId;
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+        },
+        updateCashManagementSettingsFetchStatus(draft, action) {
+            draft.fetchState = action.payload.fetchState;
+            draft.error = action.payload.error;
+        },
+        /**
+         * Live-update the buffer (risk band) as the user toggles the risk picker
+         * on the setup page, without staging frequency/memo. The selector derives
+         * the risk-adjusted sweep amount off `bufferAmount`, so dispatching this on
+         * every risk change keeps the setup and review screens in sync.
+         */
+        updateAutoSweepRisk(draft, action) {
+            draft.bufferAmount = action.payload.bufferAmount;
+        },
+        /**
+         * Stage the in-flight form values without submitting them — fired from
+         * the setup→review transition so other selectors (and devtools) can see
+         * what the user is about to confirm. Leaves `saveStatus` untouched; the
+         * actual PUT only kicks off when the user clicks "Confirm Sweep" via
+         * `saveAutoSweepSettings`.
+         */
+        updateAutoSweepDraft(draft, action) {
+            draft.bufferAmount = action.payload.bufferAmount;
+            draft.frequency = action.payload.frequency;
+            draft.memo = action.payload.memo;
+        },
+        /**
+         * Trigger the PUT for the auto-sweep settings already staged via
+         * `updateAutoSweepDraft`. Carries no payload — flips `saveStatus` to
+         * `In-Progress` and the save epic reads `bufferAmount` / `frequency` /
+         * `memo` straight from the slice. Callers must ensure those fields
+         * reflect the user's latest input before dispatching.
+         */
+        saveAutoSweepSettings(draft) {
+            draft.saveStatus = { fetchState: 'In-Progress', error: undefined };
+        },
+        updateAutoSweepSettingsFetchStatus(draft, action) {
+            draft.saveStatus = {
+                fetchState: action.payload.fetchState,
+                error: action.payload.error,
+            };
+        },
+        clearAutoSweepFlow() {
+            return initialAutoSweepFlowState;
+        },
+    },
+});
+export const { fetchCashManagementSettings, updateCashManagementSettings, updateCashManagementSettingsFetchStatus, updateAutoSweepRisk, updateAutoSweepDraft, saveAutoSweepSettings, updateAutoSweepSettingsFetchStatus, clearAutoSweepFlow, } = autoSweepFlow.actions;
+export default autoSweepFlow.reducer;

package/lib/esm/view/spendManagement/cashManagement/autoSweepFlow/autoSweepFlowSelector.js

@@ -0,0 +1,49 @@
+import { getDepositAccountByDepositAccountId } from '../../../../entity/depositAccount/depositAccountSelector';
+import { mapDepositAccToFundingAccount, } from '../../commonSetup/setupViewSelector';
+import { getTreasuryDetail } from '../../treasury/treasuryList/treasuryDetailSelector';
+import { getCashManagementOverviewBanner } from '../cashManagementOverview/cashManagementOverviewSelector';
+import { RISK_BUFFER_AMOUNT, bufferAmountToRisk, } from './autoSweepFlowState';
+/**
+ * Risk band the agent's recommended sweep amount is computed against. The
+ * `sweepAmount` returned by the banner assumes this buffer, so the selector
+ * adjusts the displayed sweep by the delta between the user's selected band
+ * and this default.
+ */
+const DEFAULT_RISK_LEVEL = 'moderate';
+export const getAutoSweepFlow = (state) => {
+    const { bufferAmount, frequency, memo, saveStatus, settingsId, primaryFundingAccountId, fetchState, error, } = state.autoSweepFlowState;
+    const depositAccount = primaryFundingAccountId != null
+        ? getDepositAccountByDepositAccountId(state.depositAccountState, primaryFundingAccountId)
+        : undefined;
+    const risk = bufferAmountToRisk(bufferAmount.amount);
+    // The banner's recommended sweep assumes the default buffer band; shift it
+    // by the delta between the default buffer and the user's selected band so a
+    // tighter buffer (higher risk → smaller buffer) sweeps more and a looser
+    // buffer (lower risk → larger buffer) sweeps less. Clamp at zero so a buffer
+    // larger than the available surplus never yields a negative sweep.
+    const baseSweepAmount = getCashManagementOverviewBanner(state).amount;
+    const sweepAmount = {
+        ...baseSweepAmount,
+        amount: Math.max(0, baseSweepAmount.amount +
+            RISK_BUFFER_AMOUNT[DEFAULT_RISK_LEVEL] -
+            RISK_BUFFER_AMOUNT[risk]),
+    };
+    return {
+        fetchState,
+        error,
+        formData: {
+            bufferAmount,
+            frequency,
+            memo,
+            risk,
+        },
+        primaryFundingAccount: depositAccount != null
+            ? mapDepositAccToFundingAccount(depositAccount)
+            : undefined,
+        saveStatus,
+        settingsId,
+        sweepAmount,
+        treasurySummary: getTreasuryDetail(state).accountSummary,
+        version: 0,
+    };
+};

package/lib/esm/view/spendManagement/cashManagement/autoSweepFlow/autoSweepFlowState.js

@@ -0,0 +1,47 @@
+import { toAmount } from '../../../../commonStateTypes/amount';
+import { stringToUnion } from '../../../../commonStateTypes/stringToUnion';
+/**
+ * Cadence at which the auto-sweep transfer fires. Lowercase to match the
+ * cash-management settings API contract (and the `SweepFrequency` literal
+ * already used by `<AutoSweepSetupPage>` in web-components).
+ */
+export const ALL_AUTO_SWEEP_FREQUENCIES = [
+    'daily',
+    'weekly',
+    'biweekly',
+    'monthly',
+];
+export const toAutoSweepFrequency = (v) => stringToUnion(v ?? '', ALL_AUTO_SWEEP_FREQUENCIES);
+/**
+ * Risk presets the auto-sweep setup form exposes. Each level maps to a
+ * canonical minimum-buffer amount (USD). Selecting a level in the UI is
+ * shorthand for choosing that buffer.
+ */
+export const ALL_AUTO_SWEEP_RISK_LEVELS = ['low', 'moderate', 'high'];
+export const toAutoSweepRiskLevel = (v) => stringToUnion(v ?? '', ALL_AUTO_SWEEP_RISK_LEVELS);
+export const RISK_BUFFER_AMOUNT = {
+    low: 15000,
+    moderate: 10000,
+    high: 5000,
+};
+/**
+ * Maps a buffer amount back onto the closest preset risk level. Falls back
+ * to `'moderate'` when the amount doesn't match a known preset (e.g. the
+ * server returned a custom value). The dropdown in `<AutoSweepSetupPage>`
+ * uses this so it can pre-select the user's existing band on edit.
+ */
+export const bufferAmountToRisk = (amount) => {
+    const match = Object.entries(RISK_BUFFER_AMOUNT).find(([, presetAmount]) => presetAmount === amount);
+    return match != null ? match[0] : 'moderate';
+};
+export const initialAutoSweepFlowState = {
+    bufferAmount: toAmount(10000, 'USD', '$'),
+    frequency: 'weekly',
+    memo: '',
+    saveStatus: { fetchState: 'Not-Started', error: undefined },
+    nextTransferDate: undefined,
+    primaryFundingAccountId: undefined,
+    settingsId: undefined,
+    fetchState: 'Not-Started',
+    error: undefined,
+};

package/lib/esm/view/spendManagement/cashManagement/autoSweepFlow/epics/fetchCashManagementSettingsEpic.js

@@ -0,0 +1,32 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { updateDepositAccounts } from '../../../../../entity/depositAccount/depositAccountReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../../responsePayload';
+import { fetchCashManagementSettings, updateCashManagementSettings, updateCashManagementSettingsFetchStatus, } from '../autoSweepFlowReducer';
+/**
+ * Hits `GET /cash-management/settings` and hydrates the auto-sweep slice
+ * with the server's existing settings (frequency, minimum buffer, settings
+ * id). Called from the cash management overview page-fetch epic alongside
+ * the other top-level fetches.
+ */
+export const fetchCashManagementSettingsEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCashManagementSettings.match), switchMap(() => {
+    const endpoint = `${zeniAPI.apiEndPoints.cashManagementAgentBaseUrl}/1.0/cash-management/settings`;
+    return zeniAPI.getJSON(endpoint).pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            return of(
+            // Publish the source deposit account into the shared entity
+            // bucket so the selector can hydrate the full `FundingAccount`
+            // from `getDepositAccountByDepositAccountId` rather than the
+            // auto-sweep slice holding a duplicate copy.
+            updateDepositAccounts([response.data.source_bank_account]), updateCashManagementSettings({ data: response.data }));
+        }
+        return of(updateCashManagementSettingsFetchStatus({
+            fetchState: 'Error',
+            error: response.status,
+        }));
+    }), catchError((error) => of(updateCashManagementSettingsFetchStatus({
+        fetchState: 'Error',
+        error: createZeniAPIStatus('Unexpected Error', 'Fetch cash management settings REST API call errored out: ' +
+            (error?.message ?? String(error))),
+    }))));
+}));

package/lib/esm/view/spendManagement/cashManagement/autoSweepFlow/epics/saveAutoSweepSettingsEpic.js

@@ -0,0 +1,32 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../../responsePayload';
+import { toSaveAutoSweepSettingsBody, } from '../autoSweepFlowPayload';
+import { saveAutoSweepSettings, updateAutoSweepSettingsFetchStatus, } from '../autoSweepFlowReducer';
+export const saveAutoSweepSettingsEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(saveAutoSweepSettings.match), switchMap(() => {
+    const endpoint = `${zeniAPI.apiEndPoints.cashManagementAgentBaseUrl}/1.0/cash-management/settings`;
+    const { bufferAmount, frequency, memo, settingsId } = state$.value.autoSweepFlowState;
+    const payload = toSaveAutoSweepSettingsBody({
+        bufferAmount,
+        frequency,
+        memo,
+    });
+    // First-time setup (no settings id from the GET yet) → POST a new
+    // record. Subsequent edits update the existing one via PUT.
+    const request$ = settingsId == null
+        ? zeniAPI.postAndGetJSON(endpoint, payload)
+        : zeniAPI.putAndGetJSON(endpoint, payload);
+    return request$.pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            return of(updateAutoSweepSettingsFetchStatus({ fetchState: 'Completed' }));
+        }
+        return of(updateAutoSweepSettingsFetchStatus({
+            fetchState: 'Error',
+            error: response?.status,
+        }));
+    }), catchError((error) => of(updateAutoSweepSettingsFetchStatus({
+        fetchState: 'Error',
+        error: createZeniAPIStatus('Unexpected Error', 'Save auto-sweep settings REST API call errored out: ' +
+            (error?.message ?? String(error))),
+    }))));
+}));

package/lib/esm/view/spendManagement/cashManagement/cashManagementOverview/cashManagementOverviewPayload.js

@@ -0,0 +1,54 @@
+import { toAmount } from '../../../../commonStateTypes/amount';
+import { date as zeniDate } from '../../../../zeniDayJS';
+// ---------------------------------------------------------------------------
+// Converters
+// ---------------------------------------------------------------------------
+// The cash agent payload reports `currency_code` only; the v1 surface is
+// USD-only, so we pair it with the canonical `$` symbol here. If the agent
+// grows multi-currency support, this is the single place to widen.
+const CASH_AGENT_CURRENCY_SYMBOL = '$';
+export const toUpcomingPaymentEvent = (event) => ({
+    accountId: event.account_id,
+    accountType: event.account_type,
+    amount: toAmount(event.amount_usd, event.currency_code, CASH_AGENT_CURRENCY_SYMBOL),
+    label: event.label,
+    paymentDate: zeniDate(event.payment_date),
+});
+/**
+ * The agent reports a `null` account id whenever the "account" in question is
+ * a singleton inferred from the account type (today: the treasury account —
+ * there's only one per company, so the type alone identifies it). Callers
+ * already branch on `*BankAccountType`, so collapsing the id to `""` keeps the
+ * state type a plain `ID` (string) without losing information.
+ */
+const toCashManagementMovement = (payload) => ({
+    amount: toAmount(payload.amount, payload.currency_code, CASH_AGENT_CURRENCY_SYMBOL),
+    destinationBankAccountId: payload.destination_bank_account_id ?? '',
+    destinationBankAccountType: payload.destination_bank_account_type,
+    reasoning: payload.reasoning,
+    sourceBankAccountId: payload.source_bank_account_id ?? '',
+    sourceBankAccountType: payload.source_bank_account_type,
+    subMovementType: payload.sub_movement_type,
+});
+const toCashManagementMoneyMovementGroup = (payload) => ({
+    movements: payload.movements.map(toCashManagementMovement),
+    movementType: payload.movement_type,
+});
+export const toCashManagementBannerData = (payload) => ({
+    inflows: payload.inflows.map(toUpcomingPaymentEvent),
+    moneyMovements: payload.money_movements.map(toCashManagementMoneyMovementGroup),
+    outflows: payload.outflows.map(toUpcomingPaymentEvent),
+});
+export const toCashManagementTransfer = (payload) => ({
+    amount: toAmount(payload.amount, payload.currency_code, CASH_AGENT_CURRENCY_SYMBOL),
+    atomicTransactionId: payload.atomic_transaction_id,
+    cashManagementTransferId: payload.cash_management_transfer_id,
+    createTime: zeniDate(payload.create_time),
+    date: zeniDate(payload.date),
+    depositAccountId: payload.deposit_account_id,
+    reasoning: payload.reasoning,
+    scenario: payload.scenario,
+    status: payload.status,
+    transactionType: payload.transaction_type,
+    updateTime: zeniDate(payload.update_time),
+});

package/lib/esm/view/spendManagement/cashManagement/cashManagementOverview/cashManagementOverviewReducer.js

@@ -0,0 +1,92 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { toCashManagementBannerData, toCashManagementTransfer, } from './cashManagementOverviewPayload';
+import { initialCashManagementBannerState, initialCashManagementRecentTransferState, } from './cashManagementOverviewState';
+export const initialState = {
+    banner: initialCashManagementBannerState,
+    recentTransfer: initialCashManagementRecentTransferState,
+};
+const cashManagementOverview = createSlice({
+    name: 'cashManagementOverview',
+    initialState,
+    reducers: {
+        fetchCashManagementOverviewPage: {
+            reducer() { },
+            prepare(cacheOverride) {
+                return { payload: { cacheOverride } };
+            },
+        },
+        /**
+         * Public banner-fetch entry point. Triggers an orchestrator epic that
+         * fans out to the recommend, settings, and recent-transfer API calls
+         * in parallel. No reducer-side state change — each inner action drives
+         * its own sub-state.
+         *
+         * `cacheOverride === true` forces all three inner fetches regardless
+         * of current slice state; `false` keeps the per-slice dedup so repeat
+         * dispatches are no-ops once a slice is loaded or in-flight.
+         */
+        fetchCashManagementBanner: {
+            reducer() { },
+            prepare(cacheOverride) {
+                return { payload: { cacheOverride } };
+            },
+        },
+        /**
+         * Internal trigger for the recommend API (`/cash-agent/recommend`).
+         * Dispatched by the orchestrator; not exported.
+         */
+        fetchCashManagementRecommendation(draft) {
+            // Keep `draft.banner.data` so the projection chart renders the last
+            // good payload while the refetch is in flight, instead of flickering
+            // to the empty/skeleton state on every page revisit.
+            draft.banner.fetchState = 'In-Progress';
+            draft.banner.error = undefined;
+        },
+        updateCashManagementRecommendation(draft, action) {
+            draft.banner = {
+                fetchState: 'Completed',
+                error: undefined,
+                data: toCashManagementBannerData(action.payload.data),
+            };
+        },
+        updateCashManagementRecommendationFetchStatus(draft, action) {
+            draft.banner = {
+                ...draft.banner,
+                fetchState: action.payload.fetchState,
+                error: action.payload.error,
+            };
+        },
+        /**
+         * Internal trigger for the recent-transfer API
+         * (`/cash-management/transfers`). Dispatched by the orchestrator; not
+         * exported.
+         */
+        fetchRecentTransfer(draft) {
+            // Same anti-flicker pattern as the recommend fetch: keep prior data
+            // while the refetch is in flight.
+            draft.recentTransfer.fetchState = 'In-Progress';
+            draft.recentTransfer.error = undefined;
+        },
+        updateRecentTransfer(draft, action) {
+            draft.recentTransfer = {
+                fetchState: 'Completed',
+                error: undefined,
+                data: action.payload.data != null
+                    ? toCashManagementTransfer(action.payload.data)
+                    : undefined,
+            };
+        },
+        updateRecentTransferFetchStatus(draft, action) {
+            draft.recentTransfer = {
+                ...draft.recentTransfer,
+                fetchState: action.payload.fetchState,
+                error: action.payload.error,
+            };
+        },
+        clearCashManagementOverview(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { fetchCashManagementOverviewPage, fetchCashManagementBanner, fetchCashManagementRecommendation, updateCashManagementRecommendation, updateCashManagementRecommendationFetchStatus, fetchRecentTransfer, updateRecentTransfer, updateRecentTransferFetchStatus, clearCashManagementOverview, } = cashManagementOverview.actions;
+export default cashManagementOverview.reducer;