@fiado/type-kit 3.470.0 → 3.472.0

package/_test_/unit/common/IsStringValueRecord.test.ts

@@ -0,0 +1,25 @@
+import 'reflect-metadata';
+import { IsStringValueRecord } from '../../../src/common';
+import { IsStringValueRecord as FromMessagesConnector } from '../../../src/messagesConnector/validators/IsStringValueRecord';
+
+describe('IsStringValueRecord (common)', () => {
+    const validator = new IsStringValueRecord();
+    const args = {} as never;
+
+    it('acepta un mapa de strings', () => {
+        expect(validator.validate({ a: 'x', b: '' }, args)).toBe(true);
+    });
+
+    it('rechaza un valor que no es string', () => {
+        expect(validator.validate({ a: 1 }, args)).toBe(false);
+    });
+
+    it('rechaza null y valores que no son objeto', () => {
+        expect(validator.validate(null, args)).toBe(false);
+        expect(validator.validate('x', args)).toBe(false);
+    });
+
+    it('messagesConnector reexporta la misma clase', () => {
+        expect(FromMessagesConnector).toBe(IsStringValueRecord);
+    });
+});

package/_test_/unit/moneyTransfer/accountDtos.test.ts

@@ -0,0 +1,206 @@
+import "reflect-metadata";
+import { plainToInstance } from "class-transformer";
+import { validateSync } from "class-validator";
+import {
+    AccountImpactResponse,
+    AccountListResponse,
+    AccountResponse,
+    AccountWithImpactResponse,
+    CreateAccountRequest,
+    PendingDetailsResponse,
+    SettlementResponse,
+    TransactionDetailResponse,
+    TransferChannelEnum,
+    UpdateAccountRequest,
+} from "../../../src/moneyTransfer";
+
+const propertiesWithErrors = (dto: object) => validateSync(dto).map((error) => error.property);
+
+/** Cuenta destino válida (DEC-041). */
+const CUENTA_COMPLETA = {
+    accountId: "ACC-BANORTE-01",
+    tenantId: "SPEI",
+    channel: TransferChannelEnum.SPEI,
+    account: "072180000123456789",
+    beneficiaryName: "ACME SA DE CV",
+    beneficiaryRfc: "ACM010101AB1",
+    bankName: "Banorte",
+    currency: "MXN",
+    enabled: true,
+};
+
+describe("CreateAccountRequest", () => {
+    it("una cuenta completa pasa la validación", () => {
+        expect(validateSync(plainToInstance(CreateAccountRequest, CUENTA_COMPLETA))).toHaveLength(0);
+    });
+
+    it("beneficiaryRfc es opcional", () => {
+        const { beneficiaryRfc: _omit, ...sinRfc } = CUENTA_COMPLETA;
+        expect(validateSync(plainToInstance(CreateAccountRequest, sinRfc))).toHaveLength(0);
+    });
+
+    it("exige todos los campos obligatorios cuando llega vacía", () => {
+        const props = propertiesWithErrors(plainToInstance(CreateAccountRequest, {}));
+        for (const campo of [
+            "accountId",
+            "tenantId",
+            "channel",
+            "account",
+            "beneficiaryName",
+            "bankName",
+            "currency",
+            "enabled",
+        ]) {
+            expect(props).toContain(campo);
+        }
+    });
+
+    it("rechaza un accountId en minúsculas o con caracteres fuera de [A-Z0-9-]", () => {
+        for (const accountId of ["acc-banorte-01", "ACC BANORTE", "-ACC", "ACC_01"]) {
+            expect(propertiesWithErrors(plainToInstance(CreateAccountRequest, { ...CUENTA_COMPLETA, accountId })))
+                .toContain("accountId");
+        }
+    });
+
+    it("acepta un accountId de 64 chars y rechaza 65", () => {
+        const enElLimite = { ...CUENTA_COMPLETA, accountId: "A".repeat(64) };
+        expect(validateSync(plainToInstance(CreateAccountRequest, enElLimite))).toHaveLength(0);
+
+        const pasado = { ...CUENTA_COMPLETA, accountId: "A".repeat(65) };
+        expect(propertiesWithErrors(plainToInstance(CreateAccountRequest, pasado))).toContain("accountId");
+    });
+
+    it("rechaza un canal fuera de TransferChannelEnum", () => {
+        expect(propertiesWithErrors(plainToInstance(CreateAccountRequest, { ...CUENTA_COMPLETA, channel: "SWIFT" })))
+            .toContain("channel");
+    });
+
+    it("rechaza beneficiaryName > 40, bankName > 60, account > 34 y currency != 3", () => {
+        const dto = plainToInstance(CreateAccountRequest, {
+            ...CUENTA_COMPLETA,
+            beneficiaryName: "N".repeat(41),
+            bankName: "B".repeat(61),
+            account: "9".repeat(35),
+            currency: "MX",
+        });
+        const props = propertiesWithErrors(dto);
+        expect(props).toContain("beneficiaryName");
+        expect(props).toContain("bankName");
+        expect(props).toContain("account");
+        expect(props).toContain("currency");
+    });
+
+    it("rechaza beneficiaryRfc fuera del rango 12-13 chars", () => {
+        for (const beneficiaryRfc of ["CORTO", "R".repeat(14)]) {
+            expect(propertiesWithErrors(plainToInstance(CreateAccountRequest, { ...CUENTA_COMPLETA, beneficiaryRfc })))
+                .toContain("beneficiaryRfc");
+        }
+    });
+});
+
+describe("UpdateAccountRequest", () => {
+    it("un body vacío es válido: todos los campos son opcionales", () => {
+        expect(validateSync(plainToInstance(UpdateAccountRequest, {}))).toHaveLength(0);
+    });
+
+    it("DEC-045: permite mandar solo el número de cuenta corregido", () => {
+        expect(validateSync(plainToInstance(UpdateAccountRequest, { account: "072180000987654321" }))).toHaveLength(0);
+    });
+
+    it("DEC-049: permite deshabilitar mandando solo enabled", () => {
+        expect(validateSync(plainToInstance(UpdateAccountRequest, { enabled: false }))).toHaveLength(0);
+    });
+
+    it("accountId no es una propiedad del DTO: la PK viaja en el path, no en el body", () => {
+        // `accountId` no está declarado ni validado; si alguien lo manda, el DTO no lo reconoce
+        // como campo propio y el manager no lo puede usar para reasignar la PK.
+        const dto = plainToInstance(UpdateAccountRequest, { accountId: "ACC-OTRA-01" });
+        expect(validateSync(dto)).toHaveLength(0);
+        expect(Object.keys(new UpdateAccountRequest())).not.toContain("accountId");
+    });
+
+    it("cuando un campo opcional viene, se valida igual que en el alta", () => {
+        const dto = plainToInstance(UpdateAccountRequest, {
+            channel: "SWIFT",
+            account: "",
+            beneficiaryName: "N".repeat(41),
+            beneficiaryRfc: "CORTO",
+            bankName: "B".repeat(61),
+            currency: "MX",
+            enabled: "si",
+        });
+        const props = propertiesWithErrors(dto);
+        for (const campo of ["channel", "account", "beneficiaryName", "beneficiaryRfc", "bankName", "currency", "enabled"]) {
+            expect(props).toContain(campo);
+        }
+    });
+});
+
+describe("DTOs de respuesta de cuentas", () => {
+    it("AccountResponse es instanciable y lleva la CLABE sin enmascarar", () => {
+        const response = plainToInstance(AccountResponse, {
+            ...CUENTA_COMPLETA,
+            createdBy: "system",
+            updatedBy: "system",
+            createdAt: 1_758_000_000_000,
+            updatedAt: 1_758_000_000_000,
+        });
+        expect(response).toBeInstanceOf(AccountResponse);
+        expect(response.account).toBe(CUENTA_COMPLETA.account);
+        expect(response.channel).toBe(TransferChannelEnum.SPEI);
+    });
+
+    it("AccountListResponse anida AccountResponse y nextToken es opcional", () => {
+        const page = plainToInstance(AccountListResponse, { items: [] });
+        expect(page).toBeInstanceOf(AccountListResponse);
+        expect(page.items).toEqual([]);
+        expect(page.nextToken).toBeUndefined();
+    });
+
+    it("AccountImpactResponse (DEC-050) lleva los 4 contadores del impacto", () => {
+        const impact = plainToInstance(AccountImpactResponse, {
+            products: 2,
+            pendingDetails: 7,
+            pendingAmount: 1500,
+            pendingSettlements: 1,
+        });
+        expect(impact).toBeInstanceOf(AccountImpactResponse);
+        expect(impact.products).toBe(2);
+        expect(impact.pendingDetails).toBe(7);
+        expect(impact.pendingAmount).toBe(1500);
+        expect(impact.pendingSettlements).toBe(1);
+    });
+
+    it("AccountWithImpactResponse compone cuenta + impacto", () => {
+        const dto = plainToInstance(AccountWithImpactResponse, {
+            account: { ...CUENTA_COMPLETA, createdBy: "system", updatedBy: "system", createdAt: 1, updatedAt: 2 },
+            impact: { products: 0, pendingDetails: 0, pendingAmount: 0, pendingSettlements: 0 },
+        });
+        expect(dto).toBeInstanceOf(AccountWithImpactResponse);
+        expect(dto.account.accountId).toBe("ACC-BANORTE-01");
+        expect(dto.impact.products).toBe(0);
+    });
+});
+
+describe("Campos nuevos en los DTOs de respuesta existentes", () => {
+    it("DEC-044: SettlementResponse lleva sentToAccount, opcional", () => {
+        const conCuenta = plainToInstance(SettlementResponse, { sentToAccount: "072180000123456789" });
+        expect(conCuenta.sentToAccount).toBe("072180000123456789");
+        expect(plainToInstance(SettlementResponse, {}).sentToAccount).toBeUndefined();
+    });
+
+    it("DEC-051: TransactionDetailResponse lleva blockedByAccount, opcional", () => {
+        expect(plainToInstance(TransactionDetailResponse, { blockedByAccount: true }).blockedByAccount).toBe(true);
+        expect(plainToInstance(TransactionDetailResponse, {}).blockedByAccount).toBeUndefined();
+    });
+
+    it("PendingDetailsResponse propaga blockedByAccount vía sus items (F9)", () => {
+        const page = plainToInstance(PendingDetailsResponse, {
+            items: [{ transactionNumber: "T-1", blockedByAccount: true }],
+            count: 1,
+            totalAmount: 100,
+        });
+        expect(page).toBeInstanceOf(PendingDetailsResponse);
+        expect(page.items[0].blockedByAccount).toBe(true);
+    });
+});

package/_test_/unit/moneyTransfer/dtos.test.ts

@@ -22,7 +22,7 @@ const propertiesWithErrors = (dto: object) => validateSync(dto).map((error) => e
 const VALID_UUID = "3f6c2c5e-8b1a-4f3e-9d2a-1c4b5e6f7a8b";
 
 const PRODUCTO_COMPLETO = {
-    idProducto: "SPEI-BATCH-001",
+    idProducto: "ACC-BANORTE-01",
     producto: "Dispersión SPEI en lote",
     precio: 0,
     amountType: AmountTypeEnum.VARIABLE,
@@ -39,8 +39,6 @@ const PRODUCTO_COMPLETO = {
     enabled: true,
     channel: TransferChannelEnum.SPEI,
     settlementMode: SettlementModeEnum.BATCH,
-    beneficiaryName: "ACME SA DE CV",
-    beneficiaryRfc: "ACM010101AB1",
     minAmount: 1,
     maxAmount: 50000,
     batchSchedule: { cron: "0 18 * * 1-5", timezone: "America/Mexico_City" },
@@ -131,15 +129,27 @@ describe("MoneyTransferProductRequest", () => {
         expect(propertiesWithErrors(dto)).toContain("batchSchedule");
     });
 
-    it("rechaza beneficiaryRfc fuera de 12-13 chars y beneficiaryName > 40", () => {
+    it("DEC-046: ignora beneficiaryName/beneficiaryRfc, que ya no son del producto", () => {
         const dto = plainToInstance(MoneyTransferProductRequest, {
             ...PRODUCTO_COMPLETO,
             beneficiaryRfc: "CORTO",
             beneficiaryName: "N".repeat(41),
         });
-        const props = propertiesWithErrors(dto);
-        expect(props).toContain("beneficiaryRfc");
-        expect(props).toContain("beneficiaryName");
+        expect(validateSync(dto)).toHaveLength(0);
+    });
+
+    it("DEC-041: idProducto acepta un accountId de hasta 64 chars y rechaza 65", () => {
+        const enElLimite = plainToInstance(MoneyTransferProductRequest, {
+            ...PRODUCTO_COMPLETO,
+            idProducto: "A".repeat(64),
+        });
+        expect(validateSync(enElLimite)).toHaveLength(0);
+
+        const pasado = plainToInstance(MoneyTransferProductRequest, {
+            ...PRODUCTO_COMPLETO,
+            idProducto: "A".repeat(65),
+        });
+        expect(propertiesWithErrors(pasado)).toContain("idProducto");
     });
 
     it("rechaza channel y settlementMode fuera de sus enums", () => {
@@ -175,7 +185,7 @@ describe("MoneyTransferServiceCreateRequest", () => {
         const nested = listError!.children?.[0]?.children?.map((child) => child.property) ?? [];
         expect(nested).toContain("producto");
         expect(nested).toContain("channel");
-        expect(nested).toContain("beneficiaryName");
+        expect(nested).toContain("settlementMode");
     });
 
     it("exige al menos un producto", () => {

package/_test_/unit/platformRbac/dtos/tenantUserCustomFields.test.ts

@@ -0,0 +1,55 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { CreateTenantUserRequest } from '../../../../src/platformRbac/dtos/CreateTenantUserRequest';
+import { UpdateTenantUserRequest } from '../../../../src/platformRbac/dtos/UpdateTenantUserRequest';
+import { PermissionScope } from '../../../../src/platformRbac/enums/PermissionScope';
+
+const createBase = {
+    email: 'agente@example.com',
+    roleId: 'role-agente',
+    scope: PermissionScope.LEVEL_1,
+    scopeRef: 'grp-1',
+    createdBy: 'admin-sub-1',
+};
+const updateBase = { actedBy: 'admin-sub-1' };
+
+describe.each([
+    ['CreateTenantUserRequest', CreateTenantUserRequest, createBase],
+    ['UpdateTenantUserRequest', UpdateTenantUserRequest, updateBase],
+] as const)('%s.customFields', (_name, Dto, base) => {
+    const validateWith = async (customFields: unknown) =>
+        validate(plainToInstance(Dto as new () => object, { ...base, customFields }));
+
+    it('es opcional', async () => {
+        expect(await validate(plainToInstance(Dto as new () => object, base))).toEqual([]);
+    });
+
+    it('acepta un mapa de strings y lo conserva', async () => {
+        const dto = plainToInstance(Dto as new () => object, {
+            ...base,
+            customFields: { directory_id: 'dir-1', home_group_id: 'grp-1' },
+        }) as { customFields?: Record<string, string> };
+        expect(await validate(dto)).toEqual([]);
+        expect(dto.customFields).toEqual({ directory_id: 'dir-1', home_group_id: 'grp-1' });
+    });
+
+    it('acepta la cadena vacía (marca de borrado del rbac)', async () => {
+        expect(await validateWith({ directory_id: '' })).toEqual([]);
+    });
+
+    it('rechaza un valor que no es string', async () => {
+        const errors = await validateWith({ directory_id: 123 });
+        expect(errors.some((e) => e.property === 'customFields')).toBe(true);
+    });
+
+    it('rechaza un arreglo', async () => {
+        const errors = await validateWith(['dir-1']);
+        expect(errors.some((e) => e.property === 'customFields')).toBe(true);
+    });
+
+    it('rechaza un string suelto', async () => {
+        const errors = await validateWith('dir-1');
+        expect(errors.some((e) => e.property === 'customFields')).toBe(true);
+    });
+});

package/bin/common/index.d.ts

@@ -1,4 +1,5 @@
 export * from './decorators/Trim';
+export * from './validators/IsStringValueRecord';
 export * from './dtos/ProcessValidationResultDto';
 export * from './enums/ProcessValidationEnum';
 export * from './enums/ProcessResultEnum';

package/bin/common/index.js

@@ -16,6 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 //decorators
 __exportStar(require("./decorators/Trim"), exports);
+//validators
+__exportStar(require("./validators/IsStringValueRecord"), exports);
 //dtos
 __exportStar(require("./dtos/ProcessValidationResultDto"), exports);
 //Enums

package/bin/common/validators/IsStringValueRecord.d.ts

@@ -0,0 +1,5 @@
+import { ValidatorConstraintInterface, ValidationArguments } from 'class-validator';
+export declare class IsStringValueRecord implements ValidatorConstraintInterface {
+    validate(value: unknown, _args: ValidationArguments): boolean;
+    defaultMessage(_args: ValidationArguments): string;
+}

package/bin/common/validators/IsStringValueRecord.js

@@ -0,0 +1,25 @@
+"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.IsStringValueRecord = void 0;
+const class_validator_1 = require("class-validator");
+// Valida que un objeto sea un mapa clave → string.
+let IsStringValueRecord = class IsStringValueRecord {
+    validate(value, _args) {
+        if (!value || typeof value !== 'object')
+            return false;
+        return Object.values(value).every(v => typeof v === 'string');
+    }
+    defaultMessage(_args) {
+        return 'All values in variables must be strings';
+    }
+};
+exports.IsStringValueRecord = IsStringValueRecord;
+exports.IsStringValueRecord = IsStringValueRecord = __decorate([
+    (0, class_validator_1.ValidatorConstraint)({ name: 'IsStringValueRecord', async: false })
+], IsStringValueRecord);

package/bin/messagesConnector/validators/IsStringValueRecord.d.ts

@@ -1,5 +1 @@
-import { ValidatorConstraintInterface, ValidationArguments } from 'class-validator';
-export declare class IsStringValueRecord implements ValidatorConstraintInterface {
-    validate(value: unknown, _args: ValidationArguments): boolean;
-    defaultMessage(_args: ValidationArguments): string;
-}
+export { IsStringValueRecord } from '../../common/validators/IsStringValueRecord';

package/bin/messagesConnector/validators/IsStringValueRecord.js

@@ -1,24 +1,6 @@
 "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.IsStringValueRecord = void 0;
-const class_validator_1 = require("class-validator");
-let IsStringValueRecord = class IsStringValueRecord {
-    validate(value, _args) {
-        if (!value || typeof value !== 'object')
-            return false;
-        return Object.values(value).every(v => typeof v === 'string');
-    }
-    defaultMessage(_args) {
-        return 'All values in variables must be strings';
-    }
-};
-exports.IsStringValueRecord = IsStringValueRecord;
-exports.IsStringValueRecord = IsStringValueRecord = __decorate([
-    (0, class_validator_1.ValidatorConstraint)({ name: 'IsStringValueRecord', async: false })
-], IsStringValueRecord);
+// Movido a common: se reexporta para no romper a quien importa desde messagesConnector.
+var IsStringValueRecord_1 = require("../../common/validators/IsStringValueRecord");
+Object.defineProperty(exports, "IsStringValueRecord", { enumerable: true, get: function () { return IsStringValueRecord_1.IsStringValueRecord; } });

package/bin/moneyTransfer/dtos/AccountImpactResponse.d.ts

@@ -0,0 +1,18 @@
+/**
+ * DEC-050: qué se rompe antes de romperlo. Deshabilitar o editar una cuenta NO bloquea aunque haya
+ * folios pendientes o liquidaciones en vuelo — pero el operador tiene que ver el número en el momento
+ * de apretar el botón, no descubrirlo después.
+ *
+ * `pendingSettlements` cuenta liquidaciones en estado NO terminal (CREATED, SCHEDULED, SENDING, FAILED):
+ * esas son las que todavía pueden salir al riel y por lo tanto resolverían la cuenta editada (DEC-042).
+ */
+export declare class AccountImpactResponse {
+    /** Productos del catálogo que referencian esta cuenta por `idProducto`. */
+    products: number;
+    /** Folios en `PENDING_SETTLEMENT` de esta cuenta (GSI `pendingProductId-createdAt-index`). */
+    pendingDetails: number;
+    /** Suma de los montos de esos folios. */
+    pendingAmount: number;
+    /** Liquidaciones en estado no terminal que todavía pueden salir al riel. */
+    pendingSettlements: number;
+}

package/bin/moneyTransfer/dtos/AccountImpactResponse.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountImpactResponse = void 0;
+/**
+ * DEC-050: qué se rompe antes de romperlo. Deshabilitar o editar una cuenta NO bloquea aunque haya
+ * folios pendientes o liquidaciones en vuelo — pero el operador tiene que ver el número en el momento
+ * de apretar el botón, no descubrirlo después.
+ *
+ * `pendingSettlements` cuenta liquidaciones en estado NO terminal (CREATED, SCHEDULED, SENDING, FAILED):
+ * esas son las que todavía pueden salir al riel y por lo tanto resolverían la cuenta editada (DEC-042).
+ */
+class AccountImpactResponse {
+}
+exports.AccountImpactResponse = AccountImpactResponse;

package/bin/moneyTransfer/dtos/AccountListResponse.d.ts

@@ -0,0 +1,6 @@
+import { AccountResponse } from "./AccountResponse";
+/** Página de cuentas de un tenant (GSI `tenantId-createdAt-index`). Paginada por cursor opaco. */
+export declare class AccountListResponse {
+    items: AccountResponse[];
+    nextToken?: string;
+}

package/bin/moneyTransfer/dtos/AccountListResponse.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountListResponse = void 0;
+/** Página de cuentas de un tenant (GSI `tenantId-createdAt-index`). Paginada por cursor opaco. */
+class AccountListResponse {
+}
+exports.AccountListResponse = AccountListResponse;

package/bin/moneyTransfer/dtos/AccountResponse.d.ts

@@ -0,0 +1,23 @@
+import { TransferChannelEnum } from "../enums/TransferChannelEnum";
+/**
+ * Cuenta destino en la respuesta de backoffice. Sin decoradores `class-validator`: el consumidor la
+ * lee tal cual viene por la red. Timestamps en epoch ms.
+ *
+ * `account` (la CLABE) SÍ sale: el operador de backoffice necesita verla para conciliar contra el
+ * estado de cuenta del banco. El enmascarado aplica a los LOGS, no a esta respuesta autenticada.
+ */
+export declare class AccountResponse {
+    accountId: string;
+    tenantId: string;
+    channel: TransferChannelEnum;
+    account: string;
+    beneficiaryName: string;
+    beneficiaryRfc?: string;
+    bankName: string;
+    currency: string;
+    enabled: boolean;
+    createdBy: string;
+    updatedBy: string;
+    createdAt: number;
+    updatedAt: number;
+}

package/bin/moneyTransfer/dtos/AccountResponse.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountResponse = void 0;
+/**
+ * Cuenta destino en la respuesta de backoffice. Sin decoradores `class-validator`: el consumidor la
+ * lee tal cual viene por la red. Timestamps en epoch ms.
+ *
+ * `account` (la CLABE) SÍ sale: el operador de backoffice necesita verla para conciliar contra el
+ * estado de cuenta del banco. El enmascarado aplica a los LOGS, no a esta respuesta autenticada.
+ */
+class AccountResponse {
+}
+exports.AccountResponse = AccountResponse;

package/bin/moneyTransfer/dtos/AccountWithImpactResponse.d.ts

@@ -0,0 +1,11 @@
+import { AccountImpactResponse } from "./AccountImpactResponse";
+import { AccountResponse } from "./AccountResponse";
+/**
+ * Respuesta del `PUT /backoffice/accounts/{accountId}` (DEC-050): la cuenta ya editada, más el impacto
+ * que esa edición tiene. Se devuelve el impacto incluso cuando el operador no consultó
+ * `/impact` antes, que es el caso que hay que cubrir.
+ */
+export declare class AccountWithImpactResponse {
+    account: AccountResponse;
+    impact: AccountImpactResponse;
+}

package/bin/moneyTransfer/dtos/AccountWithImpactResponse.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountWithImpactResponse = void 0;
+/**
+ * Respuesta del `PUT /backoffice/accounts/{accountId}` (DEC-050): la cuenta ya editada, más el impacto
+ * que esa edición tiene. Se devuelve el impacto incluso cuando el operador no consultó
+ * `/impact` antes, que es el caso que hay que cubrir.
+ */
+class AccountWithImpactResponse {
+}
+exports.AccountWithImpactResponse = AccountWithImpactResponse;

package/bin/moneyTransfer/dtos/CreateAccountRequest.d.ts

@@ -0,0 +1,27 @@
+import { TransferChannelEnum } from "../enums/TransferChannelEnum";
+/**
+ * Alta de una cuenta destino (DEC-041). La cuenta vive en `MoneyTransferAccount_GT` y el producto
+ * del catálogo la referencia por `accountId`; el número de cuenta (CLABE en SPEI) es el ÚNICO campo
+ * que cambia cuando el tercero cambia de banco.
+ *
+ * Sin `idempotencyKey` a propósito: el alta ya tiene llave natural (`accountId` repetido → 409) y no
+ * mueve dinero ni lotes, así que el doble click no puede duplicar nada.
+ */
+export declare class CreateAccountRequest {
+    /** Identificador estable y legible, p. ej. `ACC-BANORTE-01`. Es la PK de la tabla. */
+    accountId: string;
+    /** DEC-034: tenant (partner) dueño de la cuenta; = subcategoría del servicio. */
+    tenantId: string;
+    channel: TransferChannelEnum;
+    /** Número de cuenta del riel: CLABE de 18 dígitos en SPEI. El conector lo valida por canal (DEC-053). */
+    account: string;
+    /** Nombre del titular tal como viaja al riel (SPEI acepta máx. 40 chars). */
+    beneficiaryName: string;
+    /** RFC del titular: 12 chars persona moral, 13 persona física. */
+    beneficiaryRfc?: string;
+    /** Nombre del banco, para que el operador reconozca la cuenta en backoffice. */
+    bankName: string;
+    /** ISO 4217 (`MXN`, `USD`). */
+    currency: string;
+    enabled: boolean;
+}

package/bin/moneyTransfer/dtos/CreateAccountRequest.js

@@ -0,0 +1,75 @@
+"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.CreateAccountRequest = void 0;
+const class_validator_1 = require("class-validator");
+const TransferChannelEnum_1 = require("../enums/TransferChannelEnum");
+/**
+ * Alta de una cuenta destino (DEC-041). La cuenta vive en `MoneyTransferAccount_GT` y el producto
+ * del catálogo la referencia por `accountId`; el número de cuenta (CLABE en SPEI) es el ÚNICO campo
+ * que cambia cuando el tercero cambia de banco.
+ *
+ * Sin `idempotencyKey` a propósito: el alta ya tiene llave natural (`accountId` repetido → 409) y no
+ * mueve dinero ni lotes, así que el doble click no puede duplicar nada.
+ */
+class CreateAccountRequest {
+}
+exports.CreateAccountRequest = CreateAccountRequest;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(64),
+    (0, class_validator_1.Matches)(/^[A-Z0-9][A-Z0-9-]*$/, { message: "accountId debe ser mayúsculas, dígitos y guiones" }),
+    __metadata("design:type", String)
+], CreateAccountRequest.prototype, "accountId", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(64),
+    __metadata("design:type", String)
+], CreateAccountRequest.prototype, "tenantId", void 0);
+__decorate([
+    (0, class_validator_1.IsEnum)(TransferChannelEnum_1.TransferChannelEnum),
+    __metadata("design:type", String)
+], CreateAccountRequest.prototype, "channel", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(34),
+    __metadata("design:type", String)
+], CreateAccountRequest.prototype, "account", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(40),
+    __metadata("design:type", String)
+], CreateAccountRequest.prototype, "beneficiaryName", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.Length)(12, 13),
+    __metadata("design:type", String)
+], CreateAccountRequest.prototype, "beneficiaryRfc", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(60),
+    __metadata("design:type", String)
+], CreateAccountRequest.prototype, "bankName", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.Length)(3, 3),
+    __metadata("design:type", String)
+], CreateAccountRequest.prototype, "currency", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], CreateAccountRequest.prototype, "enabled", void 0);