@zeniai/client-epic-state 4.17.64 → 4.17.65

package/lib/view/tagView/tagViewState.d.ts

@@ -1,6 +1,6 @@
 import { FetchStateAndError, FetchedState, ID } from '../../commonStateTypes/common';
 export interface TagViewState extends FetchedState {
-    tagsId: ID[];
     tagCreateStatus: FetchStateAndError;
     tagDeleteStatusById: Record<ID, FetchStateAndError>;
+    tagsId: ID[];
 }

package/lib/view/taskManager/taskDetailView/taskDetail.d.ts

@@ -4,38 +4,38 @@ import { ZeniDate } from '../../../zeniDayJS';
 import { RecurringDatePickerOptions, RecurringFrequencyType } from '../../common/recurringViewHelper';
 import { CommonHistoryView } from '../../spendManagement/commonHistoryView/commonHistory';
 export interface TaskDetailViewState {
-    newTaskState: EditTaskDetail;
     editTaskStateById: Record<ID, EditTaskDetail>;
+    newTaskState: EditTaskDetail;
     taskHistoryById: Record<ID, CommonHistoryView>;
 }
 export interface EditTaskDetail {
-    taskDetailLocalData: EditTaskLocalData;
-    saveStatus: FetchStateAndError;
     archiveStatus: FetchStateAndError;
-    fetchTaskStatus: FetchStateAndError;
     deleteTaskStatus: FetchStateAndError;
+    fetchTaskStatus: FetchStateAndError;
+    saveStatus: FetchStateAndError;
+    taskDetailLocalData: EditTaskLocalData;
     taskId?: ID;
 }
 export interface EditTaskLocalData {
-    name: string;
-    description: string;
-    status: TaskStatusCodeType;
     assignee: ID[];
-    tagIds: ID[];
+    description: string;
+    fileIds: ID[];
+    name: string;
     priority: PriorityCodeType;
-    type: TaskType;
     recurringEndDateLocalData: {
+        recurringCount?: number;
         recurringDatePickerOptionsType?: RecurringDatePickerOptions;
         recurringEndDate?: ZeniDate;
-        recurringCount?: number;
     };
-    fileIds: ID[];
+    status: TaskStatusCodeType;
+    tagIds: ID[];
     timeSpent: string;
-    savedRecurringEndDate?: ZeniDate;
-    savedRecurringTasksCount?: number;
+    type: TaskType;
+    dueDate?: ZeniDate;
     recurringFrequency?: RecurringFrequencyType;
     recurringStartDate?: ZeniDate;
-    dueDate?: ZeniDate;
+    savedRecurringEndDate?: ZeniDate;
+    savedRecurringTasksCount?: number;
 }
 export declare const initialTaskDetailLocalData: EditTaskLocalData;
 export declare const initialTaskDetail: EditTaskDetail;

package/lib/view/taskManager/taskDetailView/taskDetailReducer.d.ts

@@ -12,8 +12,8 @@ export declare const fetchTaskDetailPage: import("@reduxjs/toolkit").ActionCreat
 }, "taskDetailView/fetchTaskDetail", never, never>, initializeTaskToLocalStore: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskId: string], {
     taskId: string;
 }, "taskDetailView/initializeTaskToLocalStore", never, never>, updateEditTaskFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
-    taskId: ID;
     fetchState: FetchState;
+    taskId: ID;
     error?: ZeniAPIStatus;
 }, "taskDetailView/updateEditTaskFetchStatus">, saveTaskUpdatesToLocalStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     taskDetailLocalData: EditTaskLocalData;
@@ -31,24 +31,24 @@ export declare const fetchTaskDetailPage: import("@reduxjs/toolkit").ActionCreat
     error?: ZeniAPIStatus;
 }, "taskDetailView/archiveTaskSuccessOrFailure">, saveTaskSuccessOrFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     fetchState: FetchState;
+    error?: ZeniAPIStatus;
     newTaskId?: ID;
     taskId?: ID;
-    error?: ZeniAPIStatus;
 }, "taskDetailView/saveTaskSuccessOrFailure">, deleteTask: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskId?: string | undefined], {
     taskId: string | undefined;
 }, "taskDetailView/deleteTask", never, never>, removeTaskDetail: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "taskDetailView/removeTaskDetail">, deleteTaskSuccessOrFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     fetchState: FetchState;
-    taskId?: ID;
     error?: ZeniAPIStatus;
+    taskId?: ID;
 }, "taskDetailView/deleteTaskSuccessOrFailure">, fetchTaskHistory: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskId: string, cacheOverride?: any], {
     taskId: string;
     cacheOverride: any;
 }, "taskDetailView/fetchTaskHistory", never, never>, updateTaskHistory: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
-    taskId: ID;
     historicEventsPayload: HistoricEventPayload[];
-}, "taskDetailView/updateTaskHistory">, updateTaskHistoryFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     taskId: ID;
+}, "taskDetailView/updateTaskHistory">, updateTaskHistoryFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     fetchState: FetchState;
+    taskId: ID;
     error?: ZeniAPIStatus;
 }, "taskDetailView/updateTaskHistoryFetchStatus">, clearTaskDetail: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"taskDetailView/clearTaskDetail">, updateCreatedTagToLocalStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     tagId: ID;

package/lib/view/taskManager/taskDetailView/taskDetailSelector.d.ts

@@ -9,14 +9,14 @@ import { HistoricEvent } from '../../spendManagement/commonHistoryView/commonHis
 import { UserListSelectorView } from '../../userListView/userListViewSelector';
 import { EditTaskDetail } from './taskDetail';
 export interface TaskDetailSelectorView extends SelectorView {
-    taskDetailView: EditTaskDetail;
-    userList: UserListSelectorView;
     allAccountingClasses: Class[];
     deleteFileStatusById: Record<ID, FetchStateAndError | undefined>;
-    updateFileStatusById: Record<ID, FetchStateAndError | undefined>;
     files: File[];
-    taskHistory: HistoricEvent[];
     showTaskDetailFormFooter: boolean;
+    taskDetailView: EditTaskDetail;
+    taskHistory: HistoricEvent[];
+    updateFileStatusById: Record<ID, FetchStateAndError | undefined>;
+    userList: UserListSelectorView;
     createdByUser?: UserAndRole;
 }
 export declare const getTaskDetail: (state: RootState, taskId?: ID) => TaskDetailSelectorView;

package/lib/view/taskManager/taskGroupTemplateView/taskGroupTemplateViewPayload.d.ts

@@ -7,8 +7,8 @@ export interface FetchTaskGroupTemplatesPayload {
 }
 export type FetchTaskGroupTemplatesResponse = ZeniAPIResponse<FetchTaskGroupTemplatesPayload>;
 interface CreateTaskFromTaskGroupTemplatePayload {
-    tasks: TaskPayload[];
     groups: TaskGroupPayload[];
+    tasks: TaskPayload[];
 }
 export type CreateTaskFromTaskGroupTemplateResponse = ZeniAPIResponse<CreateTaskFromTaskGroupTemplatePayload>;
 export {};

package/lib/view/taskManager/taskGroupTemplateView/taskGroupTemplateViewState.d.ts

@@ -1,5 +1,5 @@
 import { FetchStateAndError, FetchedState, ID } from '../../../commonStateTypes/common';
 export interface TaskGroupTemplateViewState extends FetchedState {
-    taskGroupTemplateIds: ID[];
     createTaskFetchState: FetchStateAndError;
+    taskGroupTemplateIds: ID[];
 }

package/lib/view/taskManager/taskGroupView/taskGroupViewState.d.ts

@@ -1,7 +1,7 @@
 import { FetchStateAndError, FetchedState, ID } from '../../../commonStateTypes/common';
 export interface TaskGroupViewState extends FetchedState {
-    taskGroupsIds: ID[];
     taskGroupCreationStatus: FetchStateAndError;
     taskGroupDeleteStatus: FetchStateAndError;
+    taskGroupsIds: ID[];
     taskGroupUpdateStatus: FetchStateAndError;
 }

package/lib/view/taskManager/taskListView/epics/bulkUpdateTaskListEpic.d.ts

@@ -12,21 +12,21 @@ export declare const bulkUpdateTaskListEpic: (actions$: ActionsObservable<Action
  * Helpers
  */
 interface UpdateTaskPayload {
-    task_id: string;
-    name: string;
     assignees: string[];
     description: string;
     due_date: string | null;
-    priority: string;
-    status: string;
-    tags: string[];
-    type: string;
     file_ids: ID[];
+    name: string;
+    priority: string;
     recurring_end_date: string | null;
     recurring_frequency: string | null;
     recurring_start_date: string | null;
+    status: string;
+    tags: string[];
     task_group_ids: string[];
+    task_id: string;
     time_spent: number;
+    type: string;
 }
 export declare const getTasksListPayload: (state: RootState, taskIds: ID[], updates: Partial<Task>) => UpdateTaskPayload[];
 export declare const getTaskPayload: (state: RootState, taskId: ID, updates: Partial<Task>) => UpdateTaskPayload;

package/lib/view/taskManager/taskListView/taskList.d.ts

@@ -4,30 +4,30 @@ import { ZeniDate } from '../../../zeniDayJS';
 import { SpendManagementUIState } from '../../spendManagement/billPay/billList/billListState';
 import { CategoryCombinationOperator, FilterCategoryType } from '../../spendManagement/spendManagementFilterHelpers';
 export interface TaskListLocalData {
+    defaultTaskGroupId: ID | null;
+    existingTaskGroupNamesByGroupId: Record<ID, string>;
     newTaskGroupName: string;
     selectedTaskIds: ID[];
-    existingTaskGroupNamesByGroupId: Record<ID, string>;
-    defaultTaskGroupId: ID | null;
 }
 export declare const DUE_DATE_GROUP_KEYS: readonly ["overdue", "today", "this_week", "this_month", "upcoming"];
 export declare const toDueDateGroupKeyType: (v: string) => "overdue" | "today" | "this_week" | "this_month" | "upcoming";
 export declare type DueDateGroupKey = ReturnType<typeof toDueDateGroupKeyType>;
 export interface TaskListState extends FetchedState {
+    filters: TaskListFilters;
+    localData: TaskListLocalData;
     taskIds: ID[];
+    taskIdsByAssignees: Record<ID, ID[]>;
+    taskIdsByDueDate: Record<DueDateGroupKey, ID[]>;
     taskIdsByGroupsIds: Record<ID, ID[]>;
     taskIdsByPriority: Record<PriorityCodeType, ID[]>;
     taskIdsByStatus: Record<TaskStatusCodeType, ID[]>;
-    taskIdsByAssignees: Record<ID, ID[]>;
-    taskIdsByDueDate: Record<DueDateGroupKey, ID[]>;
     taskIdsByTags: Record<ID, ID[]>;
     uiState: TaskListUIState;
-    filters: TaskListFilters;
-    localData: TaskListLocalData;
     updateTasksFetchState: FetchStateAndError;
 }
 export interface TaskListFilters {
-    categoryCombinationOperator: CategoryCombinationOperator;
     categories: TaskFilterCategory[];
+    categoryCombinationOperator: CategoryCombinationOperator;
 }
 export interface TaskFilterCategory {
     field: TaskListFilterCategoryField;
@@ -41,9 +41,9 @@ export declare const toTaskListGroupByKeyType: (v: string) => "status" | "dueDat
 export declare const toTaskListGroupByKeyTypeStrict: (v: string) => "status" | "dueDate" | "groupName" | "tag" | "priority" | "assignee" | undefined;
 export declare type TaskGroupKey = ReturnType<typeof toTaskListGroupByKeyType>;
 export interface TaskListUIState extends SpendManagementUIState {
-    sortKey: TaskListViewSortKey;
-    searchText: string;
     groupByKey: TaskGroupKey;
+    searchText: string;
+    sortKey: TaskListViewSortKey;
 }
 declare const toTaskListSortKeyType: (v: string) => "status" | "dueDate" | "name" | "tag" | "priority" | "timeSpent" | "assignee" | "creationDate";
 export declare type TaskListViewSortKey = ReturnType<typeof toTaskListSortKeyType>;

package/lib/view/taskManager/taskListView/taskListReducer.d.ts

@@ -28,8 +28,8 @@ export declare const fetchTaskListPage: import("@reduxjs/toolkit").ActionCreator
     updates: Partial<Task>;
     groupId: string;
 }, "taskList/bulkUpdateTaskList", never, never>, updateTasksListOnBulkUpdateTasksSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
-    taskIds: ID[];
     groupId: ID | null;
+    taskIds: ID[];
 }, "taskList/updateTasksListOnBulkUpdateTasksSuccess">, updateTasksListOnBulkUpdateTasksFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     error: ZeniAPIStatus;
 }, "taskList/updateTasksListOnBulkUpdateTasksFailure">, initiateTaskListLocalData: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
@@ -46,8 +46,8 @@ export declare const fetchTaskListPage: import("@reduxjs/toolkit").ActionCreator
     taskGroupId: ID;
     currentTaskState?: Task;
 }, "taskList/updateTaskListOnNewTaskCreationSuccess">, updateTaskListOnTaskGroupNameUpdate: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
-    taskGroupName: ID;
     taskGroupId: ID;
+    taskGroupName: ID;
 }, "taskList/updateTaskListOnTaskGroupNameUpdate">, updateTaskFromListView: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     task: Task;
     updates: Partial<Task>;

package/lib/view/taskManager/taskListView/taskListSelector.d.ts

@@ -16,29 +16,29 @@ export interface TaskWithUserDetails extends Task {
 export interface TaskGroupWithTasksList {
     groupName: string;
     id: string;
-    tasks: TaskWithUserDetails[];
     isDefault: boolean;
+    tasks: TaskWithUserDetails[];
 }
 export interface TaskListSelectorView extends SelectorView {
-    taskGroupsWithTasksList: TaskGroupWithTasksList[];
-    uiState: TaskListUIState;
     filters: TaskListFilters;
-    userList: UserListSelectorView;
     localData: TaskListLocalData;
-    taskGroupTemplates: TaskGroupTemplate[];
-    updateTasksFetchState: FetchStateAndError;
+    taskCreationFromTemplateStatus: FetchStateAndError;
+    taskGroupCreationStatus: FetchStateAndError;
     taskGroupDeleteStatus: FetchStateAndError;
+    taskGroupsWithTasksList: TaskGroupWithTasksList[];
+    taskGroupTemplates: TaskGroupTemplate[];
     taskGroupUpdateStatus: FetchStateAndError;
-    taskGroupCreationStatus: FetchStateAndError;
-    taskCreationFromTemplateStatus: FetchStateAndError;
+    uiState: TaskListUIState;
+    updateTasksFetchState: FetchStateAndError;
+    userList: UserListSelectorView;
 }
 export declare const getTaskListGroupedByAssignees: ({ taskListState, taskState, userState, userRoleState, addressState, tagState, }: {
+    addressState: AddressState;
+    tagState: TagState;
     taskListState: TaskListState;
     taskState: TaskState;
-    userState: UserState;
     userRoleState: UserRoleState;
-    addressState: AddressState;
-    tagState: TagState;
+    userState: UserState;
 }) => {
     groupName: string;
     id: string;
@@ -46,12 +46,12 @@ export declare const getTaskListGroupedByAssignees: ({ taskListState, taskState,
     tasks: TaskWithUserDetails[];
 }[];
 export declare const getTaskListGroupedByPriority: ({ taskListState, taskState, userState, userRoleState, addressState, tagState, }: {
+    addressState: AddressState;
+    tagState: TagState;
     taskListState: TaskListState;
     taskState: TaskState;
-    userState: UserState;
     userRoleState: UserRoleState;
-    addressState: AddressState;
-    tagState: TagState;
+    userState: UserState;
 }) => {
     groupName: string;
     id: "urgent" | "high" | "normal" | "medium" | "low";

package/lib/view/tasksCard/tasksCardPayload.d.ts

@@ -1,10 +1,10 @@
 import { ReportPayload } from '../../commonPayloadTypes/viewAndReportPayload';
 import { ZeniReportResponse } from '../../responsePayload';
 export interface TasksCardPayload extends ReportPayload {
-    is_uncategorized_income_transactions_exist: boolean;
+    is_uncategorized_expense_account_identified: boolean;
     is_uncategorized_expenses_transactions_exist: boolean;
     is_uncategorized_income_account_identified: boolean;
-    is_uncategorized_expense_account_identified: boolean;
+    is_uncategorized_income_transactions_exist: boolean;
     num_of_bills_pending_approval: number;
     num_of_reimbursements_pending_approval: number;
 }

package/lib/view/tasksCard/tasksCardSelector.d.ts

@@ -7,12 +7,12 @@ export declare const getTasksCardReport: (state: RootState) => {
     fetchState: import("../..").FetchState;
     firstMonthOfFY: 1 | 3 | 12 | 2 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
     tasks: {
+        isUncategorizedExpenseAccountIdentified: boolean;
+        isUncategorizedExpensesTransactionsExist: boolean;
+        isUncategorizedIncomeAccountIdentified: boolean;
         isUncategorizedIncomeTransactionsExist: boolean;
         numOfBillsPendingApproval: number;
         numOfReimbursementsPendingApproval: number;
-        isUncategorizedExpensesTransactionsExist: boolean;
-        isUncategorizedIncomeAccountIdentified: boolean;
-        isUncategorizedExpenseAccountIdentified: boolean;
     };
     showCard: boolean;
     isMulti: boolean;

package/lib/view/tasksCard/tasksCardState.d.ts

@@ -2,12 +2,12 @@ import { FetchedState } from '../../commonStateTypes/common';
 import { Report } from '../../commonStateTypes/viewAndReport/viewAndReport';
 export interface TasksCardState extends FetchedState, Report {
     tasks: {
+        isUncategorizedExpenseAccountIdentified: boolean;
+        isUncategorizedExpensesTransactionsExist: boolean;
+        isUncategorizedIncomeAccountIdentified: boolean;
         isUncategorizedIncomeTransactionsExist: boolean;
         numOfBillsPendingApproval: number;
         numOfReimbursementsPendingApproval: number;
-        isUncategorizedExpensesTransactionsExist: boolean;
-        isUncategorizedIncomeAccountIdentified: boolean;
-        isUncategorizedExpenseAccountIdentified: boolean;
     };
 }
 export type TaskCardKeysType = 'isUncategorizedIncomeTransactionsExist' | 'numOfBillsPendingApproval' | 'numOfReimbursementsPendingApproval' | 'isUncategorizedExpensesTransactionsExist' | 'isUncategorizedIncomeAccountIdentified' | 'isUncategorizedExpenseAccountIdentified';

package/lib/view/topEx/topExPayload.d.ts

@@ -8,13 +8,13 @@ export interface AccountBalancePayload {
 }
 export interface TopExpensePayload {
     accounts: AccountBalancePayload[];
-    total: number;
-    start_date: string;
-    end_date: string;
-    time_period_label: string;
-    time_period: string;
     currency_code: string;
     currency_symbol: string;
+    end_date: string;
+    start_date: string;
+    time_period: string;
+    time_period_label: string;
+    total: number;
 }
 export interface TopExPayload extends ReportPayload {
     accounts: AccountPayload[];

package/lib/view/topEx/topExSelectorTypes.d.ts

@@ -8,28 +8,28 @@ import { ZeniDate } from '../../zeniDayJS';
 import { ZeniUrl as Url } from '../../zeniUrl';
 import { TopExTimePeriod } from './topExState';
 export interface TopExAccount {
+    accountDescription: string;
     accountId: ID;
     accountName: string;
-    accountDescription: string;
     balance: Balance;
-    accountType?: AccountType;
     accountSubType?: string;
+    accountType?: AccountType;
     logo?: Url;
 }
 export interface TopExTimePeriodWithMetaData {
     timePeriod: TopExTimePeriod;
-    timePeriodLabel?: string;
-    startDate?: ZeniDate;
     endDate?: ZeniDate;
+    startDate?: ZeniDate;
+    timePeriodLabel?: string;
 }
 export interface TopExpenses extends TopExTimePeriodWithMetaData {
-    itemOrder: EntityOrder;
     accountsOrdered: TopExAccount[];
+    itemOrder: EntityOrder;
     total?: Amount;
 }
 export interface TopExReport extends SelectorReport {
-    topExTimePeriod: TopExTimePeriod;
-    topExpenses: TopExpenses;
     allTimePeriods: TopExTimePeriodWithMetaData[];
     downloadState: FetchState;
+    topExpenses: TopExpenses;
+    topExTimePeriod: TopExTimePeriod;
 }

package/lib/view/topEx/topExState.d.ts

@@ -11,15 +11,15 @@ export interface AccountBalance {
     balance: Balance;
 }
 export interface TopExpense {
-    total: Amount;
-    startDate: ZeniDate;
+    accountBalances: AccountBalance[];
     endDate: ZeniDate;
+    startDate: ZeniDate;
     timePeriod: TopExTimePeriod;
     timePeriodLabel: string;
-    accountBalances: AccountBalance[];
+    total: Amount;
 }
 export interface TopExState extends FetchedState, Report {
-    topExTimePeriod: TopExTimePeriod;
-    topExpenses: TopExpense[];
     downloadState: FetchState;
+    topExpenses: TopExpense[];
+    topExTimePeriod: TopExTimePeriod;
 }

package/lib/view/transactionDetail/transactionDetailLocalDataHelper.js

@@ -185,13 +185,14 @@ const buildLineItemById = (transaction, uncategorizedIncomeExpense, recommendati
                     record.isRetainedClassSelected = false;
                 }
                 if (Boolean((_e = record.account) === null || _e === void 0 ? void 0 : _e.qboId) === false ||
-                    (0, exports.isAccountUncategorized)(uncategorizedIncomeExpense, (_f = accountLine.account) === null || _f === void 0 ? void 0 : _f.qboId) === true &&
-                        Boolean(recommendedAccount === null || recommendedAccount === void 0 ? void 0 : recommendedAccount.qboId)) {
+                    ((0, exports.isAccountUncategorized)(uncategorizedIncomeExpense, (_f = accountLine.account) === null || _f === void 0 ? void 0 : _f.qboId) === true &&
+                        Boolean(recommendedAccount === null || recommendedAccount === void 0 ? void 0 : recommendedAccount.qboId))) {
                     const _k = recommendedAccount || {}, { accountNameConfidence } = _k, recommendedAccountWithoutCOT = __rest(_k, ["accountNameConfidence"]);
                     void accountNameConfidence;
                     record.account = Object.assign(Object.assign({}, recommendedAccountWithoutCOT), { isPreFilled: true });
                 }
-                if (Boolean((_g = record.class) === null || _g === void 0 ? void 0 : _g.qboId) === false && Boolean(recommendedClass === null || recommendedClass === void 0 ? void 0 : recommendedClass.qboId)) {
+                if (Boolean((_g = record.class) === null || _g === void 0 ? void 0 : _g.qboId) === false &&
+                    Boolean(recommendedClass === null || recommendedClass === void 0 ? void 0 : recommendedClass.qboId)) {
                     const _l = recommendedClass || {}, { accountingClassNameConfidence } = _l, recommendedClassWithoutCOT = __rest(_l, ["accountingClassNameConfidence"]);
                     void accountingClassNameConfidence;
                     record.class = Object.assign(Object.assign({}, recommendedClassWithoutCOT), { isPreFilled: true });

package/lib/view/transactionDetail/transactionDetailPayload.d.ts

@@ -4,26 +4,26 @@ import { SupportedTransactionPayload } from '../../entity/transaction/transactio
 import { VendorPayload } from '../../entity/vendor/vendorPayload';
 import { ZeniAPIResponse } from '../../responsePayload';
 interface TransactionDetailPayload {
-    transaction: SupportedTransactionPayload;
     query: {
         transaction_id: string;
         transaction_type: string;
     };
     query_definitions: Record<string, unknown>;
+    transaction: SupportedTransactionPayload;
     vendors?: VendorPayload[];
 }
 export type TransactionDetailResponse = ZeniAPIResponse<TransactionDetailPayload>;
 export interface EntityRelatedUpdatesPayload {
-    recommendations: EntityRecommendationPayload;
     entity_id: string;
     entity_type: string;
     is_bulk_update: boolean;
+    recommendations: EntityRecommendationPayload;
     updated_entity_id: string | undefined;
 }
 export interface UpdateTransactionDetailPayload {
     transaction: Partial<TransactionPayload>;
-    transaction_type: string;
     transaction_id: string;
+    transaction_type: string;
     entity_related_updates?: EntityRelatedUpdatesPayload[];
 }
 interface UpdateTransactionDetailResponsePayload {
@@ -32,8 +32,8 @@ interface UpdateTransactionDetailResponsePayload {
 }
 export type TransactionDetailUpdateResponse = ZeniAPIResponse<UpdateTransactionDetailResponsePayload>;
 interface DeleteTransactionAttachmentResponsePayload {
-    message: string;
     deleted_filenames: string[];
+    message: string;
 }
 export type TransactionAttachmentDeleteResponse = ZeniAPIResponse<DeleteTransactionAttachmentResponsePayload>;
 export {};

package/lib/view/transactionDetail/transactionDetailReducer.d.ts

@@ -55,17 +55,17 @@ export declare const downloadAccountingProviderAttachment: import("@reduxjs/tool
     fetchState: FetchState;
     error: ZeniAPIStatus<Record<string, unknown>> | undefined;
 }, "transactionDetail/updateStatusForTransactionNotMiscategorizedUpdate", never, never>, updateStatusConsolidatedSaveTransactionDetail: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
-    transactionId: TransactionID;
     fetchState: FetchState;
+    transactionId: TransactionID;
 }, "transactionDetail/updateStatusConsolidatedSaveTransactionDetail">, updateTransactionStateIfUpdateActionNotAllowed: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     transactionId: TransactionID;
 }, "transactionDetail/updateTransactionStateIfUpdateActionNotAllowed">, saveTransactionDetail: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
-    transactionId: TransactionID;
     isExpenseAutomationEnabled: boolean;
+    transactionId: TransactionID;
 }, "transactionDetail/saveTransactionDetail">, initializeTransactionDetailLocalData: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     transactionId: TransactionID;
-    vendorId?: ID;
     customerId?: ID;
+    vendorId?: ID;
 }, "transactionDetail/initializeTransactionDetailLocalData">, saveTransactionDetailLocalData: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     transactionId: TransactionID;
     transactionLocalData: TransactionDetailLocalData;
@@ -121,8 +121,8 @@ export declare const downloadAccountingProviderAttachment: import("@reduxjs/tool
     entity?: Entity;
     resetRecommendations?: boolean;
 }, "transactionDetail/updateSelectedVendor">, updateSelectedCustomer: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
-    transactionId: TransactionID;
     customerUpdates: TransactionVendorUpdates;
+    transactionId: TransactionID;
     entity?: Entity;
     resetRecommendations?: boolean;
 }, "transactionDetail/updateSelectedCustomer">, resetVendor: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
@@ -130,8 +130,8 @@ export declare const downloadAccountingProviderAttachment: import("@reduxjs/tool
 }, "transactionDetail/resetVendor">, resetSelectedCustomer: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     transactionId: TransactionID;
 }, "transactionDetail/resetSelectedCustomer">, updateLocalDataWithTransactionsUpdateWithVendorCheckbox: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
-    transactionId: TransactionID;
     isUpdateEnabled: boolean;
+    transactionId: TransactionID;
 }, "transactionDetail/updateLocalDataWithTransactionsUpdateWithVendorCheckbox">, updateVendorToAllLineItems: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionId: TransactionID, transaction: SupportedTransaction, entity: Entity], {
     transactionId: TransactionID;
     transaction: SupportedTransaction;
@@ -141,9 +141,9 @@ export declare const downloadAccountingProviderAttachment: import("@reduxjs/tool
     transaction: SupportedTransaction;
     lineIdToRetainVendorSelection: string;
 }, "transactionDetail/resetAllLineItemsToVendor", never, never>, updateLatestSelectedEntity: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
-    transactionId: TransactionID;
-    lineId: ID;
     entity: Entity;
+    lineId: ID;
+    transactionId: TransactionID;
 }, "transactionDetail/updateLatestSelectedEntity">, updateVendorBulkRecommendationsFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionId: TransactionID, fetchState: FetchState, error?: ZeniAPIStatus<Record<string, unknown>> | undefined], {
     transactionId: TransactionID;
     fetchState: FetchState;

package/lib/view/transactionDetail/transactionDetailSelector.d.ts

@@ -11,15 +11,15 @@ import { AccountListSelectorView } from '../accountList/accountListSelector';
 import { ClassListSelectorView } from '../classList/classListSelector';
 import { TransactionDetailLocalData } from './transactionDetailTypes';
 export interface TransactionDetailReport extends SelectorView {
-    transactionDetailUpdateStatus: FetchStateAndError;
-    deleteStatusByAttachmentName: Record<string, FetchStateAndError>;
-    linkedTransactions: SupportedTransactionWithCOT[];
     accountList: AccountListSelectorView;
-    classList: ClassListSelectorView;
-    transactionDetailLocalData: TransactionDetailLocalData;
     accountsHierarchyList: NestedAccountHierarchyForReport[];
-    classHierarchyList: NestedClassHierarchyForReport[];
     allVendors: Vendor[];
+    classHierarchyList: NestedClassHierarchyForReport[];
+    classList: ClassListSelectorView;
+    deleteStatusByAttachmentName: Record<string, FetchStateAndError>;
+    linkedTransactions: SupportedTransactionWithCOT[];
+    transactionDetailLocalData: TransactionDetailLocalData;
+    transactionDetailUpdateStatus: FetchStateAndError;
     isUpdateNotAllowed?: boolean;
     transaction?: SupportedTransactionWithCOT;
 }
@@ -30,6 +30,6 @@ export declare const getTransactionDetail: (state: RootState, transactionId: Tra
 export declare function getTransactionDetailForTransaction(rootState: RootState, transactionId: TransactionID): TransactionDetailReport | undefined;
 export declare const getInitialUpdatablePeriodsForTransactionRecommendations: (companyIncorporationDate?: ZeniDate, bookCloseDate?: ZeniDate) => {
     minDate: ZeniDate;
-    startDate?: ZeniDate;
     endDate?: ZeniDate;
+    startDate?: ZeniDate;
 };

package/lib/view/transactionDetail/transactionDetailState.d.ts

@@ -22,18 +22,18 @@ export declare const getThirdPartyIdFromTransactionId: (transactionId: Transacti
 export declare const getActualTransactionID: (zeniGeneratedId: string) => string;
 export declare function getAllLinkedTransactions(transaction: Transaction): TransactionID[];
 export interface SupportedTransactionDetail extends FetchedState {
+    deleteStatusByAttachmentName: Record<string, FetchStateAndError>;
+    transactionDetailLocalData: TransactionDetailLocalData;
     transactionDetailUpdateStatus: {
-        consolidatedFetchState: FetchState;
-        saveStatus: FetchStateAndError;
         bulkUpdateStatus: FetchStateAndError;
-        recommendationUpdateStatus: FetchStateAndError;
+        consolidatedFetchState: FetchState;
         markAsNotMiscatStatus: FetchStateAndError;
+        recommendationUpdateStatus: FetchStateAndError;
+        saveStatus: FetchStateAndError;
     };
-    transactionDetailLocalData: TransactionDetailLocalData;
-    deleteStatusByAttachmentName: Record<string, FetchStateAndError>;
-    transactionId?: TransactionID;
-    isUpdateNotAllowed?: boolean;
     attachments?: AccountingProviderAttachment;
+    isUpdateNotAllowed?: boolean;
+    transactionId?: TransactionID;
 }
 interface AccountingProviderAttachment {
     blobs: [];
@@ -41,37 +41,37 @@ interface AccountingProviderAttachment {
 }
 export declare const initialSupportedTransactionDetail: SupportedTransactionDetail;
 export interface TransactionDetailState {
-    transactionDetailById: Record<TransactionDetailKey, SupportedTransactionDetail | undefined>;
     accountingProviderAttachment: {
         attachmentDataByID: Record<ID, ArrayBuffer>;
         fetchState: FetchState;
     };
+    transactionDetailById: Record<TransactionDetailKey, SupportedTransactionDetail | undefined>;
 }
 export interface TransactionLineUpdates {
-    class?: ClassBase;
     account?: AccountBase;
-    lineDescription?: string;
+    class?: ClassBase;
     customer?: CustomerBase;
-    vendor?: VendorBase;
+    lineDescription?: string;
     recommendation?: Recommendation[];
+    vendor?: VendorBase;
 }
 export interface TransactionUpdates {
     updatesByLineId: Record<ID, TransactionLineUpdates>;
+    customerId?: ID;
     memo?: string;
     vendorId?: ID;
-    customerId?: ID;
 }
 export interface EntityRelatedRecommendationUpdates {
     entityId: ID;
     entityType: EntityType;
-    recommendations: Recommendation;
     isBulkUpdate: boolean;
+    recommendations: Recommendation;
     updatedEntityId: ID | undefined;
 }
 export interface TransactionSaveUpdates {
-    updates: TransactionUpdates;
+    anyBulkUpdates: boolean;
     entityRelatedUpdates: Record<EntityRecommendationKey, EntityRelatedRecommendationUpdates>;
     markAsMiscatUpdates: boolean;
-    anyBulkUpdates: boolean;
+    updates: TransactionUpdates;
 }
 export {};