@zeniai/client-epic-state 4.20.0 → 4.20.1-beta11ND

package/lib/commonStateTypes/coaBalance/additionalBalances/getSummationBalance.d.ts

@@ -13,6 +13,6 @@ export declare function getSummationBalance(summationType: 'year_to_date_total'
     allClosingMonthlyBalanceOrderedAsc: COABalance[];
     allOpeningMonthlyBalanceOrderedAsc: COABalance[];
 } | undefined): COABalance | undefined;
-export declare function getSummationFreeRangeTotalBalance(resultSlice: COABalance[]): COABalance | undefined;
+export declare function getSummationFreeRangeTotalBalance(resultSlice: readonly COABalance[]): COABalance | undefined;
 export declare function getFreeRangeCashAndEquivalentsOpeningBalance(resultSlice: COABalance[], resultBalancesOrder: COABalancesOrder): COABalance | undefined;
 export declare function getFreeRangeCashAndEquivalentsClosingBalance(resultSlice: COABalance[], resultBalancesOrder: COABalancesOrder): COABalance | undefined;

package/lib/esm/index.js

@@ -217,6 +217,7 @@ import { changeZeniPersonRoles, deletePerson, fetchAllPeopleRequiredViews, fetch
 import { getPeople, getPeopleLocalData } from './view/people/peopleSelector';
 import { fetchProfitAndLoss, fetchProfitAndLossForTimeframe, resetProfitAndLossNodeCollapseState, updateProfitAndLossUIState, } from './view/profitAndLoss/profitAndLossReducer';
 import { getPandLReportFetchState, getProfitAndLossReport, } from './view/profitAndLoss/profitAndLossSelector';
+import { getEmptyHorizontalSectionBalancesSlice } from './view/profitAndLossClassesView/horizontalSectionEmptyBalancesSlice';
 import { getProfitAndLossClassesHorizontalView } from './view/profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelector';
 import { HORIZONTAL_CLASS_TOTAL_BALANCE_ID, isHorizontalAccountReportData, } from './view/profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelectorTypes';
 import { fetchProfitAndLossClassesView, resetProfitAndLossClassesNodeCollapseState, updateClassViewLayout, updateAccountViewMode as updateProfitAndLossAccountViewMode, updateClassesToFilterOut as updateProfitAndLossClassesToFilterOut, updateProfitAndLossClassesViewUIState, } from './view/profitAndLossClassesView/profitAndLossClassesViewReducer';
@@ -453,7 +454,7 @@ export { fetchDashboard, getDashboard, updateTreasuryVideoClosed, };
 export { updateDashboardLayout };
 export { getPandLWithForecast, } from './view/profitAndLoss/pAndLWithForecast/pAndLWithForecastSelector';
 export { fetchProfitAndLoss, resetProfitAndLossNodeCollapseState, updateProfitAndLossUIState, getProfitAndLossReport, getPandLReportFetchState, fetchProfitAndLossForTimeframe, };
-export { fetchProfitAndLossClassesView, updateProfitAndLossClassesToFilterOut, resetProfitAndLossClassesNodeCollapseState, updateProfitAndLossClassesViewUIState, updateProfitAndLossAccountViewMode, updateClassViewLayout, getProfitAndLossClassesView, getProfitAndLossClassesHorizontalView, isPandLReportViewCalculatedSectionID, isPandLReportViewSectionID, HORIZONTAL_CLASS_TOTAL_BALANCE_ID, isHorizontalAccountReportData, };
+export { fetchProfitAndLossClassesView, updateProfitAndLossClassesToFilterOut, resetProfitAndLossClassesNodeCollapseState, updateProfitAndLossClassesViewUIState, updateProfitAndLossAccountViewMode, updateClassViewLayout, getProfitAndLossClassesView, getEmptyHorizontalSectionBalancesSlice, getProfitAndLossClassesHorizontalView, isPandLReportViewCalculatedSectionID, isPandLReportViewSectionID, HORIZONTAL_CLASS_TOTAL_BALANCE_ID, isHorizontalAccountReportData, };
 export { getAccountingProviderAttachment };
 export { fetchUserListByType, getUserList };
 export { fetchAllPeopleRequiredViews, fetchPeoplePage, fetchPeople, deletePerson, resendInvite, changeZeniPersonRoles, invitePeople, inviteZeniPeople, updatePeopleUIState, peopleSaveUpdates, resetUpdateErrorMessage, peopleSaveDataInLocalStore, peopleClearDataInLocalStore, getPeople, getPeopleLocalData, initializeEditPerson, };

package/lib/esm/view/profitAndLossClassesView/horizontalSectionEmptyBalancesSlice.js

@@ -0,0 +1,17 @@
+/**
+ * Empty `COABalancesSlice` for horizontal P&L-by-class section / calculated headers when
+ * enrichment has not produced balances yet, or for UI mapping fallbacks.
+ * Structure matches {@link enrichProfitAndLossByClassHorizontalReport} output.
+ */
+export function getEmptyHorizontalSectionBalancesSlice(firstMonthOfFY, timeframe = 'month') {
+    return {
+        balances: [],
+        additionalBalances: [],
+        filter: {
+            firstMonthOfFY,
+            timeframe,
+            balancesRange: { numberOfPeriods: 0, orderBy: 'ascending_date' },
+            additionalBalances: [],
+        },
+    };
+}

package/lib/esm/view/profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelector.js

@@ -49,16 +49,11 @@ export const getProfitAndLossClassesHorizontalView = (filter, accountState, clas
     const calculatedSections = {};
     let reportCurrency = defaultCustomerCurrency;
     if (fetchState.fetchState === 'Completed' && selectedPeriod != null) {
-        // Get section reports using existing selector infrastructure
-        const sectionReports = {};
-        HORIZONTAL_PANDL_SECTION_IDS.forEach((sectionId) => {
-            sectionReports[sectionId] = getSectionClassesViewReport(accountState, classState, sectionsState, { reportId, sectionId }, filter);
-        });
         reportCurrency =
             profitAndLossClassesViewState.currency ?? defaultCustomerCurrency;
-        // Pivot each section from class→account to account→class
+        // Fetch each section and pivot class→account to account→class in one pass
         HORIZONTAL_PANDL_SECTION_IDS.forEach((sectionId) => {
-            const sectionReport = sectionReports[sectionId];
+            const sectionReport = getSectionClassesViewReport(accountState, classState, sectionsState, { reportId, sectionId }, filter);
             if (sectionReport != null) {
                 sections[sectionId] = pivotSectionToHorizontal(sectionReport, classColumns, SECTION_TITLES[sectionId] ?? sectionId, reportCurrency);
             }
@@ -261,7 +256,7 @@ function sumBalancesInSlice(balances) {
     if (balances.length === 0) {
         return 0;
     }
-    const summed = getSummationFreeRangeTotalBalance([...balances]);
+    const summed = getSummationFreeRangeTotalBalance(balances);
     return summed?.balance.amount ?? 0;
 }
 /**

package/lib/esm/view/profitAndLossClassesView/profitAndLossHorizontalEnrichment.js

@@ -1,4 +1,5 @@
 import { defaultCustomerCurrency } from '../../commonStateTypes/currencyHelper';
+import { getEmptyHorizontalSectionBalancesSlice } from './horizontalSectionEmptyBalancesSlice';
 import { HORIZONTAL_CLASS_TOTAL_BALANCE_ID, } from './profitAndLossClassesByClassHorizontalSelectorTypes';
 /**
  * Populates `sectionHeaderBalancesSlice`, and per-account `accountReportData`, so the
@@ -25,30 +26,31 @@ function enrichHorizontalSection(report, section) {
         return total?.balance.amount ?? 0;
     });
     section.sectionHeaderBalancesSlice = buildHorizontalClassColumnBalancesSlice(report, classAmounts, section.sectionTotal.amount);
-    const childrenRowIndicesByParent = buildHorizontalAccountChildIndicesByParent(section.accounts);
+    const parentIndices = computeHorizontalAccountParentIndices(section.accounts);
+    const childrenRowIndicesByParent = buildHorizontalAccountChildIndicesByParent(parentIndices);
     const childrenRecord = {};
     childrenRowIndicesByParent.forEach((childIndices, parentIndex) => {
         childrenRecord[parentIndex] = childIndices;
     });
     section.treeLayout = {
         rootAccountRowIndices: section.accounts
-            .map((_, i) => findHorizontalAccountParentIndex(section.accounts, i) === -1 ? i : -1)
+            .map((_, i) => (parentIndices[i] === -1 ? i : -1))
             .filter((i) => i >= 0),
         childrenRowIndicesByParent: childrenRecord,
     };
-    for (let i = 0; i < section.accounts.length; i++) {
-        const row = section.accounts[i];
-        const classRowAmounts = report.classColumns.map((col) => {
-            const cb = row.classBalances.find((b) => b.classId === col.classId);
-            return cb?.balance.amount ?? 0;
-        });
+    const siblingsPerRow = buildSiblingIndicesPerRow(section.accounts, parentIndices);
+    const hasChildFlags = computeHorizontalHasChildFlags(parentIndices);
+    for (let accountIndex = 0; accountIndex < section.accounts.length; accountIndex++) {
+        const row = section.accounts[accountIndex];
+        // Same column order as `report.classColumns` (see `pivotSectionToHorizontal`).
+        const classRowAmounts = row.classBalances.map((classBalance) => classBalance.balance.amount);
         row.accountReportData = {
             accountId: row.accountId,
             accountName: row.accountName,
             accountType: row.accountType,
             depth: row.depth,
             balancesInTimeframe: buildHorizontalClassColumnBalancesSlice(report, classRowAmounts, row.rowTotal.amount),
-            horizontalTreeView: buildHorizontalTreeView(section.accounts, i),
+            horizontalTreeView: buildHorizontalTreeViewFromPrecomputed(section.accounts, accountIndex, parentIndices, siblingsPerRow, hasChildFlags),
         };
     }
 }
@@ -66,23 +68,14 @@ function buildHorizontalClassColumnBalancesSlice(report, classAmounts, totalAmou
     const currencyCode = firstHeader?.balance.currencyCode ?? fallback.currencyCode;
     const currencySymbol = firstHeader?.balance.currencySymbol ?? fallback.currencySymbol;
     const timeframe = firstHeader?.balanceTimeFrame ?? 'month';
-    const emptySlice = {
-        balances: [],
-        additionalBalances: [],
-        filter: {
-            firstMonthOfFY: report.firstMonthOfFY,
-            timeframe,
-            balancesRange: { numberOfPeriods: 0, orderBy: 'ascending_date' },
-            additionalBalances: [],
-        },
-    };
+    const emptySlice = getEmptyHorizontalSectionBalancesSlice(report.firstMonthOfFY, timeframe);
     if (report.selectedPeriod == null) {
         return emptySlice;
     }
     const { startDate, endDate } = report.selectedPeriod;
-    const balances = report.classColumns.map((col, i) => ({
+    const balances = report.classColumns.map((col, columnIndex) => ({
         balance: {
-            amount: classAmounts[i] ?? 0,
+            amount: classAmounts[columnIndex] ?? 0,
             currencyCode,
             currencySymbol,
         },
@@ -120,64 +113,143 @@ function buildHorizontalClassColumnBalancesSlice(report, classAmounts, totalAmou
         },
     };
 }
-function findHorizontalAccountParentIndex(dfsOrderedAccountRows, childRowIndex) {
-    const childDepth = dfsOrderedAccountRows[childRowIndex].depth;
-    if (childDepth <= 2) {
-        return -1;
-    }
-    for (let earlierRowIndex = childRowIndex - 1; earlierRowIndex >= 0; earlierRowIndex--) {
-        const earlierDepth = dfsOrderedAccountRows[earlierRowIndex].depth;
-        if (earlierDepth < childDepth) {
-            if (earlierDepth === childDepth - 1) {
-                return earlierRowIndex;
+/**
+ * Parent index per DFS row — O(n). Matches the scan in the former
+ * `findHorizontalAccountParentIndex` (depth &lt;= 2 rows have no parent).
+ */
+function computeHorizontalAccountParentIndices(rows) {
+    const accountRowCount = rows.length;
+    const parentIndex = new Array(accountRowCount).fill(-1);
+    const stack = [];
+    for (let rowIndex = 0; rowIndex < accountRowCount; rowIndex++) {
+        const accountRow = rows[rowIndex];
+        if (accountRow == null) {
+            continue;
+        }
+        const depth = accountRow.depth;
+        while (stack.length > 0) {
+            const topRow = rows[stack[stack.length - 1]];
+            if (topRow == null) {
+                stack.pop();
+                continue;
+            }
+            if (topRow.depth < depth) {
+                break;
+            }
+            stack.pop();
+        }
+        if (depth > 2 && stack.length > 0) {
+            const peek = stack[stack.length - 1];
+            const parentRow = rows[peek];
+            if (parentRow != null && parentRow.depth === depth - 1) {
+                parentIndex[rowIndex] = peek;
             }
-            return -1;
         }
+        stack.push(rowIndex);
     }
-    return -1;
+    return parentIndex;
 }
-function getHorizontalAccountSiblingIndices(dfsOrderedAccountRows, rowIndex) {
-    const parentRowIndex = findHorizontalAccountParentIndex(dfsOrderedAccountRows, rowIndex);
-    const rowDepth = dfsOrderedAccountRows[rowIndex].depth;
-    const siblings = [];
-    for (let i = 0; i < dfsOrderedAccountRows.length; i++) {
-        if (dfsOrderedAccountRows[i].depth === rowDepth &&
-            findHorizontalAccountParentIndex(dfsOrderedAccountRows, i) ===
-                parentRowIndex) {
-            siblings.push(i);
+/** Sibling row indices (same parent + depth), in traversal order — O(n). */
+function buildSiblingIndicesPerRow(rows, parentIndices) {
+    const accountRowCount = rows.length;
+    const keyToIndices = new Map();
+    for (let rowIndex = 0; rowIndex < accountRowCount; rowIndex++) {
+        const parentRowIndex = parentIndices[rowIndex];
+        const accountRow = rows[rowIndex];
+        if (parentRowIndex == null || accountRow == null) {
+            continue;
+        }
+        const key = `${parentRowIndex}:${accountRow.depth}`;
+        let siblingGroup = keyToIndices.get(key);
+        if (siblingGroup == null) {
+            siblingGroup = [];
+            keyToIndices.set(key, siblingGroup);
+        }
+        siblingGroup.push(rowIndex);
+    }
+    const siblingsPerRow = new Array(accountRowCount);
+    for (let rowIndex = 0; rowIndex < accountRowCount; rowIndex++) {
+        const parentRowIndex = parentIndices[rowIndex];
+        const accountRow = rows[rowIndex];
+        if (parentRowIndex == null || accountRow == null) {
+            siblingsPerRow[rowIndex] = [rowIndex];
+            continue;
         }
+        const key = `${parentRowIndex}:${accountRow.depth}`;
+        const group = keyToIndices.get(key);
+        siblingsPerRow[rowIndex] = group != null ? group : [rowIndex];
     }
-    return siblings;
+    return siblingsPerRow;
 }
-function horizontalAccountHasChildRows(dfsOrderedAccountRows, parentRowIndex) {
-    return dfsOrderedAccountRows.some((_, rowIndex) => findHorizontalAccountParentIndex(dfsOrderedAccountRows, rowIndex) ===
-        parentRowIndex);
+function computeHorizontalHasChildFlags(parentIndices) {
+    const rowCount = parentIndices.length;
+    const flags = new Array(rowCount).fill(false);
+    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+        const parentRowIndex = parentIndices[rowIndex];
+        if (parentRowIndex != null &&
+            parentRowIndex >= 0 &&
+            parentRowIndex < rowCount) {
+            flags[parentRowIndex] = true;
+        }
+    }
+    return flags;
 }
-function buildHorizontalSubAccountAncestorMetadata(dfsOrderedAccountRows, currentRowIndex) {
-    const ancestorRowIndicesRootToLeaf = [];
+function buildHorizontalSubAccountAncestorMetadataFromPrecomputed(dfsOrderedAccountRows, currentRowIndex, parentIndices, siblingsPerRow, hasChildFlags) {
+    const chain = [];
     let walkRowIndex = currentRowIndex;
     while (walkRowIndex >= 0) {
-        ancestorRowIndicesRootToLeaf.unshift(walkRowIndex);
-        walkRowIndex = findHorizontalAccountParentIndex(dfsOrderedAccountRows, walkRowIndex);
+        chain.unshift(walkRowIndex);
+        const parentRowIndex = parentIndices[walkRowIndex];
+        if (parentRowIndex == null) {
+            break;
+        }
+        walkRowIndex = parentRowIndex;
     }
-    return ancestorRowIndicesRootToLeaf.map((rowIndex) => {
-        const siblingIndices = getHorizontalAccountSiblingIndices(dfsOrderedAccountRows, rowIndex);
+    return chain.map((rowIndex) => {
+        const accountRow = dfsOrderedAccountRows[rowIndex];
+        const siblingIndices = siblingsPerRow[rowIndex];
+        const hasChild = hasChildFlags[rowIndex];
+        if (accountRow == null || siblingIndices == null) {
+            return {
+                depth: 0,
+                hasSibling: false,
+                hasChildren: hasChild === true,
+                isLastNode: true,
+                name: '',
+            };
+        }
         return {
-            depth: dfsOrderedAccountRows[rowIndex].depth - 2,
+            depth: accountRow.depth - 2,
             hasSibling: siblingIndices.length > 1,
-            hasChildren: horizontalAccountHasChildRows(dfsOrderedAccountRows, rowIndex),
+            hasChildren: hasChild === true,
             isLastNode: rowIndex === siblingIndices[siblingIndices.length - 1],
-            name: dfsOrderedAccountRows[rowIndex].accountName,
+            name: accountRow.accountName,
         };
     });
 }
-function buildHorizontalAccountChildIndicesByParent(dfsOrderedAccountRows) {
+function buildHorizontalTreeViewFromPrecomputed(dfsOrderedAccountRows, currentRowIndex, parentIndices, siblingsPerRow, hasChildFlags) {
+    const siblingIndices = siblingsPerRow[currentRowIndex];
+    const accountRow = dfsOrderedAccountRows[currentRowIndex];
+    const hasChildrenFlag = hasChildFlags[currentRowIndex];
+    const treeDepth = accountRow != null ? Math.max(0, accountRow.depth - 2) : 0;
+    const hasChildren = hasChildrenFlag === true;
+    const siblings = siblingIndices ?? [currentRowIndex];
+    return {
+        subAccountAncestorMetadata: buildHorizontalSubAccountAncestorMetadataFromPrecomputed(dfsOrderedAccountRows, currentRowIndex, parentIndices, siblingsPerRow, hasChildFlags),
+        treeDepth,
+        hasChildren,
+        hasSiblings: siblings.length > 1,
+        isLeaf: !hasChildren,
+        isLastNode: currentRowIndex === siblings[siblings.length - 1],
+    };
+}
+function buildHorizontalAccountChildIndicesByParent(parentIndices) {
     const childIndicesByParentRowIndex = new Map();
-    for (let rowIndex = 0; rowIndex < dfsOrderedAccountRows.length; rowIndex++) {
-        const parentRowIndex = findHorizontalAccountParentIndex(dfsOrderedAccountRows, rowIndex);
-        if (parentRowIndex >= 0) {
+    for (let rowIndex = 0; rowIndex < parentIndices.length; rowIndex++) {
+        const parentRowIndex = parentIndices[rowIndex];
+        if (parentRowIndex != null && parentRowIndex >= 0) {
             let childRowIndices = childIndicesByParentRowIndex.get(parentRowIndex);
-            if (childRowIndices === undefined) {
+            if (childRowIndices == null) {
                 childRowIndices = [];
                 childIndicesByParentRowIndex.set(parentRowIndex, childRowIndices);
             }
@@ -186,16 +258,3 @@ function buildHorizontalAccountChildIndicesByParent(dfsOrderedAccountRows) {
     }
     return childIndicesByParentRowIndex;
 }
-function buildHorizontalTreeView(dfsOrderedAccountRows, currentRowIndex) {
-    const treeDepth = Math.max(0, dfsOrderedAccountRows[currentRowIndex].depth - 2);
-    const siblingIndices = getHorizontalAccountSiblingIndices(dfsOrderedAccountRows, currentRowIndex);
-    const hasChildren = horizontalAccountHasChildRows(dfsOrderedAccountRows, currentRowIndex);
-    return {
-        subAccountAncestorMetadata: buildHorizontalSubAccountAncestorMetadata(dfsOrderedAccountRows, currentRowIndex),
-        treeDepth,
-        hasChildren,
-        hasSiblings: siblingIndices.length > 1,
-        isLeaf: !hasChildren,
-        isLastNode: currentRowIndex === siblingIndices[siblingIndices.length - 1],
-    };
-}

package/lib/index.d.ts

@@ -347,6 +347,7 @@ import { PeopleViewSortKey } from './view/people/peopleTypes';
 import { fetchProfitAndLoss, fetchProfitAndLossForTimeframe, resetProfitAndLossNodeCollapseState, updateProfitAndLossUIState } from './view/profitAndLoss/profitAndLossReducer';
 import { ProfitAndLossReport, getPandLReportFetchState, getProfitAndLossReport } from './view/profitAndLoss/profitAndLossSelector';
 import { ProfitAndLossState, ProfitAndLossUIState } from './view/profitAndLoss/profitAndLossState';
+import { getEmptyHorizontalSectionBalancesSlice } from './view/profitAndLossClassesView/horizontalSectionEmptyBalancesSlice';
 import { getProfitAndLossClassesHorizontalView } from './view/profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelector';
 import { ClassColumnDefinition, HORIZONTAL_CLASS_TOTAL_BALANCE_ID, HorizontalAccountReportData, HorizontalAccountRow, HorizontalCalculatedSection, HorizontalClassBalance, HorizontalSectionReport, HorizontalSectionTreeLayout, ProfitAndLossByClassHorizontalReport, isHorizontalAccountReportData } from './view/profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelectorTypes';
 import { fetchProfitAndLossClassesView, resetProfitAndLossClassesNodeCollapseState, updateClassViewLayout, updateAccountViewMode as updateProfitAndLossAccountViewMode, updateClassesToFilterOut as updateProfitAndLossClassesToFilterOut, updateProfitAndLossClassesViewUIState } from './view/profitAndLossClassesView/profitAndLossClassesViewReducer';
@@ -667,7 +668,7 @@ export { fetchDashboard, getDashboard, DashboardReport, updateTreasuryVideoClose
 export { updateDashboardLayout };
 export { PandLWithForecastView, getPandLWithForecast, } from './view/profitAndLoss/pAndLWithForecast/pAndLWithForecastSelector';
 export { fetchProfitAndLoss, resetProfitAndLossNodeCollapseState, updateProfitAndLossUIState, ProfitAndLossState, ProfitAndLossUIState, getProfitAndLossReport, ProfitAndLossReport, getPandLReportFetchState, fetchProfitAndLossForTimeframe, };
-export { fetchProfitAndLossClassesView, updateProfitAndLossClassesToFilterOut, resetProfitAndLossClassesNodeCollapseState, updateProfitAndLossClassesViewUIState, updateProfitAndLossAccountViewMode, updateClassViewLayout, ProfitAndLossClassesViewUIState, ProfitAndLossClassesViewReport, getProfitAndLossClassesView, getProfitAndLossClassesHorizontalView, PandLReportViewSectionID, PandLReportViewCalculatedSectionID, isPandLReportViewCalculatedSectionID, isPandLReportViewSectionID, ClassViewLayout, ProfitAndLossByClassHorizontalReport, ClassColumnDefinition, HORIZONTAL_CLASS_TOTAL_BALANCE_ID, HorizontalAccountReportData, HorizontalAccountRow, HorizontalClassBalance, HorizontalSectionReport, HorizontalSectionTreeLayout, HorizontalCalculatedSection, isHorizontalAccountReportData, };
+export { fetchProfitAndLossClassesView, updateProfitAndLossClassesToFilterOut, resetProfitAndLossClassesNodeCollapseState, updateProfitAndLossClassesViewUIState, updateProfitAndLossAccountViewMode, updateClassViewLayout, ProfitAndLossClassesViewUIState, ProfitAndLossClassesViewReport, getProfitAndLossClassesView, getEmptyHorizontalSectionBalancesSlice, getProfitAndLossClassesHorizontalView, PandLReportViewSectionID, PandLReportViewCalculatedSectionID, isPandLReportViewCalculatedSectionID, isPandLReportViewSectionID, ClassViewLayout, ProfitAndLossByClassHorizontalReport, ClassColumnDefinition, HORIZONTAL_CLASS_TOTAL_BALANCE_ID, HorizontalAccountReportData, HorizontalAccountRow, HorizontalClassBalance, HorizontalSectionReport, HorizontalSectionTreeLayout, HorizontalCalculatedSection, isHorizontalAccountReportData, };
 export { AccountingProviderAttachmentSelector, getAccountingProviderAttachment };
 export { fetchUserListByType, getUserList, UserListSelectorView };
 export { fetchAllPeopleRequiredViews, fetchPeoplePage, fetchPeople, deletePerson, resendInvite, changeZeniPersonRoles, invitePeople, inviteZeniPeople, updatePeopleUIState, peopleSaveUpdates, resetUpdateErrorMessage, peopleSaveDataInLocalStore, peopleClearDataInLocalStore, PeopleSelectorView, PeopleLocalDataView, Person, getPeople, getPeopleLocalData, PeopleState, PersonUpdateType, PeoplePageMode, ZeniPersonUserRoleType, PeopleUIState, PeopleLocalData, initializeEditPerson, };