@fiado/type-kit 3.609.0 → 3.611.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/customerReadDtos.test.ts

@@ -3,6 +3,8 @@ import {
     ContractTypeEnum,
     CreditSaleContext,
     LoanContractDownloadUrl,
+    LoanCustomerCreditDocument,
+    LoanCustomerCreditDocumentUrl,
     LoanPaymentListItem,
     LoanPaymentListResponse,
 } from '../../../src/loanCredit/index';
@@ -68,4 +70,24 @@ describe('loanCredit — DTOs de lectura de cliente (I1)', () => {
         };
         expect(url.type).toBe(ContractTypeEnum.CREDIT);
     });
+
+    it('un documento del ciclo de vida sin PDF todavía no tiene fecha de generación', () => {
+        const pending: LoanCustomerCreditDocument = {
+            documentType: ContractTypeEnum.PAYMENT_RECEIPT,
+            documentKey: '01K8Z5Q2J6V3W4X5Y6Z7A8B9C0',
+            generatedAt: null,
+        };
+        expect(pending.generatedAt).toBeNull();
+    });
+
+    it('la URL de un documento del ciclo de vida trae su tipo, su llave y su vencimiento', () => {
+        const url: LoanCustomerCreditDocumentUrl = {
+            creditId: 'CR-1',
+            documentType: ContractTypeEnum.ACCOUNT_STATEMENT,
+            documentKey: '2026-09',
+            url: 'https://s3.example/statement.pdf',
+            expiresAt: '2026-10-21T15:00:00.000Z',
+        };
+        expect(url.documentKey).toBe('2026-09');
+    });
 });

package/_test_/unit/retailLoan/contract.test.ts

@@ -18,6 +18,11 @@ describe('retailLoan — contrato app ↔ retail-loan-business (I1)', () => {
     it('los ids de grupo de documentos son los que espera el módulo de la app', () => {
         expect(MyDocumentGroupIdEnum.CONTRACT).toBe('contract');
         expect(MyDocumentGroupIdEnum.MONTHLY).toBe('monthly');
+        expect(MyDocumentGroupIdEnum.PAYMENT_RECEIPTS).toBe('receipts');
+    });
+
+    it('un comprobante de pago es su propio tipo de documento', () => {
+        expect(MyDocumentKindEnum.PAYMENT_RECEIPT).toBe('PAYMENT_RECEIPT');
     });
 
     it('el detalle del crédito va en pesos y con frecuencia semanal', () => {

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"
+}

package/bin/kyc/enums/KycProgressStageEnum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KycProgressStageEnum = void 0;
+/** Etapa de avance de una verificación de Metamap, tal como la publica `kyc-metamap-webhook`. */
+var KycProgressStageEnum;
+(function (KycProgressStageEnum) {
+    KycProgressStageEnum["STARTED"] = "STARTED";
+    KycProgressStageEnum["INPUTS_COMPLETED"] = "INPUTS_COMPLETED";
+    KycProgressStageEnum["EXPIRED"] = "EXPIRED";
+})(KycProgressStageEnum || (exports.KycProgressStageEnum = KycProgressStageEnum = {}));

package/bin/kyc/events/KycProofOfAddressCompletedV1.d.ts

@@ -46,4 +46,6 @@ export declare class KycProofOfAddressCompletedV1 {
      * truena. Normalizar a UTC es trabajo del webhook; este candado lo manda al DLQ si deja de hacerlo.
      */
     occurredAt: string;
+    /** Intento del wizard que originó el comprobante; el consumidor descarta los que no son el vigente. */
+    attemptId?: string;
 }

package/bin/kyc/events/KycProofOfAddressCompletedV1.js

@@ -73,3 +73,10 @@ __decorate([
     }),
     __metadata("design:type", String)
 ], KycProofOfAddressCompletedV1.prototype, "occurredAt", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], KycProofOfAddressCompletedV1.prototype, "attemptId", void 0);

package/bin/kyc/events/KycStepCompletedV1.d.ts

@@ -1,3 +1,4 @@
+import { KycFlowEnum } from '../enums/KycFlowEnum';
 import { KycSubCheckNameEnum } from '../enums/KycSubCheckNameEnum';
 import { KycSubCheckStatusEnum } from '../enums/KycSubCheckStatusEnum';
 import { KycWatchlistStatusEnum } from '../enums/KycWatchlistStatusEnum';
@@ -82,4 +83,8 @@ export declare class KycStepCompletedV1 {
     occurredAt: string;
     /** El flujo de Metamap que corrió. Solo para diagnóstico — nadie ramifica por él. */
     metamapFlowId?: string;
+    /** Intento del wizard que originó la verificación; el consumidor descarta los que no son el vigente. */
+    attemptId?: string;
+    /** Flujo al que pertenece la estación, derivado de `metadata.kycStep`. */
+    flow?: KycFlowEnum;
 }