@zeniai/client-epic-state 5.2.10 → 5.2.11-betaAM1

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

@@ -3,22 +3,151 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAiAccountantSchedule = void 0;
+exports.isRenderableOneTimeAccrual = isRenderableOneTimeAccrual;
+exports.getJEScheduleRowType = getJEScheduleRowType;
+exports.isPendingReviewRow = isPendingReviewRow;
+exports.isExistingTabRow = isExistingTabRow;
+exports.isAccruedScheduleRow = isAccruedScheduleRow;
+exports.isOneTimeAccrualRow = isOneTimeAccrualRow;
 exports.getExpenseAutomationJESchedulesView = getExpenseAutomationJESchedulesView;
+exports.getExpenseAutomationJEOneTimeAccrualDetailView = getExpenseAutomationJEOneTimeAccrualDetailView;
 const omit_1 = __importDefault(require("lodash/omit"));
 const orderBy_1 = __importDefault(require("lodash/orderBy"));
 const reduceFetchState_1 = require("../../../commonStateTypes/reduceFetchState");
 const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
 const accountSelector_1 = require("../../../entity/account/accountSelector");
+const jeScheduleHelper_1 = require("../../../entity/jeSchedules/jeScheduleHelper");
 const jeSchedulesSelector_1 = require("../../../entity/jeSchedules/jeSchedulesSelector");
+const jeSchedulesTypes_1 = require("../../../entity/jeSchedules/jeSchedulesTypes");
 const tenantSelector_1 = require("../../../entity/tenant/tenantSelector");
 const accountListSelector_1 = require("../../accountList/accountListSelector");
 const classListSelector_1 = require("../../classList/classListSelector");
 const scheduleDetailLocalDataHelper_1 = require("../../scheduleView/scheduleDetailView/scheduleDetailLocalDataHelper");
 const scheduleDetailSelector_1 = require("../../scheduleView/scheduleDetailView/scheduleDetailSelector");
 const scheduleListHelper_1 = require("../../scheduleView/scheduleListView/scheduleListHelper");
+const jeSchedulesViewState_1 = require("../types/jeSchedulesViewState");
 const getAllStepsHelper_1 = require("./getAllStepsHelper");
 const jeAccountSettingsViewSelector_1 = require("./jeAccountSettingsViewSelector");
+const jeNewScheduleViewSelector_1 = require("./jeNewScheduleViewSelector");
+// Matches the AI-automation user addresses webc's schedule list row already
+// checks (JEScheduleReadOnlyListRow/JEScheduleDraftListRow "Method" column,
+// strings.ts aiBotEmail/botEmail) to determine whether a schedule was
+// created by the AI accountant vs. a human.
+const AI_BOT_EMAIL = 'ai@zeni.ai';
+const BOT_EMAIL = 'bot@zeni.ai';
+// A one-time accrual has no jeScheduleType of its own — it is not a JE schedule. It is still an
+// accrued expense, so it counts and filters under that type on the page's type tabs.
+const ONE_TIME_ACCRUAL_SCHEDULE_TYPE = 'accrued_expenses';
+// Which of the two list buckets an accrual belongs in. `draft` still needs a human to post it;
+// everything else is already on the books or in a transient claim.
+const ONE_TIME_ACCRUAL_REVIEW_STATUSES = [
+    'draft',
+];
+/**
+ * `posting_blocked` is written by the posting Cron when a JE fails to post. It is an internal
+ * failure state with no human action attached, so it is dropped here rather than hidden at render
+ * time — filtering in the view would leave the group counts and KPI totals counting rows nobody
+ * can see. The expense-automation endpoint applies no status filter on the close-period path, so
+ * these rows do arrive.
+ */
+function isRenderableOneTimeAccrual(accrual) {
+    return accrual.accrualStatus !== 'posting_blocked';
+}
+function getJEScheduleRowType(schedule) {
+    return isOneTimeAccrualRow(schedule)
+        ? ONE_TIME_ACCRUAL_SCHEDULE_TYPE
+        : schedule.jeScheduleType;
+}
+function isPendingReviewRow(schedule) {
+    return isOneTimeAccrualRow(schedule)
+        ? ONE_TIME_ACCRUAL_REVIEW_STATUSES.includes(schedule.accrualStatus)
+        : schedule.status.code === 'draft';
+}
+// Belongs on the Existing Schedules tab. For an accrual the endpoint has already filtered to
+// posted, so this only has to agree with that rather than re-derive it.
+function isExistingTabRow(schedule) {
+    return isOneTimeAccrualRow(schedule)
+        ? schedule.accrualStatus === 'posted'
+        : schedule.status.code === 'ongoing';
+}
+// Exported (rather than kept as a closure inside the selector) so it can be
+// unit-tested directly — confidenceScore is a separate, more narrowly
+// populated field that can be null on a schedule the bot user created,
+// which previously caused these schedules to display as "AI Accountant" in
+// the list but count under "Manual" in the KPI summary.
+const isAiAccountantSchedule = (schedule) => {
+    // A one-time accrual records who made it as `origin`, which is authoritative — no email
+    // sniffing needed, and the JE bot is often absent from the user entity entirely.
+    if (isOneTimeAccrualRow(schedule)) {
+        return schedule.origin === 'agent';
+    }
+    return (schedule.createdByUser?.email === AI_BOT_EMAIL ||
+        schedule.createdByUser?.email === BOT_EMAIL);
+};
+exports.isAiAccountantSchedule = isAiAccountantSchedule;
+// Accrued schedules are structurally distinct — no baseTransaction, carrying recurringAmount and
+// memo in its place — so anything reading baseTransaction has to branch on this first.
+//
+// Discriminates on jeAccruedScheduleKey, which only JEAccruedSchedule carries. jeScheduleType
+// cannot be used: it is a data field present on BOTH row shapes, so an accrued-typed row that
+// arrived through the prepaid/fixed DTO (failed_je_postings, legacy fetches) would be
+// misclassified and then crash on recurringAmount / jeAccruedScheduleKey.
+function isAccruedScheduleRow(schedule) {
+    return 'jeAccruedScheduleKey' in schedule;
+}
+// Same structural approach as isAccruedScheduleRow, and for the same reason: jeOneTimeAccrualKey
+// exists only on this shape. Note the two guards are NOT interchangeable — a one-time accrual is
+// not an accrued *schedule*, and routing it into the accrued branch would read recurringAmount,
+// render postedCount/lifecycleTotal as a lifecycle and startDate–endDate as a period, none of
+// which it has.
+function isOneTimeAccrualRow(schedule) {
+    return 'jeOneTimeAccrualKey' in schedule;
+}
+function getScheduleAmount(schedule) {
+    if (isOneTimeAccrualRow(schedule)) {
+        return schedule.estimatedAmount.amount;
+    }
+    if (isAccruedScheduleRow(schedule)) {
+        return schedule.recurringAmount.amount;
+    }
+    return schedule.baseTransaction.amount.amount;
+}
+// A one-time accrual shares almost no sortable field with a schedule, so it gets its own accessor
+// rather than a guard on each of the dozen cases below. Keys with no meaning for a single-month
+// accrual -- amortizationPeriod, remainingMonths, runningBalance, jePostingDate, scheduleCategory --
+// deliberately fall through to undefined, which sorts them together at one end.
+function getOneTimeAccrualSortValue(accrual, sortKey) {
+    switch (sortKey) {
+        case 'vendor':
+            return accrual.vendorName.toLowerCase();
+        case 'category':
+            return accrual.jeDebitAccountName?.toLowerCase();
+        case 'class':
+            return accrual.jeDebitAccountingClassName?.toLowerCase();
+        case 'depCategory':
+            return accrual.jeCreditAccountName?.toLowerCase();
+        case 'type':
+            return ONE_TIME_ACCRUAL_SCHEDULE_TYPE;
+        case 'totalAmount':
+            return accrual.estimatedAmount.amount;
+        case 'transactionDate':
+            return accrual.postingDate?.valueOf();
+        case 'memo':
+            return accrual.memo.toLowerCase();
+        case 'startMonth':
+            return accrual.serviceMonth;
+        default:
+            return undefined;
+    }
+}
 function getJEScheduleSortAccessor(sortKey) {
+    const scheduleAccessor = getScheduleRowSortAccessor(sortKey);
+    return (schedule) => isOneTimeAccrualRow(schedule)
+        ? getOneTimeAccrualSortValue(schedule, sortKey)
+        : scheduleAccessor(schedule);
+}
+function getScheduleRowSortAccessor(sortKey) {
     switch (sortKey) {
         case 'vendor':
             return (s) => s.vendor.name?.toLowerCase();
@@ -29,7 +158,9 @@ function getJEScheduleSortAccessor(sortKey) {
         case 'depCategory':
             return (s) => s.jeCredit.account?.accountName?.toLowerCase();
         case 'scheduleCategory':
-            return (s) => s.baseTransaction.account?.accountName?.toLowerCase();
+            return (s) => isAccruedScheduleRow(s)
+                ? undefined
+                : s.baseTransaction.account?.accountName?.toLowerCase();
         case 'startMonth':
             return (s) => s.startDate?.valueOf();
         case 'type':
@@ -57,11 +188,13 @@ function getJEScheduleSortAccessor(sortKey) {
                 return s.balanceAsOfToday?.amount ?? null;
             };
         case 'totalAmount':
-            return (s) => s.baseTransaction.amount.amount;
+            return (s) => getScheduleAmount(s);
         case 'transactionDate':
-            return (s) => s.baseTransaction.date.valueOf();
+            return (s) => s.createTime?.valueOf();
         case 'memo':
-            return (s) => s.baseTransaction.memo?.toLowerCase();
+            return (s) => isAccruedScheduleRow(s)
+                ? s.memo.toLowerCase()
+                : s.baseTransaction.memo?.toLowerCase();
         default:
             return (s) => s.startDate?.valueOf();
     }
@@ -73,9 +206,15 @@ function sortJEScheduledTransactions(transactions, sortKey, sortOrder) {
 function getExpenseAutomationJESchedulesView(state) {
     const jeScheduledTransaction = [];
     const failedJeScheduledTransaction = [];
+    const accruedSchedules = [];
+    const oneTimeAccruals = [];
     const { accountState, accountListState, classState, classListState, expenseAutomationJESchedulesViewState, expenseAutomationViewState, monthEndCloseChecksState, monthEndCloseChecksViewState, } = state;
-    const { jeScheduleTransactionKeysByPeriod, failedJeScheduleTransactionKeysByPeriod, jeScheduleLocalDataById, postStatusById, ignoreStatusById, uiState, error, fetchState, refreshStatus, } = expenseAutomationJESchedulesViewState;
+    const { jeScheduleTransactionKeysByPeriodAndTab, jeScheduleAccruedKeysByPeriodAndTab, jeScheduleOneTimeAccrualKeysByPeriodAndTab, failedJeScheduleTransactionKeysByPeriodAndTab, jeScheduleLocalDataById, postStatusById, ignoreStatusById, revertStatusById, oneTimeAccrualActionStatusById, uiState, error, fetchState, refreshStatus, newSchedule, } = expenseAutomationJESchedulesViewState;
     const accountSettingsView = (0, jeAccountSettingsViewSelector_1.getJEAccountSettingsView)(state);
+    const newScheduleView = newSchedule.selectedDetailScheduleType === 'fixed_assets' ||
+        newSchedule.selectedDetailScheduleType === 'prepaid_expenses'
+        ? (0, jeNewScheduleViewSelector_1.getNewScheduleView)(state, newSchedule.selectedDetailScheduleType)
+        : undefined;
     const currentTenant = (0, tenantSelector_1.getCurrentTenant)(state);
     const { selectedPeriodByTenantId } = expenseAutomationViewState;
     const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
@@ -103,27 +242,48 @@ function getExpenseAutomationJESchedulesView(state) {
     const filteredDepAccountListNestedAccountHierarchy = (0, scheduleDetailSelector_1.filterNestedAccountHierarchyById)(depAccountListNestedAccountHierarchy, filteredDepAccounts.map((account) => account.accountId));
     const classListNestedAccountHierarchy = (0, classListSelector_1.getNestedClassListHierarchy)(classListState);
     const monthYearPeriodId = selectedPeriod != null ? (0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod) : null;
-    const jeScheduleTransactionKeysForSelectedPeriod = monthYearPeriodId != null
-        ? jeScheduleTransactionKeysByPeriod[monthYearPeriodId]
-        : null;
-    const failedJeScheduleTransactionKeysForSelectedPeriod = monthYearPeriodId != null
-        ? failedJeScheduleTransactionKeysByPeriod[monthYearPeriodId]
+    const selectedPeriodTabKey = monthYearPeriodId != null
+        ? (0, jeSchedulesViewState_1.getJESchedulePeriodTabKey)(uiState.selectedPageTab, monthYearPeriodId)
         : null;
-    const jeScheduleTransactionKeys = jeScheduleTransactionKeysForSelectedPeriod ?? [];
-    const failedJeScheduleTransactionKeys = failedJeScheduleTransactionKeysForSelectedPeriod ?? [];
+    const jeScheduleTransactionKeysForSelectedTab = selectedPeriodTabKey != null
+        ? jeScheduleTransactionKeysByPeriodAndTab[selectedPeriodTabKey]
+        : undefined;
+    const failedJeScheduleTransactionKeysForSelectedTab = selectedPeriodTabKey != null
+        ? failedJeScheduleTransactionKeysByPeriodAndTab[selectedPeriodTabKey]
+        : undefined;
+    // Distinguishes "this tab has never been fetched for this period" from "fetched and genuinely
+    // empty". Without it the page cannot tell a first visit from a real empty state, and renders an
+    // empty table where it should render a skeleton.
+    const hasLoadedForSelectedTab = jeScheduleTransactionKeysForSelectedTab != null;
+    const jeScheduleTransactionKeys = jeScheduleTransactionKeysForSelectedTab ?? [];
+    const failedJeScheduleTransactionKeys = failedJeScheduleTransactionKeysForSelectedTab ?? [];
+    const jeScheduleAccruedKeys = (selectedPeriodTabKey != null
+        ? jeScheduleAccruedKeysByPeriodAndTab[selectedPeriodTabKey]
+        : undefined) ?? [];
+    const jeScheduleOneTimeAccrualKeys = (selectedPeriodTabKey != null
+        ? jeScheduleOneTimeAccrualKeysByPeriodAndTab[selectedPeriodTabKey]
+        : undefined) ?? [];
+    jeScheduleOneTimeAccrualKeys.forEach((jeOneTimeAccrualKey) => {
+        const accrual = (0, jeSchedulesSelector_1.getJEOneTimeAccrualByKey)(jeOneTimeAccrualKey, state.jeSchedulesState);
+        if (accrual != null && isRenderableOneTimeAccrual(accrual)) {
+            oneTimeAccruals.push(accrual);
+        }
+    });
     jeScheduleTransactionKeys.forEach((jeScheduleKey) => {
         const jeScheduleDetails = (0, jeSchedulesSelector_1.getJEScheduledTransactionByJEScheduleTransactionKey)(jeScheduleKey, state);
         jeScheduledTransaction.push(jeScheduleDetails);
     });
+    jeScheduleAccruedKeys.forEach((jeAccruedScheduleKey) => {
+        const accruedScheduleDetails = (0, jeSchedulesSelector_1.getJEAccruedScheduleByJEScheduleKey)(jeAccruedScheduleKey, state);
+        if (accruedScheduleDetails != null) {
+            accruedSchedules.push(accruedScheduleDetails);
+        }
+    });
     failedJeScheduleTransactionKeys.forEach((jeScheduleKey) => {
         const jeScheduleDetails = (0, jeSchedulesSelector_1.getJEScheduledTransactionByJEScheduleTransactionKey)(jeScheduleKey, state);
         failedJeScheduledTransaction.push(jeScheduleDetails);
     });
-    const { sortKey, sortOrder } = uiState;
-    const draftSchedules = sortJEScheduledTransactions(jeScheduledTransaction.filter((schedule) => schedule.status.code === 'draft'), sortKey, sortOrder);
-    const ongoingSchedules = sortJEScheduledTransactions(jeScheduledTransaction.filter((schedule) => schedule.status.code === 'ongoing'), sortKey, sortOrder);
-    const completedSchedules = sortJEScheduledTransactions(jeScheduledTransaction.filter((schedule) => schedule.status.code === 'completed' ||
-        schedule.status.code === 'marked_as_completed'), sortKey, sortOrder);
+    const { sortKey, sortOrder, selectedJETypeFilter } = uiState;
     const unsortedResolveSchedules = [];
     failedJeScheduledTransaction.forEach((schedule) => {
         schedule.scheduledJournalEntry.forEach((journalEntry) => {
@@ -135,10 +295,90 @@ function getExpenseAutomationJESchedulesView(state) {
     });
     const resolveSchedules = sortJEScheduledTransactions(unsortedResolveSchedules, sortKey, sortOrder);
     const validResolveForPending = unsortedResolveSchedules.filter((r) => jeScheduleLocalDataById[r.scheduledJournalEntry.scheduledJournalEntryID] != null);
+    const matchesTypeFilter = (schedule) => selectedJETypeFilter == null ||
+        getJEScheduleRowType(schedule) === selectedJETypeFilter;
+    const isCreatedStatus = (schedule) => {
+        // An accrual is "created" once it is not review work: posted, reversing, reversed, or in a
+        // transient posting claim.
+        if (isOneTimeAccrualRow(schedule)) {
+            return !isPendingReviewRow(schedule);
+        }
+        return (schedule.status.code === 'ongoing' ||
+            schedule.status.code === 'completed' ||
+            schedule.status.code === 'marked_as_completed');
+    };
+    const allScheduleRows = [
+        ...jeScheduledTransaction,
+        ...accruedSchedules,
+        ...oneTimeAccruals,
+    ];
     const pendingReviewSchedules = sortJEScheduledTransactions([
-        ...jeScheduledTransaction.filter((schedule) => schedule.status.code === 'draft'),
+        ...allScheduleRows.filter((schedule) => isPendingReviewRow(schedule) && matchesTypeFilter(schedule)),
         ...validResolveForPending,
     ], sortKey, sortOrder);
+    const createdSchedules = sortJEScheduledTransactions(allScheduleRows.filter((schedule) => isCreatedStatus(schedule) && matchesTypeFilter(schedule)), sortKey, sortOrder);
+    // KPI summary — derived from unfiltered schedules so counts are always accurate
+    const allSchedules = allScheduleRows;
+    const sumAmount = (schedules) => schedules.reduce((total, schedule) => total + (getScheduleAmount(schedule) ?? 0), 0);
+    const pendingReviewTotal = sumAmount(pendingReviewSchedules);
+    const createdTotal = sumAmount(createdSchedules);
+    const aiAccountantSchedules = allSchedules.filter(exports.isAiAccountantSchedule);
+    const manualSchedules = allSchedules.filter((schedule) => !(0, exports.isAiAccountantSchedule)(schedule));
+    const pendingUnfiltered = allSchedules.filter((schedule) => isPendingReviewRow(schedule));
+    const kpiSummary = {
+        aiAccountant: {
+            count: aiAccountantSchedules.length,
+            amount: sumAmount(aiAccountantSchedules),
+        },
+        manual: {
+            count: manualSchedules.length,
+            amount: sumAmount(manualSchedules),
+        },
+        needsReview: {
+            count: pendingUnfiltered.length,
+            amount: sumAmount(pendingUnfiltered),
+        },
+        total: {
+            count: allSchedules.length,
+            amount: sumAmount(allSchedules),
+        },
+    };
+    // Each tab's badge counts from that tab's own bucket. A tab that has not been fetched yet
+    // reports undefined rather than 0, so the UI can hide the badge instead of asserting "none".
+    const scheduleCountsByTab = {};
+    jeSchedulesViewState_1.ALL_JE_PAGE_TABS.forEach((pageTab) => {
+        if (pageTab === 'actual_matching') {
+            return;
+        }
+        const periodTabKey = monthYearPeriodId != null
+            ? (0, jeSchedulesViewState_1.getJESchedulePeriodTabKey)(pageTab, monthYearPeriodId)
+            : null;
+        const transactionKeys = periodTabKey != null
+            ? jeScheduleTransactionKeysByPeriodAndTab[periodTabKey]
+            : undefined;
+        if (transactionKeys == null) {
+            return;
+        }
+        const accruedKeys = (periodTabKey != null
+            ? jeScheduleAccruedKeysByPeriodAndTab[periodTabKey]
+            : undefined) ?? [];
+        const oneTimeAccrualKeys = (periodTabKey != null
+            ? jeScheduleOneTimeAccrualKeysByPeriodAndTab[periodTabKey]
+            : undefined) ?? [];
+        const rowsForTab = [
+            ...transactionKeys.map((transactionKey) => (0, jeSchedulesSelector_1.getJEScheduledTransactionByJEScheduleTransactionKey)(transactionKey, state)),
+            ...accruedKeys
+                .map((accruedKey) => (0, jeSchedulesSelector_1.getJEAccruedScheduleByJEScheduleKey)(accruedKey, state))
+                .filter((accruedRow) => accruedRow != null),
+            ...oneTimeAccrualKeys
+                .map((accrualKey) => (0, jeSchedulesSelector_1.getJEOneTimeAccrualByKey)(accrualKey, state.jeSchedulesState))
+                .filter((accrualRow) => accrualRow != null && isRenderableOneTimeAccrual(accrualRow)),
+        ];
+        scheduleCountsByTab[pageTab] =
+            pageTab === 'existing_schedules'
+                ? rowsForTab.filter((row) => isExistingTabRow(row)).length
+                : rowsForTab.filter((row) => isPendingReviewRow(row) || isCreatedStatus(row)).length;
+    });
     const allSteps = monthYearPeriodId != null
         ? (0, getAllStepsHelper_1.getAllSteps)(monthEndCloseChecksState, monthYearPeriodId, currentTenant.tenantId)
         : [];
@@ -151,6 +391,20 @@ function getExpenseAutomationJESchedulesView(state) {
         { fetchState, error },
         monthEndFetchState,
     ]);
+    const countByType = (schedules) => {
+        const counts = jeSchedulesTypes_1.ALL_SCHEDULES_TYPES.reduce((acc, type) => ({ ...acc, [type]: 0 }), {});
+        schedules.forEach((schedule) => {
+            const scheduleType = getJEScheduleRowType(schedule);
+            if (scheduleType != null) {
+                counts[scheduleType] += 1;
+            }
+        });
+        return counts;
+    };
+    const jeScheduleTypeCounts = {
+        active: countByType(allSchedules.filter((schedule) => isPendingReviewRow(schedule) || isCreatedStatus(schedule))),
+        ongoing: countByType(allSchedules.filter((schedule) => isExistingTabRow(schedule))),
+    };
     return {
         uncategorizedAccounts,
         allDepreciationAccountList: filteredDepAccounts,
@@ -159,14 +413,21 @@ function getExpenseAutomationJESchedulesView(state) {
         allAccountList: filteredAccounts,
         accountListNestedAccountHierarchy,
         allClassList: allClasses,
-        completedSchedules,
-        draftSchedules,
-        ongoingSchedules,
+        createdSchedules,
+        createdTotal,
+        hasLoadedForSelectedTab,
+        jeScheduleTypeCounts,
+        scheduleCountsByTab,
+        kpiSummary,
         pendingReviewSchedules,
+        pendingReviewTotal,
         resolveSchedules: resolveSchedules,
         accountSettingsView,
+        newScheduleView,
         postStatusById: postStatusById,
         ignoreStatusById: ignoreStatusById,
+        revertStatusById: revertStatusById,
+        oneTimeAccrualActionStatusById: oneTimeAccrualActionStatusById,
         fetchState: reducedFetchStatus.fetchState,
         jeScheduleLocalDataById: jeScheduleLocalDataById,
         uiState: uiState,
@@ -175,3 +436,26 @@ function getExpenseAutomationJESchedulesView(state) {
         completionStatus,
     };
 }
+/**
+ * One accrual plus the status of its promote / ignore request, for the detail screen.
+ *
+ * `accrual` is undefined on a cold load — a refresh or a shared link, where the list has never run
+ * — so the screen dispatches `fetchOneTimeAccrual` and waits on `detailFetchState`. The two states
+ * are separate on purpose: `actionFetchState` drives the row spinner and the post-revert navigation,
+ * and a page load must not look like an action that just finished.
+ */
+function getExpenseAutomationJEOneTimeAccrualDetailView(state, accrualId) {
+    return {
+        accrual: (0, jeSchedulesSelector_1.getJEOneTimeAccrualByKey)((0, jeScheduleHelper_1.generateJEOneTimeAccrualKey)(accrualId), state.jeSchedulesState),
+        actionFetchState: state.expenseAutomationJESchedulesViewState
+            .oneTimeAccrualActionStatusById[accrualId] ?? {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+        detailFetchState: state.expenseAutomationJESchedulesViewState
+            .oneTimeAccrualFetchStatusById[accrualId] ?? {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+    };
+}

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

@@ -0,0 +1,76 @@
+import { FetchStateAndError, FetchedState, ID } from '../../../commonStateTypes/common';
+import { SortOrder } from '../../../commonStateTypes/selectorTypes/sortOrderTypes';
+import { MonthYearPeriodId } from '../../../commonStateTypes/timePeriod';
+import { JEOneTimeAccrualKey } from '../../../entity/jeSchedules/jeSchedulesTypes';
+export declare const toActualMatchingSortKey: (v: string) => "type" | "date" | "vendor" | "category" | "class" | "amount" | "lifecycle";
+export type ActualMatchingSortKey = ReturnType<typeof toActualMatchingSortKey>;
+export declare const MATCH_TRANSACTION_SEARCH_PAGE_SIZE = 10;
+export declare const MATCH_ACCRUAL_SEARCH_LIMIT = 50;
+export declare const MATCH_SEARCH_DEBOUNCE_MS = 300;
+export declare const toMatchAndReverseResultStatus: (v: string) => "error" | "reversed" | "noop" | "conflict" | "claim_lost";
+export type MatchAndReverseResultStatus = ReturnType<typeof toMatchAndReverseResultStatus>;
+export interface ActualMatchingViewUIState {
+    scrollPosition: {
+        scrollTop: number;
+        scrollLeft?: number;
+    } | undefined;
+    searchString: string;
+    sortKey: ActualMatchingSortKey;
+    sortOrder: SortOrder;
+}
+/**
+ * Sibling of Missing Receipts `MatchCandidate`. Confirm needs `lineId` and
+ * `transactionIntegrationId` on every row — those fields are required here.
+ */
+export interface ActualMatchingTransactionSearchResult {
+    amount: number;
+    currencyCode: string;
+    currencySymbol: string;
+    lineId: string;
+    transactionDate: string;
+    transactionId: ID;
+    transactionIntegrationId: string;
+    transactionType: string;
+    vendorName: string;
+    accountId?: ID;
+    accountName?: string;
+    transactionMemo?: string;
+    vendorId?: ID;
+}
+export interface MatchAndReverseResult {
+    accrualId: ID;
+    status: MatchAndReverseResultStatus;
+    reason?: string;
+}
+export interface MatchAndReverseAccrualsParams {
+    accrualIds: ID[];
+    lineId: string;
+    transactionId: ID;
+    transactionIntegrationId: string;
+    transactionType: string;
+}
+export interface ActualMatchingTransactionSearchState extends FetchStateAndError {
+    isLoadingMore: boolean;
+    nextPageToken: string | null;
+    query: string;
+    results: ActualMatchingTransactionSearchResult[];
+}
+export interface ActualMatchingAccrualSearchState extends FetchStateAndError {
+    isLoadingMore: boolean;
+    nextPageToken: string | null;
+    query: string;
+    results: JEOneTimeAccrualKey[];
+}
+export interface ActualMatchingMatchModalState {
+    accrualSearch: ActualMatchingAccrualSearchState;
+    confirmStatus: FetchStateAndError;
+    isOpen: boolean;
+    transactionSearch: ActualMatchingTransactionSearchState;
+    lastBatchResults?: MatchAndReverseResult[];
+}
+export interface ActualMatchingViewState extends FetchedState {
+    accrualKeysByPeriod: Record<MonthYearPeriodId, JEOneTimeAccrualKey[]>;
+    matchModal: ActualMatchingMatchModalState;
+    refreshStatus: FetchStateAndError;
+    uiState: ActualMatchingViewUIState;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMatchAndReverseResultStatus = exports.MATCH_SEARCH_DEBOUNCE_MS = exports.MATCH_ACCRUAL_SEARCH_LIMIT = exports.MATCH_TRANSACTION_SEARCH_PAGE_SIZE = exports.toActualMatchingSortKey = void 0;
+const stringToUnion_1 = require("../../../commonStateTypes/stringToUnion");
+const ACTUAL_MATCHING_SORT_KEYS = [
+    'vendor',
+    'date',
+    'amount',
+    'category',
+    'class',
+    'type',
+    'lifecycle',
+];
+const toActualMatchingSortKey = (v) => (0, stringToUnion_1.stringToUnion)(v, ACTUAL_MATCHING_SORT_KEYS);
+exports.toActualMatchingSortKey = toActualMatchingSortKey;
+exports.MATCH_TRANSACTION_SEARCH_PAGE_SIZE = 10;
+exports.MATCH_ACCRUAL_SEARCH_LIMIT = 50;
+exports.MATCH_SEARCH_DEBOUNCE_MS = 300;
+const MATCH_AND_REVERSE_RESULT_STATUSES = [
+    'reversed',
+    'noop',
+    'conflict',
+    'claim_lost',
+    'error',
+];
+const toMatchAndReverseResultStatus = (v) => (0, stringToUnion_1.stringToUnion)(v, MATCH_AND_REVERSE_RESULT_STATUSES);
+exports.toMatchAndReverseResultStatus = toMatchAndReverseResultStatus;

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

@@ -1,4 +1,4 @@
-export declare const toCompletedSubTab: (v: string) => "all" | "ai_accountant" | "manual";
+export declare const toCompletedSubTab: (v: string) => "manual" | "all" | "ai_accountant";
 export type CompletedSubTab = ReturnType<typeof toCompletedSubTab>;
 /**
  * "No sub-tab filter" sentinel — single source of truth for the default

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

@@ -1,22 +1,31 @@
 import { NestedAccountHierarchyForReport } from '../../../commonStateTypes/accountView/nestedAccountID';
+import { Amount } from '../../../commonStateTypes/amount';
 import { FetchStateAndError, FetchedState, ID } from '../../../commonStateTypes/common';
 import { Recommendation } from '../../../commonStateTypes/recommendationBase';
 import { SortOrder } from '../../../commonStateTypes/selectorTypes/sortOrderTypes';
-import { MonthYearPeriodId } from '../../../commonStateTypes/timePeriod';
+import { MonthYearPeriodId, ScheduleDaysOfMonth } from '../../../commonStateTypes/timePeriod';
 import { AccountBase } from '../../../entity/account/accountState';
-import { JEScheduleTransactionKey, ScheduleTypes } from '../../../entity/jeSchedules/jeSchedulesTypes';
+import { JEOneTimeAccrualKey, JEScheduleKey, JEScheduleTransactionKey, ScheduleJournalEntryStatusCodeType, ScheduleTransactionID, ScheduleTypes } from '../../../entity/jeSchedules/jeSchedulesTypes';
 import { VendorBase } from '../../../entity/vendor/vendorState';
-export declare const toJEScheduleSortKey: (v: string) => "type" | "vendor" | "category" | "class" | "memo" | "depCategory" | "scheduleCategory" | "startMonth" | "amortizationPeriod" | "jePostingDate" | "remainingMonths" | "runningBalance" | "totalAmount" | "transactionDate";
+import { ZeniDate } from '../../../zeniDayJS';
+import { JETransactionLink } from '../../scheduleView/scheduleDetailView/scheduleDetailState';
+export declare const toJEScheduleSortKey: (v: string) => "type" | "vendor" | "category" | "class" | "memo" | "jePostingDate" | "runningBalance" | "depCategory" | "scheduleCategory" | "startMonth" | "amortizationPeriod" | "remainingMonths" | "totalAmount" | "transactionDate";
 export type JEScheduleSortKey = ReturnType<typeof toJEScheduleSortKey>;
-export declare const toJEScheduleMainTab: (v: string) => "pending_review" | "completed" | "ongoing";
-export type JEScheduleMainTab = ReturnType<typeof toJEScheduleMainTab>;
+export declare const toJEPageTab: (v: string) => "schedules" | "actual_matching" | "existing_schedules";
+export type JEPageTab = ReturnType<typeof toJEPageTab>;
+export declare const ALL_JE_PAGE_TABS: readonly JEPageTab[];
+export type JESchedulePeriodTabKey = `${JEPageTab}_${MonthYearPeriodId}`;
+export declare const getJESchedulePeriodTabKey: (selectedPageTab: JEPageTab, monthYearPeriodId: MonthYearPeriodId) => JESchedulePeriodTabKey;
 export interface JESchedulesViewUIState {
+    createdGroupCollapsed: boolean;
+    pendingGroupCollapsed: boolean;
     scrollPosition: {
         scrollTop: number;
         scrollLeft?: number;
     } | undefined;
     searchString: string;
-    selectedMainTab: JEScheduleMainTab;
+    selectedJETypeFilter: ScheduleTypes | null;
+    selectedPageTab: JEPageTab;
     sortKey: JEScheduleSortKey;
     sortOrder: SortOrder;
     totalCount: number;
@@ -33,14 +42,79 @@ export interface JEScheduleLocalData {
 }
 export interface JESchedulesViewState extends FetchedState {
     accountSettings: AccountSettingsState;
-    failedJeScheduleTransactionKeysByPeriod: Record<MonthYearPeriodId, JEScheduleTransactionKey[]>;
+    failedJeScheduleTransactionKeysByPeriodAndTab: Record<JESchedulePeriodTabKey, JEScheduleTransactionKey[]>;
     ignoreStatusById: Record<JEScheduleTransactionKey, FetchStateAndError>;
+    jeScheduleAccruedKeysByPeriodAndTab: Record<JESchedulePeriodTabKey, JEScheduleKey[]>;
     jeScheduleLocalDataById: Record<ID, JEScheduleLocalData>;
-    jeScheduleTransactionKeysByPeriod: Record<MonthYearPeriodId, JEScheduleTransactionKey[]>;
+    jeScheduleOneTimeAccrualKeysByPeriodAndTab: Record<JESchedulePeriodTabKey, JEOneTimeAccrualKey[]>;
+    jeScheduleTransactionKeysByPeriodAndTab: Record<JESchedulePeriodTabKey, JEScheduleTransactionKey[]>;
+    newSchedule: NewJeScheduleState;
+    oneTimeAccrualActionStatusById: Record<ID, FetchStateAndError>;
+    oneTimeAccrualFetchStatusById: Record<ID, FetchStateAndError>;
     postStatusById: Record<ID, FetchStateAndError>;
     refreshStatus: FetchStateAndError;
+    revertStatusById: Record<JEScheduleKey | JEScheduleTransactionKey, FetchStateAndError>;
     uiState: JESchedulesViewUIState;
 }
+export interface NewJeDetailLocalData {
+    amount: Amount;
+    jeLink: JETransactionLink;
+    memo: string;
+    postingDate: ZeniDate;
+    postingStatus: ScheduleJournalEntryStatusCodeType;
+    runningBalance: Amount;
+}
+export interface NewScheduleLocalData {
+    jeScheduleDetails: NewJeDetailLocalData[];
+    scheduleType: ScheduleTypes;
+    lastDayOfMonth?: boolean;
+    selectedAccount?: ID;
+    selectedBaseTransactionId?: ScheduleTransactionID;
+    selectedClass?: ID;
+    selectedDate?: ZeniDate;
+    selectedDayOfMonth?: ScheduleDaysOfMonth;
+    selectedJEScheduleKey?: JEScheduleTransactionKey;
+    selectedMonths?: number;
+    selectedVendor?: VendorBase;
+}
+export interface NewScheduleLocalDataFixedAssets extends NewScheduleLocalData {
+    assetId?: string;
+    selectedAccumulatedDepreciationCategory?: ID;
+}
+/**
+ * The form values for creating a one-time accrual. Not stored in the slice — a one-time accrual is
+ * created in a single POST with no draft/resume step, so this is passed straight through the action
+ * to the payload builder.
+ */
+export interface NewOneTimeAccrualLocalData {
+    amount: number;
+    creditAccountId: ID;
+    debitAccountId: ID;
+    memo: string;
+    reverseNextMonth: boolean;
+    serviceMonth: ZeniDate;
+    vendorId: ID;
+    vendorName: string;
+    creditAccountName?: string;
+    debitAccountName?: string;
+    debitClassId?: ID;
+    debitClassName?: string;
+}
+export interface SearchTransactionsState extends FetchStateAndError {
+    searchResults: JEScheduleTransactionKey[];
+    searchString?: string;
+}
+export declare const MIN_NEW_SCHEDULE_SEARCH_LENGTH = 2;
+export interface NewJeScheduleState extends FetchStateAndError {
+    createOneTimeAccrualStatus: FetchStateAndError;
+    newScheduleState: {
+        fixed_assets: NewScheduleLocalDataFixedAssets;
+        prepaid_expenses: NewScheduleLocalData;
+    };
+    saveStatus: FetchStateAndError;
+    searchTransactions: SearchTransactionsState;
+    selectedDetailScheduleType?: ScheduleTypes;
+}
 export interface AccountSettingsLocalData {
     previousAccruedExpensesAccount: AccountBase[];
     previousFixedAssetsAccount: AccountBase[];
@@ -57,6 +131,7 @@ export interface AccountSettingsState {
     fixedAssetsAccountIdList: ID[];
     fixedAssetsNestedAccountListHierarchy: NestedAccountHierarchyForReport[];
     fixedAssetsRecommendations: Recommendation[];
+    hasLoadedAccountSettings: boolean;
     localData: AccountSettingsLocalData;
     prepaidExpensesAccountIdList: ID[];
     prepaidExpensesNestedAccountListHierarchy: NestedAccountHierarchyForReport[];