@zeniai/client-epic-state 5.2.0-beta0AK → 5.2.1

package/lib/esm/view/expenseAutomationView/epics/accountRecon/confirmStatementMappingEpic.js

@@ -0,0 +1,43 @@
+import { of } from 'rxjs';
+import { catchError, exhaustMap, filter, mergeMap } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { isConfirmStatementMappingConflictResponse, transformConfirmStatementMappingConflictToState, transformConfirmStatementMappingPayloadToState, } from '../../payload/reconciliationPayload';
+import { confirmStatementMapping, confirmStatementMappingFailure, confirmStatementMappingSuccess, } from '../../reducers/reconciliationViewReducer';
+const confirmStatementMappingErrorSnackbar = openSnackbar({
+    messageSection: 'confirm_statement_mapping',
+    messageText: 'failed',
+    type: 'error',
+});
+export const confirmStatementMappingEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(confirmStatementMapping.match), exhaustMap((action) => {
+    const { accountId, selectedPeriod, statementUploadId, accountMappings } = action.payload;
+    const confirmMappingApi$ = zeniAPI.postAndGetJSON(`${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/1.0/reconciliation/statements/${statementUploadId}/confirm-mapping`, {
+        account_mappings: accountMappings.map((mapping) => ({
+            ledger_identifier: mapping.ledgerIdentifier,
+            account_id: mapping.accountId,
+        })),
+    });
+    return confirmMappingApi$.pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) === true && response.data != null) {
+            return of(confirmStatementMappingSuccess({
+                accountId,
+                selectedPeriod,
+                statementUploads: transformConfirmStatementMappingPayloadToState(response.data),
+            }));
+        }
+        const mappingConflict = isConfirmStatementMappingConflictResponse(response)
+            ? transformConfirmStatementMappingConflictToState(response)
+            : null;
+        return of(confirmStatementMappingFailure({
+            accountId,
+            selectedPeriod,
+            error: response.status,
+            mappingConflict,
+        }), confirmStatementMappingErrorSnackbar);
+    }), catchError((error) => of(confirmStatementMappingFailure({
+        accountId,
+        selectedPeriod,
+        error: createZeniAPIStatus('Unexpected Error', 'Confirm Statement Mapping REST API call errored out ' +
+            (error instanceof Error ? error.message : String(error))),
+    }), confirmStatementMappingErrorSnackbar)));
+}));

package/lib/esm/view/expenseAutomationView/epics/accountRecon/deleteAccountStatementEpic.js

@@ -4,7 +4,7 @@ import { updateAccountReconDeleteStatement } from '../../../../entity/accountRec
 import { toAccountReconKey } from '../../../../entity/accountRecon/accountReconState';
 import { removeFiles } from '../../../../entity/file/fileReducer';
 import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
-import { deleteAccountStatement, deleteAccountStatementFailure, deleteAccountStatementSuccess, fetchReconciliation, } from '../../reducers/reconciliationViewReducer';
+import { deleteAccountStatement, deleteAccountStatementFailure, deleteAccountStatementSuccess, } from '../../reducers/reconciliationViewReducer';
 export const deleteAccountStatementEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(deleteAccountStatement.match), switchMap((action) => {
     const { accountId, selectedPeriod, statementUploadId, fileId } = action.payload;
     const request = zeniAPI.deleteAndGetJSON(`${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/1.0/reconciliation/statements/${statementUploadId}`);
@@ -17,7 +17,6 @@ export const deleteAccountStatementEpic = (actions$, _state$, zeniAPI) => action
                 actions.push(updateAccountReconDeleteStatement(accountReconKey, response.data));
             }
             actions.push(deleteAccountStatementSuccess({ accountId, selectedPeriod }));
-            actions.push(fetchReconciliation(selectedPeriod, undefined, true, true));
             return of(...actions);
         }
         else {

package/lib/esm/view/expenseAutomationView/epics/accountRecon/parseCombinedStatementEpic.js

@@ -0,0 +1,31 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { transformCombinedStatementGroupPayloadToState, } from '../../payload/reconciliationPayload';
+import { parseCombinedStatement, parseStatementFailure, parseStatementSuccess, updateParsedStatementData, } from '../../reducers/reconciliationViewReducer';
+export const parseCombinedStatementEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(parseCombinedStatement.match), switchMap((action) => {
+    const { accountId, selectedPeriod, combinedStatementGroupId } = action.payload;
+    const parseUrl = `${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/2.0/statement-uploads/combined-statement-groups/${combinedStatementGroupId}`;
+    return zeniAPI.getJSON(parseUrl).pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) === true && response.data != null) {
+            return from([
+                updateParsedStatementData({
+                    accountId,
+                    selectedPeriod,
+                    parsedStatementData: transformCombinedStatementGroupPayloadToState(response.data),
+                }),
+                parseStatementSuccess({ accountId, selectedPeriod }),
+            ]);
+        }
+        return of(parseStatementFailure({
+            accountId,
+            selectedPeriod,
+            error: response.status,
+        }));
+    }), catchError((error) => of(parseStatementFailure({
+        accountId,
+        selectedPeriod,
+        error: createZeniAPIStatus('Unexpected Error', 'Parse Combined Statement REST API call errored out ' +
+            (error instanceof Error ? error.message : String(error))),
+    }))));
+}));

package/lib/esm/view/expenseAutomationView/epics/accountRecon/parseStatementEpic.js

@@ -5,26 +5,23 @@ import { transformParseStatementPayloadToState, } from '../../payload/reconcilia
 import { parseStatement, parseStatementFailure, parseStatementSuccess, updateParsedStatementData, } from '../../reducers/reconciliationViewReducer';
 export const parseStatementEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(parseStatement.match), switchMap((action) => {
     const { accountId, selectedPeriod, statementUploadId } = action.payload;
-    const parseStatementApi$ = zeniAPI.getJSON(`${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/2.0/statement-uploads/${statementUploadId}`);
-    return parseStatementApi$.pipe(mergeMap((response) => {
+    const parseUrl = `${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/2.0/statement-uploads/${statementUploadId}`;
+    return zeniAPI.getJSON(parseUrl).pipe(mergeMap((response) => {
         if (isSuccessResponse(response) === true && response.data != null) {
-            const actions = [];
-            const transformedData = transformParseStatementPayloadToState(response.data);
-            actions.push(updateParsedStatementData({
-                accountId,
-                selectedPeriod,
-                parsedStatementData: transformedData,
-            }));
-            actions.push(parseStatementSuccess({ accountId, selectedPeriod }));
-            return from(actions);
-        }
-        else {
-            return of(parseStatementFailure({
-                accountId,
-                selectedPeriod,
-                error: response.status,
-            }));
+            return from([
+                updateParsedStatementData({
+                    accountId,
+                    selectedPeriod,
+                    parsedStatementData: transformParseStatementPayloadToState(response.data),
+                }),
+                parseStatementSuccess({ accountId, selectedPeriod }),
+            ]);
         }
+        return of(parseStatementFailure({
+            accountId,
+            selectedPeriod,
+            error: response.status,
+        }));
     }), catchError((error) => of(parseStatementFailure({
         accountId,
         selectedPeriod,

package/lib/esm/view/expenseAutomationView/epics/accountRecon/updateCombinedStatementInfoEpic.js

@@ -0,0 +1,68 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { toMonthYearPeriodId } from '../../../../commonStateTypes/timePeriod';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { mapCombinedStatementUpdateLocalDataToRequestBody } from '../../helpers/mapStatementUpdateLocalDataToRequestBody';
+import { getStatementUploadsFromParsedData } from '../../selectors/statementParseViewSelector';
+import { isStatementDateConflictResponse, transformStatementDateConflictToState, transformUpdateStatementInfoPayloadToState, } from '../../payload/reconciliationPayload';
+import { submitCombinedStatementUpdate, submitStatementUpdateFailure, submitStatementUpdateSuccess, updateParsedStatementData, } from '../../reducers/reconciliationViewReducer';
+export const updateCombinedStatementInfoEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(submitCombinedStatementUpdate.match), switchMap((action) => {
+    const { accountId, selectedPeriod } = action.payload;
+    const accountRecon = state$.value.expenseAutomationReconciliationViewState
+        .accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+    const parsedStatementData = accountRecon?.parsedStatementData;
+    const localDataByUploadId = accountRecon?.localData?.statementUpdateLocalDataByUploadId;
+    const statementUploads = getStatementUploadsFromParsedData(parsedStatementData);
+    if (parsedStatementData == null ||
+        localDataByUploadId == null ||
+        statementUploads.length === 0 ||
+        statementUploads.some((statementUpload) => localDataByUploadId[statementUpload.statementMeta.statementUploadId] == null)) {
+        return of(submitStatementUpdateFailure({
+            accountId,
+            selectedPeriod,
+            error: createZeniAPIStatus('Missing Data', 'No statement update data found for combined accounts'),
+        }));
+    }
+    const combinedStatementGroupId = accountRecon?.combinedStatementGroupId ??
+        parsedStatementData.statementUpload.statementMeta
+            .combinedStatementGroupId ??
+        parsedStatementData.statementUpload.combinedStatementDetails
+            ?.combinedStatementGroupId;
+    if (combinedStatementGroupId == null || combinedStatementGroupId === '') {
+        return of(submitStatementUpdateFailure({
+            accountId,
+            selectedPeriod,
+            error: createZeniAPIStatus('Missing Data', 'No combined statement group id found for bulk update'),
+        }));
+    }
+    const body = mapCombinedStatementUpdateLocalDataToRequestBody(localDataByUploadId, parsedStatementData);
+    const updateUrl = `${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/2.0/statement-uploads/combined-statement-groups/${combinedStatementGroupId}`;
+    return zeniAPI
+        .putAndGetJSON(updateUrl, body)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) === true && response.data != null) {
+            return of(updateParsedStatementData({
+                accountId,
+                selectedPeriod,
+                parsedStatementData: transformUpdateStatementInfoPayloadToState(response.data),
+            }), submitStatementUpdateSuccess({
+                accountId,
+                selectedPeriod,
+            }));
+        }
+        const dateConflict = isStatementDateConflictResponse(response)
+            ? transformStatementDateConflictToState(response)
+            : null;
+        return of(submitStatementUpdateFailure({
+            accountId,
+            selectedPeriod,
+            error: response.status,
+            dateConflict,
+        }));
+    }), catchError((error) => of(submitStatementUpdateFailure({
+        accountId,
+        selectedPeriod,
+        error: createZeniAPIStatus('Unexpected Error', 'Update Statement REST API call errored out ' +
+            (error instanceof Error ? error.message : String(error))),
+    }))));
+}));

package/lib/esm/view/expenseAutomationView/epics/accountRecon/updateStatementInfoEpic.js

@@ -7,12 +7,11 @@ import { isStatementDateConflictResponse, transformStatementDateConflictToState,
 import { submitStatementUpdate, submitStatementUpdateFailure, submitStatementUpdateSuccess, updateParsedStatementData, } from '../../reducers/reconciliationViewReducer';
 export const updateStatementInfoEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(submitStatementUpdate.match), switchMap((action) => {
     const { accountId, selectedPeriod, statementUploadId } = action.payload;
-    const state = state$.value;
-    const reconciliationView = state.expenseAutomationReconciliationViewState;
-    const accountRecon = reconciliationView.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
-    const localData = accountRecon?.localData?.statementUpdateLocalData;
+    const accountRecon = state$.value.expenseAutomationReconciliationViewState
+        .accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
     const parsedStatementData = accountRecon?.parsedStatementData;
-    if (localData == null || parsedStatementData == null) {
+    const localData = accountRecon?.localData?.statementUpdateLocalDataByUploadId?.[statementUploadId];
+    if (parsedStatementData == null || localData == null) {
         return of(submitStatementUpdateFailure({
             accountId,
             selectedPeriod,
@@ -20,7 +19,7 @@ export const updateStatementInfoEpic = (actions$, state$, zeniAPI) => actions$.p
         }));
     }
     const hasInvalidUpdates = localData.statementTransactions.updated.some((txn) => txn.statementTransactionId == null);
-    if (hasInvalidUpdates) {
+    if (hasInvalidUpdates === true) {
         return of(submitStatementUpdateFailure({
             accountId,
             selectedPeriod,
@@ -28,14 +27,15 @@ export const updateStatementInfoEpic = (actions$, state$, zeniAPI) => actions$.p
         }));
     }
     const body = mapStatementUpdateLocalDataToRequestBody(localData, parsedStatementData);
-    const updateStatementApi$ = zeniAPI.putAndGetJSON(`${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/2.0/statement-uploads/${statementUploadId}`, body);
-    return updateStatementApi$.pipe(mergeMap((response) => {
+    const updateUrl = `${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/2.0/statement-uploads/${statementUploadId}`;
+    return zeniAPI
+        .putAndGetJSON(updateUrl, body)
+        .pipe(mergeMap((response) => {
         if (isSuccessResponse(response) === true && response.data != null) {
-            const parsedStatementData = transformUpdateStatementInfoPayloadToState(response.data);
             return of(updateParsedStatementData({
                 accountId,
                 selectedPeriod,
-                parsedStatementData,
+                parsedStatementData: transformUpdateStatementInfoPayloadToState(response.data),
             }), submitStatementUpdateSuccess({
                 accountId,
                 selectedPeriod,

package/lib/esm/view/expenseAutomationView/epics/accountRecon/uploadAccountStatementDocumentAIHelper.js

@@ -1,14 +1,22 @@
 import fetch from 'cross-fetch';
 import { zeniAPI } from '../../../../init';
-export default async function uploadAccountStatementIntoDocumentAI(accountType, fileBlob, authParams) {
+function toStatementDocumentType(accountType, isCombinedStatement) {
+    if (isCombinedStatement === true) {
+        return accountType === 'credit_card'
+            ? 'reconciliation_combined_card_statement_upload'
+            : 'reconciliation_combined_bank_statement_upload';
+    }
+    return accountType === 'credit_card'
+        ? 'reconciliation_card_statement_upload'
+        : 'reconciliation_bank_statement_upload';
+}
+export default async function uploadAccountStatementIntoDocumentAI(accountType, fileBlob, authParams, isCombinedStatement = false) {
     let statementUpload;
     const urlEndPoint = `${zeniAPI.apiEndPoints.documentAIMicroServiceBaseUrl}/1.0/processors/statement`;
     const data = new FormData();
     data.append('attachment_file_0', fileBlob);
     const attachment_json = JSON.stringify({
-        document_type: accountType === 'credit_card'
-            ? 'reconciliation_card_statement_upload'
-            : 'reconciliation_bank_statement_upload',
+        document_type: toStatementDocumentType(accountType, isCombinedStatement),
         purpose_id: 'reconciliation',
     });
     data.append('attachment_json_0', attachment_json);

package/lib/esm/view/expenseAutomationView/epics/accountRecon/uploadAccountStatementEpic.js

@@ -1,6 +1,6 @@
 import { from, of } from 'rxjs';
 import { catchError, filter, mergeMap } from 'rxjs/operators';
-import { convertToPeriod } from '../../../../commonStateTypes/timePeriod';
+import { convertToPeriod, toMonthYearPeriodId, } from '../../../../commonStateTypes/timePeriod';
 import { getAccountBase } from '../../../../entity/account/accountSelector';
 import { updateAccountReconUploadStatement } from '../../../../entity/accountRecon/accountReconReducer';
 import { toAccountReconKey } from '../../../../entity/accountRecon/accountReconState';
@@ -8,7 +8,7 @@ import { updateFiles } from '../../../../entity/file/fileReducer';
 import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
 import { uploadAccountStatement, uploadAccountStatementFailure, uploadAccountStatementSuccess, } from '../../reducers/reconciliationViewReducer';
 export const uploadAccountStatementEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(uploadAccountStatement.match), mergeMap((action) => {
-    const { accountId, selectedPeriod, payload } = action.payload;
+    const { accountId, selectedPeriod, payload, statementAccountScope } = action.payload;
     const { start, end } = convertToPeriod(selectedPeriod, true);
     const accountBase = getAccountBase(state$.value.accountState, accountId, 'account_reconciliation');
     if (accountBase == null) {
@@ -19,6 +19,11 @@ export const uploadAccountStatementEpic = (actions$, state$, zeniAPI) => actions
         }));
     }
     const statementType = accountBase.accountType == 'credit_card' ? 'card' : 'bank';
+    const localStatementAccountScope = state$.value.expenseAutomationReconciliationViewState
+        .accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId]?.localData
+        ?.statementAccountScope;
+    const resolvedStatementAccountScope = statementAccountScope ?? localStatementAccountScope ?? 'single_account';
+    const isCombinedStatement = resolvedStatementAccountScope === 'multi_account';
     const requestPayload = {
         account_id: accountId,
         statement_start_date: start.toString(),
@@ -26,6 +31,7 @@ export const uploadAccountStatementEpic = (actions$, state$, zeniAPI) => actions
         processor_run_id: payload.processor_run_id,
         file_id: payload.files[0].file_id,
         statement_type: statementType,
+        is_combined_statement: isCombinedStatement,
     };
     const uploadAccountStatementApi$ = zeniAPI.postAndGetJSON(`${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/1.0/reconciliation/statements`, requestPayload);
     return uploadAccountStatementApi$.pipe(mergeMap((response) => {

package/lib/esm/view/expenseAutomationView/helpers/mapStatementUpdateLocalDataToRequestBody.js

@@ -1,7 +1,7 @@
-import { toStatementUpdateRequestBody } from '../payload/reconciliationPayload';
-import { getEffectiveStatementPeriod, mergeStatementParseDeletedTransactionIds, } from '../selectors/statementParseViewSelector';
-const prepareStatementUpdateLocalData = (localData, parsedStatementData) => {
-    const { statementMeta, statementTransactions } = parsedStatementData.statementUpload;
+import { toBulkStatementUpdateRequestBody, toStatementUpdateRequestBody, } from '../payload/reconciliationPayload';
+import { getEffectiveStatementPeriod, getStatementUploadsFromParsedData, mergeStatementParseDeletedTransactionIds, } from '../selectors/statementParseViewSelector';
+const prepareStatementUpdateLocalData = (localData, statementUpload) => {
+    const { statementMeta, statementTransactions } = statementUpload;
     const statementPeriod = getEffectiveStatementPeriod(statementMeta, localData.statementMeta);
     const localDeletedIds = localData.statementTransactions?.deletedIds ?? [];
     const currentTransactionIds = new Set(statementTransactions
@@ -27,4 +27,19 @@ const prepareStatementUpdateLocalData = (localData, parsedStatementData) => {
         },
     };
 };
-export const mapStatementUpdateLocalDataToRequestBody = (localData, parsedStatementData) => toStatementUpdateRequestBody(prepareStatementUpdateLocalData(localData, parsedStatementData));
+export const mapStatementUpdateLocalDataToRequestBody = (localData, parsedStatementData) => toStatementUpdateRequestBody(prepareStatementUpdateLocalData(localData, parsedStatementData.statementUpload));
+export const mapCombinedStatementUpdateLocalDataToRequestBody = (localDataByUploadId, parsedStatementData) => {
+    const statementUploads = getStatementUploadsFromParsedData(parsedStatementData);
+    const updates = statementUploads.map((statementUpload) => {
+        const statementUploadId = statementUpload.statementMeta.statementUploadId;
+        const localData = localDataByUploadId[statementUploadId];
+        if (localData == null) {
+            throw new Error(`Missing statement update local data for upload ${statementUploadId}`);
+        }
+        return {
+            statementUploadId,
+            localData: prepareStatementUpdateLocalData(localData, statementUpload),
+        };
+    });
+    return toBulkStatementUpdateRequestBody(updates);
+};

package/lib/esm/view/expenseAutomationView/payload/reconciliationPayload.js

@@ -1,6 +1,7 @@
 import { convertToPeriod, } from '../../../commonStateTypes/timePeriod';
 import { toTransactionsToReviewPayload, } from '../../../entity/accountRecon/accountReconPayload';
 import { toMatchedTransactionPayload, } from '../../../entity/transaction/payloadTypes/reconciliationTransactionPayloads';
+import { toStatementBalanceSourceStrict, } from '../types/reconciliationViewState';
 export function createSaveReconciliationPayloadBasedOnActionAndMethod(state, selectedPeriod, localData, accountReconciliationEntity, action, method) {
     const { balance, initialClearedBalance } = accountReconciliationEntity;
     const { expenseAutomationReconciliationViewState: { selectedAccountId, reconTabsState: { reconcile: { localData: { selectedTransactionIds }, }, }, }, } = state;
@@ -67,10 +68,60 @@ function createReviewTransactionPayload(accountReconciliationEntity) {
     });
     return reviewTransactionsPayload;
 }
+export function isParseStatementCombinedResponsePayload(payload) {
+    return ('statement_uploads' in payload &&
+        Array.isArray(payload.statement_uploads) &&
+        payload.statement_uploads.length > 0 &&
+        // Batch group GET nests each upload under statement_upload — exclude that shape.
+        'statement_upload' in (payload.statement_uploads[0] ?? {}) === false);
+}
+export function isUpdateStatementInfoCombinedResponsePayload(payload) {
+    return ('statement_uploads' in payload &&
+        Array.isArray(payload.statement_uploads) &&
+        payload.statement_uploads.length > 0);
+}
 export function isStatementDateConflictResponse(response) {
     return response.status.code === 409 && response.error_code != null;
 }
+function transformConfirmedCombinedStatementUploadsToState(statementUploads) {
+    return (statementUploads ?? []).map((statementUpload) => ({
+        accountId: statementUpload.account_id,
+        isCombinedStatementAnchor: statementUpload.is_combined_statement_anchor,
+        ledgerIdentifiers: statementUpload.ledger_identifiers ?? [],
+        statementUploadId: statementUpload.statement_upload_id,
+    }));
+}
+function transformCombinedStatementDetailsToState(details) {
+    if (details == null) {
+        return undefined;
+    }
+    return {
+        combinedStatementGroupId: details.combined_statement_group_id,
+        isMappingConfirmed: details.is_mapping_confirmed,
+        accounts: (details.accounts ?? []).map((account) => ({
+            ledgerIdentifier: account.ledger_identifier,
+            accountName: account.account_name,
+            accountType: account.account_type,
+            maskedAccountNumber: account.masked_account_number,
+            openingBalance: account.opening_balance,
+            closingBalance: account.closing_balance,
+            transactionCount: account.transaction_count,
+            isUploadContext: account.is_upload_context,
+            existingStatementStatus: account.existing_statement_status ?? null,
+            suggestion: account.suggestion != null
+                ? {
+                    accountId: account.suggestion.account_id,
+                    accountName: account.suggestion.account_name,
+                    matchedBy: account.suggestion.matched_by,
+                    matchConfidence: account.suggestion.match_confidence,
+                }
+                : null,
+        })),
+        statementUploads: transformConfirmedCombinedStatementUploadsToState(details.statement_uploads),
+    };
+}
 function transformStatementUploadPayloadToState(statementUploadPayload) {
+    const balanceSource = toStatementBalanceSourceStrict(statementUploadPayload.statement_meta.balance_source);
     return {
         account: {
             accountId: statementUploadPayload.account.account_id,
@@ -96,6 +147,13 @@ function transformStatementUploadPayloadToState(statementUploadPayload) {
             statementUploadId: statementUploadPayload.statement_meta.statement_upload_id,
             totalDeposits: statementUploadPayload.statement_meta.total_deposits,
             totalPayments: statementUploadPayload.statement_meta.total_payments,
+            isCombinedStatement: statementUploadPayload.statement_meta.is_combined_statement ??
+                undefined,
+            isCombinedStatementAnchor: statementUploadPayload.statement_meta.is_combined_statement_anchor ??
+                undefined,
+            combinedStatementGroupId: statementUploadPayload.statement_meta.combined_statement_group_id ??
+                undefined,
+            ...(balanceSource != null ? { balanceSource } : {}),
         },
         statementTransactions: (statementUploadPayload.statement_transactions ?? []).map((txn) => ({
             amount: txn.amount,
@@ -117,6 +175,7 @@ function transformStatementUploadPayloadToState(statementUploadPayload) {
             transactionMemo: txn.transaction_memo,
         })),
         aiSummary: transformAiSummaryPayloadToState(statementUploadPayload.ai_summary),
+        combinedStatementDetails: transformCombinedStatementDetailsToState(statementUploadPayload.combined_statement_details),
     };
 }
 function transformPreviousReconciliationInfoToState(payload) {
@@ -177,11 +236,71 @@ export function transformStatementDateConflictToState(response) {
     };
 }
 export function transformParseStatementPayloadToState(payload) {
+    if (isParseStatementCombinedResponsePayload(payload) === true) {
+        const statementUploads = payload.statement_uploads.map(transformStatementUploadPayloadToState);
+        const anchorUpload = statementUploads.find((upload) => upload.statementMeta.isCombinedStatementAnchor === true) ?? statementUploads[0];
+        return {
+            statementUpload: anchorUpload,
+            statementUploads,
+        };
+    }
     return {
         statementUpload: transformStatementUploadPayloadToState(payload.statement_upload),
     };
 }
+export function transformCombinedStatementGroupPayloadToState(payload) {
+    const groupId = payload.combined_statement_group_id;
+    const statementUploads = (payload.statement_uploads ?? []).map((entry) => {
+        const upload = transformStatementUploadPayloadToState(entry.statement_upload);
+        if ((upload.statementMeta.combinedStatementGroupId == null ||
+            upload.statementMeta.combinedStatementGroupId === '') &&
+            groupId !== '') {
+            return {
+                ...upload,
+                statementMeta: {
+                    ...upload.statementMeta,
+                    combinedStatementGroupId: groupId,
+                },
+            };
+        }
+        return upload;
+    });
+    if (statementUploads.length === 0) {
+        throw new Error('Combined statement response has no statement uploads');
+    }
+    const anchorUpload = statementUploads.find((upload) => upload.statementMeta.isCombinedStatementAnchor === true) ?? statementUploads[0];
+    return {
+        statementUpload: anchorUpload,
+        statementUploads,
+    };
+}
+export function isConfirmStatementMappingConflictResponse(response) {
+    return response.status.code === 409;
+}
+export function transformConfirmStatementMappingPayloadToState(payload) {
+    return transformConfirmedCombinedStatementUploadsToState(payload.statement_uploads);
+}
+export function transformConfirmStatementMappingConflictToState(response) {
+    if (isConfirmStatementMappingConflictResponse(response) === false) {
+        return null;
+    }
+    return {
+        collidingAccountId: response.colliding_account_id != null
+            ? response.colliding_account_id
+            : undefined,
+        collidingLedgerIdentifiers: response.colliding_ledger_identifiers ?? [],
+        previousReconciliationInfo: transformPreviousReconciliationInfoToState(response.previous_reconciliation_info),
+    };
+}
 export function transformUpdateStatementInfoPayloadToState(payload) {
+    if (isUpdateStatementInfoCombinedResponsePayload(payload) === true) {
+        const statementUploads = payload.statement_uploads.map(transformStatementUploadPayloadToState);
+        const anchorUpload = statementUploads.find((upload) => upload.statementMeta.isCombinedStatementAnchor === true) ?? statementUploads[0];
+        return {
+            statementUpload: anchorUpload,
+            statementUploads,
+        };
+    }
     return {
         statementUpload: transformStatementUploadPayloadToState(payload.statement_upload),
     };
@@ -221,3 +340,19 @@ export function transformStatementUpdateStateToPayload(localData) {
 export function toStatementUpdateRequestBody(localData) {
     return transformStatementUpdateStateToPayload(localData);
 }
+export function transformBulkStatementUpdateStateToPayload(updates) {
+    return {
+        statement_uploads: updates.map(({ localData, statementUploadId }) => {
+            const body = transformStatementUpdateStateToPayload(localData);
+            return {
+                statement_upload_id: statementUploadId,
+                statement_meta: body.statement_meta,
+                statement_transactions: body.statement_transactions,
+            };
+        }),
+    };
+}
+/** Bulk PUT body for combined multi-account Confirm & Save. */
+export function toBulkStatementUpdateRequestBody(updates) {
+    return transformBulkStatementUpdateStateToPayload(updates);
+}