@zeniai/client-epic-state 4.13.17 → 4.13.19

package/lib/view/expenseAutomationView/helpers/saveTransactionHelper.d.ts

@@ -0,0 +1,8 @@
+import { SupportedTransaction } from '../../../entity/transaction/transactionState';
+import { UncategorizedAccounts } from '../../accountList/accountListSelector';
+import { TransactionReviewLocalData, TransactionSaveUpdates } from '../types/transactionsViewState';
+/**
+ *
+ * @param transactionCategorizationLocalData
+ */
+export declare const toTransactionUpdatesFromTransactionCategorizationLocalData: (transactionCategorizationLocalData: TransactionReviewLocalData, transaction: SupportedTransaction, uncategorizedIncomeExpense: UncategorizedAccounts) => TransactionSaveUpdates;

package/lib/view/expenseAutomationView/helpers/saveTransactionHelper.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTransactionUpdatesFromTransactionCategorizationLocalData = void 0;
+const entity_1 = require("../../../entity/genericEntity/entity");
+const vendorTransaction_1 = require("../../../entity/transaction/stateTypes/vendorTransaction");
+const recommendationState_1 = require("../../recommendation/recommendationState");
+const saveTransactionHelper_1 = require("../../transactionDetail/epics/saveTransactionHelper");
+/**
+ *
+ * @param transactionCategorizationLocalData
+ */
+const toTransactionUpdatesFromTransactionCategorizationLocalData = (transactionCategorizationLocalData, transaction, uncategorizedIncomeExpense) => {
+    var _a, _b, _c;
+    const updates = {
+        updatesByLineId: {},
+    };
+    const updatesByLineId = {};
+    const entityUpdates = {};
+    const isTransactionMisCategorized = (0, saveTransactionHelper_1.isTransactionMiscategorized)(transaction);
+    const isTransactionUnCategorized = (0, saveTransactionHelper_1.isTransactionUncategorized)(transaction, uncategorizedIncomeExpense);
+    updates.memo = transactionCategorizationLocalData.memo;
+    if ((0, vendorTransaction_1.isVendorTransaction)(transaction) === true) {
+        updates.vendorId = (_a = transactionCategorizationLocalData.vendorUpdates) === null || _a === void 0 ? void 0 : _a.id;
+    }
+    const entity = transaction.vendorId != null
+        ? {
+            id: transaction.vendorId,
+            name: (_b = transaction.vendorName) !== null && _b !== void 0 ? _b : '',
+            type: (0, entity_1.toEntityType)('vendor'),
+            qboId: transaction.vendorId,
+            zeniId: transaction.vendorId,
+        }
+        : undefined;
+    let lastUpdatedCategory;
+    let lastUpdatedClass;
+    // single recommendation to just pick the last recommendation in the list of lines
+    (_c = transaction.lines) === null || _c === void 0 ? void 0 : _c.forEach((line) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        const updatedEntityId = (_a = transactionCategorizationLocalData.vendorUpdates) === null || _a === void 0 ? void 0 : _a.qboId;
+        const entityDetails = getEntityDetails(entity, transactionCategorizationLocalData.lineItemById[line.id], transactionCategorizationLocalData.vendorUpdates);
+        if (line.type === 'transaction_with_account_and_class_line' ||
+            line.type === 'transaction_with_product_or_service_line' ||
+            line.type === 'journal_entry_transaction_line') {
+            const lineItem = transactionCategorizationLocalData.lineItemById[line.id];
+            updatesByLineId[line.id] = {
+                lineDescription: lineItem.lineDescription,
+                class: lineItem.class,
+                account: lineItem.account,
+                recommendation: lineItem.recommendations,
+            };
+            if (line.type === 'journal_entry_transaction_line' ||
+                line.platformLineDetailType === 'deposit_line_detail') {
+                updatesByLineId[line.id] = Object.assign(Object.assign({}, updatesByLineId[line.id]), { vendor: lineItem.vendor });
+            }
+            let hasCategoryChanged = false;
+            let hasClassChanged = false;
+            const accountLine = line;
+            hasCategoryChanged =
+                ((_b = lineItem.account) === null || _b === void 0 ? void 0 : _b.qboId) !== accountLine.account.qboId &&
+                    Boolean((_c = lineItem.account) === null || _c === void 0 ? void 0 : _c.qboId);
+            hasClassChanged =
+                Boolean((_d = lineItem.class) === null || _d === void 0 ? void 0 : _d.qboId) &&
+                    ((_e = lineItem.class) === null || _e === void 0 ? void 0 : _e.qboId) !== accountLine.class.qboId;
+            const recommendedAccountBase = (0, saveTransactionHelper_1.toRecommendedAccountBase)(lineItem.amount.amount, lineItem.account);
+            const recommendedClassBase = (0, saveTransactionHelper_1.toRecommendedClassBase)(lineItem.amount.amount, lineItem.class);
+            const updatedLineEntityId = ((_f = accountLine.vendor) === null || _f === void 0 ? void 0 : _f.id) != null
+                ? ((_g = accountLine.vendor) === null || _g === void 0 ? void 0 : _g.id) != ((_h = lineItem.vendor) === null || _h === void 0 ? void 0 : _h.id)
+                    ? (_j = lineItem.vendor) === null || _j === void 0 ? void 0 : _j.id
+                    : (_k = accountLine.vendor) === null || _k === void 0 ? void 0 : _k.id
+                : undefined;
+            if (entityDetails != null &&
+                (updatedEntityId != null || updatedLineEntityId != null)) {
+                lastUpdatedCategory =
+                    hasCategoryChanged === true ? recommendedAccountBase : undefined;
+                lastUpdatedClass =
+                    hasClassChanged === true ? recommendedClassBase : undefined;
+                // Category might have been recommended one, and class may not have been updated and was undefined
+                // in this case check for each
+                const recommended = {
+                    account: lastUpdatedCategory,
+                    class: lastUpdatedClass,
+                };
+                if (recommended.class != null ||
+                    recommended.account != null ||
+                    updatedEntityId != null) {
+                    const vendorIdToUpdate = (_l = transactionCategorizationLocalData.vendorUpdates) === null || _l === void 0 ? void 0 : _l.qboId;
+                    let entityId = entityDetails.entityId;
+                    if (line.type === 'journal_entry_transaction_line' ||
+                        line.platformLineDetailType === 'deposit_line_detail') {
+                        const entityId = (_m = accountLine.vendor) === null || _m === void 0 ? void 0 : _m.id;
+                        if (entityId != null) {
+                            doUpdateEntityUpdates(entityUpdates, entityId, entityDetails.entityType, recommended, false, updatedLineEntityId);
+                        }
+                    }
+                    else {
+                        if (vendorIdToUpdate != null) {
+                            entityId = vendorIdToUpdate;
+                        }
+                        doUpdateEntityUpdates(entityUpdates, entityId, entityDetails.entityType, recommended, false, updatedEntityId);
+                    }
+                }
+            }
+        }
+        else {
+            updatesByLineId[line.id] = line;
+        }
+    });
+    updates.updatesByLineId = updatesByLineId;
+    return {
+        transactionId: transaction.id,
+        updates,
+        entityRelatedUpdates: entityUpdates,
+        /*Note: We need to call `mark-miscategorized-as-correct` api only when any of the line item is miscategorized
+        and all the line items are NOT uncategorized*/
+        markAsMiscatUpdates: isTransactionMisCategorized === true &&
+            isTransactionUnCategorized === false,
+        anyBulkUpdates: false,
+    };
+};
+exports.toTransactionUpdatesFromTransactionCategorizationLocalData = toTransactionUpdatesFromTransactionCategorizationLocalData;
+const doUpdateEntityUpdates = (entityUpdates, entityId, entityType, recommendation, isBulkUpdate = false, updatedEntityId) => {
+    // see if this entity is already being updated
+    const entityKey = (0, recommendationState_1.getEntityRecommendationKey)(entityType, entityId);
+    const entityUpdate = entityUpdates[entityKey];
+    if (entityUpdate == null) {
+        entityUpdates[entityKey] = {
+            entityId,
+            entityType,
+            recommendations: recommendation,
+            isBulkUpdate,
+            updatedEntityId,
+        };
+    }
+    else {
+        entityUpdates[entityKey] = Object.assign(Object.assign({}, entityUpdate), { recommendations: recommendation });
+    }
+};
+const getEntityDetails = (entity, lineItemLocalData, vendorUpdates) => {
+    var _a, _b, _c;
+    if (entity != null) {
+        return {
+            entityId: (_a = entity.qboId) !== null && _a !== void 0 ? _a : entity.id,
+            entityType: entity.type,
+        };
+    }
+    if (lineItemLocalData.lineEntity != null) {
+        return {
+            entityId: (_b = lineItemLocalData.lineEntity.qboId) !== null && _b !== void 0 ? _b : lineItemLocalData.lineEntity.id,
+            entityType: lineItemLocalData.vendor != null ? 'vendor' : 'customer',
+        };
+    }
+    if (vendorUpdates != null && vendorUpdates.id != null) {
+        return {
+            entityId: vendorUpdates.id,
+            entityType: 'vendor',
+        };
+    }
+    if (((_c = lineItemLocalData.vendor) === null || _c === void 0 ? void 0 : _c.id) != null) {
+        return {
+            entityId: lineItemLocalData.vendor.id,
+            entityType: 'vendor',
+        };
+    }
+    return undefined;
+};

package/lib/view/expenseAutomationView/helpers/transactionCategorizationLocalDataHelper.d.ts

@@ -0,0 +1,8 @@
+import { ID } from '../../../commonStateTypes/common';
+import { AccountBase } from '../../../entity/account/accountState';
+import { ClassBase } from '../../../entity/class/classState';
+import { SupportedTransaction } from '../../../entity/transaction/transactionState';
+import { TransactionReviewLocalData, TransactionsTabViewState } from '../types/transactionsViewState';
+export declare const MAX_SELECTION_LIMIT = 5;
+export declare const toTransactionDetailLocalData: (transaction: SupportedTransaction) => TransactionReviewLocalData;
+export declare const toSetAllLineItemsToCategoryClass: (draft: TransactionsTabViewState, transaction: SupportedTransaction, transactionId: ID, transactionLineId: ID, transactionDetailLocalData: TransactionReviewLocalData, vendorId?: string | undefined, selectedAccount?: AccountBase | undefined, selectedClassBase?: ClassBase | undefined) => TransactionReviewLocalData;

package/lib/view/expenseAutomationView/helpers/transactionCategorizationLocalDataHelper.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSetAllLineItemsToCategoryClass = exports.toTransactionDetailLocalData = exports.MAX_SELECTION_LIMIT = void 0;
+const transactionDetailLocalDataHelper_1 = require("../../transactionDetail/transactionDetailLocalDataHelper");
+const transactionsViewState_1 = require("../types/transactionsViewState");
+exports.MAX_SELECTION_LIMIT = 5;
+const toTransactionDetailLocalData = (transaction) => {
+    const transactionLocal = Object.assign({}, transactionsViewState_1.initialSupportedTransactionCategorization.transactionReviewLocalData);
+    transactionLocal.memo = transaction.memo;
+    transactionLocal.transactionDate = transaction.date;
+    transactionLocal.transactionType = transaction.type;
+    transactionLocal.transactionTypeName = transaction.typeName;
+    transactionLocal.vendor =
+        transaction.vendorId != null && transaction.vendorName != null
+            ? {
+                id: transaction.vendorId,
+                name: transaction.vendorName,
+                logo: transaction.logo,
+            }
+            : undefined;
+    transactionLocal.vendorUpdates = undefined;
+    transactionLocal.lineItemById =
+        transaction.lines != null && transaction.lines.length > 0
+            ? buildLineItemById(transaction, transaction.recommendations)
+            : {};
+    return transactionLocal;
+};
+exports.toTransactionDetailLocalData = toTransactionDetailLocalData;
+const buildLineItemById = (transaction, recommendations) => {
+    const lineItemData = {};
+    const { lines } = transaction;
+    lines === null || lines === void 0 ? void 0 : lines.forEach((line) => {
+        var _a, _b;
+        if (line.type === 'transaction_with_account_and_class_line' ||
+            line.type === 'transaction_with_product_or_service_line' ||
+            line.type === 'journal_entry_transaction_line') {
+            const record = Object.assign(Object.assign({}, line), { lineId: line.id, transactionId: transaction.id, transactionDate: transaction.date, billable: line.billable, isCategoryMiscategorized: (_a = line
+                    .isCategoryMiscategorized) !== null && _a !== void 0 ? _a : false, isClassMiscategorized: (_b = line.isClassMiscategorized) !== null && _b !== void 0 ? _b : false });
+            const accountLine = line;
+            const lineId = line.id;
+            record.account = accountLine.account;
+            record.class = accountLine.class;
+            record.vendor =
+                accountLine.vendor != null
+                    ? {
+                        id: accountLine.vendor.id,
+                        name: accountLine.vendor.name,
+                        logo: accountLine.vendor.logo,
+                    }
+                    : undefined;
+            record.customer = accountLine.customer;
+            record.billable = accountLine.billable;
+            record.categorizationStatus = accountLine.categorizationStatus;
+            record.reviewPendingReasons = accountLine.reviewPendingReasons;
+            if (recommendations != null) {
+                record.recommendations = recommendations[lineId];
+            }
+            lineItemData[line.id] = record;
+            if (line.platformLineDetailType === 'deposit_line_detail') {
+                record.lineEntity = (0, transactionDetailLocalDataHelper_1.toLineEntity)(line);
+            }
+            if (line.type === 'transaction_with_product_or_service_line') {
+                const lineRecord = line;
+                record.item = lineRecord.item;
+                record.lineDetailType = lineRecord.lineDetailType;
+            }
+            if (line.type === 'journal_entry_transaction_line') {
+                const lineRecord = line;
+                record.lineTransactionType = lineRecord.lineTransactionType;
+                record.postingType = lineRecord.postingType;
+                record.postingTypeName = lineRecord.postingTypeName;
+                record.lineEntity = (0, transactionDetailLocalDataHelper_1.toLineEntity)(lineRecord);
+            }
+            lineItemData[line.id] = record;
+        }
+        if (line.type === 'linked_transaction_line') {
+            const linkedRecord = line;
+            lineItemData[line.id] = Object.assign(Object.assign({}, linkedRecord), { lineId: linkedRecord.id, transactionId: transaction.id, transactionDate: transaction.date, billable: 'billable', isCategoryMiscategorized: false, isClassMiscategorized: false });
+        }
+        if (line.type === 'transaction_info_line') {
+            const infoRecord = line;
+            lineItemData[line.id] = Object.assign(Object.assign({}, infoRecord), { lineId: infoRecord.id, transactionId: transaction.id, transactionDate: transaction.date, billable: 'billable', isCategoryMiscategorized: false, isClassMiscategorized: false });
+        }
+    });
+    return lineItemData;
+};
+const toSetAllLineItemsToCategoryClass = (draft, transaction, transactionId, transactionLineId, transactionDetailLocalData, vendorId, selectedAccount, selectedClassBase) => {
+    const newLineItems = {};
+    let selectedCheckBoxTransactionIds = draft.selectedCheckBoxTransactionIds;
+    if (transaction.lines != null) {
+        // always preserving the order of the line items. hence iterating over this
+        transaction.lines.forEach((line) => {
+            var _a, _b;
+            if (line.type === 'transaction_with_account_and_class_line' ||
+                line.type === 'transaction_with_product_or_service_line' ||
+                line.type === 'journal_entry_transaction_line') {
+                const lineId = line.id;
+                const record = Object.assign({}, transactionDetailLocalData.lineItemById[lineId]);
+                // if the line is the one that is being updated, then set the account and class
+                if (transactionId === record.transactionId &&
+                    transactionLineId === lineId) {
+                    record.account = selectedAccount;
+                    record.class = selectedClassBase;
+                    if (record.class != null && record.account != null) {
+                        if (selectedCheckBoxTransactionIds.length <= exports.MAX_SELECTION_LIMIT &&
+                            selectedCheckBoxTransactionIds.includes(transaction.id) === false) {
+                            selectedCheckBoxTransactionIds.push(transaction.id);
+                        }
+                    }
+                    else {
+                        if (selectedCheckBoxTransactionIds.includes(transaction.id) === true) {
+                            selectedCheckBoxTransactionIds =
+                                selectedCheckBoxTransactionIds.filter((id) => id !== transaction.id);
+                        }
+                    }
+                }
+                else {
+                    if ((transactionDetailLocalData.vendor != null &&
+                        transactionDetailLocalData.vendor.id === vendorId) ||
+                        (record.vendor != null && record.vendor.id === vendorId)) {
+                        // if the vendor is same, then set the account and class with the selected ones and add the transaction to the selected list
+                        if (((_a = record.account) === null || _a === void 0 ? void 0 : _a.qboId) == null) {
+                            record.account = selectedAccount;
+                            if (record.class != null &&
+                                selectedCheckBoxTransactionIds.length <= exports.MAX_SELECTION_LIMIT &&
+                                selectedCheckBoxTransactionIds.includes(transaction.id) ===
+                                    false) {
+                                selectedCheckBoxTransactionIds.push(transaction.id);
+                            }
+                        }
+                        if (((_b = record.class) === null || _b === void 0 ? void 0 : _b.qboId) == null) {
+                            record.class = selectedClassBase;
+                            if (record.account != null &&
+                                selectedCheckBoxTransactionIds.length <= exports.MAX_SELECTION_LIMIT &&
+                                selectedCheckBoxTransactionIds.includes(transaction.id) ===
+                                    false) {
+                                selectedCheckBoxTransactionIds.push(transaction.id);
+                            }
+                        }
+                    }
+                }
+                if (line.type === 'transaction_with_product_or_service_line') {
+                    const lineRecord = transactionDetailLocalData.lineItemById[lineId];
+                    record.item = lineRecord.item;
+                    record.lineDetailType = lineRecord.lineDetailType;
+                }
+                if (line.type === 'journal_entry_transaction_line') {
+                    const lineRecord = transactionDetailLocalData.lineItemById[lineId];
+                    record.lineTransactionType = lineRecord.lineTransactionType;
+                    record.postingType = lineRecord.postingType;
+                    record.postingTypeName = lineRecord.postingTypeName;
+                    record.lineEntity = (0, transactionDetailLocalDataHelper_1.toLineEntity)(lineRecord);
+                }
+                newLineItems[lineId] = record;
+            }
+            else {
+                newLineItems[line.id] = Object.assign({}, transactionDetailLocalData.lineItemById[line.id]);
+            }
+        });
+    }
+    const newLocalData = Object.assign(Object.assign({}, transactionsViewState_1.initialSupportedTransactionCategorization.transactionReviewLocalData), { memo: transactionDetailLocalData.memo, lineItemById: newLineItems, transactionDate: transactionDetailLocalData.transactionDate, transactionType: transactionDetailLocalData.transactionType, transactionTypeName: transactionDetailLocalData.transactionTypeName, vendor: transactionDetailLocalData.vendor, vendorUpdates: transactionDetailLocalData.vendorUpdates, vendorDetails: transactionDetailLocalData.vendorDetails });
+    if (transactionDetailLocalData.vendor != null &&
+        transactionDetailLocalData.vendor.id === vendorId) {
+        if (!checkIfAllLineItemsAreCategoryClassFilled(newLocalData)) {
+            selectedCheckBoxTransactionIds = selectedCheckBoxTransactionIds.filter((id) => id !== transaction.id);
+        }
+        draft.selectedCheckBoxTransactionIds = selectedCheckBoxTransactionIds;
+    }
+    return newLocalData;
+};
+exports.toSetAllLineItemsToCategoryClass = toSetAllLineItemsToCategoryClass;
+const checkIfAllLineItemsAreCategoryClassFilled = (transactionDetailLocalData) => {
+    const lineItems = Object.values(transactionDetailLocalData.lineItemById);
+    return lineItems.every((lineItem) => lineItem.account != null && lineItem.class != null);
+};

package/lib/view/expenseAutomationView/payload/transactionCategorizationPayload.d.ts

@@ -0,0 +1,48 @@
+import { EntityRecommendationPayload } from '../../../commonPayloadTypes/recommendationPayload';
+import { TransactionPayload } from '../../../entity/transaction/payloadTypes/transactionPayload';
+import { SupportedTransactionPayload } from '../../../entity/transaction/transactionState';
+import { ZeniAPIResponse } from '../../../responsePayload';
+export interface TransactionCategorizationQueryPayload {
+    auto_categorized: boolean;
+    page_token: string | null;
+    page_size: number;
+    start_date: string | null;
+    end_date: string | null;
+    sort_by: string;
+    sort_order: string;
+    search_text: string | null;
+}
+export interface TransactionCategorizationPayload {
+    transactions: SupportedTransactionPayload[];
+    total_count: number;
+    query: TransactionCategorizationQueryPayload;
+    next_page_token: string | null;
+}
+export declare type TransactionCategorizationResponse = ZeniAPIResponse<TransactionCategorizationPayload>;
+export interface EntityRelatedUpdatesPayload {
+    recommendations: EntityRecommendationPayload;
+    entity_id: string;
+    entity_type: string;
+    is_bulk_update: boolean;
+    updated_entity_id: string | undefined;
+}
+export interface UpdateTransactionCategorizationPayload {
+    transaction: Partial<TransactionPayload>;
+    entity_related_updates?: EntityRelatedUpdatesPayload[];
+    transaction_type: string;
+    transaction_id: string;
+}
+export interface UpdateTransactionCategorization {
+    transaction_id: string;
+    line_ids: string[];
+}
+interface UpdateTransactionCategorizationResponsePayload {
+    transactions_update_failed: UpdateTransactionCategorization[];
+    transactions_update_success: UpdateTransactionCategorization[];
+}
+export declare type TransactionCategorizationUpdateResponse = ZeniAPIResponse<UpdateTransactionCategorizationResponsePayload>;
+export interface MarkAsReviewTransactionCategorizationPayload {
+    transactions_reviewed: UpdateTransactionCategorization[];
+}
+export declare type MarkAsReviewTransactionCategorizationPayloadResponse = ZeniAPIResponse<MarkAsReviewTransactionCategorizationPayload>;
+export {};

package/lib/view/expenseAutomationView/payload/transactionCategorizationPayload.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/view/expenseAutomationView/reducers/transactionsViewReducer.d.ts

@@ -1,5 +1,103 @@
-import { TransactionsViewState } from '../types/transactionsViewState';
+import { TransactionsViewState, TransactionsTabViewState, SupportedTransactionCategorization, TransactionSaveUpdates, TransactionsTab, TransactionsViewUIState } from '../types/transactionsViewState';
+import { PageToken } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { ZeniAPIStatus } from '../../../responsePayload';
+import { FetchState, ID } from '../../../commonStateTypes/common';
+import { MonthYearPeriod, TimePeriod } from '../../../commonStateTypes/timePeriod';
+import { Recommendation } from '../../../commonStateTypes/recommendationBase';
+import { AccountBase } from '../../../entity/account/accountState';
+import { ClassBase } from '../../../entity/class/classState';
+import { Entity } from '../../../entity/genericEntity/entity';
+import { SupportedTransaction } from '../../../entity/transaction/transactionState';
+import { VendorBase } from '../../../entity/vendor/vendorState';
+import { UpdateTransactionCategorization } from '../payload/transactionCategorizationPayload';
+export declare const initialTransactionTabViewState: TransactionsTabViewState;
 export declare const initialState: TransactionsViewState;
-export declare const clearExpenseAutomationTransactionsView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const fetchTransactionCategorization: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[selectedTab: "review" | "autoCategorized", period: TimePeriod, cacheOverride?: any, keepExistingListItems?: any, searchString?: string | undefined, pageToken?: PageToken | undefined, refreshViewInBackground?: any], {
+    selectedTab: "review" | "autoCategorized";
+    period: TimePeriod;
+    searchString: string | undefined;
+    keepExistingListItems: any;
+    pageToken: PageToken | undefined;
+    cacheOverride: any;
+    refreshViewInBackground: any;
+}, string, never, never>, updateTransactionCategorizationUIState: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    selectedTab: TransactionsTab;
+    uiState: Partial<TransactionsViewUIState>;
+}, string>, initializeTransactionCategorizationViewLocalData: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[selectedTab: "review" | "autoCategorized", transactionIds: string[], selectedPeriod: MonthYearPeriod, keepExistingListItems: any, pageToken: PageToken, totalCount: number, refreshViewInBackground?: any], {
+    selectedTab: "review" | "autoCategorized";
+    transactionIds: string[];
+    selectedPeriod: MonthYearPeriod;
+    keepExistingListItems: any;
+    pageToken: PageToken;
+    totalCount: number;
+    refreshViewInBackground: any;
+}, string, never, never>, saveTransactionCategorizationLocalData: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    selectedTab: TransactionsTab;
+    transactionIds: ID[];
+    selectedPeriod: MonthYearPeriod;
+    keepExistingListItems: boolean;
+    transactionLocalData: Record<ID, SupportedTransactionCategorization>;
+    pageToken: PageToken;
+    totalCount: number;
+    refreshViewInBackground?: boolean | undefined;
+}, string>, fetchTransactionCategorizationFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    status: ZeniAPIStatus;
+    selectedPeriod: MonthYearPeriod;
+    selectedTab: TransactionsTab;
+}, string>, saveTransactionCategorization: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[selectedTab: "review" | "autoCategorized", transactionIds: string[]], {
+    selectedTab: "review" | "autoCategorized";
+    transactionIds: string[];
+}, string, never, never>, updateTransactionCategorization: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[selectedTab: "review" | "autoCategorized", transactionIds: string[], transactionSaveUpdates: TransactionSaveUpdates[]], {
+    selectedTab: "review" | "autoCategorized";
+    transactionIds: string[];
+    transactionSaveUpdates: TransactionSaveUpdates[];
+}, string, never, never>, updateTransactionCategorizationSaveStatus: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[selectedTab: "review" | "autoCategorized", fetchState: FetchState, error?: ZeniAPIStatus<Record<string, unknown>> | undefined], {
+    selectedTab: "review" | "autoCategorized";
+    fetchState: FetchState;
+    error: ZeniAPIStatus<Record<string, unknown>> | undefined;
+}, string, never, never>, markTransactionAsNotMiscategorized: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[selectedTab: "review" | "autoCategorized", transactionsInReview: UpdateTransactionCategorization[]], {
+    selectedTab: "review" | "autoCategorized";
+    transactionsInReview: UpdateTransactionCategorization[];
+}, string, never, never>, updateStatusForTransactionNotMiscategorizedUpdate: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[selectedTab: "review" | "autoCategorized", transactionIds: string[], selectedPeriod: MonthYearPeriod, fetchState: FetchState, error?: ZeniAPIStatus<Record<string, unknown>> | undefined], {
+    selectedPeriod: MonthYearPeriod;
+    transactionIds: string[];
+    selectedTab: "review" | "autoCategorized";
+    fetchState: FetchState;
+    error: ZeniAPIStatus<Record<string, unknown>> | undefined;
+}, string, never, never>, updateSelectedVendorForTransaction: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    selectedTab: TransactionsTab;
+    transactionId: ID;
+    lineId: ID;
+    selectedTransaction: SupportedTransaction;
+    updatedVendor?: VendorBase | undefined;
+}, string>, setAllItemsToCategoryClassInLocalDataForCategorization: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[selectedTab: "review" | "autoCategorized", transactionId: string, lineId: string, transactions: SupportedTransaction[], vendorId?: string | undefined, selectedAccount?: AccountBase | undefined, selectedClassBase?: ClassBase | undefined, lineEntity?: Entity | undefined, recommendations?: Recommendation[] | undefined], {
+    selectedTab: "review" | "autoCategorized";
+    transactionId: string;
+    lineId: string;
+    transactions: SupportedTransaction[];
+    vendorId: string | undefined;
+    lineEntity: Entity | undefined;
+    selectedAccount: AccountBase | undefined;
+    selectedClassBase: ClassBase | undefined;
+    recommendations: Recommendation[] | undefined;
+}, string, never, never>, updateTotalCountForTransactionCategorization: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    selectedTab: TransactionsTab;
+    totalCount: number;
+}, string>, fetchTransactionCategorizationSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    status: ZeniAPIStatus;
+    selectedTab: TransactionsTab;
+    refreshViewInBackground?: boolean | undefined;
+}, string>, fetchTransactionCategorizationView: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[selectedTab: "review" | "autoCategorized", period: TimePeriod, cacheOverride?: any, keepExistingListItems?: any, searchString?: string | undefined, pageToken?: PageToken | undefined, refreshViewInBackground?: any], {
+    selectedTab: "review" | "autoCategorized";
+    period: TimePeriod;
+    searchString: string | undefined;
+    keepExistingListItems: any;
+    pageToken: PageToken | undefined;
+    cacheOverride: any;
+    refreshViewInBackground: any;
+}, string, never, never>, updateSelectedCheckboxTransactionIds: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    selectedTab: TransactionsTab;
+    transactionIds: ID[];
+}, string>, clearExpenseAutomationTransactionsViewPerTabView: import("@reduxjs/toolkit").ActionCreatorWithPayload<"review" | "autoCategorized", string>, clearExpenseAutomationTransactionsView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
 declare const _default: import("@reduxjs/toolkit").Reducer<TransactionsViewState, import("@reduxjs/toolkit").AnyAction>;
 export default _default;