@fiado/type-kit 3.616.0 → 3.618.0

package/_test_/unit/account/BankAccountMCSendTransfer.test.ts

@@ -0,0 +1,43 @@
+import 'reflect-metadata';
+import { BankAccountMCSendTransferRequest, BankAccountMCSendTransferResponse } from '../../../src/account/index';
+import { TransactionStatusEnum } from '../../../src/transaction';
+
+/**
+ * MC Send directo a una tarjeta del programa (CARD_PUSH_FUNDS): el request admite el cd_ del
+ * beneficiario y entonces email y teléfono dejan de ser obligatorios; la respuesta expone el id
+ * de la network transfer de CP (mt_) además de los tx_.
+ */
+describe('BankAccountMCSendTransferRequest', () => {
+  it('acepta un push directo a tarjeta sin email ni teléfono del beneficiario', () => {
+    const request: BankAccountMCSendTransferRequest = {
+      transactionNumber: 'T1',
+      amount: 1,
+      externalAccountId: 'cd_origen',
+      beneficiaryExternalAccountId: 'cd_destino',
+    };
+    expect(request.beneficiaryExternalAccountId).toBe('cd_destino');
+    expect(request.beneficiaryEmail).toBeUndefined();
+  });
+
+  it('sigue aceptando la intención por email y teléfono', () => {
+    const request: BankAccountMCSendTransferRequest = {
+      transactionNumber: 'T2',
+      amount: 1,
+      beneficiaryEmail: 'a@b.com',
+      beneficiaryPhoneNumber: '3055550100',
+    };
+    expect(request.beneficiaryExternalAccountId).toBeUndefined();
+  });
+});
+
+describe('BankAccountMCSendTransferResponse', () => {
+  it('expone externalTransferId (mt_) junto a externalTransactionId (tx_)', () => {
+    const response: BankAccountMCSendTransferResponse = {
+      externalTransactionId: 'tx_1|tx_2',
+      externalTransferId: 'mt_1',
+      transactionStatus: TransactionStatusEnum.COMPLETED,
+      transactionNumber: 'T1',
+    };
+    expect(response.externalTransferId).toBe('mt_1');
+  });
+});

package/_test_/unit/loanRetailAudit/m8AuditCatalog.test.ts

@@ -0,0 +1,58 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validateSync } from 'class-validator';
+import * as LoanRetailAudit from '../../../src/loanRetailAudit';
+
+const { AuditTrailRecordedV1, AuditTrailActionEnum, LoanAuditEntityTypeEnum, AUDIT_TRAIL_ENTITY_TYPES } = LoanRetailAudit;
+
+describe('entidades de auditoría de M8', () => {
+    it.each(['TRANSFER_NOTE', 'TRANSFER_NOTE_CONFIG', 'RECONCILIATION_DEFINITION', 'RECONCILIATION_ITEM'])(
+        '%s existe y la acepta el central',
+        (entityType) => {
+            expect(Object.values(LoanAuditEntityTypeEnum)).toContain(entityType);
+            expect(AUDIT_TRAIL_ENTITY_TYPES).toContain(entityType);
+        },
+    );
+});
+
+describe('acciones de auditoría de M8', () => {
+    it.each([
+        'TRANSFER_NOTE_ISSUE',
+        'TRANSFER_NOTE_SPEI_CAPTURE',
+        'TRANSFER_NOTE_SPEI_REVERT',
+        'TRANSFER_NOTE_RECEPTION_CONFIRM',
+        'TRANSFER_NOTE_SETTLEMENT_CONFIRM',
+        'TRANSFER_NOTE_CANCEL',
+        'TRANSFER_NOTE_DISPUTE',
+        'TRANSFER_NOTE_DISPUTE_RESOLVE',
+        'RECONCILIATION_ITEM_RESOLVE',
+        'RECONCILIATION_ITEM_REACTIVATE',
+        'RECONCILIATION_ITEM_NOTE',
+    ])('%s existe con su mismo valor', (action) => {
+        expect((AuditTrailActionEnum as Record<string, string>)[action]).toBe(action);
+    });
+
+    it('la configuración reusa UPDATE', () => {
+        expect(AuditTrailActionEnum.UPDATE).toBe('UPDATE');
+    });
+
+    it('el central acepta un evento de nota emitida', () => {
+        const dto = plainToInstance(
+            AuditTrailRecordedV1,
+            {
+                eventId: '01JABCDEF0123456789XYZABCD',
+                entityType: LoanAuditEntityTypeEnum.TRANSFER_NOTE,
+                entityId: 'note-1',
+                action: AuditTrailActionEnum.TRANSFER_NOTE_ISSUE,
+                changes: [{ field: 'status', newValue: 'ISSUED' }],
+                context: [{ key: 'pairKey', value: 'GATEWAY#SOFOM' }],
+                performedBy: 'transfer-note-business',
+                sourceLambda: 'transfer-note-business',
+                occurredAt: '2026-10-29T12:00:00.000Z',
+                tenantId: 'surekeep',
+            },
+            { excludeExtraneousValues: true },
+        );
+        expect(validateSync(dto)).toEqual([]);
+    });
+});

package/_test_/unit/reconciliation/reconciliationCatalogs.test.ts

@@ -0,0 +1,126 @@
+import 'reflect-metadata';
+import * as Reconciliation from '../../../src/reconciliation';
+import * as TransferNote from '../../../src/transferNote';
+
+const {
+    ReconciliationRuleTypeEnum,
+    ReconciliationDefinitionStatusEnum,
+    ReconciliationItemStateEnum,
+    ReconciliationResolutionTypeEnum,
+    ReconciliationResolutionStatusEnum,
+    ReconciliationRunStatusEnum,
+    ReconciliationLayerEnum,
+    ReconciliationFeedConceptEnum,
+    ReconciliationErrorCodeEnum,
+    RECONCILIATION_ERROR_HTTP_STATUS,
+    ReconciliationFeedErrorCodeEnum,
+    RECONCILIATION_FEED_ERROR_HTTP_STATUS,
+    RECONCILIATION_EVENTS_SOURCE,
+    ReconciliationEventDetailTypeEnum,
+    RECONCILIATION_FEED_PAGE_SIZE,
+    ReconciliationFeedOwnerEnum,
+} = Reconciliation;
+
+describe('catálogos de reconciliation', () => {
+    it('los 4 tipos de regla del spec; el agregado es capa, no regla', () => {
+        expect(Object.values(ReconciliationRuleTypeEnum)).toEqual(['PAIRWISE', 'COMPLETENESS', 'SETTLEMENT', 'BANK_STATEMENT']);
+        expect(Object.values(ReconciliationLayerEnum)).toContain('AGGREGATE');
+    });
+
+    it('estados de definición', () => {
+        expect(Object.values(ReconciliationDefinitionStatusEnum)).toEqual(['PAUSED', 'SHADOW', 'ACTIVE']);
+    });
+
+    it('estados calculados de partida de las 4 capas, completitud y sandbox', () => {
+        expect(Object.values(ReconciliationItemStateEnum).sort()).toEqual(
+            [
+                'MATCHED',
+                'PENDING',
+                'MISSING_IN_EXPECTED',
+                'MISSING_IN_EXECUTED',
+                'AMOUNT_MISMATCH',
+                'MISSING_IN_BANK_STATEMENT',
+                'UNEXPLAINED_DIFFERENCE',
+                'OUT_OF_WINDOW',
+                'ACCOUNT_MISMATCH',
+                'COMPLETE',
+                'INCOMPLETE',
+                'TEST',
+            ].sort(),
+        );
+    });
+
+    it('resolución: tipo aparte de su estado, con ADJUSTING y ADJUSTED', () => {
+        expect(Object.values(ReconciliationResolutionTypeEnum)).toEqual(['ACCEPT', 'INVESTIGATE', 'EXCLUDE', 'ADJUST']);
+        expect(Object.values(ReconciliationResolutionStatusEnum)).toEqual(
+            expect.arrayContaining(['INVESTIGATING', 'CLOSED', 'ADJUSTING', 'ADJUSTED']),
+        );
+    });
+
+    it('estados de corrida', () => {
+        expect(Object.values(ReconciliationRunStatusEnum)).toEqual(['RUNNING', 'COMPLETED', 'FAILED']);
+    });
+
+    it('conceptos de feed reusan los strings de transferNote', () => {
+        expect(ReconciliationFeedConceptEnum.INSTALLMENT_COLLECTION).toBe(TransferNote.TransferNoteConceptEnum.INSTALLMENT_COLLECTION);
+        expect(ReconciliationFeedConceptEnum.DEVICE_PAYMENT).toBe(TransferNote.TransferNoteConceptEnum.DEVICE_PAYMENT);
+        expect(ReconciliationFeedConceptEnum.TRANSFER_NOTE_ITEM).toBe(TransferNote.TransferNoteFeedConceptEnum.TRANSFER_NOTE_ITEM);
+        expect(ReconciliationFeedConceptEnum.TRANSFER_NOTE_SETTLEMENT).toBe(
+            TransferNote.TransferNoteFeedConceptEnum.TRANSFER_NOTE_SETTLEMENT,
+        );
+        expect(Object.values(ReconciliationFeedConceptEnum)).toEqual(expect.arrayContaining(['SIGNED_CREDIT', 'GATEWAY_LEDGER']));
+        expect(Object.values(ReconciliationFeedConceptEnum)).not.toContain('ADJUSTMENT');
+        expect(RECONCILIATION_FEED_PAGE_SIZE).toBe(500);
+    });
+
+    it('cada code del motor tiene su status; el ajuste caído es 502', () => {
+        const codes = Object.values(ReconciliationErrorCodeEnum);
+        expect(codes).toEqual(
+            expect.arrayContaining([
+                'DEFINITION_NOT_FOUND',
+                'RUN_IN_PROGRESS',
+                'ITEM_NOT_FOUND',
+                'ITEM_ALREADY_RESOLVED',
+                'ADJUSTMENT_IN_PROGRESS',
+                'ADJUSTMENT_UNDER_EXECUTED',
+                'ADJUSTMENT_NOT_ALLOWED',
+                'ADJUSTMENT_REJECTED',
+                'ADJUSTMENT_UNAVAILABLE',
+                'ITEM_ADJUSTED',
+                'AUTHOR_NOT_ALLOWED',
+            ]),
+        );
+        for (const code of codes) {
+            expect([400, 404, 409, 422, 502]).toContain(RECONCILIATION_ERROR_HTTP_STATUS[code]);
+        }
+        expect(RECONCILIATION_ERROR_HTTP_STATUS[ReconciliationErrorCodeEnum.ADJUSTMENT_UNAVAILABLE]).toBe(502);
+        expect(RECONCILIATION_ERROR_HTTP_STATUS[ReconciliationErrorCodeEnum.ITEM_ALREADY_RESOLVED]).toBe(409);
+        expect(RECONCILIATION_ERROR_HTTP_STATUS[ReconciliationErrorCodeEnum.ADJUSTMENT_UNDER_EXECUTED]).toBe(422);
+        expect(RECONCILIATION_ERROR_HTTP_STATUS[ReconciliationErrorCodeEnum.ITEM_ADJUSTED]).toBe(409);
+    });
+
+    it('el 404 del feed genérico tiene el mismo string que el de transferNote', () => {
+        expect(ReconciliationFeedErrorCodeEnum.FEED_RECORD_NOT_FOUND).toBe(
+            TransferNote.TransferNoteErrorCodeEnum.FEED_RECORD_NOT_FOUND,
+        );
+        expect(RECONCILIATION_FEED_ERROR_HTTP_STATUS[ReconciliationFeedErrorCodeEnum.FEED_RECORD_NOT_FOUND]).toBe(404);
+    });
+
+    it('nombres de los eventos que publica y consume el motor', () => {
+        expect(RECONCILIATION_EVENTS_SOURCE).toBe('fiado.reconciliation');
+        expect(ReconciliationEventDetailTypeEnum.RECONCILIATION_ITEM_MATCHED).toBe('reconciliation.ReconciliationItemMatched');
+        expect(Object.keys(Reconciliation)).not.toContain('TRANSFER_NOTE_EVENTS_SOURCE');
+        expect(Object.keys(Reconciliation)).not.toContain('TransferNoteEventDetailTypeEnum');
+    });
+
+    it('los dueños de feed son los lambdas del ciclo, por su nombre', () => {
+        expect(Object.values(ReconciliationFeedOwnerEnum).sort()).toEqual([
+            'loan-credit-business',
+            'loan-offerings-business',
+            'retail-customer-business',
+            'retail-wizard-business',
+            'transaction-business',
+            'transfer-note-business',
+        ]);
+    });
+});

package/_test_/unit/reconciliation/reconciliationRequests.test.ts

@@ -0,0 +1,208 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validateSync } from 'class-validator';
+import * as Reconciliation from '../../../src/reconciliation';
+
+const {
+    ReconciliationDefinitionStatusEnum,
+    ReconciliationItemStateEnum,
+    ReconciliationResolutionTypeEnum,
+    ReconciliationFeedConceptEnum,
+    ReconciliationExportFormatEnum,
+    ConfigureReconciliationDefinitionRequest,
+    ListReconciliationRunsQuery,
+    RunReconciliationRequest,
+    GetReconciliationMatrixQuery,
+    GetReconciliationSummaryQuery,
+    ListReconciliationItemsQuery,
+    ResolveReconciliationItemRequest,
+    ReactivateReconciliationItemRequest,
+    AddReconciliationItemNoteRequest,
+    PrivateConfigureReconciliationDefinitionRequest,
+    PrivateListReconciliationDefinitionsQuery,
+    PrivateRunReconciliationRequest,
+    PrivateResolveReconciliationItemRequest,
+    PrivateAddReconciliationItemNoteRequest,
+    PrivateGetReconciliationItemQuery,
+    PrivateListReconciliationItemsQuery,
+    PrivateListReconciliationFeedQuery,
+    PrivateGetReconciliationFeedRecordQuery,
+    ReconciliationFeedPathParams,
+} = Reconciliation;
+
+function errorsOf<T extends object>(cls: new () => T, payload: Record<string, unknown>): string[] {
+    const dto = plainToInstance(cls, payload, { excludeExtraneousValues: true });
+    return validateSync(dto).map((e) => e.property);
+}
+
+const operator = { tenantId: 'surekeep', author: 'conciliacion-dashboard', actor: 'operador@fsa.mx' };
+
+describe('definiciones', () => {
+    it('configurar pide un estado válido y listas de sandbox opcionales', () => {
+        expect(
+            errorsOf(ConfigureReconciliationDefinitionRequest, {
+                status: ReconciliationDefinitionStatusEnum.SHADOW,
+                sandboxRetailerIds: ['r-test'],
+                sandboxDirectoryIds: ['d-test'],
+            }),
+        ).toEqual([]);
+        expect(errorsOf(ConfigureReconciliationDefinitionRequest, { status: 'ON' })).toContain('status');
+        expect(
+            errorsOf(ConfigureReconciliationDefinitionRequest, {
+                status: ReconciliationDefinitionStatusEnum.ACTIVE,
+                sandboxRetailerIds: [''],
+            }),
+        ).toContain('sandboxRetailerIds');
+    });
+});
+
+describe('corridas', () => {
+    it('la corrida manual pide definición y periodo diario, semanal o mensual', () => {
+        for (const periodKey of ['2026-10-29', '2026-W44', '2026-10']) {
+            expect(errorsOf(RunReconciliationRequest, { definitionId: 'm8-gateway-sofom', periodKey })).toEqual([]);
+        }
+        expect(errorsOf(RunReconciliationRequest, { definitionId: 'm8-gateway-sofom', periodKey: 'octubre' })).toContain(
+            'periodKey',
+        );
+        expect(errorsOf(RunReconciliationRequest, { periodKey: '2026-10' })).toContain('definitionId');
+    });
+
+    it('el listado de corridas pide la definición', () => {
+        expect(errorsOf(ListReconciliationRunsQuery, { definitionId: 'm8-gateway-bank', limit: '20' })).toEqual([]);
+        expect(errorsOf(ListReconciliationRunsQuery, {})).toContain('definitionId');
+    });
+
+    it('el periodo del listado de corridas es opcional pero con formato', () => {
+        expect(errorsOf(ListReconciliationRunsQuery, { definitionId: 'm8-gateway-bank', periodKey: '2026-W44' })).toEqual([]);
+        expect(errorsOf(ListReconciliationRunsQuery, { definitionId: 'm8-gateway-bank', periodKey: 'octubre' })).toContain(
+            'periodKey',
+        );
+    });
+});
+
+describe('matriz, resumen y partidas', () => {
+    it('la matriz pide definición y año', () => {
+        expect(errorsOf(GetReconciliationMatrixQuery, { definitionId: 'm8-gateway-sofom', year: '2026' })).toEqual([]);
+        expect(errorsOf(GetReconciliationMatrixQuery, { definitionId: 'm8-gateway-sofom', year: 'dos mil' })).toContain(
+            'year',
+        );
+    });
+
+    it('el resumen por capa pide definición y periodo', () => {
+        expect(errorsOf(GetReconciliationSummaryQuery, { definitionId: 'm8-gateway-sofom', periodKey: '2026-W44' })).toEqual(
+            [],
+        );
+        expect(errorsOf(GetReconciliationSummaryQuery, { definitionId: 'm8-gateway-sofom' })).toContain('periodKey');
+    });
+
+    it('las partidas aceptan state=TEST y format=csv', () => {
+        expect(
+            errorsOf(ListReconciliationItemsQuery, {
+                definitionId: 'm8-gateway-sofom',
+                state: ReconciliationItemStateEnum.TEST,
+                format: ReconciliationExportFormatEnum.CSV,
+                month: '2026-10',
+            }),
+        ).toEqual([]);
+        expect(ReconciliationExportFormatEnum.CSV).toBe('csv');
+        expect(errorsOf(ListReconciliationItemsQuery, { definitionId: 'x', format: 'xlsx' })).toContain('format');
+        expect(errorsOf(ListReconciliationItemsQuery, { definitionId: 'x', month: '2026-13' })).toContain('month');
+        expect(errorsOf(ListReconciliationItemsQuery, { definitionId: 'x', periodKey: '2026-10' })).toEqual([]);
+        expect(errorsOf(ListReconciliationItemsQuery, { definitionId: 'x', periodKey: 'octubre' })).toContain('periodKey');
+    });
+});
+
+describe('resolución, reactivación y notas', () => {
+    it('resolver pide tipo y razón', () => {
+        expect(
+            errorsOf(ResolveReconciliationItemRequest, {
+                type: ReconciliationResolutionTypeEnum.ADJUST,
+                reason: 'cobro duplicado del intento',
+            }),
+        ).toEqual([]);
+        expect(errorsOf(ResolveReconciliationItemRequest, { type: 'REJECT', reason: 'x' })).toContain('type');
+        expect(errorsOf(ResolveReconciliationItemRequest, { type: ReconciliationResolutionTypeEnum.ACCEPT, reason: '  ' })).toContain(
+            'reason',
+        );
+    });
+
+    it('reactivar pide razón', () => {
+        expect(errorsOf(ReactivateReconciliationItemRequest, { reason: 'se aceptó por error' })).toEqual([]);
+        expect(errorsOf(ReactivateReconciliationItemRequest, {})).toContain('reason');
+    });
+
+    it('la nota de investigación pide 10+ caracteres sin contar relleno', () => {
+        expect(errorsOf(AddReconciliationItemNoteRequest, { text: 'revisar con tesorería' })).toEqual([]);
+        expect(errorsOf(AddReconciliationItemNoteRequest, { text: '   corta   ' })).toContain('text');
+    });
+});
+
+describe('espejo privado', () => {
+    it('agrega tenantId, author y actor a la versión pública', () => {
+        expect(
+            errorsOf(PrivateResolveReconciliationItemRequest, {
+                ...operator,
+                type: ReconciliationResolutionTypeEnum.EXCLUDE,
+                reason: 'prueba interna',
+            }),
+        ).toEqual([]);
+        const missing = errorsOf(PrivateResolveReconciliationItemRequest, {
+            type: ReconciliationResolutionTypeEnum.EXCLUDE,
+            reason: 'prueba interna',
+        });
+        expect(missing).toEqual(expect.arrayContaining(['tenantId', 'author', 'actor']));
+        expect(errorsOf(PrivateAddReconciliationItemNoteRequest, { ...operator, actor: 'no-es-correo', text: 'revisar con tesorería' })).toContain(
+            'actor',
+        );
+    });
+
+    it('cubre definiciones, corridas y lecturas', () => {
+        expect(
+            errorsOf(PrivateConfigureReconciliationDefinitionRequest, {
+                ...operator,
+                status: ReconciliationDefinitionStatusEnum.PAUSED,
+            }),
+        ).toEqual([]);
+        expect(errorsOf(PrivateListReconciliationDefinitionsQuery, operator)).toEqual([]);
+        expect(errorsOf(PrivateRunReconciliationRequest, { ...operator, definitionId: 'm8-gateway-bank', periodKey: '2026-10-29' })).toEqual(
+            [],
+        );
+        expect(errorsOf(PrivateGetReconciliationItemQuery, { tenantId: 'surekeep', author: 'x' })).toContain('actor');
+        expect(errorsOf(PrivateListReconciliationItemsQuery, { ...operator, definitionId: 'm8-gateway-sofom' })).toEqual([]);
+    });
+});
+
+describe('feed genérico de los dueños', () => {
+    it('lista por tenant y ventana, con cursor opcional', () => {
+        expect(
+            errorsOf(PrivateListReconciliationFeedQuery, {
+                tenantId: 'surekeep',
+                from: '2026-10-19T06:00:00.000Z',
+                to: '2026-10-26T05:59:59.999Z',
+                cursor: 'abc',
+            }),
+        ).toEqual([]);
+        expect(errorsOf(PrivateListReconciliationFeedQuery, { tenantId: 'surekeep', from: 'ayer' })).toEqual(
+            expect.arrayContaining(['from', 'to']),
+        );
+    });
+
+    it('el registro por recordId pide tenant y el servicio que llama; el actor es opcional', () => {
+        expect(errorsOf(PrivateGetReconciliationFeedRecordQuery, { tenantId: 'surekeep', author: 'reconciliation-engine-business' })).toEqual(
+            [],
+        );
+        expect(
+            errorsOf(PrivateGetReconciliationFeedRecordQuery, {
+                tenantId: 'surekeep',
+                author: 'reconciliation-engine-business',
+                actor: 'no-es-correo',
+            }),
+        ).toContain('actor');
+        expect(errorsOf(PrivateGetReconciliationFeedRecordQuery, { tenantId: 'surekeep' })).toContain('author');
+    });
+
+    it('el concepto del path es del catálogo de feeds', () => {
+        expect(errorsOf(ReconciliationFeedPathParams, { concept: ReconciliationFeedConceptEnum.SIGNED_CREDIT })).toEqual([]);
+        expect(errorsOf(ReconciliationFeedPathParams, { concept: 'ADJUSTMENT' })).toContain('concept');
+    });
+});

package/_test_/unit/reconciliation/reconciliationShapes.test.ts

@@ -0,0 +1,74 @@
+import 'reflect-metadata';
+import * as Reconciliation from '../../../src/reconciliation';
+import * as TransferNote from '../../../src/transferNote';
+import { CurrencyId } from '../../../src/currency/enums/CurrencyId';
+
+const { ReconciliationFeedConceptEnum, ReconciliationRuleTypeEnum, ReconciliationItemStateEnum, ReconciliationLayerEnum } =
+    Reconciliation;
+
+describe('formas del contrato', () => {
+    it('una reversa es una fila nueva con signo contrario y refs cerrados', () => {
+        const reversal: Reconciliation.ReconciliationFeedRecord = {
+            recordId: 'pay-1#rev',
+            tenantId: 'surekeep',
+            concept: ReconciliationFeedConceptEnum.INSTALLMENT_COLLECTION,
+            matchKey: 'att-1',
+            amountCents: -15000,
+            currency: CurrencyId.MXN,
+            occurredAt: '2026-10-20T15:00:00.000Z',
+            feedDay: '2026-10-20',
+            refs: { attemptId: 'att-1', creditId: 'cr-1', customerId: 'c-1', reversesRecordId: 'pay-1' },
+        };
+        expect(reversal.refs.reversesRecordId).toBe('pay-1');
+        expect(Object.keys(reversal)).not.toContain('sandbox');
+    });
+
+    it('el feed de notas usa la misma envoltura con sus registros', () => {
+        const page: Reconciliation.PrivateListReconciliationFeedResponse<TransferNote.TransferNoteSettlementFeedRecord> = {
+            records: [],
+        };
+        expect(page.cursor).toBeUndefined();
+    });
+
+    it('ReconciliationItemMatched exige refs.noteId', () => {
+        const detail: Reconciliation.ReconciliationItemMatchedEventDetail = {
+            eventId: 'surekeep#m8-gateway-bank#TRANSFER_NOTE_SETTLEMENT#n-1',
+            tenantId: 'surekeep',
+            definitionId: 'm8-gateway-bank',
+            itemKey: 'TRANSFER_NOTE_SETTLEMENT#n-1',
+            ruleType: ReconciliationRuleTypeEnum.BANK_STATEMENT,
+            periodKey: '2026-10-29',
+            amountCents: 125000,
+            matchedAt: '2026-10-29T10:00:00.000Z',
+            refs: { noteId: 'n-1', trackingKey: 'BBVA123' },
+        };
+        expect(detail.refs.noteId).toBe('n-1');
+    });
+
+    it('el detalle de completitud trae piezas y omite el campo en vivo que falló', () => {
+        const detail: Reconciliation.GetReconciliationItemResponse = {
+            tenantId: 'surekeep',
+            definitionId: 'm8-sofom-retailer-cycle',
+            itemKey: 'SIGNED_CREDIT#cr-1',
+            concept: ReconciliationFeedConceptEnum.SIGNED_CREDIT,
+            matchKey: 'cr-1',
+            layer: ReconciliationLayerEnum.COMPLETENESS,
+            periodKey: '2026-10-20',
+            state: ReconciliationItemStateEnum.INCOMPLETE,
+            currency: CurrencyId.MXN,
+            parts: [
+                { partName: 'DEVICE_PAYMENT', concept: ReconciliationFeedConceptEnum.TRANSFER_NOTE_ITEM, recordId: 'it-1' },
+                { partName: 'DOWN_PAYMENT', concept: ReconciliationFeedConceptEnum.TRANSFER_NOTE_ITEM },
+            ],
+            firstSeenRunId: 'run-1',
+            lastSeenRunId: 'run-2',
+            createdAt: '2026-10-21T10:00:00.000Z',
+            updatedAt: '2026-10-28T10:00:00.000Z',
+            notes: [],
+            resolutionHistory: [],
+            liveDetail: { creditId: 'cr-1', amountCents: 450000, productModel: 'Galaxy A15' },
+        };
+        expect(detail.parts?.[1].recordId).toBeUndefined();
+        expect(detail.liveDetail.customerName).toBeUndefined();
+    });
+});

package/_test_/unit/retailWizard/privateGetSale.test.ts

@@ -0,0 +1,59 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validateSync } from 'class-validator';
+import * as RetailWizard from '../../../src/retailWizard';
+
+const { PrivateGetSaleRequest, PRIVATE_SALE_DETAIL_FIELDS, RETAIL_WIZARD_CALLER_SERVICE_PATTERN } = RetailWizard;
+
+function errorsOf(payload: Record<string, unknown>): string[] {
+    const dto = plainToInstance(PrivateGetSaleRequest, payload, { excludeExtraneousValues: true });
+    return validateSync(dto).map((e) => e.property);
+}
+
+const valid = {
+    saleId: 'sale-1',
+    tenantId: 'surekeep',
+    actor: 'operador@fsa.mx',
+    callerService: 'reconciliation-engine-business',
+};
+
+describe('PrivateGetSaleRequest', () => {
+    it('acepta saleId, tenant, actor y callerService', () => {
+        expect(errorsOf(valid)).toEqual([]);
+    });
+
+    it('los cuatro son obligatorios', () => {
+        expect(errorsOf({}).sort()).toEqual(['actor', 'callerService', 'saleId', 'tenantId']);
+    });
+
+    it('callerService es el nombre del lambda en kebab-case', () => {
+        expect(errorsOf({ ...valid, callerService: 'Reconciliation Engine' })).toEqual(['callerService']);
+        expect(RETAIL_WIZARD_CALLER_SERVICE_PATTERN.test('reconciliation-engine-business')).toBe(true);
+    });
+});
+
+describe('PRIVATE_SALE_DETAIL_FIELDS', () => {
+    it('es la lista cerrada del detalle más ids', () => {
+        expect([...PRIVATE_SALE_DETAIL_FIELDS].sort()).toEqual(
+            [
+                'amountCents',
+                'creditId',
+                'customerName',
+                'customerPhone',
+                'productModel',
+                'retailCustomerId',
+                'retailerId',
+                'saleId',
+                'sellerName',
+                'sellerRetailUserId',
+            ].sort(),
+        );
+    });
+
+    it('nunca incluye IMEI, CURP ni RFC', () => {
+        const fields = PRIVATE_SALE_DETAIL_FIELDS.map((f) => f.toLowerCase());
+        for (const forbidden of ['imei', 'customercurp', 'curp', 'rfc', 'email', 'address']) {
+            expect(fields).not.toContain(forbidden);
+        }
+    });
+});

package/_test_/unit/transaction/transactionCreateRequestM8.test.ts

@@ -0,0 +1,27 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validateSync } from 'class-validator';
+import { TransactionCreateRequest } from '../../../src/transaction';
+
+function errorPropsOf(payload: Record<string, unknown>): string[] {
+    return validateSync(plainToInstance(TransactionCreateRequest, payload)).map((e) => e.property);
+}
+
+describe('TransactionCreateRequest · executionId y tenant SOFOM', () => {
+    it('ambos son opcionales', () => {
+        const props = errorPropsOf({});
+        expect(props).not.toContain('executionId');
+        expect(props).not.toContain('sofomTenantId');
+    });
+
+    it('acepta strings no vacíos', () => {
+        const props = errorPropsOf({ executionId: 'exec-1', sofomTenantId: 'surekeep' });
+        expect(props).not.toContain('executionId');
+        expect(props).not.toContain('sofomTenantId');
+    });
+
+    it('rechaza tipos que no son string o vacíos', () => {
+        expect(errorPropsOf({ executionId: 12 })).toContain('executionId');
+        expect(errorPropsOf({ sofomTenantId: '' })).toContain('sofomTenantId');
+    });
+});

package/_test_/unit/transactionProcessor/reconciliationAdjustment.test.ts

@@ -0,0 +1,63 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validateSync } from 'class-validator';
+import * as TransactionProcessor from '../../../src/transactionProcessor';
+import { OperationEnum } from '../../../src/transaction';
+import { CurrencyId } from '../../../src/currency/enums/CurrencyId';
+
+const { PrivateAuthorizeReconciliationAdjustmentRequest } = TransactionProcessor;
+
+function errorsOf(payload: Record<string, unknown>): string[] {
+    const dto = plainToInstance(PrivateAuthorizeReconciliationAdjustmentRequest, payload, { excludeExtraneousValues: true });
+    return validateSync(dto).map((e) => e.property);
+}
+
+const valid = {
+    tenantId: 'surekeep',
+    adjustmentKey: 'surekeep#INSTALLMENT_COLLECTION_L1#exec-1#1',
+    directoryId: '3f2b8c1e-7a4d-4b9e-9c1a-2d5e6f7a8b9c',
+    operation: OperationEnum.ADD,
+    amountCents: 15000,
+    currencyId: CurrencyId.MXN,
+    originalTransactionId: 'tx-1',
+    executionId: 'exec-1',
+    reference: { definitionId: 'INSTALLMENT_COLLECTION_L1', itemKey: 'exec-1' },
+    reason: 'cobro duplicado del intento exec-1',
+    actor: 'operador@fsa.mx',
+    author: 'reconciliation-engine-business',
+};
+
+describe('PrivateAuthorizeReconciliationAdjustmentRequest', () => {
+    it('acepta un ajuste completo', () => {
+        expect(errorsOf(valid)).toEqual([]);
+    });
+
+    it('executionId es opcional', () => {
+        const { executionId, ...rest } = valid;
+        expect(errorsOf(rest)).toEqual([]);
+    });
+
+    it('la llave debe empezar con el tenantId', () => {
+        expect(errorsOf({ ...valid, adjustmentKey: 'otro#INSTALLMENT_COLLECTION_L1#exec-1#1' })).toEqual(['adjustmentKey']);
+        expect(errorsOf({ ...valid, adjustmentKey: 'INSTALLMENT_COLLECTION_L1#exec-1#1' })).toEqual(['adjustmentKey']);
+    });
+
+    it('el monto es entero positivo en centavos', () => {
+        expect(errorsOf({ ...valid, amountCents: 0 })).toEqual(['amountCents']);
+        expect(errorsOf({ ...valid, amountCents: -100 })).toEqual(['amountCents']);
+        expect(errorsOf({ ...valid, amountCents: 10.5 })).toEqual(['amountCents']);
+    });
+
+    it('rechaza operación, moneda, directoryId y actor inválidos', () => {
+        expect(errorsOf({ ...valid, operation: 'CREDIT' })).toEqual(['operation']);
+        expect(errorsOf({ ...valid, currencyId: 'MEX' })).toEqual(['currencyId']);
+        expect(errorsOf({ ...valid, directoryId: 'no-uuid' })).toEqual(['directoryId']);
+        expect(errorsOf({ ...valid, actor: 'no-email' })).toEqual(['actor']);
+    });
+
+    it('exige la referencia a la partida y la razón', () => {
+        expect(errorsOf({ ...valid, reference: { definitionId: 'X' } })).toEqual(['reference']);
+        expect(errorsOf({ ...valid, reason: '   ' })).toEqual(['reason']);
+        expect(errorsOf({ ...valid, originalTransactionId: '' })).toEqual(['originalTransactionId']);
+    });
+});