@fiado/type-kit 3.218.0 → 3.220.0

package/bin/kyc/events/KycStepCompletedV1.js

@@ -0,0 +1,93 @@
+"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.KycStepCompletedV1 = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const KycSubCheckNameEnum_1 = require("../enums/KycSubCheckNameEnum");
+const IsKycStepStatusByStep_1 = require("../validators/IsKycStepStatusByStep");
+/**
+ * El resultado de UNA estación del KYC, publicado por `kyc-metamap-webhook` en cuanto Metamap la
+ * cierra (`step_completed`) — no al final de la verificación.
+ *
+ * **Por qué existe:** `KycVerificationChangedV1` llega UNA vez, cuando todo terminó. Con eso la
+ * pantalla del vendedor solo puede mostrar una ruedita hasta el veredicto. Metamap emite un webhook
+ * por estación y el webhook ya los recibía; lo único que faltaba era reenviarlos. Este evento es ese
+ * reenvío: deja que SureKeep pinte el avance estación por estación mientras el cliente espera.
+ *
+ * **Convive con `KycVerificationChangedV1` en la MISMA cola** (`RetailKycInboundQueue`). El
+ * discriminador es la presencia de `step`: si lo trae, es una estación; si no, es el cierre. Por eso
+ * `KycVerificationChangedV1` no se tocó — un consumidor viejo que no conoce este evento lo descarta
+ * en su propio parseo sin romperse.
+ *
+ * 🔴 **NO es un veredicto.** Un `FAIL` acá no rechaza nada ni frena la venta: el cliente reintenta
+ * dentro del mismo SDK, en el mismo dispositivo, sin salir de la sesión. La decisión sigue viniendo
+ * del estado consolidado (`RetailKycStatusEnum`) que llega en el cierre. Esto es progreso visible,
+ * no política.
+ *
+ * 🔴 **Sin PII, a propósito.** No lleva `person`, ni `address`, ni `peopleId`: una estación solo
+ * necesita decir cuál es y cómo salió. Lo que sí lleva son identificadores operacionales, que es lo
+ * único que se puede loguear.
+ *
+ * **Idempotencia:** la clave es `(verificationId, step)` — NO viaja `eventId` a propósito. Una
+ * estación cierra una sola vez por verificación, y asentar su resultado sobre el progreso
+ * (`applyKycStep`) es idempotente por diseño: reprocesar el mismo evento escribe el mismo valor. Que
+ * quede dicho acá y no en la cabeza de cada consumidor: deducirlo mal lleva a deduplicar por el
+ * `MessageId` de SQS, que cambia en cada reintento de entrega y por lo tanto no deduplica nada.
+ *
+ * SureKeep Fase 2 — progreso del KYC estación por estación.
+ */
+class KycStepCompletedV1 {
+}
+exports.KycStepCompletedV1 = KycStepCompletedV1;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsIn)(['KycStepCompletedV1']),
+    __metadata("design:type", String)
+], KycStepCompletedV1.prototype, "eventType", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], KycStepCompletedV1.prototype, "verificationId", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], KycStepCompletedV1.prototype, "directoryId", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEnum)(KycSubCheckNameEnum_1.KycSubCheckNameEnum),
+    __metadata("design:type", String)
+], KycStepCompletedV1.prototype, "step", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Validate)(IsKycStepStatusByStep_1.IsKycStepStatusByStep),
+    __metadata("design:type", String)
+], KycStepCompletedV1.prototype, "status", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsISO8601)({ strict: true }),
+    (0, class_validator_1.Matches)(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/, {
+        message: 'occurredAt debe ser ISO-8601 en UTC con Z (ej. 2026-07-26T10:05:00.000Z): un offset rompe el orden léxico',
+    }),
+    __metadata("design:type", String)
+], KycStepCompletedV1.prototype, "occurredAt", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], KycStepCompletedV1.prototype, "metamapFlowId", void 0);

package/bin/kyc/helpers/applyKycStep.d.ts

@@ -0,0 +1,26 @@
+import { KycSubChecks } from '../dtos/KycSubChecks';
+import { KycSubCheckNameEnum } from '../enums/KycSubCheckNameEnum';
+import { KycSubCheckStatusEnum } from '../enums/KycSubCheckStatusEnum';
+import { KycWatchlistStatusEnum } from '../enums/KycWatchlistStatusEnum';
+/**
+ * Asienta el resultado de UNA estación (`KycStepCompletedV1`) sobre el progreso acumulado de la
+ * verificación, y devuelve un objeto NUEVO — no muta el que recibe.
+ *
+ * **Por qué esto vive en la lib y no en cada consumidor:** la asignación obvia
+ * `progreso[evento.step] = evento.status` **no compila**. Todos los campos de `KycSubChecks` son
+ * opcionales, así que al escribir a través de una llave-unión TypeScript exige el tipo intersección
+ * de todas las propiedades, que colapsa a `undefined` (TS2322). El consumidor que se topa con eso
+ * lo resuelve con `(progreso as Record<string, string>)[step] = status`, y ese cast desactiva
+ * justamente el cruce estación ↔ vocabulario que `IsKycStepStatusByStep` acaba de defender: un
+ * `watchlists: 'FAIL'` armado en memoria ya no lo detiene nadie.
+ *
+ * Concentrar el cast acá lo deja en UN solo lugar auditado, en vez de replicado en cada repo que
+ * consuma el evento. La seguridad real viene de haber validado el evento en el boundary; este helper
+ * solo evita que cada consumidor reinvente el atajo inseguro.
+ *
+ * ⚠️ NO valida la coherencia estación ↔ status: eso ya lo hizo el DTO en el boundary. Si se le pasa
+ * un par incoherente a mano, lo escribe — igual que lo haría el cast que reemplaza.
+ *
+ * SureKeep Fase 2 — progreso del KYC estación por estación.
+ */
+export declare function applyKycStep(progreso: KycSubChecks | undefined, step: KycSubCheckNameEnum, status: KycSubCheckStatusEnum | KycWatchlistStatusEnum): KycSubChecks;

package/bin/kyc/helpers/applyKycStep.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyKycStep = applyKycStep;
+/**
+ * Asienta el resultado de UNA estación (`KycStepCompletedV1`) sobre el progreso acumulado de la
+ * verificación, y devuelve un objeto NUEVO — no muta el que recibe.
+ *
+ * **Por qué esto vive en la lib y no en cada consumidor:** la asignación obvia
+ * `progreso[evento.step] = evento.status` **no compila**. Todos los campos de `KycSubChecks` son
+ * opcionales, así que al escribir a través de una llave-unión TypeScript exige el tipo intersección
+ * de todas las propiedades, que colapsa a `undefined` (TS2322). El consumidor que se topa con eso
+ * lo resuelve con `(progreso as Record<string, string>)[step] = status`, y ese cast desactiva
+ * justamente el cruce estación ↔ vocabulario que `IsKycStepStatusByStep` acaba de defender: un
+ * `watchlists: 'FAIL'` armado en memoria ya no lo detiene nadie.
+ *
+ * Concentrar el cast acá lo deja en UN solo lugar auditado, en vez de replicado en cada repo que
+ * consuma el evento. La seguridad real viene de haber validado el evento en el boundary; este helper
+ * solo evita que cada consumidor reinvente el atajo inseguro.
+ *
+ * ⚠️ NO valida la coherencia estación ↔ status: eso ya lo hizo el DTO en el boundary. Si se le pasa
+ * un par incoherente a mano, lo escribe — igual que lo haría el cast que reemplaza.
+ *
+ * SureKeep Fase 2 — progreso del KYC estación por estación.
+ */
+function applyKycStep(progreso, step, status) {
+    // El único cast del ecosistema para escribir por llave dinámica sobre `KycSubChecks`.
+    const siguiente = { ...(progreso ?? {}) };
+    siguiente[step] = status;
+    return siguiente;
+}

package/bin/kyc/index.d.ts

@@ -1,8 +1,12 @@
 export * from './enums/KycVerificationStatusEnum';
 export * from './enums/KycSubCheckStatusEnum';
 export * from './enums/KycWatchlistStatusEnum';
+export * from './enums/KycSubCheckNameEnum';
 export * from './dtos/KycSubChecks';
+export * from './validators/IsKycStepStatusByStep';
+export * from './helpers/applyKycStep';
 export * from './dtos/KycAddress';
 export * from './dtos/responses/KycPersonData';
 export * from './dtos/responses/KycByDirectoryResponse';
 export * from './events/KycVerificationChangedV1';
+export * from './events/KycStepCompletedV1';

package/bin/kyc/index.js

@@ -19,8 +19,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./enums/KycVerificationStatusEnum"), exports);
 __exportStar(require("./enums/KycSubCheckStatusEnum"), exports);
 __exportStar(require("./enums/KycWatchlistStatusEnum"), exports);
+__exportStar(require("./enums/KycSubCheckNameEnum"), exports);
 // Sub-pasos descompuestos (SureKeep F2)
 __exportStar(require("./dtos/KycSubChecks"), exports);
+// Validators
+__exportStar(require("./validators/IsKycStepStatusByStep"), exports);
+// Helpers
+__exportStar(require("./helpers/applyKycStep"), exports);
 // Domicilio del INE normalizado por places (SureKeep F2)
 __exportStar(require("./dtos/KycAddress"), exports);
 // Response DTOs
@@ -28,3 +33,4 @@ __exportStar(require("./dtos/responses/KycPersonData"), exports);
 __exportStar(require("./dtos/responses/KycByDirectoryResponse"), exports);
 // Events
 __exportStar(require("./events/KycVerificationChangedV1"), exports);
+__exportStar(require("./events/KycStepCompletedV1"), exports);

package/bin/kyc/validators/IsKycStepStatusByStep.d.ts

@@ -0,0 +1,26 @@
+import { ValidatorConstraintInterface, ValidationArguments } from 'class-validator';
+/**
+ * Valida que el `status` de un `KycStepCompletedV1` pertenezca al vocabulario de SU estación:
+ * las de lista hablan `CLEAR`/`HIT`, las binarias `PASS`/`FAIL`.
+ *
+ * **Por qué un validador y no un `@IsIn` con los cuatro valores:** un `@IsIn(['PASS','FAIL','CLEAR','HIT'])`
+ * aceptaría `{ step: 'watchlists', status: 'FAIL' }`. Eso rompe el matiz que `KycWatchlistStatusEnum`
+ * existe para proteger — un HIT **no es un fallo**, es "que lo mire cumplimiento". Con ese evento
+ * colado, el consumidor lo escribiría en el progreso y la pantalla del vendedor marcaría como falla
+ * algo que solo requiere revisión. El candado del anidado (`KycSubChecks`) tiene que valer igual
+ * cuando la estación viaja suelta.
+ *
+ * Es la misma razón por la que `KycSubChecks` tipa cada campo a su enum en vez de a un string.
+ *
+ * Uso:
+ * ```ts
+ *   @Validate(IsKycStepStatusByStep)
+ *   status!: KycSubCheckStatusEnum | KycWatchlistStatusEnum;
+ * ```
+ *
+ * SureKeep Fase 2 — progreso del KYC estación por estación.
+ */
+export declare class IsKycStepStatusByStep implements ValidatorConstraintInterface {
+    validate(value: unknown, args: ValidationArguments): boolean;
+    defaultMessage(args: ValidationArguments): string;
+}

package/bin/kyc/validators/IsKycStepStatusByStep.js

@@ -0,0 +1,64 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsKycStepStatusByStep = void 0;
+const class_validator_1 = require("class-validator");
+const KycSubCheckNameEnum_1 = require("../enums/KycSubCheckNameEnum");
+const KycSubCheckStatusEnum_1 = require("../enums/KycSubCheckStatusEnum");
+const KycWatchlistStatusEnum_1 = require("../enums/KycWatchlistStatusEnum");
+const VALORES_LISTA = Object.values(KycWatchlistStatusEnum_1.KycWatchlistStatusEnum);
+const VALORES_BINARIO = Object.values(KycSubCheckStatusEnum_1.KycSubCheckStatusEnum);
+/**
+ * Valida que el `status` de un `KycStepCompletedV1` pertenezca al vocabulario de SU estación:
+ * las de lista hablan `CLEAR`/`HIT`, las binarias `PASS`/`FAIL`.
+ *
+ * **Por qué un validador y no un `@IsIn` con los cuatro valores:** un `@IsIn(['PASS','FAIL','CLEAR','HIT'])`
+ * aceptaría `{ step: 'watchlists', status: 'FAIL' }`. Eso rompe el matiz que `KycWatchlistStatusEnum`
+ * existe para proteger — un HIT **no es un fallo**, es "que lo mire cumplimiento". Con ese evento
+ * colado, el consumidor lo escribiría en el progreso y la pantalla del vendedor marcaría como falla
+ * algo que solo requiere revisión. El candado del anidado (`KycSubChecks`) tiene que valer igual
+ * cuando la estación viaja suelta.
+ *
+ * Es la misma razón por la que `KycSubChecks` tipa cada campo a su enum en vez de a un string.
+ *
+ * Uso:
+ * ```ts
+ *   @Validate(IsKycStepStatusByStep)
+ *   status!: KycSubCheckStatusEnum | KycWatchlistStatusEnum;
+ * ```
+ *
+ * SureKeep Fase 2 — progreso del KYC estación por estación.
+ */
+let IsKycStepStatusByStep = class IsKycStepStatusByStep {
+    validate(value, args) {
+        if (typeof value !== 'string')
+            return false;
+        const step = args.object.step;
+        // Un `step` fuera del enum ya falla por su propio `@IsEnum`. Acá se rechaza igual en vez de
+        // dejar pasar el status: sin estación conocida no hay vocabulario contra el cual validar.
+        if (!Object.values(KycSubCheckNameEnum_1.KycSubCheckNameEnum).includes(step))
+            return false;
+        return KycSubCheckNameEnum_1.KYC_WATCHLIST_STEPS.includes(step)
+            ? VALORES_LISTA.includes(value)
+            : VALORES_BINARIO.includes(value);
+    }
+    defaultMessage(args) {
+        const step = args.object.step;
+        if (KycSubCheckNameEnum_1.KYC_WATCHLIST_STEPS.includes(step)) {
+            return `status de la estación ${String(step)} debe ser ${VALORES_LISTA.join(' o ')} (un HIT no es un fallo)`;
+        }
+        if (Object.values(KycSubCheckNameEnum_1.KycSubCheckNameEnum).includes(step)) {
+            return `status de la estación ${String(step)} debe ser ${VALORES_BINARIO.join(' o ')}`;
+        }
+        return 'status no se puede validar sin un step reconocido';
+    }
+};
+exports.IsKycStepStatusByStep = IsKycStepStatusByStep;
+exports.IsKycStepStatusByStep = IsKycStepStatusByStep = __decorate([
+    (0, class_validator_1.ValidatorConstraint)({ name: 'IsKycStepStatusByStep', async: false })
+], IsKycStepStatusByStep);

package/bin/loanConfig/enums/ModifiableByRoleEnum.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Rol RBAC mínimo que puede modificar un parámetro (RBAC a nivel de parámetro, modelo-datos §8).
+ * `retailer_admin` = "Admin VentasLuga" de M6 §8. Valores = identificadores de rol de RBAC F0.
+ * TD-004: confirmar mapeo super_admin ↔ platform_super_admin con el naming real de F0.
+ * @enum {string}
+ */
+export declare enum ModifiableByRoleEnum {
+    SUPER_ADMIN = "super_admin",
+    SOFOM_ADMIN = "sofom_admin",
+    RETAILER_ADMIN = "retailer_admin"
+}

package/bin/loanConfig/enums/ModifiableByRoleEnum.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModifiableByRoleEnum = void 0;
+/**
+ * Rol RBAC mínimo que puede modificar un parámetro (RBAC a nivel de parámetro, modelo-datos §8).
+ * `retailer_admin` = "Admin VentasLuga" de M6 §8. Valores = identificadores de rol de RBAC F0.
+ * TD-004: confirmar mapeo super_admin ↔ platform_super_admin con el naming real de F0.
+ * @enum {string}
+ */
+var ModifiableByRoleEnum;
+(function (ModifiableByRoleEnum) {
+    ModifiableByRoleEnum["SUPER_ADMIN"] = "super_admin";
+    ModifiableByRoleEnum["SOFOM_ADMIN"] = "sofom_admin";
+    ModifiableByRoleEnum["RETAILER_ADMIN"] = "retailer_admin";
+})(ModifiableByRoleEnum || (exports.ModifiableByRoleEnum = ModifiableByRoleEnum = {}));

package/bin/places/dtos/CashInFeeDto.d.ts

@@ -0,0 +1,17 @@
+import { CurrencyId } from '../../currency/enums/CurrencyId';
+/**
+ * Comisión que cobra un punto de cash-in (lo que el lambda MUESTRA, no cobra).
+ * - GreenDot (US): representativo por cadena → `fixed` + `cap` (cada tienda cobra hasta el tope).
+ * - Passport (MX): por red → `fixed` + `percentage`.
+ * Response DTO — sin decoradores de validación.
+ */
+export declare class CashInFeeDto {
+    /** Comisión fija, en la moneda del país. */
+    fixed?: number;
+    /** Porcentaje del monto depositado (0–100). */
+    percentage?: number;
+    /** Tope máximo de comisión (GreenDot: el asociado cobra hasta este cap). */
+    cap?: number;
+    /** Moneda del fee: USD (GreenDot) | MXN (Passport). */
+    currency: CurrencyId;
+}

package/bin/places/dtos/CashInFeeDto.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CashInFeeDto = void 0;
+/**
+ * Comisión que cobra un punto de cash-in (lo que el lambda MUESTRA, no cobra).
+ * - GreenDot (US): representativo por cadena → `fixed` + `cap` (cada tienda cobra hasta el tope).
+ * - Passport (MX): por red → `fixed` + `percentage`.
+ * Response DTO — sin decoradores de validación.
+ */
+class CashInFeeDto {
+}
+exports.CashInFeeDto = CashInFeeDto;

package/bin/platformRbac/dtos/ResendOtpRequest.d.ts

@@ -0,0 +1,22 @@
+import { MfaMethodEnum } from '../enums/MfaMethodEnum';
+/**
+ * Body del POST /auth/resend-otp (público, anónimo). DEC-RBAC-054.
+ * Reenvía el OTP del login re-disparando el challenge real CUSTOM_AUTH (EMAIL_OTP) para la
+ * identidad SIN password. `tenantId` obligatorio (DEC-064 — el picker ya lo resolvió, NO "solo email").
+ * El email se normaliza lowercase server-side. Postura anti-enumeración: respuesta 200 genérica
+ * siempre, sin filtrar existencia (ver AuthLoginManager.resendChallengeOtp).
+ */
+export declare class ResendOtpRequest {
+    email: string;
+    tenantId: string;
+}
+/**
+ * Respuesta del resend-otp. `session`/`mfaMethod` frescos del nuevo challenge CUSTOM_AUTH.
+ * Plain sin validators (no validamos lo que mandamos al cliente — fiado-validation-and-dtos § 7).
+ * Ambos opcionales: en los caminos de rechazo silencioso (anti-enumeración) o ramas sin CUSTOM_AUTH
+ * el server responde 200 genérico sin session ni método.
+ */
+export interface ResendOtpResponse {
+    session?: string;
+    mfaMethod?: MfaMethodEnum;
+}

package/bin/platformRbac/dtos/ResendOtpRequest.js

@@ -0,0 +1,36 @@
+"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.ResendOtpRequest = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+/**
+ * Body del POST /auth/resend-otp (público, anónimo). DEC-RBAC-054.
+ * Reenvía el OTP del login re-disparando el challenge real CUSTOM_AUTH (EMAIL_OTP) para la
+ * identidad SIN password. `tenantId` obligatorio (DEC-064 — el picker ya lo resolvió, NO "solo email").
+ * El email se normaliza lowercase server-side. Postura anti-enumeración: respuesta 200 genérica
+ * siempre, sin filtrar existencia (ver AuthLoginManager.resendChallengeOtp).
+ */
+class ResendOtpRequest {
+}
+exports.ResendOtpRequest = ResendOtpRequest;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEmail)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], ResendOtpRequest.prototype, "email", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], ResendOtpRequest.prototype, "tenantId", void 0);

package/bin/platformRbac/dtos/ResendSelfRegisterOtpRequest.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Body del POST /self-register/resend-otp (público, anónimo). DEC-RBAC-054.
+ * Re-envía el OTP del autoregistro (mecanismo messages-business, NO Cognito) tras validar un
+ * `pending` existente. Misma postura anti-enumeración del start. El email se normaliza lowercase
+ * server-side. DTO propio por endpoint (NO reusa SelfRegisterStartRequest, que exige roleId/scope/
+ * scopeRef, ni SelfRegisterVerifyOtpRequest, que exige otp).
+ */
+export declare class ResendSelfRegisterOtpRequest {
+    tenantId: string;
+    email: string;
+}

package/bin/platformRbac/dtos/ResendSelfRegisterOtpRequest.js

@@ -0,0 +1,36 @@
+"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.ResendSelfRegisterOtpRequest = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+/**
+ * Body del POST /self-register/resend-otp (público, anónimo). DEC-RBAC-054.
+ * Re-envía el OTP del autoregistro (mecanismo messages-business, NO Cognito) tras validar un
+ * `pending` existente. Misma postura anti-enumeración del start. El email se normaliza lowercase
+ * server-side. DTO propio por endpoint (NO reusa SelfRegisterStartRequest, que exige roleId/scope/
+ * scopeRef, ni SelfRegisterVerifyOtpRequest, que exige otp).
+ */
+class ResendSelfRegisterOtpRequest {
+}
+exports.ResendSelfRegisterOtpRequest = ResendSelfRegisterOtpRequest;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], ResendSelfRegisterOtpRequest.prototype, "tenantId", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEmail)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], ResendSelfRegisterOtpRequest.prototype, "email", void 0);

package/bin/retailWizard/dtos/responses/KycPrepareResponse.d.ts

@@ -22,6 +22,12 @@ export interface KycSdkMetadata {
     phoneNumber: string;
     typeOfDocumentId?: string;
     isPartial?: boolean;
+    /**
+     * Idioma con el que Metamap fija el flujo del widget. El wizard lo manda como `'es'` para que
+     * la verificación salga en español por defecto (si no viaja, Metamap arranca en su default, inglés).
+     * Va opcional en el tipo porque es un ajuste de presentación del SDK, no parte de la correlación.
+     */
+    fixedLanguage?: string;
     customInput?: boolean;
     userPhotoLink?: string;
     userPhotoLinkHash?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiado/type-kit",
-  "version": "3.218.0",
+  "version": "3.220.0",
   "description": "",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",

package/src/kyc/enums/KycSubCheckNameEnum.ts

@@ -0,0 +1,36 @@
+/**
+ * Nombre de la estación del KYC que reporta un `KycStepCompletedV1`.
+ *
+ * ⚠️ Los VALORES son exactamente las llaves de `KycSubChecks`. No es coincidencia ni estética: el
+ * consumidor arma el progreso de la verificación asentando cada estación sobre el acumulado, sin
+ * tabla de traducción. Si un valor dejara de coincidir con su llave, el progreso quedaría con un
+ * campo huérfano y la estación real nunca se marcaría — una falla muda. Ese acumulado se arma con
+ * `applyKycStep`, NO indexando a mano: la asignación directa no compila (los campos de `KycSubChecks`
+ * son opcionales) y el cast que la destraba desactiva el candado del vocabulario.
+ *
+ * Son las 8 del contrato, no las 13 que Metamap puede emitir: las otras (ip-validation, selfie,
+ * voice, duplicate-user-detection, curp/ine validation) no forman parte de `KycSubChecks` y por lo
+ * tanto no viajan. Ampliar la lista es un cambio de contrato en los dos lados, no un valor más aquí.
+ *
+ * SureKeep Fase 2 — progreso del KYC estación por estación.
+ */
+export enum KycSubCheckNameEnum {
+    DOCUMENT_READING = 'documentReading',
+    TEMPLATE_MATCHING = 'templateMatching',
+    ALTERATION_DETECTION = 'alterationDetection',
+    FACEMATCH = 'facematch',
+    LIVENESS = 'liveness',
+    AGE_CHECK = 'ageCheck',
+    WATCHLISTS = 'watchlists',
+    PREMIUM_AML_WATCHLISTS = 'premiumAmlWatchlists',
+}
+
+/**
+ * Las estaciones de LISTA — las únicas cuyo resultado se expresa en `CLEAR`/`HIT`. El resto son
+ * binarias (`PASS`/`FAIL`). Se exporta porque el validador del evento y los consumidores necesitan
+ * la MISMA partición: duplicarla en cada repo es drift garantizado.
+ */
+export const KYC_WATCHLIST_STEPS: readonly KycSubCheckNameEnum[] = [
+    KycSubCheckNameEnum.WATCHLISTS,
+    KycSubCheckNameEnum.PREMIUM_AML_WATCHLISTS,
+];

package/src/kyc/events/KycStepCompletedV1.ts

@@ -0,0 +1,105 @@
+import { Expose } from 'class-transformer';
+import { IsEnum, IsIn, IsISO8601, IsNotEmpty, IsOptional, IsString, Matches, Validate } from 'class-validator';
+import { KycSubCheckNameEnum } from '../enums/KycSubCheckNameEnum';
+import { KycSubCheckStatusEnum } from '../enums/KycSubCheckStatusEnum';
+import { KycWatchlistStatusEnum } from '../enums/KycWatchlistStatusEnum';
+import { IsKycStepStatusByStep } from '../validators/IsKycStepStatusByStep';
+
+/**
+ * El resultado de UNA estación del KYC, publicado por `kyc-metamap-webhook` en cuanto Metamap la
+ * cierra (`step_completed`) — no al final de la verificación.
+ *
+ * **Por qué existe:** `KycVerificationChangedV1` llega UNA vez, cuando todo terminó. Con eso la
+ * pantalla del vendedor solo puede mostrar una ruedita hasta el veredicto. Metamap emite un webhook
+ * por estación y el webhook ya los recibía; lo único que faltaba era reenviarlos. Este evento es ese
+ * reenvío: deja que SureKeep pinte el avance estación por estación mientras el cliente espera.
+ *
+ * **Convive con `KycVerificationChangedV1` en la MISMA cola** (`RetailKycInboundQueue`). El
+ * discriminador es la presencia de `step`: si lo trae, es una estación; si no, es el cierre. Por eso
+ * `KycVerificationChangedV1` no se tocó — un consumidor viejo que no conoce este evento lo descarta
+ * en su propio parseo sin romperse.
+ *
+ * 🔴 **NO es un veredicto.** Un `FAIL` acá no rechaza nada ni frena la venta: el cliente reintenta
+ * dentro del mismo SDK, en el mismo dispositivo, sin salir de la sesión. La decisión sigue viniendo
+ * del estado consolidado (`RetailKycStatusEnum`) que llega en el cierre. Esto es progreso visible,
+ * no política.
+ *
+ * 🔴 **Sin PII, a propósito.** No lleva `person`, ni `address`, ni `peopleId`: una estación solo
+ * necesita decir cuál es y cómo salió. Lo que sí lleva son identificadores operacionales, que es lo
+ * único que se puede loguear.
+ *
+ * **Idempotencia:** la clave es `(verificationId, step)` — NO viaja `eventId` a propósito. Una
+ * estación cierra una sola vez por verificación, y asentar su resultado sobre el progreso
+ * (`applyKycStep`) es idempotente por diseño: reprocesar el mismo evento escribe el mismo valor. Que
+ * quede dicho acá y no en la cabeza de cada consumidor: deducirlo mal lleva a deduplicar por el
+ * `MessageId` de SQS, que cambia en cada reintento de entrega y por lo tanto no deduplica nada.
+ *
+ * SureKeep Fase 2 — progreso del KYC estación por estación.
+ */
+export class KycStepCompletedV1 {
+    /**
+     * Discriminador EXPLÍCITO del tipo de evento. Opcional hoy, y esa es toda la gracia: agregarlo
+     * ahora es gratis; agregarlo después de que el webhook publique en Dev ya sería breaking.
+     *
+     * Sin él, el ruteo del consumidor depende de la presencia de `step`. Eso funciona con los dos
+     * eventos de hoy, pero Metamap también emite `step_started`: el día que alguien publique un
+     * `KycStepStartedV1` traería `step` sin `status`, el consumidor lo rutearía a esta rama y el
+     * mensaje caería al DLQ etiquetado como "corrupto" en vez de "no soportado" — se diagnostica
+     * como bug del webhook cuando en realidad es un evento nuevo legítimo.
+     *
+     * Regla de ruteo hacia adelante: si `eventType` viene y matchea → esta rama; si no viene
+     * ninguno → el cierre legacy (`KycVerificationChangedV1`).
+     */
+    @Expose() @IsOptional() @IsIn(['KycStepCompletedV1'])
+    eventType?: string;
+
+    /** Correlaciona la estación con su verificación. */
+    @Expose() @IsString() @IsNotEmpty()
+    verificationId!: string;
+
+    /**
+     * Con esto el consumidor encuentra la sesión (el gate de pertenencia). DEC-KYC-015: `@IsNotEmpty()`
+     * y no solo `@IsString()` — un `''` colado dejaría el gate sin nada contra qué buscar y el evento
+     * fallaría tres pasos río abajo en vez de en el boundary.
+     */
+    @Expose() @IsString() @IsNotEmpty()
+    directoryId!: string;
+
+    /** Cuál estación cerró. El valor coincide con su llave en `KycSubChecks`. */
+    @Expose() @IsEnum(KycSubCheckNameEnum)
+    step!: KycSubCheckNameEnum;
+
+    /**
+     * Cómo salió, en el vocabulario de SU estación: `CLEAR`/`HIT` en las de lista, `PASS`/`FAIL` en
+     * las binarias. El cruce lo valida `IsKycStepStatusByStep` — un `@IsIn` con los cuatro valores
+     * aceptaría `watchlists: FAIL` y perdería el matiz de que un HIT no es un fallo.
+     */
+    @Expose() @Validate(IsKycStepStatusByStep)
+    status!: KycSubCheckStatusEnum | KycWatchlistStatusEnum;
+
+    /**
+     * Cuándo cerró la estación, según Metamap. **Obligatorio, y no es decorativo:** la cola es SQS
+     * estándar, que no garantiza orden. Sin una marca de tiempo por evento, una estación reordenada
+     * puede pisar el cierre de la verificación y "des-cerrar" la lista ya completa en pantalla. El
+     * consumidor descarta las que llegan más viejas que lo que ya escribió.
+     *
+     * ⚠️ **UTC estricto, con `Z` y sin offset** — por eso el `@Matches` además del `@IsISO8601()`.
+     * `@IsISO8601()` solo NO alcanza: acepta `2026-07-26` (sin hora), `2026-W30-1` (fecha de semana)
+     * y, sobre todo, `2026-07-26T15:05:00+05:00`. Ese último es el que hace daño. Si una estación
+     * llega con offset `+05:00` y la siguiente en `Z`, la comparación léxica que hace el consumidor
+     * concluye que la más nueva es más vieja y la DESCARTA: la estación nunca se pinta y nada truena.
+     *
+     * Normalizar a UTC es trabajo del webhook — es el traductor del proveedor, y este candado existe
+     * para que si algún día deja de hacerlo, el evento caiga al DLQ en el boundary en vez de
+     * corromper el orden en silencio.
+     */
+    @Expose() @IsString() @IsISO8601({ strict: true })
+    @Matches(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/, {
+        message: 'occurredAt debe ser ISO-8601 en UTC con Z (ej. 2026-07-26T10:05:00.000Z): un offset rompe el orden léxico',
+    })
+    occurredAt!: string;
+
+    /** El flujo de Metamap que corrió. Solo para diagnóstico — nadie ramifica por él. */
+    @Expose() @IsOptional() @IsString()
+    metamapFlowId?: string;
+}