@fiado/type-kit 3.608.0 → 3.610.0

package/_test_/unit/biometrics/BiometricEventTypeEnum.test.ts

@@ -0,0 +1,35 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { BiometricEventTypeEnum, BiometricVerificationChangedV1 } from '../../../src/biometrics/index';
+
+const base = {
+  eventId: 'evt-1',
+  biometricVerificationId: 'bio-1',
+  provider: 'METAMAP',
+  eventType: 'VERIFICATION_STARTED',
+  occurredAt: '2026-10-28T10:05:00.000Z',
+};
+
+describe('BiometricEventTypeEnum', () => {
+  it('declara los seis eventos que traduce el webhook', () => {
+    expect(Object.values(BiometricEventTypeEnum)).toEqual([
+      'VERIFICATION_STARTED',
+      'STEP_COMPLETED',
+      'VERIFICATION_COMPLETED',
+      'VERIFICATION_EXPIRED',
+      'INPUTS_COMPLETED',
+      'UPDATED',
+    ]);
+  });
+
+  it.each([BiometricEventTypeEnum.INPUTS_COMPLETED, BiometricEventTypeEnum.UPDATED])(
+    'BiometricVerificationChangedV1 acepta el eventType %s',
+    async (eventType) => {
+      const dto = plainToInstance(BiometricVerificationChangedV1, { ...base, eventType }, { excludeExtraneousValues: true });
+
+      expect(await validate(dto as object)).toHaveLength(0);
+      expect(dto.eventType).toBe(eventType);
+    },
+  );
+});

package/_test_/unit/biometrics/BiometricVerificationResponse.test.ts

@@ -60,4 +60,23 @@ describe('BiometricVerificationResponse', () => {
       expect(instancia(base).referenceImageSource).toBe(BiometricReferenceSourceEnum.KYC_SELFIE);
     });
   });
+
+  // Cuándo el cliente terminó de subir su información; lo usa el wizard para INPUTS_COMPLETED.
+  describe('inputsCompletedAt', () => {
+    it('es opcional', async () => {
+      expect(await propiedadesConError(base)).toEqual([]);
+      expect(instancia(base).inputsCompletedAt).toBeUndefined();
+    });
+
+    it('acepta ISO-8601 UTC y sobrevive al plainToInstance', async () => {
+      const raw = { ...base, inputsCompletedAt: '2026-10-28T10:07:00.000Z' };
+
+      expect(await propiedadesConError(raw)).toEqual([]);
+      expect(instancia(raw).inputsCompletedAt).toBe('2026-10-28T10:07:00.000Z');
+    });
+
+    it('rechaza una fecha que no es ISO-8601', async () => {
+      expect(await propiedadesConError({ ...base, inputsCompletedAt: '28/10/2026' })).toContain('inputsCompletedAt');
+    });
+  });
 });

package/_test_/unit/kyc/KycProgressEnums.test.ts

@@ -0,0 +1,20 @@
+import 'reflect-metadata';
+import { KycFlowEnum, KycProgressStageEnum } from '../../../src/kyc/index';
+import { KycMetadataStepEnum } from '../../../src/retailWizard/index';
+
+describe('KycProgressStageEnum', () => {
+  it('declara solo las tres etapas que publica el webhook', () => {
+    expect(Object.values(KycProgressStageEnum)).toEqual(['STARTED', 'INPUTS_COMPLETED', 'EXPIRED']);
+  });
+});
+
+describe('KycFlowEnum', () => {
+  it('declara los dos flujos de Metamap que salen del wizard', () => {
+    expect(Object.values(KycFlowEnum)).toEqual(['IDENTITY', 'PROOF_OF_ADDRESS']);
+  });
+
+  // El webhook deriva flow de metadata.kycStep: si los valores divergen, el comprobante se rutea como identidad.
+  it('PROOF_OF_ADDRESS coincide con el kycStep de la metadata', () => {
+    expect(KycFlowEnum.PROOF_OF_ADDRESS).toBe(KycMetadataStepEnum.PROOF_OF_ADDRESS);
+  });
+});

package/_test_/unit/kyc/KycProofOfAddressCompletedV1.test.ts

@@ -192,4 +192,28 @@ describe('KycProofOfAddressCompletedV1', () => {
       ].sort(),
     );
   });
+
+  // ── Intento (estados MetaMap/QR) ──────────────────────────────────────────
+
+  describe('attemptId', () => {
+    it('acepta y expone attemptId', async () => {
+      const dto = instancia({ ...base, attemptId: 'att-1' });
+
+      expect(await validate(dto as object)).toHaveLength(0);
+      expect(dto.attemptId).toBe('att-1');
+    });
+
+    it('valida sin attemptId (compatibilidad hacia atrás)', async () => {
+      const dto = instancia(base);
+
+      expect(await validate(dto as object)).toHaveLength(0);
+      expect(dto.attemptId).toBeUndefined();
+    });
+
+    it('rechaza attemptId vacío', async () => {
+      const errors = await validate(instancia({ ...base, attemptId: '' }) as object);
+
+      expect(errors.map((e) => e.property)).toContain('attemptId');
+    });
+  });
 });

package/_test_/unit/kyc/KycStepCompletedV1.test.ts

@@ -2,6 +2,7 @@ import 'reflect-metadata';
 import { plainToInstance } from 'class-transformer';
 import { validate } from 'class-validator';
 import {
+  KycFlowEnum,
   KycStepCompletedV1,
   KycVerificationChangedV1,
   KycSubCheckNameEnum,
@@ -236,4 +237,37 @@ describe('KycStepCompletedV1', () => {
     );
     expect(Object.values(KycWatchlistStatusEnum)).toEqual(['CLEAR', 'HIT']);
   });
+
+  // ── Intento y flujo (estados MetaMap/QR) ──────────────────────────────────
+
+  describe('attemptId y flow', () => {
+    it('acepta y expone attemptId y flow', async () => {
+      const dto = instancia({ ...base, attemptId: 'att-1', flow: 'IDENTITY' });
+
+      expect(await validate(dto as object)).toHaveLength(0);
+      expect(dto.attemptId).toBe('att-1');
+      expect(dto.flow).toBe(KycFlowEnum.IDENTITY);
+    });
+
+    // Mensajes en vuelo y sesiones previas al despliegue no los traen.
+    it('valida sin attemptId ni flow', async () => {
+      const dto = instancia(base);
+
+      expect(await validate(dto as object)).toHaveLength(0);
+      expect(dto.attemptId).toBeUndefined();
+      expect(dto.flow).toBeUndefined();
+    });
+
+    it('rechaza attemptId vacío', async () => {
+      const errors = await validate(instancia({ ...base, attemptId: '' }) as object);
+
+      expect(errors.map((e) => e.property)).toContain('attemptId');
+    });
+
+    it.each(['FACEMATCH', 'identity'])('rechaza el flow %s', async (flow) => {
+      const errors = await validate(instancia({ ...base, flow }) as object);
+
+      expect(errors.map((e) => e.property)).toContain('flow');
+    });
+  });
 });

package/_test_/unit/kyc/KycVerificationChangedV1.test.ts

@@ -152,4 +152,34 @@ describe('KycVerificationChangedV1', () => {
 
     expect(errors.map((e) => e.property)).toContain('updateDate');
   });
+
+  // Estados MetaMap/QR: el cierre trae el intento para que el wizard descarte los ajenos.
+  describe('attemptId', () => {
+    const closing = {
+      verificationId: 'ver-1', directoryId: 'dir-1', peopleId: 'ppl-1',
+      verificationStatus: 'COMPLETED', verificationResult: 'VERIFIED',
+      updateDate: '2026-10-28T10:05:00.000Z',
+    };
+
+    it('acepta y expone attemptId', async () => {
+      const dto = plainToInstance(KycVerificationChangedV1, { ...closing, attemptId: 'att-1' }, { excludeExtraneousValues: true });
+
+      expect(await validate(dto as object)).toHaveLength(0);
+      expect(dto.attemptId).toBe('att-1');
+    });
+
+    it('valida sin attemptId (compatibilidad hacia atrás)', async () => {
+      const dto = plainToInstance(KycVerificationChangedV1, closing, { excludeExtraneousValues: true });
+
+      expect(await validate(dto as object)).toHaveLength(0);
+      expect(dto.attemptId).toBeUndefined();
+    });
+
+    it('rechaza attemptId vacío', async () => {
+      const dto = plainToInstance(KycVerificationChangedV1, { ...closing, attemptId: '' }, { excludeExtraneousValues: true });
+      const errors = await validate(dto as object);
+
+      expect(errors.map((e) => e.property)).toContain('attemptId');
+    });
+  });
 });

package/_test_/unit/kyc/KycVerificationProgressV1.test.ts

@@ -0,0 +1,144 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import {
+  KycFlowEnum,
+  KycProgressStageEnum,
+  KycProofOfAddressCompletedV1,
+  KycStepCompletedV1,
+  KycVerificationChangedV1,
+  KycVerificationProgressV1,
+} from '../../../src/kyc/index';
+
+/** Base válida; cada caso pisa solo el campo que prueba. */
+const base = {
+  eventType: 'KycVerificationProgressV1',
+  stage: 'STARTED',
+  flow: 'IDENTITY',
+  verificationId: 'ver-1',
+  directoryId: 'dir-1',
+  attemptId: 'att-1',
+  occurredAt: '2026-10-28T10:05:00.000Z',
+};
+
+const toDto = (raw: Record<string, unknown>): KycVerificationProgressV1 =>
+  plainToInstance(KycVerificationProgressV1, raw, { excludeExtraneousValues: true });
+
+const errorProps = async (raw: Record<string, unknown>): Promise<string[]> =>
+  (await validate(toDto(raw) as object)).map((e) => e.property);
+
+describe('KycVerificationProgressV1', () => {
+  it('valida el shape que publica el webhook', async () => {
+    const dto = toDto(base);
+
+    expect(await errorProps(base)).toEqual([]);
+    expect(dto.stage).toBe(KycProgressStageEnum.STARTED);
+    expect(dto.flow).toBe(KycFlowEnum.IDENTITY);
+    expect(dto.attemptId).toBe('att-1');
+  });
+
+  it.each(Object.values(KycProgressStageEnum))('acepta la etapa %s', async (stage) => {
+    expect(await errorProps({ ...base, stage })).toEqual([]);
+  });
+
+  it.each(Object.values(KycFlowEnum))('acepta el flujo %s', async (flow) => {
+    expect(await errorProps({ ...base, flow })).toEqual([]);
+  });
+
+  // Sesiones creadas antes del despliegue: la metadata no trae attemptId.
+  it('valida sin attemptId', async () => {
+    const { attemptId: _omitted, ...withoutAttempt } = base;
+
+    expect(await errorProps(withoutAttempt)).toEqual([]);
+    expect(toDto(withoutAttempt).attemptId).toBeUndefined();
+  });
+
+  it('rechaza attemptId vacío', async () => {
+    expect(await errorProps({ ...base, attemptId: '' })).toContain('attemptId');
+  });
+
+  describe('eventType', () => {
+    it('rechaza el evento sin eventType', async () => {
+      const { eventType: _omitted, ...withoutType } = base;
+
+      expect(await errorProps(withoutType)).toContain('eventType');
+    });
+
+    it('rechaza el eventType de otro evento', async () => {
+      expect(await errorProps({ ...base, eventType: 'KycStepCompletedV1' })).toContain('eventType');
+    });
+  });
+
+  // AWAITING_START y RESULT son etapas del wizard, nunca llegan por evento.
+  it.each(['AWAITING_START', 'RESULT', 'COMPLETED'])('rechaza la etapa %s', async (stage) => {
+    expect(await errorProps({ ...base, stage })).toContain('stage');
+  });
+
+  // FACEMATCH no pasa por este evento: su avance sale del GET de biometrics.
+  it('rechaza el flujo FACEMATCH', async () => {
+    expect(await errorProps({ ...base, flow: 'FACEMATCH' })).toContain('flow');
+  });
+
+  it.each(['verificationId', 'directoryId'])('rechaza %s vacío', async (field) => {
+    expect(await errorProps({ ...base, [field]: '' })).toContain(field);
+  });
+
+  it.each(['stage', 'flow', 'verificationId', 'directoryId', 'occurredAt'])('rechaza el evento sin %s', async (field) => {
+    const raw: Record<string, unknown> = { ...base };
+    delete raw[field];
+
+    expect(await errorProps(raw)).toContain(field);
+  });
+
+  describe('occurredAt', () => {
+    it.each([
+      ['offset positivo en vez de Z', '2026-10-28T15:05:00+05:00'],
+      ['solo fecha, sin hora', '2026-10-28'],
+      ['sin zona horaria', '2026-10-28T10:05:00'],
+      ['formato local', '28/10/2026'],
+    ])('rechaza occurredAt %s', async (_label, value) => {
+      expect(await errorProps({ ...base, occurredAt: value })).toContain('occurredAt');
+    });
+
+    it.each([
+      ['con milisegundos', '2026-10-28T10:05:00.000Z'],
+      ['sin milisegundos', '2026-10-28T10:05:00Z'],
+    ])('acepta occurredAt en UTC %s', async (_label, value) => {
+      expect(await errorProps({ ...base, occurredAt: value })).toEqual([]);
+    });
+  });
+
+  // Comparte RetailKycInboundQueue con otros tres eventos: ninguno se puede hacer pasar por otro.
+  describe('convivencia en RetailKycInboundQueue', () => {
+    it('un avance NO valida como estación', async () => {
+      const errors = await validate(plainToInstance(KycStepCompletedV1, base, { excludeExtraneousValues: true }) as object);
+
+      expect(errors.map((e) => e.property)).toEqual(expect.arrayContaining(['eventType', 'step', 'status']));
+    });
+
+    it('un avance NO valida como cierre', async () => {
+      const errors = await validate(plainToInstance(KycVerificationChangedV1, base, { excludeExtraneousValues: true }) as object);
+
+      expect(errors.map((e) => e.property)).toEqual(
+        expect.arrayContaining(['peopleId', 'verificationStatus', 'verificationResult', 'updateDate']),
+      );
+    });
+
+    it('un avance NO valida como comprobante', async () => {
+      const errors = await validate(
+        plainToInstance(KycProofOfAddressCompletedV1, base, { excludeExtraneousValues: true }) as object,
+      );
+
+      expect(errors.map((e) => e.property)).toEqual(expect.arrayContaining(['eventType', 'status', 'addressPersisted']));
+    });
+
+    it('una estación NO valida como avance', async () => {
+      const station = {
+        eventType: 'KycStepCompletedV1', verificationId: 'ver-1', directoryId: 'dir-1',
+        step: 'facematch', status: 'PASS', occurredAt: '2026-10-28T10:05:00.000Z',
+      };
+
+      expect(await errorProps(station)).toEqual(expect.arrayContaining(['eventType', 'stage', 'flow']));
+    });
+  });
+});

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

@@ -53,4 +53,13 @@ describe('OriginateLoanCreditRequest', () => {
 
         expect(errors.some((error) => error.property === 'sellerId')).toBe(true);
     });
+
+    it('acepta tipo y gama del equipo opcionales y rechaza valores fuera del enum', async () => {
+        const ok = await validateWhitelisted({ ...BASE, productCategory: 'PHONE', productTier: 'HIGH' });
+        expect(ok.errors).toEqual([]);
+        expect([ok.dto.productCategory, ok.dto.productTier]).toEqual(['PHONE', 'HIGH']);
+
+        const bad = await validateWhitelisted({ ...BASE, productCategory: 'CAR', productTier: 'ULTRA' });
+        expect(bad.errors.map((error) => error.property).sort()).toEqual(['productCategory', 'productTier']);
+    });
 });

package/_test_/unit/loanOfferings/promotionCategoryTierScope.test.ts

@@ -0,0 +1,89 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import {
+    CreatePromotionRequest,
+    ListPromotedSkusRequest,
+    ListSkuPromotionsRequest,
+    PROMOTION_SKU_BATCH_MAX_ITEMS,
+    SimulateCreditPlanRequest,
+    UpdatePromotionRequest,
+} from '../../../src/loanOfferings/index';
+import type { PromotionResponse } from '../../../src/loanOfferings/index';
+import { ProductCategoryEnum } from '../../../src/retailCatalog/enums/ProductCategoryEnum';
+import { ProductTierEnum } from '../../../src/retailCatalog/enums/ProductTierEnum';
+
+type DtoClass = new () => object;
+
+const errorsOf = async (dtoClass: DtoClass, body: object): Promise<string[]> =>
+    (await validate(plainToInstance(dtoClass, body, { excludeExtraneousValues: true }) as object)).map((e) => e.property);
+
+const createBase = {
+    name: 'Tasa preferente gama alta',
+    description: 'Baja la tasa en teléfonos de gama alta',
+    effect: { downPaymentDeltaPct: 0.05 },
+    segmentId: 'SEG_SILVER',
+    targetLevels: ['SILVER'],
+};
+
+describe('alcance por tipo y gama en promociones de crédito', () => {
+    it('Create acepta tipos y gamas del catálogo, y null como «todos»', async () => {
+        const dto = plainToInstance(CreatePromotionRequest, { ...createBase, productCategories: ['PHONE'], tiers: ['HIGH', 'PREMIUM'] }, { excludeExtraneousValues: true });
+        expect(await validate(dto)).toHaveLength(0);
+        expect(dto.productCategories).toEqual([ProductCategoryEnum.PHONE]);
+        expect(dto.tiers).toEqual([ProductTierEnum.HIGH, ProductTierEnum.PREMIUM]);
+        expect(await errorsOf(CreatePromotionRequest, { ...createBase, productCategories: null, tiers: null })).toEqual([]);
+    });
+
+    it.each([CreatePromotionRequest, UpdatePromotionRequest])('%p rechaza tipo o gama fuera del enum', async (dtoClass) => {
+        const body = dtoClass === CreatePromotionRequest ? createBase : {};
+        expect(await errorsOf(dtoClass, { ...body, productCategories: ['CAR'] })).toContain('productCategories');
+        expect(await errorsOf(dtoClass, { ...body, tiers: ['ULTRA'] })).toContain('tiers');
+        expect(await errorsOf(dtoClass, { ...body, tiers: 'HIGH' })).toContain('tiers');
+    });
+
+    it('Update acepta el parche solo con tipo y gama', async () => {
+        expect(await errorsOf(UpdatePromotionRequest, { productCategories: ['SIM', 'MODEM'], tiers: null })).toEqual([]);
+    });
+
+    it('la respuesta expone tipos y gamas con null como «todos»', () => {
+        const scope: Pick<PromotionResponse, 'productCategories' | 'tiers'> = { productCategories: null, tiers: [ProductTierEnum.LOW] };
+        expect(scope.tiers).toEqual(['LOW']);
+    });
+
+    it('el simulador recibe tipo y gama opcionales y valida el enum', async () => {
+        const base = { productPriceCents: 500000, downPaymentPct: 0.2, termWeeks: 26 };
+        expect(await errorsOf(SimulateCreditPlanRequest, base)).toEqual([]);
+        expect(await errorsOf(SimulateCreditPlanRequest, { ...base, productCategory: 'PHONE', productTier: 'MID' })).toEqual([]);
+        expect(await errorsOf(SimulateCreditPlanRequest, { ...base, productCategory: 'CAR' })).toContain('productCategory');
+        expect(await errorsOf(SimulateCreditPlanRequest, { ...base, productTier: 'ULTRA' })).toContain('productTier');
+    });
+});
+
+describe.each([ListPromotedSkusRequest, ListSkuPromotionsRequest])('%p (lote por SKU)', (dtoClass) => {
+    const valid = { storeId: 'st-1', items: [{ sku: 'SKU-1', category: 'PHONE', tier: 'MID' }] };
+
+    it('acepta tienda, nivel y segmento opcionales, y SKUs con tipo y gama opcionales', async () => {
+        expect(await errorsOf(dtoClass, valid)).toEqual([]);
+        expect(await errorsOf(dtoClass, { ...valid, level: 'GOLD', segmentId: 'SEG-1', items: [{ sku: 'SKU-2' }] })).toEqual([]);
+    });
+
+    it.each([
+        ['sin tienda', { ...valid, storeId: undefined }, 'storeId'],
+        ['tienda vacía', { ...valid, storeId: '' }, 'storeId'],
+        ['nivel fuera del enum', { ...valid, level: 'PLATINUM' }, 'level'],
+        ['sin items', { ...valid, items: undefined }, 'items'],
+        ['tipo fuera del enum', { ...valid, items: [{ sku: 'A', category: 'CAR' }] }, 'items'],
+        ['gama fuera del enum', { ...valid, items: [{ sku: 'A', tier: 'ULTRA' }] }, 'items'],
+        ['SKU no string', { ...valid, items: [{ sku: 7 }] }, 'items'],
+    ])('rechaza %s', async (_label, body, property) => {
+        expect(await errorsOf(dtoClass, body)).toContain(property);
+    });
+
+    it(`rechaza más de ${PROMOTION_SKU_BATCH_MAX_ITEMS} SKUs y acepta exactamente el tope`, async () => {
+        const items = (n: number) => Array.from({ length: n }, (_v, i) => ({ sku: `S${i}` }));
+        expect(PROMOTION_SKU_BATCH_MAX_ITEMS).toBe(100);
+        expect(await errorsOf(dtoClass, { ...valid, items: items(PROMOTION_SKU_BATCH_MAX_ITEMS) })).toEqual([]);
+        expect(await errorsOf(dtoClass, { ...valid, items: items(PROMOTION_SKU_BATCH_MAX_ITEMS + 1) })).toContain('items');
+    });
+});

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

@@ -0,0 +1,131 @@
+import 'reflect-metadata';
+import { KycProgressStageEnum } from '../../../src/kyc/index';
+import { KycModalityEnum } from '../../../src/retailCustomer/enums/KycModalityEnum';
+import {
+  KycAttemptStageEnum,
+  KycMetadataSourceEnum,
+  KycMetadataStepEnum,
+  type KycAttemptProgress,
+  type KycPrepareResponse,
+  type KycSdkMetadata,
+  type KycStatusProgress,
+  type ProofOfAddressPrepareResponse,
+} from '../../../src/retailWizard/index';
+
+const qrAttempt: KycAttemptProgress = {
+  attemptId: 'att-1',
+  modality: KycModalityEnum.CUSTOMER_LINK,
+  link: 'https://sk.fiado.test/abc',
+  stage: KycAttemptStageEnum.STARTED,
+  stageAt: '2026-10-28T10:05:00.000Z',
+  attemptStartedAt: '2026-10-28T10:00:00.000Z',
+};
+
+const tabletAttempt: KycAttemptProgress = {
+  attemptId: 'att-2',
+  modality: KycModalityEnum.STORE_DEVICE,
+  stage: KycAttemptStageEnum.AWAITING_START,
+  stageAt: '2026-10-28T10:00:00.000Z',
+  attemptStartedAt: '2026-10-28T10:00:00.000Z',
+};
+
+describe('KycAttemptStageEnum', () => {
+  it('declara las cinco etapas en orden de rango', () => {
+    expect(Object.values(KycAttemptStageEnum)).toEqual([
+      'AWAITING_START', 'STARTED', 'INPUTS_COMPLETED', 'EXPIRED', 'RESULT',
+    ]);
+  });
+
+  // El wizard copia la etapa del evento al intento por valor.
+  it.each(Object.values(KycProgressStageEnum))('incluye la etapa de evento %s', (stage) => {
+    expect(Object.values(KycAttemptStageEnum)).toContain(stage);
+  });
+});
+
+describe('KycAttemptProgress', () => {
+  it('lleva link en QR y lo omite en tablet', () => {
+    expect(qrAttempt.link).toBe('https://sk.fiado.test/abc');
+    expect(tabletAttempt.link).toBeUndefined();
+  });
+
+  it('solo admite las modalidades de prepare', () => {
+    const manual: KycAttemptProgress = {
+      ...tabletAttempt,
+      // @ts-expect-error MANUAL no es una modalidad de prepare
+      modality: KycModalityEnum.MANUAL,
+    };
+
+    expect(manual.modality).toBe('MANUAL');
+  });
+
+  // El tope de 25 min del front se mide contra la fecha del prepare, no contra el montaje.
+  it('exige attemptStartedAt', () => {
+    const { attemptStartedAt: _omitted, ...rest } = qrAttempt;
+    // @ts-expect-error attemptStartedAt es obligatorio
+    const withoutStart: KycAttemptProgress = rest;
+
+    expect(qrAttempt.attemptStartedAt).toBe('2026-10-28T10:00:00.000Z');
+    expect(withoutStart.attemptStartedAt).toBeUndefined();
+  });
+});
+
+describe('KycStatusProgress', () => {
+  it('trae un intento o null por cada flujo', () => {
+    const progress: KycStatusProgress = { identity: qrAttempt, facematch: null, proofOfAddress: tabletAttempt };
+
+    expect(Object.keys(progress).sort()).toEqual(['facematch', 'identity', 'proofOfAddress']);
+    expect(progress.facematch).toBeNull();
+  });
+});
+
+describe('KycSdkMetadata', () => {
+  it('acepta attemptId junto a source y kycStep', () => {
+    const metadata: KycSdkMetadata = {
+      directoryId: 'dir-1',
+      typeOfDirectoryId: 'PHONE',
+      peopleId: 'ppl-1',
+      countryId: 'MX',
+      phoneNumber: '5512345678',
+      source: KycMetadataSourceEnum.SUREKEEP_WIZARD,
+      kycStep: KycMetadataStepEnum.PROOF_OF_ADDRESS,
+      attemptId: 'att-1',
+    };
+
+    expect(metadata.attemptId).toBe('att-1');
+  });
+});
+
+// El front liga el SDK y los callbacks al attemptId que devuelve el prepare.
+describe('attemptId en las respuestas de prepare', () => {
+  // Sin intento creado (alreadyVerified o bypass de dev) no hay attemptId.
+  it('KycPrepareResponse lleva attemptId al preparar y lo omite sin intento', () => {
+    const prepared: KycPrepareResponse = {
+      modality: KycModalityEnum.CUSTOMER_LINK,
+      shortUrl: 'https://sk.fiado.test/abc',
+      attemptId: 'att-1',
+    };
+    const alreadyVerified: KycPrepareResponse = {
+      modality: KycModalityEnum.CUSTOMER_LINK,
+      alreadyVerified: true,
+    };
+
+    expect(prepared.attemptId).toBe('att-1');
+    expect(alreadyVerified.attemptId).toBeUndefined();
+  });
+
+  // Con domicilio ya registrado no se crea intento, por eso no hay attemptId.
+  it('ProofOfAddressPrepareResponse lleva attemptId al preparar y lo omite con alreadyHasAddress', () => {
+    const prepared: ProofOfAddressPrepareResponse = {
+      modality: KycModalityEnum.STORE_DEVICE,
+      clientId: 'client-1',
+      attemptId: 'att-3',
+    };
+    const alreadyHasAddress: ProofOfAddressPrepareResponse = {
+      modality: KycModalityEnum.STORE_DEVICE,
+      alreadyHasAddress: true,
+    };
+
+    expect(prepared.attemptId).toBe('att-3');
+    expect(alreadyHasAddress.attemptId).toBeUndefined();
+  });
+});

package/bin/biometrics/dtos/responses/BiometricVerificationResponse.d.ts

@@ -91,6 +91,8 @@ export declare class BiometricVerificationResponse {
     updatedAt: string;
     /** Cuándo vence la entrega. Es lo que el `GET` compara para persistir `EXPIRED` (DEC-015). */
     expiresAt: string;
+    /** Cuándo el usuario terminó de subir su información. ISO-8601 UTC con `Z`; ausente si aún no. */
+    inputsCompletedAt?: string;
     /** Cuándo alcanzó un estado terminal. Ausente mientras siga viva. */
     completedAt?: string;
 }

package/bin/biometrics/dtos/responses/BiometricVerificationResponse.js

@@ -129,6 +129,12 @@ __decorate([
     (0, class_validator_1.IsISO8601)({ strict: true }),
     __metadata("design:type", String)
 ], BiometricVerificationResponse.prototype, "expiresAt", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsISO8601)({ strict: true }),
+    __metadata("design:type", String)
+], BiometricVerificationResponse.prototype, "inputsCompletedAt", void 0);
 __decorate([
     (0, class_transformer_1.Expose)(),
     (0, class_validator_1.IsOptional)(),

package/bin/biometrics/enums/BiometricEventTypeEnum.d.ts

@@ -3,8 +3,8 @@
  * lo que el consumer usa para decidir la transición de estado.
  *
  * Es el vocabulario NUESTRO, no el de Metamap: `kyc-metamap-webhook` traduce sus `eventName` a
- * estos cuatro antes de publicar. Así el consumer no aprende el catálogo de un proveedor externo, y
- * el día que entre otro proveedor traduce a los mismos cuatro.
+ * estos valores antes de publicar. Así el consumer no aprende el catálogo de un proveedor externo, y
+ * el día que entre otro proveedor traduce a los mismos valores.
  *
  * `biometrics-business` — Entrega 1.
  */
@@ -24,5 +24,9 @@ export declare enum BiometricEventTypeEnum {
      * ⚠️ **No se depende de este evento para expirar.** El `GET` persiste `EXPIRED` comparando
      * contra `expiresAt` (DEC-015), así que una verificación vence aunque este evento nunca llegue.
      */
-    VERIFICATION_EXPIRED = "VERIFICATION_EXPIRED"
+    VERIFICATION_EXPIRED = "VERIFICATION_EXPIRED",
+    /** El usuario terminó de subir su información. Sigue en `IN_PROGRESS` y graba `inputsCompletedAt`. */
+    INPUTS_COMPLETED = "INPUTS_COMPLETED",
+    /** El proveedor cambió el veredicto (revisión manual). Se trata igual que `VERIFICATION_COMPLETED`. */
+    UPDATED = "UPDATED"
 }

package/bin/biometrics/enums/BiometricEventTypeEnum.js

@@ -6,8 +6,8 @@ exports.BiometricEventTypeEnum = void 0;
  * lo que el consumer usa para decidir la transición de estado.
  *
  * Es el vocabulario NUESTRO, no el de Metamap: `kyc-metamap-webhook` traduce sus `eventName` a
- * estos cuatro antes de publicar. Así el consumer no aprende el catálogo de un proveedor externo, y
- * el día que entre otro proveedor traduce a los mismos cuatro.
+ * estos valores antes de publicar. Así el consumer no aprende el catálogo de un proveedor externo, y
+ * el día que entre otro proveedor traduce a los mismos valores.
  *
  * `biometrics-business` — Entrega 1.
  */
@@ -29,4 +29,8 @@ var BiometricEventTypeEnum;
      * contra `expiresAt` (DEC-015), así que una verificación vence aunque este evento nunca llegue.
      */
     BiometricEventTypeEnum["VERIFICATION_EXPIRED"] = "VERIFICATION_EXPIRED";
+    /** El usuario terminó de subir su información. Sigue en `IN_PROGRESS` y graba `inputsCompletedAt`. */
+    BiometricEventTypeEnum["INPUTS_COMPLETED"] = "INPUTS_COMPLETED";
+    /** El proveedor cambió el veredicto (revisión manual). Se trata igual que `VERIFICATION_COMPLETED`. */
+    BiometricEventTypeEnum["UPDATED"] = "UPDATED";
 })(BiometricEventTypeEnum || (exports.BiometricEventTypeEnum = BiometricEventTypeEnum = {}));

package/bin/kyc/enums/KycFlowEnum.d.ts

@@ -0,0 +1,5 @@
+/** Flujo de Metamap al que pertenece un evento; el webhook lo deriva de `metadata.kycStep`. */
+export declare enum KycFlowEnum {
+    IDENTITY = "IDENTITY",
+    PROOF_OF_ADDRESS = "PROOF_OF_ADDRESS"
+}

package/bin/kyc/enums/KycFlowEnum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KycFlowEnum = void 0;
+/** Flujo de Metamap al que pertenece un evento; el webhook lo deriva de `metadata.kycStep`. */
+var KycFlowEnum;
+(function (KycFlowEnum) {
+    KycFlowEnum["IDENTITY"] = "IDENTITY";
+    KycFlowEnum["PROOF_OF_ADDRESS"] = "PROOF_OF_ADDRESS";
+})(KycFlowEnum || (exports.KycFlowEnum = KycFlowEnum = {}));

package/bin/kyc/enums/KycProgressStageEnum.d.ts

@@ -0,0 +1,6 @@
+/** Etapa de avance de una verificación de Metamap, tal como la publica `kyc-metamap-webhook`. */
+export declare enum KycProgressStageEnum {
+    STARTED = "STARTED",
+    INPUTS_COMPLETED = "INPUTS_COMPLETED",
+    EXPIRED = "EXPIRED"
+}