@fiado/type-kit 3.328.0 → 3.331.0

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,30 @@
+name: "Publish to npm"
+
+on:
+  push:
+    branches: [ develop ]
+    paths-ignore:
+      - '**.md'
+      - 'docs/**'
+      - '.gitignore'
+      - '.npmignore'
+  workflow_dispatch:
+    inputs:
+      dry-run:
+        description: 'Corre build, test y npm publish --dry-run sin publicar de verdad'
+        required: false
+        default: false
+        type: boolean
+
+concurrency:
+  group: npm-publish-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  publish:
+    uses: Fiado-Today/github-workflows/.github/workflows/npm-publish.yml@develop
+    permissions:
+      contents: write
+    with:
+      dry-run: ${{ inputs.dry-run == true }}
+    secrets: inherit

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

@@ -0,0 +1,283 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate, ValidationError } from 'class-validator';
+import { LoanDeviceEnrollRequest } from '../../../../src/loanCredit/dtos/requests/LoanDeviceEnrollRequest';
+import { LoanDeviceEnrollStatusRequest } from '../../../../src/loanCredit/dtos/requests/LoanDeviceEnrollStatusRequest';
+import { LoanDeviceLastSeenRequest } from '../../../../src/loanCredit/dtos/requests/LoanDeviceLastSeenRequest';
+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 { LoanDeviceLockReasonEnum } from '../../../../src/loanCredit/enums/LoanDeviceLockReasonEnum';
+import { LOAN_DEVICE_MAX_BATCH } from '../../../../src/loanCredit/constants/LoanDeviceBatchLimits';
+
+const CREDIT_ID = '5f7c8a90-1234-4abc-9def-0123456789ab';
+const OTHER_CREDIT_ID = '5f7c8a90-1234-4abc-9def-0123456789ac';
+
+/** Genera un creditId válido y distinto por índice, para armar lotes grandes. */
+const creditIdAt = (index: number): string =>
+    `5f7c8a90-1234-4abc-9def-${index.toString(16).padStart(12, '0')}`;
+
+/** 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]));
+
+const validEnrollItem = {
+    creditId: CREDIT_ID,
+    imei: '351756051523999',
+    productSku: 'SKU-MOTO-G54-128',
+    termMonths: 6,
+    firstDueDate: '2026-09-01',
+};
+
+const validEnroll = {
+    items: [validEnrollItem],
+    operationReference: 'enroll-2026-08-18-0001',
+};
+
+const enrollWithItems = (items: unknown[]) => ({ ...validEnroll, items });
+
+describe('LoanDeviceEnrollRequest', () => {
+    it('valida happy path (0 errores)', async () => {
+        const dto = plainToInstance(LoanDeviceEnrollRequest, validEnroll);
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('valida con imei2 presente', async () => {
+        const items = [{ ...validEnrollItem, imei2: '351756051523998' }];
+        const dto = plainToInstance(LoanDeviceEnrollRequest, enrollWithItems(items));
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si items viene vacío', async () => {
+        const dto = plainToInstance(LoanDeviceEnrollRequest, enrollWithItems([]));
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'items')).toBe(true);
+    });
+
+    it('falla si el imei tiene 14 dígitos', async () => {
+        const items = [{ ...validEnrollItem, imei: '35175605152399' }];
+        const dto = plainToInstance(LoanDeviceEnrollRequest, enrollWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('imei');
+    });
+
+    it('falla si el imei tiene 15 caracteres pero no son dígitos', async () => {
+        const items = [{ ...validEnrollItem, imei: 'ABCDEFGHIJKLMNO' }];
+        const dto = plainToInstance(LoanDeviceEnrollRequest, enrollWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('imei');
+    });
+
+    it('falla si el imei2 tiene 15 caracteres pero no son dígitos', async () => {
+        const items = [{ ...validEnrollItem, imei2: 'ABCDEFGHIJKLMNO' }];
+        const dto = plainToInstance(LoanDeviceEnrollRequest, enrollWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('imei2');
+    });
+
+    it(`falla si el lote supera ${LOAN_DEVICE_MAX_BATCH} ítems`, async () => {
+        const items = Array.from({ length: LOAN_DEVICE_MAX_BATCH + 1 }, (_, i) => ({
+            ...validEnrollItem,
+            creditId: creditIdAt(i),
+        }));
+        const dto = plainToInstance(LoanDeviceEnrollRequest, enrollWithItems(items));
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'items', 'arrayMaxSize')).toBe(true);
+    });
+
+    it('falla si dos ítems traen el mismo creditId', async () => {
+        const items = [validEnrollItem, { ...validEnrollItem }];
+        const dto = plainToInstance(LoanDeviceEnrollRequest, enrollWithItems(items));
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'items', 'arrayUnique')).toBe(true);
+    });
+
+    it('falla si el productSku trae caracteres fuera del patrón canónico', async () => {
+        const items = [{ ...validEnrollItem, productSku: 'SKU MOTO_G54!' }];
+        const dto = plainToInstance(LoanDeviceEnrollRequest, enrollWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('productSku');
+    });
+
+    it('falla si termMonths supera el plazo máximo', async () => {
+        const items = [{ ...validEnrollItem, termMonths: 9999 }];
+        const dto = plainToInstance(LoanDeviceEnrollRequest, enrollWithItems(items));
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('termMonths');
+    });
+
+    it('falla si operationReference supera los 64 caracteres', async () => {
+        const dto = plainToInstance(LoanDeviceEnrollRequest, {
+            ...validEnroll,
+            operationReference: 'x'.repeat(200),
+        });
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'operationReference', 'isLength')).toBe(true);
+    });
+});
+
+describe('LoanDeviceManualLockRequest', () => {
+    const validLockItem = { creditId: CREDIT_ID, reason: LoanDeviceLockReasonEnum.FRAUD };
+    const validLock = { items: [validLockItem], operationReference: 'lock-2026-08-18-0001' };
+
+    it('valida happy path (0 errores)', async () => {
+        const dto = plainToInstance(LoanDeviceManualLockRequest, validLock);
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('valida con screenMessage bien formado', async () => {
+        const items = [{ ...validLockItem, screenMessage: { title: 'Equipo bloqueado', content: 'Ponte al corriente.' } }];
+        const dto = plainToInstance(LoanDeviceManualLockRequest, { ...validLock, items });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si el screenMessage anidado es inválido', async () => {
+        const items = [{ ...validLockItem, screenMessage: { title: '', content: 5 } }];
+        const dto = plainToInstance(LoanDeviceManualLockRequest, { ...validLock, items });
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('title');
+    });
+
+    it('falla si reason está fuera del enum', async () => {
+        const dto = plainToInstance(LoanDeviceManualLockRequest, {
+            items: [{ creditId: CREDIT_ID, reason: 'PORQUE_SI' }],
+            operationReference: 'lock-2026-08-18-0002',
+        });
+        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 el lote supera ${LOAN_DEVICE_MAX_BATCH} ítems`, async () => {
+        const items = Array.from({ length: LOAN_DEVICE_MAX_BATCH + 1 }, (_, i) => ({
+            ...validLockItem,
+            creditId: creditIdAt(i),
+        }));
+        const dto = plainToInstance(LoanDeviceManualLockRequest, { ...validLock, 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(LoanDeviceManualLockRequest, {
+            ...validLock,
+            items: [validLockItem, { ...validLockItem }],
+        });
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'items', 'arrayUnique')).toBe(true);
+    });
+
+    it('falla si operationReference supera los 64 caracteres', async () => {
+        const dto = plainToInstance(LoanDeviceManualLockRequest, {
+            ...validLock,
+            operationReference: 'x'.repeat(200),
+        });
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'operationReference', 'isLength')).toBe(true);
+    });
+});
+
+describe('LoanDeviceManualUnlockRequest', () => {
+    const validUnlock = {
+        items: [{ creditId: CREDIT_ID }],
+        operationReference: 'unlock-2026-08-18-0001',
+    };
+
+    it('valida happy path (0 errores)', async () => {
+        const dto = plainToInstance(LoanDeviceManualUnlockRequest, validUnlock);
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si algún creditId no es UUID', async () => {
+        const dto = plainToInstance(LoanDeviceManualUnlockRequest, {
+            ...validUnlock,
+            items: [{ creditId: 'no-es-uuid' }],
+        });
+        const errors = await validate(dto);
+        const itemsError = errors.find(e => e.property === 'items');
+        expect(itemsError).toBeDefined();
+        expect(JSON.stringify(itemsError)).toContain('creditId');
+    });
+
+    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),
+        }));
+        const dto = plainToInstance(LoanDeviceManualUnlockRequest, { ...validUnlock, 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(LoanDeviceManualUnlockRequest, {
+            ...validUnlock,
+            items: [{ creditId: CREDIT_ID }, { creditId: CREDIT_ID }],
+        });
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'items', 'arrayUnique')).toBe(true);
+    });
+
+    it('falla si operationReference supera los 64 caracteres', async () => {
+        const dto = plainToInstance(LoanDeviceManualUnlockRequest, {
+            ...validUnlock,
+            operationReference: 'x'.repeat(200),
+        });
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'operationReference', 'isLength')).toBe(true);
+    });
+});
+
+describe.each([
+    ['LoanDeviceStatusRequest', LoanDeviceStatusRequest],
+    ['LoanDeviceEnrollStatusRequest', LoanDeviceEnrollStatusRequest],
+    ['LoanDeviceLastSeenRequest', LoanDeviceLastSeenRequest],
+] as const)('%s', (_name, RequestClass) => {
+    it('valida happy path (0 errores)', async () => {
+        const dto = plainToInstance(RequestClass, { creditIds: [CREDIT_ID, OTHER_CREDIT_ID] });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+    });
+
+    it('falla si algún creditId no es UUID', async () => {
+        const dto = plainToInstance(RequestClass, { creditIds: [CREDIT_ID, 'no-es-uuid'] });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'creditIds')).toBe(true);
+    });
+
+    it('falla si creditIds viene vacío', async () => {
+        const dto = plainToInstance(RequestClass, { creditIds: [] });
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'creditIds', 'arrayNotEmpty')).toBe(true);
+    });
+
+    it(`falla si el lote supera ${LOAN_DEVICE_MAX_BATCH} creditIds`, async () => {
+        const creditIds = Array.from({ length: LOAN_DEVICE_MAX_BATCH + 1 }, (_, i) => creditIdAt(i));
+        const dto = plainToInstance(RequestClass, { creditIds });
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'creditIds', 'arrayMaxSize')).toBe(true);
+    });
+
+    it('falla si creditIds trae un id repetido', async () => {
+        const dto = plainToInstance(RequestClass, { creditIds: [CREDIT_ID, CREDIT_ID] });
+        const errors = await validate(dto);
+        expect(hasConstraint(errors, 'creditIds', 'arrayUnique')).toBe(true);
+    });
+});

package/_test_/unit/places/GetNearbyPlacesRequest.test.ts

@@ -0,0 +1,70 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { GetNearbyPlacesRequest, PlaceTypeEnum } from '../../../src/places/index';
+
+/** El request mínimo válido: punto + al menos un tipo. */
+const base = {
+  latitude: 19.4326,
+  longitude: -99.1332,
+  types: [PlaceTypeEnum.CashInMx],
+};
+
+const instancia = (raw: Record<string, unknown>): GetNearbyPlacesRequest =>
+  plainToInstance(GetNearbyPlacesRequest, raw);
+
+/**
+ * Mismo modo en que valida el consumidor real (`places-business`): `whitelist: true`.
+ * Importa que sea idéntico, ver el test del radio más abajo.
+ */
+const propiedadesConError = async (raw: Record<string, unknown>): Promise<string[]> =>
+  (await validate(instancia(raw) as object, { whitelist: true })).map((e) => e.property);
+
+describe('GetNearbyPlacesRequest', () => {
+  it('valida sin radius: el radio es opcional', async () => {
+    const dto = instancia(base);
+
+    expect(await validate(dto as object, { whitelist: true })).toHaveLength(0);
+    expect(dto.radius).toBeUndefined();
+  });
+
+  it('valida con radius', async () => {
+    const dto = instancia({ ...base, radius: 5 });
+
+    expect(await validate(dto as object, { whitelist: true })).toHaveLength(0);
+    expect(dto.radius).toBe(5);
+  });
+
+  /**
+   * El guard que de verdad importa. El consumidor valida con `whitelist: true`, que
+   * DESCARTA toda propiedad sin decorador. Si alguien le quita los decoradores a
+   * `radius`, este contrato sigue compilando y el lambda pierde el radio en silencio:
+   * el mapa se quedaría pidiendo siempre el default. Que falle acá, no en producción.
+   */
+  it('radius sobrevive al whitelist del validador', async () => {
+    const instancia = plainToInstance(GetNearbyPlacesRequest, { ...base, radius: 12 });
+
+    await validate(instancia as object, { whitelist: true });
+
+    expect(instancia.radius).toBe(12);
+  });
+
+  it('rechaza un radius que no es positivo', async () => {
+    expect(await propiedadesConError({ ...base, radius: 0 })).toContain('radius');
+    expect(await propiedadesConError({ ...base, radius: -3 })).toContain('radius');
+  });
+
+  it('rechaza un radius que no es número', async () => {
+    expect(await propiedadesConError({ ...base, radius: 'cinco' })).toContain('radius');
+  });
+
+  /** Los campos que ya existían siguen siendo obligatorios: el cambio es aditivo. */
+  it('sigue exigiendo punto y tipos', async () => {
+    expect(await propiedadesConError({ types: [PlaceTypeEnum.CashInMx] })).toEqual(
+      expect.arrayContaining(['latitude', 'longitude']),
+    );
+    expect(await propiedadesConError({ latitude: 19.4326, longitude: -99.1332, types: [] })).toContain(
+      'types',
+    );
+  });
+});

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

@@ -12,11 +12,12 @@ describe('BlockedReasonEnum', () => {
 });
 
 describe('BlockedCategoryEnum', () => {
-  it('tiene las tres categorias que dicen quien resuelve', () => {
+  it('tiene las cuatro categorias que dicen quien resuelve', () => {
     expect(BlockedCategoryEnum.CUSTOMER_RECORD).toBe('CUSTOMER_RECORD');
     expect(BlockedCategoryEnum.UNDER_REVIEW).toBe('UNDER_REVIEW');
     expect(BlockedCategoryEnum.TEMPORARY).toBe('TEMPORARY');
-    expect(Object.keys(BlockedCategoryEnum)).toHaveLength(3);
+    expect(BlockedCategoryEnum.REJECTED).toBe('REJECTED');
+    expect(Object.keys(BlockedCategoryEnum)).toHaveLength(4);
   });
 
   it('ningun valor nombra listas de cumplimiento ni PLD', () => {

package/bin/identity/dtos/ManualApproval.d.ts

@@ -12,4 +12,13 @@ export interface ManualApproval {
     at: string;
     /** justificación obligatoria del override */
     reason: string;
+    /**
+     * Conclusión del oficial. Ausente en los sellos escritos antes de este campo, que solo se
+     * estampaban al aprobar: leerlos sin `verdict` equivale a `APPROVED`.
+     */
+    verdict?: ManualApprovalVerdict;
+    /** Alerta de PLD que se dictaminó, para rastrear el sello hasta su expediente. */
+    alertId?: string;
 }
+/** Conclusión del oficial de cumplimiento sobre la lista que revisó. */
+export type ManualApprovalVerdict = 'APPROVED' | 'REJECTED';

package/bin/identity/dtos/PeopleResponse.d.ts

@@ -131,6 +131,10 @@ export declare class PeopleResponse {
         /** Geolocalización aprobada. `null` = no evaluada; solo `false` bloquea. */
         geoApproved?: boolean | null;
         cnbvManualApproval?: ManualApproval | null;
+        /** Sello del oficial sobre las listas internacionales y PEP (`blackListApproved`). */
+        blackListManualApproval?: ManualApproval | null;
+        /** Sello del oficial sobre la lista negra interna de Fiado (`fiadoListApproved`). */
+        fiadoListManualApproval?: ManualApproval | null;
         minorManualApproval?: ManualApproval | null;
     };
     SIN: string | null;

package/bin/identity/dtos/PeopleUpdateRequest.d.ts

@@ -55,6 +55,8 @@ export declare class PeopleUpdateRequest {
     ofacListApproved?: boolean | null;
     cnbvListApproved?: boolean | null;
     cnbvManualApproval?: ManualApproval | null;
+    blackListManualApproval?: ManualApproval | null;
+    fiadoListManualApproval?: ManualApproval | null;
     minorManualApproval?: ManualApproval | null;
     blackListApproved?: boolean | null;
     whiteList?: boolean | null;

package/bin/loanCredit/constants/LoanDeviceBatchLimits.d.ts

@@ -0,0 +1,2 @@
+/** Cota de ítems por request; es el tamaño de lote del fan-out SQS de cobranza. */
+export declare const LOAN_DEVICE_MAX_BATCH = 500;

package/bin/loanCredit/constants/LoanDeviceBatchLimits.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOAN_DEVICE_MAX_BATCH = void 0;
+/** Cota de ítems por request; es el tamaño de lote del fan-out SQS de cobranza. */
+exports.LOAN_DEVICE_MAX_BATCH = 500;

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

@@ -0,0 +1,4 @@
+/** Ítem que solo referencia un crédito, para las mutaciones que no necesitan más datos. */
+export declare class LoanDeviceCreditRefItem {
+    creditId: string;
+}

package/bin/{retailWizard/dtos/requests/MarkPcfCardDeliveredRequest.js → loanCredit/dtos/LoanDeviceCreditRefItem.js}

@@ -9,15 +9,15 @@ 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.MarkPcfCardDeliveredRequest = void 0;
+exports.LoanDeviceCreditRefItem = void 0;
 const class_transformer_1 = require("class-transformer");
 const class_validator_1 = require("class-validator");
-/** POST /wizard/sessions/:id/pcf-card/mark-delivered — marca la tarjeta física PCF como entregada (S7). SureKeep Fase 2 — pista Retail. */
-class MarkPcfCardDeliveredRequest {
+/** Ítem que solo referencia un crédito, para las mutaciones que no necesitan más datos. */
+class LoanDeviceCreditRefItem {
 }
-exports.MarkPcfCardDeliveredRequest = MarkPcfCardDeliveredRequest;
+exports.LoanDeviceCreditRefItem = LoanDeviceCreditRefItem;
 __decorate([
     (0, class_transformer_1.Expose)(),
-    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsUUID)(),
     __metadata("design:type", String)
-], MarkPcfCardDeliveredRequest.prototype, "cardNumber", void 0);
+], LoanDeviceCreditRefItem.prototype, "creditId", void 0);

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

@@ -0,0 +1,11 @@
+/** Ítem de enrolamiento: un crédito con el equipo que se va a enrolar en el MDM. */
+export declare class LoanDeviceEnrollItem {
+    creditId: string;
+    imei: string;
+    /** Segundo IMEI del equipo (dual SIM), si lo tiene. */
+    imei2?: string;
+    productSku: string;
+    termMonths: number;
+    /** En modo SCHEDULED es el primer autolock. */
+    firstDueDate: string;
+}

package/bin/loanCredit/dtos/LoanDeviceEnrollItem.js

@@ -0,0 +1,62 @@
+"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.LoanDeviceEnrollItem = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const SkuPattern_1 = require("../../retailCatalog/constants/SkuPattern");
+/** Charset y largo del IMEI: exactamente 15 dígitos. */
+const IMEI_PATTERN = /^\d{15}$/;
+/** Plazo máximo del crédito en meses. */
+const MAX_TERM_MONTHS = 60;
+/** Ítem de enrolamiento: un crédito con el equipo que se va a enrolar en el MDM. */
+class LoanDeviceEnrollItem {
+}
+exports.LoanDeviceEnrollItem = LoanDeviceEnrollItem;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsUUID)(),
+    __metadata("design:type", String)
+], LoanDeviceEnrollItem.prototype, "creditId", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.Matches)(IMEI_PATTERN, { message: 'imei admite solo 15 dígitos' }),
+    __metadata("design:type", String)
+], LoanDeviceEnrollItem.prototype, "imei", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.Matches)(IMEI_PATTERN, { message: 'imei2 admite solo 15 dígitos' }),
+    __metadata("design:type", String)
+], LoanDeviceEnrollItem.prototype, "imei2", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(64),
+    (0, class_validator_1.Matches)(SkuPattern_1.SKU_PATTERN, { message: 'productSku admite solo [A-Za-z0-9-]' }),
+    __metadata("design:type", String)
+], LoanDeviceEnrollItem.prototype, "productSku", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.IsPositive)(),
+    (0, class_validator_1.Max)(MAX_TERM_MONTHS),
+    __metadata("design:type", Number)
+], LoanDeviceEnrollItem.prototype, "termMonths", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsISO8601)(),
+    __metadata("design:type", String)
+], LoanDeviceEnrollItem.prototype, "firstDueDate", void 0);

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

@@ -0,0 +1,9 @@
+import { LoanDeviceLockReasonEnum } from '../enums/LoanDeviceLockReasonEnum';
+import { DeviceLockScreenMessage } from '../../mdm/dtos/DeviceLockScreenMessage';
+/** Ítem de bloqueo manual: qué crédito se bloquea, por qué y con qué mensaje en pantalla. */
+export declare class LoanDeviceManualLockItem {
+    creditId: string;
+    reason: LoanDeviceLockReasonEnum;
+    /** Mensaje que ve el usuario en la pantalla bloqueada; si no viene, el lambda usa el default. */
+    screenMessage?: DeviceLockScreenMessage;
+}

package/bin/loanCredit/dtos/LoanDeviceManualLockItem.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.LoanDeviceManualLockItem = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const LoanDeviceLockReasonEnum_1 = require("../enums/LoanDeviceLockReasonEnum");
+const DeviceLockScreenMessage_1 = require("../../mdm/dtos/DeviceLockScreenMessage");
+/** Ítem de bloqueo manual: qué crédito se bloquea, por qué y con qué mensaje en pantalla. */
+class LoanDeviceManualLockItem {
+}
+exports.LoanDeviceManualLockItem = LoanDeviceManualLockItem;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsUUID)(),
+    __metadata("design:type", String)
+], LoanDeviceManualLockItem.prototype, "creditId", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEnum)(LoanDeviceLockReasonEnum_1.LoanDeviceLockReasonEnum),
+    __metadata("design:type", String)
+], LoanDeviceManualLockItem.prototype, "reason", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.ValidateNested)(),
+    (0, class_transformer_1.Type)(() => DeviceLockScreenMessage_1.DeviceLockScreenMessage),
+    __metadata("design:type", DeviceLockScreenMessage_1.DeviceLockScreenMessage)
+], LoanDeviceManualLockItem.prototype, "screenMessage", void 0);

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

@@ -0,0 +1,9 @@
+import { LoanDeviceResult } from './LoanDeviceResult';
+/** Resultado por ítem de las mutaciones (enroll, lock, unlock), que sí llevan referencia de operación. */
+export declare class LoanDeviceOperationResult extends LoanDeviceResult {
+    /** Referencia de la operación con la que el caller correlaciona el batch. */
+    operationReference: string;
+    /** Referencia opaca del proveedor, solo para trazabilidad de soporte.
+     *  El avance se consulta por `creditId` en `enroll-status` (enroll) o `status` (lock/unlock). */
+    pollingHandle?: string;
+}

package/bin/loanCredit/dtos/LoanDeviceOperationResult.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoanDeviceOperationResult = void 0;
+const LoanDeviceResult_1 = require("./LoanDeviceResult");
+/** Resultado por ítem de las mutaciones (enroll, lock, unlock), que sí llevan referencia de operación. */
+class LoanDeviceOperationResult extends LoanDeviceResult_1.LoanDeviceResult {
+}
+exports.LoanDeviceOperationResult = LoanDeviceOperationResult;

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

@@ -0,0 +1,9 @@
+import { MdmOperationStatusEnum } from '../../mdm/enums/MdmOperationStatusEnum';
+import { MdmError } from '../../mdm/dtos/MdmError';
+/** Base de todo resultado por ítem: un ítem puede fallar sin tumbar el batch completo. */
+export declare class LoanDeviceResult {
+    creditId: string;
+    /** Solo toma SUCCESS | PENDING | ERROR; el motivo del fallo viaja en `error.code`. */
+    status: MdmOperationStatusEnum;
+    error?: MdmError;
+}

package/bin/loanCredit/dtos/LoanDeviceResult.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoanDeviceResult = void 0;
+/** Base de todo resultado por ítem: un ítem puede fallar sin tumbar el batch completo. */
+class LoanDeviceResult {
+}
+exports.LoanDeviceResult = LoanDeviceResult;

package/bin/loanCredit/dtos/requests/LoanDeviceEnrollRequest.d.ts

@@ -0,0 +1,7 @@
+import { LoanDeviceEnrollItem } from '../LoanDeviceEnrollItem';
+/** Body de `POST /private/devices/enroll` (loan-credit-business). Enrola en lote. */
+export declare class LoanDeviceEnrollRequest {
+    items: LoanDeviceEnrollItem[];
+    /** Referencia con la que el caller correlaciona este batch; vuelve en cada resultado. */
+    operationReference: string;
+}