@zeniai/client-epic-state 4.19.96-beta3ND → 4.19.96-beta4ND

package/lib/commonStateTypes/coaBalance/coaBalanceType.d.ts

@@ -5,3 +5,5 @@ export type COABalanceType = 'default' | 'default_with_percent' | 'default_with_
 export declare const toCOABalanceType: (v: string) => COABalanceType;
 export declare const toCOABalanceTypeStrict: (v: string) => COABalanceType | undefined;
 export declare const isCalculatedBalanceType: (id: string) => id is CalculatedBalance;
+/** Removes compare-mode balance types (horizontal P&L-by-class does not use them). */
+export declare function stripCompareAdditionalBalanceTypes(balances: readonly COABalanceType[]): COABalanceType[];

package/lib/commonStateTypes/coaBalance/coaBalanceType.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isCalculatedBalanceType = exports.toCOABalanceTypeStrict = exports.toCOABalanceType = void 0;
+exports.stripCompareAdditionalBalanceTypes = stripCompareAdditionalBalanceTypes;
 const stringToUnion_1 = require("../stringToUnion");
 const ALL_COA_BALANCE_FIELDS = [
     'default',
@@ -33,3 +34,8 @@ const toCOABalanceTypeStrict = (v) => (0, stringToUnion_1.stringToUnionStrict)(v
 exports.toCOABalanceTypeStrict = toCOABalanceTypeStrict;
 const isCalculatedBalanceType = (id) => ALL_CALCULATED_BALANCES.find((sectionId) => id === sectionId) != null;
 exports.isCalculatedBalanceType = isCalculatedBalanceType;
+/** Removes compare-mode balance types (horizontal P&L-by-class does not use them). */
+function stripCompareAdditionalBalanceTypes(balances) {
+    return balances.filter((balanceType) => balanceType !== 'this_period_vs_last_period' &&
+        balanceType !== 'this_period_vs_last_period_percent');
+}

package/lib/esm/commonStateTypes/coaBalance/coaBalanceType.js

@@ -27,3 +27,8 @@ const ALL_CALCULATED_BALANCES = [
 export const toCOABalanceType = (v) => stringToUnion(v, ALL_COA_BALANCE_FIELDS);
 export const toCOABalanceTypeStrict = (v) => stringToUnionStrict(v, ALL_COA_BALANCE_FIELDS);
 export const isCalculatedBalanceType = (id) => ALL_CALCULATED_BALANCES.find((sectionId) => id === sectionId) != null;
+/** Removes compare-mode balance types (horizontal P&L-by-class does not use them). */
+export function stripCompareAdditionalBalanceTypes(balances) {
+    return balances.filter((balanceType) => balanceType !== 'this_period_vs_last_period' &&
+        balanceType !== 'this_period_vs_last_period_percent');
+}

package/lib/esm/index.js

@@ -3,7 +3,7 @@ import { toAmount } from './commonStateTypes/amount';
 import { defaultCustomerCurrency } from './commonStateTypes/currencyHelper';
 import { getTimeframeTickTag, isIncompleteMonthPresentInTimeframeTick, } from './commonStateTypes/bookCloseDateHelper';
 import { toCOABalanceTimeframe, } from './commonStateTypes/coaBalance/coaBalance';
-import { isCalculatedBalanceType, toCOABalanceType, toCOABalanceTypeStrict, } from './commonStateTypes/coaBalance/coaBalanceType';
+import { isCalculatedBalanceType, stripCompareAdditionalBalanceTypes, toCOABalanceType, toCOABalanceTypeStrict, } from './commonStateTypes/coaBalance/coaBalanceType';
 import { newBalancesFilter, newBalancesFilterForDateRange, toCOABalancesOrderStrict, } from './commonStateTypes/coaBalance/coaBalancesFilter';
 import { newBalancesFilterClassesView, } from './commonStateTypes/coaBalance/coaBalancesFilterClassesView';
 import { getNumberOfPeriods } from './commonStateTypes/dataAvailable';
@@ -219,6 +219,7 @@ import { fetchProfitAndLoss, fetchProfitAndLossForTimeframe, resetProfitAndLossN
 import { getPandLReportFetchState, getProfitAndLossReport, } from './view/profitAndLoss/profitAndLossSelector';
 import { fetchProfitAndLossClassesView, resetProfitAndLossClassesNodeCollapseState, updateAccountViewMode as updateProfitAndLossAccountViewMode, updateClassesToFilterOut as updateProfitAndLossClassesToFilterOut, updateClassViewLayout, updateProfitAndLossClassesViewUIState, } from './view/profitAndLossClassesView/profitAndLossClassesViewReducer';
 import { getProfitAndLossClassesHorizontalView } from './view/profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelector';
+import { HORIZONTAL_CLASS_TOTAL_BALANCE_ID, isHorizontalAccountReportData, } from './view/profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelectorTypes';
 import { getProfitAndLossClassesView } from './view/profitAndLossClassesView/profitAndLossClassesViewSelector';
 import { isPandLReportViewCalculatedSectionID, isPandLReportViewSectionID, } from './view/profitAndLossClassesView/profitAndLossClassesViewSelectorTypes';
 import { fetchEntityRecommendationsByTransactionId, fetchRecommendationByEntityId, fetchRecommendationByEntityName, } from './view/recommendation/recommendationReducer';
@@ -414,7 +415,7 @@ export { toReportID, toReportFormatStrict, isCashFlowOrBalanceSheetReport, isDas
 export { toCOABalanceTimeframe, };
 export { toCOABalancesOrderStrict, newBalancesFilter, newBalancesFilterForDateRange, };
 export { newBalancesFilterClassesView };
-export { toCOABalanceTypeStrict, toCOABalanceType as toCOABlanaceType, isCalculatedBalanceType, };
+export { toCOABalanceTypeStrict, toCOABalanceType as toCOABlanaceType, isCalculatedBalanceType, stripCompareAdditionalBalanceTypes, };
 export { stringToUnion, stringToUnionStrict };
 export { fetchMonthEndCloseChecks, fetchMonthClosePerformanceTrend, getMonthEndCloseChecksViewByTenantId, ALL_MONTH_END_CLOSE_CHECKS_FREQUENCY, };
 export { 
@@ -452,7 +453,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, };
+export { fetchProfitAndLossClassesView, updateProfitAndLossClassesToFilterOut, resetProfitAndLossClassesNodeCollapseState, updateProfitAndLossClassesViewUIState, updateProfitAndLossAccountViewMode, updateClassViewLayout, getProfitAndLossClassesView, 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/financeStatement/financeStatementSelector.js

@@ -1,4 +1,5 @@
 import { createSelector } from '@reduxjs/toolkit';
+import { stripCompareAdditionalBalanceTypes } from '../../commonStateTypes/coaBalance/coaBalanceType';
 import { newBalancesFilter, newBalancesFilterForDateRange, } from '../../commonStateTypes/coaBalance/coaBalancesFilter';
 import { newBalancesFilterClassesView } from '../../commonStateTypes/coaBalance/coaBalancesFilterClassesView';
 import { getNumberOfPeriods, } from '../../commonStateTypes/dataAvailable';
@@ -55,9 +56,15 @@ export const getFinanceStatement = createSelector((state) => state.accountState,
     if (thisPeriod == null && balancesInTimeframe.length > 0) {
         thisPeriod = toTimeframeTick(balancesInTimeframe[balancesInTimeframe.length - 1]);
     }
-    const filter = newBalancesFilter(firstMonthOfFY, financeStatementState.timeframe, Math.min(getNumberOfPeriods(firstMonthOfFY, financeStatementState.timeframe, dataAvailable) ?? financeStatementState.selectedCOABalancesRange.numberOfPeriods, financeStatementState.selectedCOABalancesRange.numberOfPeriods), thisPeriod, 'ascending_date', financeStatementState.isAdditionalBalancesShown === true
+    const rawAdditionalBalances = financeStatementState.isAdditionalBalancesShown === true
         ? financeStatementState.selectedAdditionalBalances
-        : []);
+        : [];
+    const useHorizontalClassesLayout = profitAndLossClassesViewState.uiState.classViewLayout === 'horizontal' &&
+        financeStatementState.selectedReportId === 'profit_and_loss_by_classes';
+    const additionalBalancesForFilter = useHorizontalClassesLayout
+        ? stripCompareAdditionalBalanceTypes(rawAdditionalBalances)
+        : rawAdditionalBalances;
+    const filter = newBalancesFilter(firstMonthOfFY, financeStatementState.timeframe, Math.min(getNumberOfPeriods(firstMonthOfFY, financeStatementState.timeframe, dataAvailable) ?? financeStatementState.selectedCOABalancesRange.numberOfPeriods, financeStatementState.selectedCOABalancesRange.numberOfPeriods), thisPeriod, 'ascending_date', additionalBalancesForFilter);
     const profitAndLossReport = getProfitAndLossReport(filter, undefined, accountState, accountGroupState, sectionAccountsViewState, profitAndLossState, forecastState);
     const classFilter = newBalancesFilterClassesView(filter.firstMonthOfFY, filter.timeframe, filter.balancesRange.numberOfPeriods, filter.balancesRange.thisPeriod, filter.balancesRange.orderBy, filter.additionalBalances, profitAndLossClassesViewState.uiState.classesToFilterOut);
     const profitAndLossByClassReport = getProfitAndLossClassesView(classFilter, accountState, classState, sectionsState, profitAndLossClassesViewState);
@@ -117,7 +124,9 @@ export const getFinanceStatement = createSelector((state) => state.accountState,
         filter,
         selectedReportId: financeStatementState.selectedReportId,
         downloadState: financeStatementState.downloadState,
-        isCompareModeOn: financeStatementState.selectedAdditionalBalances.includes('this_period_vs_last_period') ||
-            financeStatementState.selectedAdditionalBalances.includes('this_period_vs_last_period_percent'),
+        isCompareModeOn: useHorizontalClassesLayout
+            ? false
+            : financeStatementState.selectedAdditionalBalances.includes('this_period_vs_last_period') ||
+                financeStatementState.selectedAdditionalBalances.includes('this_period_vs_last_period_percent'),
     };
 });

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

@@ -3,6 +3,7 @@ import { getSummationFreeRangeTotalBalance } from '../../commonStateTypes/coaBal
 import { reduceFetchStateParallelTimeframes } from '../../commonStateTypes/reduceFetchState';
 import { defaultCustomerCurrency } from '../../commonStateTypes/currencyHelper';
 import { getSectionClassesViewReport } from '../../entity/sectionClassesViewV2/sectionClassesViewSelector';
+import { enrichProfitAndLossByClassHorizontalReport } from './profitAndLossHorizontalEnrichment';
 export const profitAndLossHorizontalIdsInOrder = [
     'income',
     'cogs',
@@ -91,7 +92,7 @@ export const getProfitAndLossClassesHorizontalView = (filter, accountState, clas
     }
     // Build synthetic header COABalances for rendering class names as column headers
     const headerBalances = buildHeaderBalances(classColumns, filter.timeframe, selectedPeriod, reportCurrency);
-    return {
+    const report = {
         reportId,
         reportTitle: 'Profit and Loss by Class',
         firstMonthOfFY: profitAndLossClassesViewState.firstMonthOfFY,
@@ -106,6 +107,8 @@ export const getProfitAndLossClassesHorizontalView = (filter, accountState, clas
         uiState: profitAndLossClassesViewState.uiState,
         headerBalances,
     };
+    enrichProfitAndLossByClassHorizontalReport(report);
+    return report;
 };
 /**
  * Build column definitions from class hierarchy (top-level classes only).

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

@@ -1 +1,9 @@
-export {};
+/** Synthetic COABalance `id` for the horizontal class report Total column (transaction routing). */
+export const HORIZONTAL_CLASS_TOTAL_BALANCE_ID = '__horizontal_total__';
+export function isHorizontalAccountReportData(data) {
+    return (typeof data === 'object' &&
+        data !== null &&
+        'depth' in data &&
+        typeof data.depth === 'number' &&
+        !('filter' in data));
+}

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

@@ -0,0 +1,200 @@
+import { defaultCustomerCurrency } from '../../commonStateTypes/currencyHelper';
+import { HORIZONTAL_CLASS_TOTAL_BALANCE_ID, } from './profitAndLossClassesByClassHorizontalSelectorTypes';
+/**
+ * Populates `sectionHeaderBalancesSlice`, and per-account `accountReportData`, so the
+ * web layer only maps selector output to tree nodes.
+ */
+export function enrichProfitAndLossByClassHorizontalReport(report) {
+    if (report.fetchState !== 'Completed' || report.selectedPeriod == null) {
+        return;
+    }
+    for (const section of Object.values(report.sections)) {
+        if (section != null) {
+            enrichHorizontalSection(report, section);
+        }
+    }
+    for (const calc of Object.values(report.calculatedSections)) {
+        if (calc != null) {
+            enrichHorizontalCalculatedSection(report, calc);
+        }
+    }
+}
+function enrichHorizontalSection(report, section) {
+    const classAmounts = report.classColumns.map((col) => {
+        const total = section.classTotals.find((ct) => ct.classId === col.classId);
+        return total?.balance.amount ?? 0;
+    });
+    section.sectionHeaderBalancesSlice = buildHorizontalClassColumnBalancesSlice(report, classAmounts, section.sectionTotal.amount);
+    const childrenRowIndicesByParent = buildHorizontalAccountChildIndicesByParent(section.accounts);
+    const childrenRecord = {};
+    childrenRowIndicesByParent.forEach((childIndices, parentIndex) => {
+        childrenRecord[parentIndex] = childIndices;
+    });
+    section.treeLayout = {
+        rootAccountRowIndices: section.accounts
+            .map((_, i) => findHorizontalAccountParentIndex(section.accounts, 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;
+        });
+        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),
+        };
+    }
+}
+function enrichHorizontalCalculatedSection(report, calcSection) {
+    const classAmounts = report.classColumns.map((col) => {
+        const total = calcSection.classTotals.find((ct) => ct.classId === col.classId);
+        return total?.balance.amount ?? 0;
+    });
+    calcSection.sectionHeaderBalancesSlice = buildHorizontalClassColumnBalancesSlice(report, classAmounts, calcSection.sectionTotal.amount);
+}
+function buildHorizontalClassColumnBalancesSlice(report, classAmounts, totalAmount) {
+    const fallback = defaultCustomerCurrency;
+    const firstHeader = report.headerBalances[0];
+    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: [],
+        },
+    };
+    if (report.selectedPeriod == null) {
+        return emptySlice;
+    }
+    const { startDate, endDate } = report.selectedPeriod;
+    const balances = report.classColumns.map((col, i) => ({
+        balance: {
+            amount: classAmounts[i] ?? 0,
+            currencyCode,
+            currencySymbol,
+        },
+        balanceTimeFrame: timeframe,
+        startDate,
+        endDate,
+        type: 'default',
+        id: col.classId,
+        label: col.className,
+    }));
+    balances.push({
+        balance: {
+            amount: totalAmount,
+            currencyCode,
+            currencySymbol,
+        },
+        balanceTimeFrame: timeframe,
+        startDate,
+        endDate,
+        type: 'default',
+        id: HORIZONTAL_CLASS_TOTAL_BALANCE_ID,
+        label: 'Total',
+    });
+    return {
+        balances,
+        additionalBalances: [],
+        filter: {
+            firstMonthOfFY: report.firstMonthOfFY,
+            timeframe,
+            balancesRange: {
+                numberOfPeriods: balances.length,
+                orderBy: 'ascending_date',
+            },
+            additionalBalances: [],
+        },
+    };
+}
+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;
+            }
+            return -1;
+        }
+    }
+    return -1;
+}
+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);
+        }
+    }
+    return siblings;
+}
+function horizontalAccountHasChildRows(dfsOrderedAccountRows, parentRowIndex) {
+    return dfsOrderedAccountRows.some((_, rowIndex) => findHorizontalAccountParentIndex(dfsOrderedAccountRows, rowIndex) ===
+        parentRowIndex);
+}
+function buildHorizontalSubAccountAncestorMetadata(dfsOrderedAccountRows, currentRowIndex) {
+    const ancestorRowIndicesRootToLeaf = [];
+    let walkRowIndex = currentRowIndex;
+    while (walkRowIndex >= 0) {
+        ancestorRowIndicesRootToLeaf.unshift(walkRowIndex);
+        walkRowIndex = findHorizontalAccountParentIndex(dfsOrderedAccountRows, walkRowIndex);
+    }
+    return ancestorRowIndicesRootToLeaf.map((rowIndex) => {
+        const siblingIndices = getHorizontalAccountSiblingIndices(dfsOrderedAccountRows, rowIndex);
+        return {
+            depth: dfsOrderedAccountRows[rowIndex].depth - 2,
+            hasSibling: siblingIndices.length > 1,
+            hasChildren: horizontalAccountHasChildRows(dfsOrderedAccountRows, rowIndex),
+            isLastNode: rowIndex === siblingIndices[siblingIndices.length - 1],
+            name: dfsOrderedAccountRows[rowIndex].accountName,
+        };
+    });
+}
+function buildHorizontalAccountChildIndicesByParent(dfsOrderedAccountRows) {
+    const childIndicesByParentRowIndex = new Map();
+    for (let rowIndex = 0; rowIndex < dfsOrderedAccountRows.length; rowIndex++) {
+        const parentRowIndex = findHorizontalAccountParentIndex(dfsOrderedAccountRows, rowIndex);
+        if (parentRowIndex >= 0) {
+            let childRowIndices = childIndicesByParentRowIndex.get(parentRowIndex);
+            if (childRowIndices === undefined) {
+                childRowIndices = [];
+                childIndicesByParentRowIndex.set(parentRowIndex, childRowIndices);
+            }
+            childRowIndices.push(rowIndex);
+        }
+    }
+    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

@@ -10,7 +10,7 @@ import { TimeFrameTickTag, getTimeframeTickTag, isIncompleteMonthPresentInTimefr
 import { NestedClassHierarchyForReport, NestedClassID, NestedClassIDHierarchy } from './commonStateTypes/classesView/nestedClassID';
 import { COABalance, COABalanceGrouped, COABalanceGroupedByPeriod, COABalanceMonthQuarterTimeframe, COABalanceTimeFrame, COABalanceWithPercent, toCOABalanceTimeframe } from './commonStateTypes/coaBalance/coaBalance';
 import { COABalanceByAdditionalPeriodGrouped } from './commonStateTypes/coaBalance/coaBalanceByAdditionalPeriod';
-import { COABalanceType, CalculatedBalance, CalculatedCompareBalance, CalculatedTotalBalance, isCalculatedBalanceType, toCOABalanceType, toCOABalanceTypeStrict } from './commonStateTypes/coaBalance/coaBalanceType';
+import { COABalanceType, CalculatedBalance, CalculatedCompareBalance, CalculatedTotalBalance, isCalculatedBalanceType, stripCompareAdditionalBalanceTypes, toCOABalanceType, toCOABalanceTypeStrict } from './commonStateTypes/coaBalance/coaBalanceType';
 import { COABalancesFilter, COABalancesOrder, COABalancesRange, COABalancesRangeWithThisPeriod, COABalancesSlice, newBalancesFilter, newBalancesFilterForDateRange, toCOABalancesOrderStrict } from './commonStateTypes/coaBalance/coaBalancesFilter';
 import { COABalancesFilterClassesView, newBalancesFilterClassesView } from './commonStateTypes/coaBalance/coaBalancesFilterClassesView';
 import { AccountViewMode, CompletionStatusType, FetchState, FetchStateAndError, FetchedState, ID, Mode, UpdateType } from './commonStateTypes/common';
@@ -349,7 +349,7 @@ import { ProfitAndLossReport, getPandLReportFetchState, getProfitAndLossReport }
 import { ProfitAndLossState, ProfitAndLossUIState } from './view/profitAndLoss/profitAndLossState';
 import { fetchProfitAndLossClassesView, resetProfitAndLossClassesNodeCollapseState, updateAccountViewMode as updateProfitAndLossAccountViewMode, updateClassesToFilterOut as updateProfitAndLossClassesToFilterOut, updateClassViewLayout, updateProfitAndLossClassesViewUIState } from './view/profitAndLossClassesView/profitAndLossClassesViewReducer';
 import { getProfitAndLossClassesHorizontalView } from './view/profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelector';
-import { ClassColumnDefinition, HorizontalAccountRow, HorizontalCalculatedSection, HorizontalClassBalance, HorizontalSectionReport, ProfitAndLossByClassHorizontalReport } from './view/profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelectorTypes';
+import { ClassColumnDefinition, HORIZONTAL_CLASS_TOTAL_BALANCE_ID, HorizontalAccountReportData, HorizontalAccountRow, HorizontalCalculatedSection, HorizontalClassBalance, HorizontalSectionReport, HorizontalSectionTreeLayout, ProfitAndLossByClassHorizontalReport, isHorizontalAccountReportData } from './view/profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelectorTypes';
 import { getProfitAndLossClassesView } from './view/profitAndLossClassesView/profitAndLossClassesViewSelector';
 import { PandLReportViewCalculatedSectionID, PandLReportViewSectionID, ProfitAndLossClassesViewReport, isPandLReportViewCalculatedSectionID, isPandLReportViewSectionID } from './view/profitAndLossClassesView/profitAndLossClassesViewSelectorTypes';
 import { ClassViewLayout, ProfitAndLossClassesViewUIState } from './view/profitAndLossClassesView/profitAndLossClassesViewState';
@@ -620,7 +620,7 @@ export { COABalance, COABalanceWithPercent, COABalanceTimeFrame, COABalanceGroup
 export { COABalanceByAdditionalPeriodGrouped };
 export { COABalancesOrder, toCOABalancesOrderStrict, COABalancesRange, COABalancesRangeWithThisPeriod, COABalancesFilter, newBalancesFilter, newBalancesFilterForDateRange, COABalancesSlice, };
 export { newBalancesFilterClassesView, COABalancesFilterClassesView };
-export { CalculatedCompareBalance, CalculatedTotalBalance, CalculatedBalance, COABalanceType, toCOABalanceTypeStrict, toCOABalanceType as toCOABlanaceType, isCalculatedBalanceType, };
+export { CalculatedCompareBalance, CalculatedTotalBalance, CalculatedBalance, COABalanceType, toCOABalanceTypeStrict, toCOABalanceType as toCOABlanaceType, isCalculatedBalanceType, stripCompareAdditionalBalanceTypes, };
 export { stringToUnion, stringToUnionStrict };
 export { TransactionsOrder, COABalancesSliceOrder, EntityOrder, Section, SectionWithAccountOnly, CalculatedSection, };
 export { ClassesViewSelectorReportV2 };
@@ -667,7 +667,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, HorizontalAccountRow, HorizontalClassBalance, HorizontalSectionReport, HorizontalCalculatedSection, };
+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 { 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, };