@fiado/type-kit 3.399.0 → 3.401.0

package/_test_/unit/loanCredit/dtos/loanDeviceContract.test.ts

@@ -7,7 +7,17 @@ import { LoanDeviceLastSeenRequest } from '../../../../src/loanCredit/dtos/reque
 import { LoanDeviceStatusRequest } from '../../../../src/loanCredit/dtos/requests/LoanDeviceStatusRequest';
 import { LoanDeviceManualLockRequest } from '../../../../src/loanCredit/dtos/requests/LoanDeviceManualLockRequest';
 import { LoanDeviceManualUnlockRequest } from '../../../../src/loanCredit/dtos/requests/LoanDeviceManualUnlockRequest';
+import { LoanDeviceNotifyRequest } from '../../../../src/loanCredit/dtos/requests/LoanDeviceNotifyRequest';
+import { LoanDeviceReleaseRequest } from '../../../../src/loanCredit/dtos/requests/LoanDeviceReleaseRequest';
+import { LoanDeviceNotifyResponse } from '../../../../src/loanCredit/dtos/responses/LoanDeviceNotifyResponse';
+import { LoanDeviceNotifyResult } from '../../../../src/loanCredit/dtos/responses/LoanDeviceNotifyResult';
+import { LoanDeviceReleaseResponse } from '../../../../src/loanCredit/dtos/responses/LoanDeviceReleaseResponse';
+import { LoanDeviceReleaseResult } from '../../../../src/loanCredit/dtos/responses/LoanDeviceReleaseResult';
 import { LoanDeviceLockReasonEnum } from '../../../../src/loanCredit/enums/LoanDeviceLockReasonEnum';
+import { LoanDeviceMdmStatusEnum } from '../../../../src/loanCredit/enums/LoanDeviceMdmStatusEnum';
+import { DeviceNotifyIntensityEnum } from '../../../../src/mdm/enums/DeviceNotifyIntensityEnum';
+import { DeviceReleaseReasonEnum } from '../../../../src/mdm/enums/DeviceReleaseReasonEnum';
+import { MdmOperationStatusEnum } from '../../../../src/mdm/enums/MdmOperationStatusEnum';
 import { LOAN_DEVICE_MAX_BATCH } from '../../../../src/loanCredit/constants/LoanDeviceBatchLimits';
 
 /** ULIDs reales del motor: así es como `LoanCreditService` genera los creditId. */
@@ -34,6 +44,9 @@ const creditIdAt = (index: number): string => {
 const hasConstraint = (errors: ValidationError[], property: string, constraint: string): boolean =>
     errors.some(e => e.property === property && Boolean(e.constraints?.[constraint]));
 
+/** Instante ISO-8601 a N días de ahora; evita que el test caduque con el calendario. */
+const isoInDays = (days: number): string => new Date(Date.now() + days * 86_400_000).toISOString();
+
 const validEnrollItem = {
     creditId: CREDIT_ID,
     imei: '351756051523999',
@@ -230,6 +243,15 @@ describe('LoanDeviceManualUnlockRequest', () => {
         expect(JSON.stringify(itemsError)).toContain('creditId');
     });
 
+    it(`acepta exactamente ${LOAN_DEVICE_MAX_BATCH} ítems`, async () => {
+        const items = Array.from({ length: LOAN_DEVICE_MAX_BATCH }, (_, i) => ({
+            creditId: creditIdAt(i),
+        }));
+        const dto = plainToInstance(LoanDeviceManualUnlockRequest, { ...validUnlock, items });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
     it(`falla si el lote supera ${LOAN_DEVICE_MAX_BATCH} ítems`, async () => {
         const items = Array.from({ length: LOAN_DEVICE_MAX_BATCH + 1 }, (_, i) => ({
             creditId: creditIdAt(i),
@@ -294,3 +316,386 @@ describe.each([
         expect(hasConstraint(errors, 'creditIds', 'arrayUnique')).toBe(true);
     });
 });
+
+describe('LoanDeviceNotifyRequest', () => {
+    const validNotifyItem = {
+        creditId: CREDIT_ID,
+        intensity: DeviceNotifyIntensityEnum.BANNER,
+        notificationCode: 'PAYMENT_REMINDER_D1',
+        title: 'Tu pago está pendiente',
+        content: 'Ponte al corriente para seguir usando tu equipo.',
+    };
+    const validNotify = { items: [validNotifyItem], operationReference: 'notify-2026-09-02-0001' };
+
+    const notifyWithItems = (items: unknown[]) => ({ ...validNotify, items });
+
+    /** Cota de cada campo de texto libre, para probar el borde exacto y el borde + 1. */
+    const NOTIFY_MAX_LENGTHS: ReadonlyArray<readonly [string, number]> = [
+        ['notificationCode', 64],
+        ['title', 128],
+        ['content', 1024],
+    ];
+
+    it('valida happy path (0 errores)', async () => {
+        const dto = plainToInstance(LoanDeviceNotifyRequest, validNotify);
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('valida con intensity FULLSCREEN', async () => {
+        const items = [{ ...validNotifyItem, intensity: DeviceNotifyIntensityEnum.FULLSCREEN }];
+        const dto = plainToInstance(LoanDeviceNotifyRequest, notifyWithItems(items));
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si intensity está fuera del enum', async () => {
+        const items = [{ ...validNotifyItem, intensity: 'POPUP' }];
+        const dto = plainToInstance(LoanDeviceNotifyRequest, notifyWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('intensity');
+    });
+
+    it.each(['notificationCode', 'title', 'content'] as const)('falla si %s viene vacío', async field => {
+        const items = [{ ...validNotifyItem, [field]: '' }];
+        const dto = plainToInstance(LoanDeviceNotifyRequest, notifyWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain(field);
+    });
+
+    it.each(['notificationCode', 'title', 'content'] as const)('falla si %s no viene', async field => {
+        const { [field]: _omitted, ...rest } = validNotifyItem;
+        const dto = plainToInstance(LoanDeviceNotifyRequest, notifyWithItems([rest]));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain(field);
+    });
+
+    it.each(['notificationCode', 'title', 'content'] as const)('falla si %s no es string', async field => {
+        const items = [{ ...validNotifyItem, [field]: 42 }];
+        const dto = plainToInstance(LoanDeviceNotifyRequest, notifyWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain(field);
+    });
+
+    it('falla si intensity no viene', async () => {
+        const { intensity: _omitted, ...rest } = validNotifyItem;
+        const dto = plainToInstance(LoanDeviceNotifyRequest, notifyWithItems([rest]));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('intensity');
+    });
+
+    it.each(NOTIFY_MAX_LENGTHS)('acepta %s en su largo máximo de %i', async (field, max) => {
+        const items = [{ ...validNotifyItem, [field]: 'x'.repeat(max) }];
+        const dto = plainToInstance(LoanDeviceNotifyRequest, notifyWithItems(items));
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it.each(NOTIFY_MAX_LENGTHS)('falla si %s supera su largo máximo de %i', async (field, max) => {
+        const items = [{ ...validNotifyItem, [field]: 'x'.repeat(max + 1) }];
+        const dto = plainToInstance(LoanDeviceNotifyRequest, notifyWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('maxLength');
+        expect(JSON.stringify(itemsError)).toContain(field);
+    });
+
+    it('falla si algún creditId no es un ULID', async () => {
+        const items = [{ ...validNotifyItem, creditId: A_UUID }];
+        const dto = plainToInstance(LoanDeviceNotifyRequest, notifyWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('creditId');
+    });
+
+    it(`acepta exactamente ${LOAN_DEVICE_MAX_BATCH} ítems`, async () => {
+        const items = Array.from({ length: LOAN_DEVICE_MAX_BATCH }, (_, i) => ({
+            ...validNotifyItem,
+            creditId: creditIdAt(i),
+        }));
+        const dto = plainToInstance(LoanDeviceNotifyRequest, notifyWithItems(items));
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it(`falla si el lote supera ${LOAN_DEVICE_MAX_BATCH} ítems`, async () => {
+        const items = Array.from({ length: LOAN_DEVICE_MAX_BATCH + 1 }, (_, i) => ({
+            ...validNotifyItem,
+            creditId: creditIdAt(i),
+        }));
+        const dto = plainToInstance(LoanDeviceNotifyRequest, notifyWithItems(items));
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'items', 'arrayMaxSize')).toBe(true);
+    });
+
+    it('falla si dos ítems traen el mismo creditId', async () => {
+        const dto = plainToInstance(LoanDeviceNotifyRequest, notifyWithItems([validNotifyItem, { ...validNotifyItem }]));
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'items', 'arrayUnique')).toBe(true);
+    });
+
+    it('falla si items viene vacío', async () => {
+        const dto = plainToInstance(LoanDeviceNotifyRequest, notifyWithItems([]));
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'items', 'arrayNotEmpty')).toBe(true);
+    });
+
+    it('falla si operationReference supera los 64 caracteres', async () => {
+        const dto = plainToInstance(LoanDeviceNotifyRequest, { ...validNotify, operationReference: 'x'.repeat(200) });
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'operationReference', 'isLength')).toBe(true);
+    });
+
+    it('falla si operationReference viene vacío', async () => {
+        const dto = plainToInstance(LoanDeviceNotifyRequest, { ...validNotify, operationReference: '' });
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'operationReference', 'isNotEmpty')).toBe(true);
+    });
+
+    it('falla si operationReference no viene', async () => {
+        const { operationReference: _omitted, ...rest } = validNotify;
+        const dto = plainToInstance(LoanDeviceNotifyRequest, rest);
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'operationReference')).toBe(true);
+    });
+});
+
+describe('LoanDeviceReleaseRequest', () => {
+    const validReleaseItem = { creditId: CREDIT_ID, reason: DeviceReleaseReasonEnum.CREDIT_PAID_OFF };
+    const validRelease = { items: [validReleaseItem], operationReference: 'release-2026-09-02-0001' };
+
+    const releaseWithItems = (items: unknown[]) => ({ ...validRelease, items });
+
+    it('valida happy path sin comment (0 errores)', async () => {
+        const dto = plainToInstance(LoanDeviceReleaseRequest, validRelease);
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('valida con comment presente', async () => {
+        const items = [{ ...validReleaseItem, reason: DeviceReleaseReasonEnum.OTHER, comment: 'Equipo robado y repuesto.' }];
+        const dto = plainToInstance(LoanDeviceReleaseRequest, releaseWithItems(items));
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si comment no es string', async () => {
+        const items = [{ ...validReleaseItem, comment: 42 }];
+        const dto = plainToInstance(LoanDeviceReleaseRequest, releaseWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('comment');
+    });
+
+    it('acepta comment en su largo máximo de 500', async () => {
+        const items = [{ ...validReleaseItem, comment: 'x'.repeat(500) }];
+        const dto = plainToInstance(LoanDeviceReleaseRequest, releaseWithItems(items));
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si comment supera los 500 caracteres', async () => {
+        const items = [{ ...validReleaseItem, comment: 'x'.repeat(501) }];
+        const dto = plainToInstance(LoanDeviceReleaseRequest, releaseWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('maxLength');
+        expect(JSON.stringify(itemsError)).toContain('comment');
+    });
+
+    it('falla si reason está fuera del enum', async () => {
+        const items = [{ creditId: CREDIT_ID, reason: 'PORQUE_SI' }];
+        const dto = plainToInstance(LoanDeviceReleaseRequest, releaseWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('reason');
+    });
+
+    it('falla si reason no viene', async () => {
+        const items = [{ creditId: CREDIT_ID }];
+        const dto = plainToInstance(LoanDeviceReleaseRequest, releaseWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('reason');
+    });
+
+    it('falla si algún creditId no es un ULID', async () => {
+        const items = [{ ...validReleaseItem, creditId: A_UUID }];
+        const dto = plainToInstance(LoanDeviceReleaseRequest, releaseWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('creditId');
+    });
+
+    it(`acepta exactamente ${LOAN_DEVICE_MAX_BATCH} ítems`, async () => {
+        const items = Array.from({ length: LOAN_DEVICE_MAX_BATCH }, (_, i) => ({
+            ...validReleaseItem,
+            creditId: creditIdAt(i),
+        }));
+        const dto = plainToInstance(LoanDeviceReleaseRequest, releaseWithItems(items));
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it(`falla si el lote supera ${LOAN_DEVICE_MAX_BATCH} ítems`, async () => {
+        const items = Array.from({ length: LOAN_DEVICE_MAX_BATCH + 1 }, (_, i) => ({
+            ...validReleaseItem,
+            creditId: creditIdAt(i),
+        }));
+        const dto = plainToInstance(LoanDeviceReleaseRequest, releaseWithItems(items));
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'items', 'arrayMaxSize')).toBe(true);
+    });
+
+    it('falla si dos ítems traen el mismo creditId', async () => {
+        const dto = plainToInstance(LoanDeviceReleaseRequest, releaseWithItems([validReleaseItem, { ...validReleaseItem }]));
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'items', 'arrayUnique')).toBe(true);
+    });
+
+    it('falla si items viene vacío', async () => {
+        const dto = plainToInstance(LoanDeviceReleaseRequest, releaseWithItems([]));
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'items', 'arrayNotEmpty')).toBe(true);
+    });
+
+    it('falla si operationReference supera los 64 caracteres', async () => {
+        const dto = plainToInstance(LoanDeviceReleaseRequest, { ...validRelease, operationReference: 'x'.repeat(200) });
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'operationReference', 'isLength')).toBe(true);
+    });
+
+    it('falla si operationReference viene vacío', async () => {
+        const dto = plainToInstance(LoanDeviceReleaseRequest, { ...validRelease, operationReference: '' });
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'operationReference', 'isNotEmpty')).toBe(true);
+    });
+
+    it('falla si operationReference no viene', async () => {
+        const { operationReference: _omitted, ...rest } = validRelease;
+        const dto = plainToInstance(LoanDeviceReleaseRequest, rest);
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'operationReference')).toBe(true);
+    });
+});
+
+describe('LoanDeviceManualUnlockRequest — unlockUntil', () => {
+    const unlockWith = (item: Record<string, unknown>) => ({
+        items: [item],
+        operationReference: 'unlock-2026-09-02-0001',
+    });
+
+    /** Falla y el error apunta a `unlockUntil`. */
+    const expectUnlockUntilRejected = async (unlockUntil: unknown): Promise<void> => {
+        const dto = plainToInstance(LoanDeviceManualUnlockRequest, unlockWith({ creditId: CREDIT_ID, unlockUntil }));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('unlockUntil');
+    };
+
+    it('valida con unlockUntil datetime futuro', async () => {
+        const dto = plainToInstance(LoanDeviceManualUnlockRequest, unlockWith({
+            creditId: CREDIT_ID,
+            unlockUntil: isoInDays(30),
+        }));
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si unlockUntil no es ISO-8601', async () => {
+        await expectUnlockUntilRejected('30/09/2026');
+    });
+
+    it('falla si unlockUntil es una fecha pasada', async () => {
+        await expectUnlockUntilRejected(isoInDays(-1));
+    });
+
+    it('falla si unlockUntil es solo fecha, sin hora', async () => {
+        await expectUnlockUntilRejected('2099-09-30');
+    });
+
+    it('falla si unlockUntil no trae zona horaria', async () => {
+        await expectUnlockUntilRejected('2099-09-30T23:59:59');
+    });
+
+    it('falla si unlockUntil no es string', async () => {
+        await expectUnlockUntilRejected(42);
+    });
+
+    it('sigue aceptando ítems sin unlockUntil (el campo es opcional)', async () => {
+        const dto = plainToInstance(LoanDeviceManualUnlockRequest, unlockWith({ creditId: CREDIT_ID }));
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+});
+
+describe('responses de notify y release', () => {
+    it('LoanDeviceNotifyResponse arma un resultado por ítem, con la referencia del batch', () => {
+        const response: LoanDeviceNotifyResponse = {
+            results: [
+                {
+                    creditId: CREDIT_ID,
+                    status: MdmOperationStatusEnum.SUCCESS,
+                    operationReference: 'notify-2026-09-02-0001',
+                    mdmStatus: LoanDeviceMdmStatusEnum.LOCKED,
+                    notifiedAt: isoInDays(0),
+                },
+            ],
+        };
+        expect(response.results[0].notifiedAt).toBeDefined();
+        expect(response.results[0].operationReference).toBe('notify-2026-09-02-0001');
+    });
+
+    it('LoanDeviceNotifyResult deja notifiedAt opcional: un ítem puede fallar sin instante', () => {
+        const failed: LoanDeviceNotifyResult = {
+            creditId: CREDIT_ID,
+            status: MdmOperationStatusEnum.ERROR,
+            operationReference: 'notify-2026-09-02-0002',
+            mdmStatus: LoanDeviceMdmStatusEnum.ACTIVE,
+        };
+        expect(failed.notifiedAt).toBeUndefined();
+    });
+
+    it('LoanDeviceReleaseResponse reporta el expediente ya liberado', () => {
+        const response: LoanDeviceReleaseResponse = {
+            results: [
+                {
+                    creditId: CREDIT_ID,
+                    status: MdmOperationStatusEnum.SUCCESS,
+                    operationReference: 'release-2026-09-02-0001',
+                    mdmStatus: LoanDeviceMdmStatusEnum.RELEASED,
+                    releasedAt: isoInDays(0),
+                },
+            ],
+        };
+        expect(response.results[0].mdmStatus).toBe(LoanDeviceMdmStatusEnum.RELEASED);
+    });
+
+    it('LoanDeviceReleaseResult deja releasedAt opcional: un ítem puede fallar sin instante', () => {
+        const failed: LoanDeviceReleaseResult = {
+            creditId: CREDIT_ID,
+            status: MdmOperationStatusEnum.ERROR,
+            operationReference: 'release-2026-09-02-0002',
+            mdmStatus: LoanDeviceMdmStatusEnum.ACTIVE,
+        };
+        expect(failed.releasedAt).toBeUndefined();
+    });
+});

package/_test_/unit/mdm/dtos/mdmDeviceContract.test.ts

@@ -0,0 +1,83 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate, ValidationError } from 'class-validator';
+import { DeviceEnrollRequest } from '../../../../src/mdm/dtos/DeviceEnrollRequest';
+import { DeviceUnlockRequest } from '../../../../src/mdm/dtos/DeviceUnlockRequest';
+import { MdmErrorCodeEnum } from '../../../../src/mdm/enums/MdmErrorCodeEnum';
+import * as MdmBarrel from '../../../../src/mdm/index';
+import { MdmLockModeEnum } from '../../../../src/retailCatalog/enums/MdmLockModeEnum';
+
+/** ULID real del motor: así genera los creditId `loan-credit-business`. */
+const CREDIT_ID = '01M0B5D7FQA3T06K4REEVPRM33';
+
+/** True si el error de `property` trae ese constraint puntual (no solo "algo falló"). */
+const hasConstraint = (errors: ValidationError[], property: string, constraint: string): boolean =>
+    errors.some(e => e.property === property && Boolean(e.constraints?.[constraint]));
+
+/** Payload de enrolamiento tal como lo manda hoy un consumidor ya desplegado. */
+const validEnroll = {
+    imei: '351756051523999',
+    creditId: CREDIT_ID,
+    termMonths: 6,
+    operationReference: 'enroll-2026-09-01-0001',
+};
+
+const validUnlock = {
+    imei: '351756051523999',
+    operationReference: 'unlock-2026-09-01-0001',
+};
+
+describe('DeviceEnrollRequest.lockMode', () => {
+    it('valida sin lockMode: el consumidor de hoy no se rompe', async () => {
+        const dto = plainToInstance(DeviceEnrollRequest, validEnroll);
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+        expect(dto.lockMode).toBeUndefined();
+    });
+
+    it.each([MdmLockModeEnum.ONDEMAND, MdmLockModeEnum.SCHEDULED])('valida con lockMode %s', async lockMode => {
+        const dto = plainToInstance(DeviceEnrollRequest, { ...validEnroll, lockMode });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+        expect(dto.lockMode).toBe(lockMode);
+    });
+
+    it('falla si lockMode está fuera del enum', async () => {
+        const dto = plainToInstance(DeviceEnrollRequest, { ...validEnroll, lockMode: 'PREPAGO' });
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'lockMode', 'isEnum')).toBe(true);
+    });
+});
+
+describe('DeviceUnlockRequest.unlockUntil', () => {
+    it('valida sin unlockUntil: el consumidor de hoy no se rompe', async () => {
+        const dto = plainToInstance(DeviceUnlockRequest, validUnlock);
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+        expect(dto.unlockUntil).toBeUndefined();
+    });
+
+    it('valida con unlockUntil en ISO-8601', async () => {
+        const dto = plainToInstance(DeviceUnlockRequest, { ...validUnlock, unlockUntil: '2026-10-01T00:00:00.000Z' });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si unlockUntil no es ISO-8601', async () => {
+        const dto = plainToInstance(DeviceUnlockRequest, { ...validUnlock, unlockUntil: '01/10/2026' });
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'unlockUntil', 'isIso8601')).toBe(true);
+    });
+});
+
+describe('MdmErrorCodeEnum', () => {
+    it('expone el código de desbloqueo sin vigencia sobre un equipo SCHEDULED', () => {
+        expect(MdmErrorCodeEnum.UNLOCK_UNTIL_REQUIRED).toBe('UNLOCK_UNTIL_REQUIRED');
+    });
+});
+
+describe('barrel de mdm', () => {
+    it('reexporta MdmLockModeEnum sin duplicar el enum de retailCatalog', () => {
+        expect(MdmBarrel.MdmLockModeEnum).toBe(MdmLockModeEnum);
+    });
+});

package/bin/loanCredit/dtos/LoanDeviceNotifyItem.d.ts

@@ -0,0 +1,12 @@
+import { DeviceNotifyIntensityEnum } from '../../mdm/enums/DeviceNotifyIntensityEnum';
+/**
+ * Ítem de notificación: a qué crédito se le avisa y con qué texto.
+ * Los tres campos de texto son obligatorios: Datacultr usa el código y Trustonic el texto crudo.
+ */
+export declare class LoanDeviceNotifyItem {
+    creditId: string;
+    intensity: DeviceNotifyIntensityEnum;
+    notificationCode: string;
+    title: string;
+    content: string;
+}

package/bin/loanCredit/dtos/LoanDeviceNotifyItem.js

@@ -0,0 +1,54 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoanDeviceNotifyItem = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const DeviceNotifyIntensityEnum_1 = require("../../mdm/enums/DeviceNotifyIntensityEnum");
+const CreditIdPattern_1 = require("../constants/CreditIdPattern");
+/**
+ * Ítem de notificación: a qué crédito se le avisa y con qué texto.
+ * Los tres campos de texto son obligatorios: Datacultr usa el código y Trustonic el texto crudo.
+ */
+class LoanDeviceNotifyItem {
+}
+exports.LoanDeviceNotifyItem = LoanDeviceNotifyItem;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Matches)(CreditIdPattern_1.CREDIT_ID_PATTERN, { message: CreditIdPattern_1.CREDIT_ID_MESSAGE }),
+    __metadata("design:type", String)
+], LoanDeviceNotifyItem.prototype, "creditId", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEnum)(DeviceNotifyIntensityEnum_1.DeviceNotifyIntensityEnum),
+    __metadata("design:type", String)
+], LoanDeviceNotifyItem.prototype, "intensity", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(64),
+    __metadata("design:type", String)
+], LoanDeviceNotifyItem.prototype, "notificationCode", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(128),
+    __metadata("design:type", String)
+], LoanDeviceNotifyItem.prototype, "title", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(1024),
+    __metadata("design:type", String)
+], LoanDeviceNotifyItem.prototype, "content", void 0);

package/bin/loanCredit/dtos/LoanDeviceReleaseItem.d.ts

@@ -0,0 +1,8 @@
+import { DeviceReleaseReasonEnum } from '../../mdm/enums/DeviceReleaseReasonEnum';
+/** Ítem de liberación definitiva: qué crédito se libera del MDM y por qué. */
+export declare class LoanDeviceReleaseItem {
+    creditId: string;
+    reason: DeviceReleaseReasonEnum;
+    /** Nota libre del operador; queda en el expediente del dispositivo. */
+    comment?: string;
+}

package/bin/loanCredit/dtos/LoanDeviceReleaseItem.js

@@ -0,0 +1,37 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoanDeviceReleaseItem = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const DeviceReleaseReasonEnum_1 = require("../../mdm/enums/DeviceReleaseReasonEnum");
+const CreditIdPattern_1 = require("../constants/CreditIdPattern");
+/** Ítem de liberación definitiva: qué crédito se libera del MDM y por qué. */
+class LoanDeviceReleaseItem {
+}
+exports.LoanDeviceReleaseItem = LoanDeviceReleaseItem;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Matches)(CreditIdPattern_1.CREDIT_ID_PATTERN, { message: CreditIdPattern_1.CREDIT_ID_MESSAGE }),
+    __metadata("design:type", String)
+], LoanDeviceReleaseItem.prototype, "creditId", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEnum)(DeviceReleaseReasonEnum_1.DeviceReleaseReasonEnum),
+    __metadata("design:type", String)
+], LoanDeviceReleaseItem.prototype, "reason", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.MaxLength)(500),
+    __metadata("design:type", String)
+], LoanDeviceReleaseItem.prototype, "comment", void 0);

package/bin/loanCredit/dtos/LoanDeviceUnlockItem.d.ts

@@ -0,0 +1,6 @@
+/** Ítem de desbloqueo: qué crédito se desbloquea y, opcionalmente, hasta cuándo. */
+export declare class LoanDeviceUnlockItem {
+    creditId: string;
+    /** Datetime ISO-8601 futuro de hasta cuándo vale el desbloqueo; solo aplica en modo SCHEDULED. */
+    unlockUntil?: string;
+}

package/bin/loanCredit/dtos/LoanDeviceUnlockItem.js

@@ -0,0 +1,31 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoanDeviceUnlockItem = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const CreditIdPattern_1 = require("../constants/CreditIdPattern");
+const IsFutureIso8601DateTime_1 = require("../validators/IsFutureIso8601DateTime");
+/** Ítem de desbloqueo: qué crédito se desbloquea y, opcionalmente, hasta cuándo. */
+class LoanDeviceUnlockItem {
+}
+exports.LoanDeviceUnlockItem = LoanDeviceUnlockItem;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Matches)(CreditIdPattern_1.CREDIT_ID_PATTERN, { message: CreditIdPattern_1.CREDIT_ID_MESSAGE }),
+    __metadata("design:type", String)
+], LoanDeviceUnlockItem.prototype, "creditId", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Validate)(IsFutureIso8601DateTime_1.IsFutureIso8601DateTime),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], LoanDeviceUnlockItem.prototype, "unlockUntil", void 0);