@zeniai/client-epic-state 5.1.0-betaSS3 → 5.1.1-beta0ND

package/lib/esm/view/spendManagement/billPay/billPaySetupApproverView/epic/initializeBillPaySetupApproverViewUpdateDataEpic.js

@@ -1,6 +1,6 @@
 import { from } from 'rxjs';
 import { filter, mergeMap } from 'rxjs/operators';
-import { getApprovalRuleById } from '../../../../../entity/approvalRule/approvalRuleSelector';
+import { getAmountCriteria, getApprovalRuleById, getDepartmentCriteria, getVendorCriteria, } from '../../../../../entity/approvalRule/approvalRuleSelector';
 import { clearBillPaySetupApproverViewUpdateData, initializeBillPaySetupApproverViewUpdateData, saveBillPaySetupApproverViewUpdateData, } from '../billPaySetupApproverViewReducer';
 export const initializeBillPaySetupApproverViewUpdateDataEpic = (actions$, state$) => actions$.pipe(filter(initializeBillPaySetupApproverViewUpdateData.match), mergeMap((action) => {
     const { approvalRuleId } = action.payload;
@@ -8,16 +8,20 @@ export const initializeBillPaySetupApproverViewUpdateDataEpic = (actions$, state
     if (approvalRuleId != null) {
         const approvalRule = getApprovalRuleById(state$.value.approvalRuleState, approvalRuleId);
         if (approvalRule != null) {
-            const criteria = approvalRule.criteria[0];
-            const range = criteria?.range;
             const billPaySetupApproverViewUpdateData = {
                 approvalRuleId,
                 steps: approvalRule.steps,
                 criteria: {
-                    rangeType: criteria?.rangeType,
-                    rangeEntity: criteria?.rangeEntity,
-                    range,
+                    amount: getAmountCriteria(approvalRule.criteria),
+                    vendor: getVendorCriteria(approvalRule.criteria),
+                    department: getDepartmentCriteria(approvalRule.criteria),
                 },
+                // Approval Rules 3.0 — seed rule-level fields so the form can
+                // round-trip them on edit. Each may be undefined on legacy rules.
+                name: approvalRule.name,
+                description: approvalRule.description,
+                separationOfDuties: approvalRule.separationOfDuties,
+                isFallback: approvalRule.isFallback,
             };
             fetchActions.push(clearBillPaySetupApproverViewUpdateData(), saveBillPaySetupApproverViewUpdateData(billPaySetupApproverViewUpdateData));
         }
@@ -25,7 +29,7 @@ export const initializeBillPaySetupApproverViewUpdateDataEpic = (actions$, state
     else {
         const billPaySetupApproverViewCreateData = {
             steps: [],
-            criteria: undefined,
+            criteria: {},
         };
         fetchActions.push(clearBillPaySetupApproverViewUpdateData(), saveBillPaySetupApproverViewUpdateData(billPaySetupApproverViewCreateData));
     }

package/lib/esm/view/spendManagement/billPay/billPaySetupApproverView/epic/reorderBillPayApprovalRulesEpic.js

@@ -0,0 +1,54 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { updateApprovalRules } from '../../../../../entity/approvalRule/approvalRuleReducer';
+import { openSnackbar } from '../../../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../../responsePayload';
+import { fetchBillPaySetupApproverView, reorderBillPayApprovalRules, reorderBillPayApprovalRulesFailure, reorderBillPayApprovalRulesSuccess, } from '../billPaySetupApproverViewReducer';
+export const reorderBillPayApprovalRulesEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(reorderBillPayApprovalRules.match), switchMap((action) => {
+    const { approvalRuleIds, useV3 } = action.payload;
+    // Approval Rules 3.0 — flag-gated endpoint selection. Mirrors
+    // the pattern used by delete + fetch epics: the v3 dev host
+    // until the production base URL ships the v2 reorder route.
+    const endpoint = `${zeniAPI.apiEndPoints.approvalMicroServiceBaseUrl}/1.0/bill-pay/approval-rules-v2/reorder`;
+    return zeniAPI
+        .putAndGetJSON(endpoint, {
+        rule_ids: approvalRuleIds,
+    })
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const serverOrderedIds = response.data.approval_rules.map((approvalRule) => approvalRule.approval_rule_id);
+            const actions = [
+                updateApprovalRules(response.data.approval_rules),
+                reorderBillPayApprovalRulesSuccess(serverOrderedIds),
+                openSnackbar({
+                    messageSection: `bill_pay_approval_reorder`,
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ];
+            return from(actions);
+        }
+        else {
+            const recovery = [
+                reorderBillPayApprovalRulesFailure(response.status),
+                openSnackbar({
+                    messageSection: `bill_pay_approval_reorder`,
+                    messageText: 'failed',
+                    type: 'error',
+                }),
+                // Refetch to revert the optimistic order to server truth.
+                fetchBillPaySetupApproverView(true, true, useV3),
+            ];
+            return from(recovery);
+        }
+    }), catchError((error) => from([
+        reorderBillPayApprovalRulesFailure(createZeniAPIStatus('Unexpected Error', 'Reorder Bill Pay Approval Rules errored out' +
+            JSON.stringify(error))),
+        openSnackbar({
+            messageSection: `bill_pay_approval_reorder`,
+            messageText: 'failed',
+            type: 'error',
+        }),
+        fetchBillPaySetupApproverView(true, true, useV3),
+    ])));
+}));

package/lib/esm/view/spendManagement/billPay/billPaySetupApproverView/epic/saveBillPaySetupApproverViewUpdatesEpic.js

@@ -5,15 +5,24 @@ import { openSnackbar } from '../../../../../entity/snackbar/snackbarReducer';
 import { updateAllUsers } from '../../../../../entity/user/userReducer';
 import { createZeniAPIStatus, isSuccessResponse, } from '../../../../../responsePayload';
 import { saveBillPaySetupApproverViewUpdates, saveBillPaySetupApproverViewUpdatesFailure, saveBillPaySetupApproverViewUpdatesSuccess, } from '../billPaySetupApproverViewReducer';
-import { toApprovalChangableInfoPayload } from '../types/commonPayload';
-export const saveBillPaySetupApproverViewUpdatesEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(saveBillPaySetupApproverViewUpdates.match), switchMap(() => {
+import { toApprovalChangableInfoPayload, toApprovalChangableInfoPayloadV1, } from '../types/commonPayload';
+export const saveBillPaySetupApproverViewUpdatesEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(saveBillPaySetupApproverViewUpdates.match), switchMap((action) => {
     const { billPaySetupApproverViewState } = state$.value;
     const billPaySetupApproverViewUpdateData = billPaySetupApproverViewState.billPaySetupApproverViewUpdateData;
     if (billPaySetupApproverViewUpdateData != null &&
         billPaySetupApproverViewUpdateData.data != null) {
-        const payload = toApprovalChangableInfoPayload(billPaySetupApproverViewUpdateData.data);
+        // Approval Rules 3.0 — gate URL + write-side payload mapper on
+        // the `approval_rule_v3_config` dynamic config. `useV3` arrives
+        // on the action payload from the screen connector.
+        const { useV3 } = action.payload;
+        const payload = useV3
+            ? toApprovalChangableInfoPayload(billPaySetupApproverViewUpdateData.data)
+            : toApprovalChangableInfoPayloadV1(billPaySetupApproverViewUpdateData.data);
+        const endpoint = useV3
+            ? `${zeniAPI.apiEndPoints.approvalMicroServiceBaseUrl}/1.0/bill-pay/approval-rules-v2`
+            : `${zeniAPI.apiEndPoints.approvalMicroServiceBaseUrl}/1.0/bill-pay/approval-rules`;
         return zeniAPI
-            .postAndGetJSON(`${zeniAPI.apiEndPoints.approvalMicroServiceBaseUrl}/1.0/bill-pay/approval-rules`, payload)
+            .postAndGetJSON(endpoint, payload)
             .pipe(mergeMap((response) => {
             if (isSuccessResponse(response) && response.data != null) {
                 const approvalRuleIds = response.data.approval_rules.map((approvalRule) => approvalRule.approval_rule_id);

package/lib/esm/view/spendManagement/billPay/billPaySetupApproverView/types/commonPayload.js

@@ -1,20 +1,48 @@
 export const toApprovalChangableInfoPayload = (approverViewUpdateData) => {
-    let criteriaPayload = [];
+    // Form-side criteria is a structured object with optional slots for
+    // amount / vendor / department; flatten it into the wire format's
+    // `conditions[]` array.
+    let criteriaPayload;
     if (approverViewUpdateData.criteria != null) {
-        const criteria = approverViewUpdateData.criteria;
-        const { rangeType, rangeEntity, range } = criteria;
-        const { min, max } = range;
-        const { currencyCode, currencySymbol } = min;
-        criteriaPayload = [
-            {
-                type: rangeType,
-                range_entity: rangeEntity,
-                min: min.amount,
-                max: max?.amount ?? null,
-                currency_code: currencyCode,
-                currency_symbol: currencySymbol,
-            },
-        ];
+        const { amount, vendor, department } = approverViewUpdateData.criteria;
+        const conditions = [];
+        if (amount?.min != null) {
+            conditions.push({
+                field: 'amount',
+                type: 'gte',
+                value: amount.min.amount,
+            });
+        }
+        if (amount?.max != null) {
+            conditions.push({
+                field: 'amount',
+                type: 'lte',
+                value: amount.max.amount,
+            });
+        }
+        if (vendor != null && vendor.vendorIds.length > 0) {
+            conditions.push({
+                field: 'vendor_id',
+                type: vendor.operator === 'is_not' ? 'not_in' : 'in',
+                value: vendor.vendorIds,
+            });
+        }
+        if (department != null && department.departmentIds.length > 0) {
+            conditions.push({
+                field: 'department_id',
+                type: department.operator === 'is_not' ? 'not_in' : 'in',
+                value: department.departmentIds,
+            });
+        }
+        if (conditions.length > 0) {
+            const currency = amount?.min ?? amount?.max ?? null;
+            criteriaPayload = {
+                conditions,
+                criteria_operator: 'and',
+                currency_code: currency?.currencyCode ?? 'USD',
+                currency_symbol: currency?.currencySymbol ?? '$',
+            };
+        }
     }
     const steps = approverViewUpdateData.steps.map((step) => {
         return {
@@ -35,10 +63,106 @@ export const toApprovalChangableInfoPayload = (approverViewUpdateData) => {
     });
     const isUpdate = approverViewUpdateData.approvalRuleId != null;
     const payload = {
-        criteria: criteriaPayload,
         steps,
         is_applicable_on_pending_approval_entity: approverViewUpdateData.isApplicableOnPendingApprovalEntity ?? true,
     };
+    if (criteriaPayload != null) {
+        payload.criteria = criteriaPayload;
+    }
+    // Approval Rules 3.0 — surface rule-level fields when the form set them.
+    // Send only what the user actually entered: an undefined value means
+    // "no opinion" and stays off the wire.
+    if (approverViewUpdateData.name != null) {
+        payload.name = approverViewUpdateData.name;
+    }
+    if (approverViewUpdateData.description != null) {
+        payload.description = approverViewUpdateData.description;
+    }
+    if (approverViewUpdateData.separationOfDuties != null) {
+        payload.is_separation_of_duty_enabled =
+            approverViewUpdateData.separationOfDuties;
+    }
+    if (approverViewUpdateData.isFallback != null) {
+        payload.is_fallback = approverViewUpdateData.isFallback;
+    }
+    if (isUpdate) {
+        payload.approval_rule_id = approverViewUpdateData.approvalRuleId;
+    }
+    return payload;
+};
+/**
+ * V1 wire mapper — used when 'approval_rule_v3_config' resolves to OFF
+ * for the current tenant. Emits the legacy snake_case array shape that
+ * '/approval-rules' historically consumed (see the V1 fixture in
+ * 'entity/entityApprovalStatus/__mocks__/json/entityApprovalStatusPayload.json'):
+ *   criteria: [{type: 'range', range_entity: 'currency', min, max,
+ *               currency_code, currency_symbol}]
+ *
+ * Open-ended semantics are preserved on the wire: an absent 'min' or
+ * 'max' is sent as 'null' rather than synthesised to '0' or
+ * 'MAX_SAFE_INTEGER', so a 'greater_than' / 'less_than' rule stays
+ * one-sided after rollback rather than collapsing into a closed range.
+ *
+ * The V1 backend does not understand vendor / department criteria or
+ * the rule-level 3.0 fields, so those are dropped on the wire.
+ */
+export const toApprovalChangableInfoPayloadV1 = (approverViewUpdateData) => {
+    const amount = approverViewUpdateData.criteria?.amount;
+    const minAmount = amount?.min;
+    const maxAmount = amount?.max;
+    const currencyCode = minAmount?.currencyCode ?? maxAmount?.currencyCode ?? 'USD';
+    const currencySymbol = minAmount?.currencySymbol ?? maxAmount?.currencySymbol ?? '$';
+    const steps = approverViewUpdateData.steps.map((step) => {
+        return {
+            action: step.action,
+            operator: step.operator,
+            actors: step.actors
+                .filter((actor) => actor.subType !== 'admin')
+                .map((actor) => {
+                return {
+                    type: actor.type,
+                    id: actor.userId ?? null,
+                    sub_type: actor.subType ?? null,
+                    id_type: actor.idType ?? null,
+                    is_implicit_actor: actor.isImplicitActor ?? false,
+                };
+            }),
+        };
+    });
+    const isUpdate = approverViewUpdateData.approvalRuleId != null;
+    const minValue = minAmount?.amount ?? null;
+    const maxValue = maxAmount?.amount ?? null;
+    // Approval Rules 3.0 — guard against the both-null case. The form
+    // is expected to always set at least one bound, but if drift ever
+    // hands us a rule with no min and no max we'd otherwise emit
+    // '[{type: range, min: null, max: null, ...}]' — a payload that
+    // (a) the read-side 'legacyAmountRangeToCriteria' decodes back to
+    // '[]' (asymmetric round-trip), and (b) the V1 backend will
+    // reject anyway. Emit 'criteria: []' instead so the save fails
+    // cleanly on the server side and we leave a breadcrumb in the
+    // console for diagnosis rather than persisting mis-shaped data.
+    const criteria = [];
+    if (minValue == null && maxValue == null) {
+        console.warn('[approvalRules][V1] toApprovalChangableInfoPayloadV1: rule has ' +
+            'no amount bounds; emitting empty criteria array. The V1 backend ' +
+            'will reject this save — caller should ensure at least one bound ' +
+            'is set on the form.');
+    }
+    else {
+        criteria.push({
+            type: 'range',
+            range_entity: 'currency',
+            min: minValue,
+            max: maxValue,
+            currency_code: currencyCode,
+            currency_symbol: currencySymbol,
+        });
+    }
+    const payload = {
+        steps,
+        is_applicable_on_pending_approval_entity: approverViewUpdateData.isApplicableOnPendingApprovalEntity ?? true,
+        criteria,
+    };
     if (isUpdate) {
         payload.approval_rule_id = approverViewUpdateData.approvalRuleId;
     }

package/lib/esm/view/spendManagement/billPay/editBillView/editBillViewSelector.js

@@ -1,6 +1,7 @@
 import recordGet from 'lodash/get';
 import has from 'lodash/has';
 import { reduceFetchState } from '../../../../commonStateTypes/reduceFetchState';
+import { getAmountCriteria, getDepartmentCriteria, getVendorCriteria, } from '../../../../entity/approvalRule/approvalRuleSelector';
 import { getBankAccountByBankAccountId, getBankAccountsByBankAccountIds, } from '../../../../entity/bankAccount/bankAccountSelector';
 import { getContactById, getContactsByIds, } from '../../../../entity/billPay/contact/contactSelector';
 import { getCompanyByCompanyId } from '../../../../entity/company/companySelector';
@@ -356,6 +357,14 @@ export const getEditBillDetail = (state, isVendorRecommendationFeatureEnabled, i
         isDeleted,
         showAutofill,
         addBillAutoFields,
+        // Bill-level accounting class. Approval Rules 3.0 'department'
+        // criteria match against this. Lives on BillTransaction; not on
+        // any sub-section. Empty-string is normalised to 'undefined'
+        // so downstream readers treat "no class" uniformly regardless
+        // of whether the wire used '' or omitted the field.
+        classId: transaction?.classId != null && transaction.classId !== ''
+            ? transaction.classId
+            : undefined,
         billStage,
         deleteStatus,
         billActivities,
@@ -678,12 +687,59 @@ export const getDefaultWithdrawFromAccount = (state, depositAccounts, companyId,
     }
     return undefined;
 };
-export const checkIfCreatorIsApprover = (billAmount, approvalRules, signedInUser) => {
+export const checkIfCreatorIsApprover = (billAmount, approvalRules, signedInUser, billVendorId, billDepartmentId) => {
     let isCreatorAlsoApprover = false;
+    // Approval Rules 3.0 — a rule applies to a bill only when all of
+    // its present criteria are satisfied. Criteria not declared on
+    // the rule are treated as "no narrowing on this axis".
+    //
+    // Strict-match semantics for vendor / department: if the rule
+    // narrows by an axis but the bill has no value on that axis, the
+    // rule does NOT apply (an absent bill-side value can't satisfy
+    // either 'is' or 'is_not'). Amount is always present on a rule
+    // (the form enforces this), but bounds may be one-sided.
     const approvalRule = approvalRules.find((rule) => {
-        const { max, min } = rule.criteria[0].range;
-        return (billAmount > min.amount &&
-            (max?.amount != null ? billAmount <= max?.amount : true));
+        const vendorCriteria = getVendorCriteria(rule.criteria);
+        if (vendorCriteria != null) {
+            if (billVendorId == null) {
+                return false;
+            }
+            const includesVendor = vendorCriteria.vendorIds.includes(billVendorId);
+            if (vendorCriteria.operator === 'is' && !includesVendor) {
+                return false;
+            }
+            if (vendorCriteria.operator === 'is_not' && includesVendor) {
+                return false;
+            }
+        }
+        const departmentCriteria = getDepartmentCriteria(rule.criteria);
+        if (departmentCriteria != null) {
+            if (billDepartmentId == null) {
+                return false;
+            }
+            const includesDepartment = departmentCriteria.departmentIds.includes(billDepartmentId);
+            if (departmentCriteria.operator === 'is' && !includesDepartment) {
+                return false;
+            }
+            if (departmentCriteria.operator === 'is_not' && includesDepartment) {
+                return false;
+            }
+        }
+        const amountCriteria = getAmountCriteria(rule.criteria);
+        if (amountCriteria == null) {
+            // The form guarantees an amount criterion on every rule, so
+            // this branch is defensive against backend drift. Keep
+            // pre-3.0 behaviour: a rule that doesn't declare amount
+            // doesn't participate here.
+            return false;
+        }
+        // Bounds use the wire's inclusive 'gte' / 'lte' semantics, and
+        // either side may be absent for a one-sided 'greater_than' /
+        // 'less_than' rule.
+        const { min, max } = amountCriteria;
+        const matchesMin = min == null || billAmount >= min.amount;
+        const matchesMax = max == null || billAmount <= max.amount;
+        return matchesMin && matchesMax;
     });
     if (approvalRule != null) {
         const requireApprovalSteps = approvalRule.steps.filter((step) => step.action === 'require_approval');

package/lib/esm/view/spendManagement/billPay/editBillView/epics/fetchEditBillDetailPageEpic.js

@@ -38,7 +38,10 @@ export const fetchEditBillDetailPageEpic = (actions$, state$) => actions$.pipe(f
         else {
             billDetailActions.push(updateShowAutofill(true));
         }
-        billDetailActions.push(fetchBillPaySetupApproverView(true));
+        // Side-fetch from the edit-bill page bootstrap. The triggering
+        // action doesn't carry the V3 flag, so we explicitly target v1
+        // here; tenants on v3 re-fetch through their own screen connector.
+        billDetailActions.push(fetchBillPaySetupApproverView(true, true, false));
     }
     else {
         if (state.ownerListState.fetchState !== 'In-Progress' &&
@@ -81,7 +84,10 @@ export const fetchEditBillDetailPageEpic = (actions$, state$) => actions$.pipe(f
         // While opening New Bill Refresh Approval Rules and Payment Accounts
         if (approvalViewFetchState !== 'In-Progress' &&
             approvalViewFetchState !== 'Completed') {
-            billDetailActions.push(fetchBillPaySetupApproverView(true));
+            // Side-fetch from the edit-bill page bootstrap. The triggering
+            // action doesn't carry the V3 flag, so we explicitly target v1
+            // here; tenants on v3 re-fetch through their own screen connector.
+            billDetailActions.push(fetchBillPaySetupApproverView(true, true, false));
         }
     }
     return concat(from(billDetailActions));

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_transfer_date != null && payload.next_transfer_date !== ''
+            ? date(payload.next_transfer_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,47 @@
+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 user's selected band and that default so a
+    // tighter buffer sweeps more and a looser buffer sweeps less.
+    const baseSweepAmount = getCashManagementOverviewBanner(state).amount;
+    const sweepAmount = {
+        ...baseSweepAmount,
+        amount: baseSweepAmount.amount +
+            RISK_BUFFER_AMOUNT[risk] -
+            RISK_BUFFER_AMOUNT[DEFAULT_RISK_LEVEL],
+    };
+    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))),
+    }))));
+}));