@fiado/type-kit 3.463.0 → 3.465.0

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

@@ -0,0 +1,298 @@
+import "reflect-metadata";
+import { plainToInstance } from "class-transformer";
+import { validateSync } from "class-validator";
+import {
+    BatchScheduleRequest,
+    CreateSettlementRequest,
+    MoneyTransferProductRequest,
+    MoneyTransferServiceCreateRequest,
+    MoneyTransferServiceUpdateRequest,
+    RescheduleSettlementRequest,
+    SettlementActionRequest,
+    SettlementModeEnum,
+    SettlementStatusMessage,
+    SpeiOrderStatusEnum,
+    TransferChannelEnum,
+} from "../../../src/moneyTransfer";
+import { AmountTypeEnum } from "../../../src/servicePayment/enums/AmountTypeEnum";
+import { ReferenceTypeEnum } from "../../../src/servicePayment/enums/ReferenceTypeEnum";
+
+const propertiesWithErrors = (dto: object) => validateSync(dto).map((error) => error.property);
+
+const VALID_UUID = "3f6c2c5e-8b1a-4f3e-9d2a-1c4b5e6f7a8b";
+
+const PRODUCTO_COMPLETO = {
+    idProducto: "SPEI-BATCH-001",
+    producto: "Dispersión SPEI en lote",
+    precio: 0,
+    amountType: AmountTypeEnum.VARIABLE,
+    fee: 5,
+    tipoReferencia: ReferenceTypeEnum.CLIENT_NUMBER,
+    verificateReference: false,
+    hasDigitoVerificador: false,
+    showAyuda: false,
+    legend: "",
+    logoSrc: "",
+    refSrc: "",
+    tipoFront: 1,
+    idCatTipoServicio: 7,
+    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" },
+};
+
+const SERVICIO_BASE = {
+    idServicio: 90001,
+    servicio: "Transferencias ACME",
+    categoria: "Transferencias",
+    subcategoria: "SPEI",
+    categoryOrder: 1,
+    subcategoryOrder: 1,
+    serviceOrder: 1,
+    beneficeId: "ben-1",
+    enabled: true,
+    currencyId: "MXN",
+    serviceCountryId: "MEX",
+    logoSrc: "",
+    idCatTipoServicio: 7,
+};
+
+describe("SettlementStatusMessage", () => {
+    it("acepta claveRastreo de hasta 30 chars y status del enum", () => {
+        const dto = plainToInstance(SettlementStatusMessage, {
+            claveRastreo: "A".repeat(30),
+            status: SpeiOrderStatusEnum.LQ,
+        });
+        expect(validateSync(dto)).toHaveLength(0);
+    });
+
+    it("rechaza claveRastreo de más de 30 chars", () => {
+        const dto = plainToInstance(SettlementStatusMessage, {
+            claveRastreo: "A".repeat(31),
+            status: SpeiOrderStatusEnum.LQ,
+        });
+        expect(propertiesWithErrors(dto)).toContain("claveRastreo");
+    });
+
+    it("rechaza claveRastreo vacía", () => {
+        const dto = plainToInstance(SettlementStatusMessage, { claveRastreo: "", status: SpeiOrderStatusEnum.D });
+        expect(propertiesWithErrors(dto)).toContain("claveRastreo");
+    });
+
+    it("rechaza status fuera del enum", () => {
+        const dto = plainToInstance(SettlementStatusMessage, { claveRastreo: "ABC123", status: "LIQUIDADO" });
+        expect(propertiesWithErrors(dto)).toContain("status");
+    });
+
+    it("reason es opcional pero acotado a 256 chars", () => {
+        const ok = plainToInstance(SettlementStatusMessage, { claveRastreo: "ABC", status: SpeiOrderStatusEnum.CN });
+        expect(validateSync(ok)).toHaveLength(0);
+        const largo = plainToInstance(SettlementStatusMessage, {
+            claveRastreo: "ABC",
+            status: SpeiOrderStatusEnum.CN,
+            reason: "x".repeat(257),
+        });
+        expect(propertiesWithErrors(largo)).toContain("reason");
+    });
+});
+
+describe("BatchScheduleRequest", () => {
+    it("exige cron y timezone no vacíos", () => {
+        const dto = plainToInstance(BatchScheduleRequest, { cron: "", timezone: "" });
+        const props = propertiesWithErrors(dto);
+        expect(props).toContain("cron");
+        expect(props).toContain("timezone");
+    });
+});
+
+describe("MoneyTransferProductRequest", () => {
+    it("un producto completo con batchSchedule válido pasa", () => {
+        const dto = plainToInstance(MoneyTransferProductRequest, PRODUCTO_COMPLETO);
+        expect(validateSync(dto)).toHaveLength(0);
+        expect(dto.batchSchedule).toBeInstanceOf(BatchScheduleRequest);
+    });
+
+    it("batchSchedule es opcional", () => {
+        const { batchSchedule: _omit, ...sinSchedule } = PRODUCTO_COMPLETO;
+        const dto = plainToInstance(MoneyTransferProductRequest, sinSchedule);
+        expect(validateSync(dto)).toHaveLength(0);
+    });
+
+    it("rechaza batchSchedule con cron vacío (validación anidada)", () => {
+        const dto = plainToInstance(MoneyTransferProductRequest, {
+            ...PRODUCTO_COMPLETO,
+            batchSchedule: { cron: "", timezone: "America/Mexico_City" },
+        });
+        expect(propertiesWithErrors(dto)).toContain("batchSchedule");
+    });
+
+    it("rechaza beneficiaryRfc fuera de 12-13 chars y beneficiaryName > 40", () => {
+        const dto = plainToInstance(MoneyTransferProductRequest, {
+            ...PRODUCTO_COMPLETO,
+            beneficiaryRfc: "CORTO",
+            beneficiaryName: "N".repeat(41),
+        });
+        const props = propertiesWithErrors(dto);
+        expect(props).toContain("beneficiaryRfc");
+        expect(props).toContain("beneficiaryName");
+    });
+
+    it("rechaza channel y settlementMode fuera de sus enums", () => {
+        const dto = plainToInstance(MoneyTransferProductRequest, {
+            ...PRODUCTO_COMPLETO,
+            channel: "SWIFT",
+            settlementMode: "LATER",
+        });
+        const props = propertiesWithErrors(dto);
+        expect(props).toContain("channel");
+        expect(props).toContain("settlementMode");
+    });
+});
+
+describe("MoneyTransferServiceCreateRequest", () => {
+    it("un servicio completo con un producto completo pasa", () => {
+        const dto = plainToInstance(MoneyTransferServiceCreateRequest, {
+            ...SERVICIO_BASE,
+            productoDTOList: [PRODUCTO_COMPLETO],
+        });
+        expect(validateSync(dto)).toHaveLength(0);
+        expect(dto.productoDTOList[0]).toBeInstanceOf(MoneyTransferProductRequest);
+    });
+
+    it("con un producto incompleto produce errores de validación anidados", () => {
+        const dto = plainToInstance(MoneyTransferServiceCreateRequest, {
+            ...SERVICIO_BASE,
+            productoDTOList: [{ idProducto: "X" }],
+        });
+        const errors = validateSync(dto);
+        const listError = errors.find((error) => error.property === "productoDTOList");
+        expect(listError).toBeDefined();
+        const nested = listError!.children?.[0]?.children?.map((child) => child.property) ?? [];
+        expect(nested).toContain("producto");
+        expect(nested).toContain("channel");
+        expect(nested).toContain("beneficiaryName");
+    });
+
+    it("exige al menos un producto", () => {
+        const dto = plainToInstance(MoneyTransferServiceCreateRequest, { ...SERVICIO_BASE, productoDTOList: [] });
+        expect(propertiesWithErrors(dto)).toContain("productoDTOList");
+    });
+
+    it("exige idServicio >= 90000 y currencyId de 3 chars", () => {
+        const dto = plainToInstance(MoneyTransferServiceCreateRequest, {
+            ...SERVICIO_BASE,
+            idServicio: 100,
+            currencyId: "MXNN",
+            productoDTOList: [PRODUCTO_COMPLETO],
+        });
+        const props = propertiesWithErrors(dto);
+        expect(props).toContain("idServicio");
+        expect(props).toContain("currencyId");
+    });
+});
+
+describe("MoneyTransferServiceUpdateRequest", () => {
+    it("acepta un payload vacío (todos los campos opcionales)", () => {
+        const dto = plainToInstance(MoneyTransferServiceUpdateRequest, {});
+        expect(validateSync(dto)).toHaveLength(0);
+    });
+
+    it("valida el producto anidado cuando viene productoDTOList", () => {
+        const dto = plainToInstance(MoneyTransferServiceUpdateRequest, {
+            productoDTOList: [{ idProducto: "X" }],
+        });
+        expect(propertiesWithErrors(dto)).toContain("productoDTOList");
+    });
+
+    it("sigue validando el tipo de los campos presentes", () => {
+        const dto = plainToInstance(MoneyTransferServiceUpdateRequest, { idServicio: 100, enabled: "si" });
+        const props = propertiesWithErrors(dto);
+        expect(props).toContain("idServicio");
+        expect(props).toContain("enabled");
+    });
+});
+
+describe("CreateSettlementRequest", () => {
+    it("acepta idempotencyKey UUID, ≥1 folio y sendNow", () => {
+        const dto = plainToInstance(CreateSettlementRequest, {
+            idempotencyKey: VALID_UUID,
+            transactionNumbers: ["TX-1", "TX-2"],
+            sendNow: true,
+        });
+        expect(validateSync(dto)).toHaveLength(0);
+    });
+
+    it("rechaza idempotencyKey que no es UUID", () => {
+        const dto = plainToInstance(CreateSettlementRequest, {
+            idempotencyKey: "no-uuid",
+            transactionNumbers: ["TX-1"],
+            sendNow: false,
+        });
+        expect(propertiesWithErrors(dto)).toContain("idempotencyKey");
+    });
+
+    it("rechaza transactionNumbers vacío", () => {
+        const dto = plainToInstance(CreateSettlementRequest, {
+            idempotencyKey: VALID_UUID,
+            transactionNumbers: [],
+            sendNow: false,
+        });
+        expect(propertiesWithErrors(dto)).toContain("transactionNumbers");
+    });
+
+    it("rechaza más de 1000 folios y elementos no string", () => {
+        const muchos = plainToInstance(CreateSettlementRequest, {
+            idempotencyKey: VALID_UUID,
+            transactionNumbers: Array.from({ length: 1001 }, (_, i) => `TX-${i}`),
+            sendNow: false,
+        });
+        expect(propertiesWithErrors(muchos)).toContain("transactionNumbers");
+        const noString = plainToInstance(CreateSettlementRequest, {
+            idempotencyKey: VALID_UUID,
+            transactionNumbers: [123],
+            sendNow: false,
+        });
+        expect(propertiesWithErrors(noString)).toContain("transactionNumbers");
+    });
+
+    it("scheduledAt es opcional, entero y >= 0", () => {
+        const dto = plainToInstance(CreateSettlementRequest, {
+            idempotencyKey: VALID_UUID,
+            transactionNumbers: ["TX-1"],
+            sendNow: false,
+            scheduledAt: -1,
+        });
+        expect(propertiesWithErrors(dto)).toContain("scheduledAt");
+    });
+});
+
+describe("SettlementActionRequest / RescheduleSettlementRequest", () => {
+    it("SettlementActionRequest exige idempotencyKey UUID", () => {
+        expect(propertiesWithErrors(plainToInstance(SettlementActionRequest, { idempotencyKey: "x" }))).toContain(
+            "idempotencyKey",
+        );
+        expect(validateSync(plainToInstance(SettlementActionRequest, { idempotencyKey: VALID_UUID }))).toHaveLength(0);
+    });
+
+    it("RescheduleSettlementRequest hereda idempotencyKey y exige scheduledAt entero >= 0", () => {
+        const dto = plainToInstance(RescheduleSettlementRequest, { idempotencyKey: "x", scheduledAt: 1.5 });
+        const props = propertiesWithErrors(dto);
+        expect(props).toContain("idempotencyKey");
+        expect(props).toContain("scheduledAt");
+        const ok = plainToInstance(RescheduleSettlementRequest, { idempotencyKey: VALID_UUID, scheduledAt: 0 });
+        expect(validateSync(ok)).toHaveLength(0);
+    });
+});
+
+describe("MoneyTransferServiceUpdateRequest — productoDTOList vacía", () => {
+    it("rechaza productoDTOList: [] (reemplaza la lista completa; no puede quedar vacía)", () => {
+        const dto = plainToInstance(MoneyTransferServiceUpdateRequest, { productoDTOList: [] });
+        const errors = validateSync(dto);
+        expect(errors.map(e => e.property)).toContain("productoDTOList");
+    });
+});

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

@@ -0,0 +1,56 @@
+import "reflect-metadata";
+import {
+    SettlementModeEnum,
+    SettlementStatusEnum,
+    SpeiOrderStatusEnum,
+    TransactionDetailStatusEnum,
+    TransferChannelEnum,
+} from "../../../src/moneyTransfer";
+
+describe("moneyTransfer enums", () => {
+    it("TransferChannelEnum tiene SPEI y ACH con valores string estables", () => {
+        expect(TransferChannelEnum.SPEI).toBe("SPEI");
+        expect(TransferChannelEnum.ACH).toBe("ACH");
+        expect(Object.values(TransferChannelEnum).sort()).toEqual(["ACH", "SPEI"]);
+    });
+
+    it("SettlementModeEnum tiene IMMEDIATE y BATCH", () => {
+        expect(SettlementModeEnum.IMMEDIATE).toBe("IMMEDIATE");
+        expect(SettlementModeEnum.BATCH).toBe("BATCH");
+        expect(Object.values(SettlementModeEnum).sort()).toEqual(["BATCH", "IMMEDIATE"]);
+    });
+
+    it("SettlementStatusEnum tiene exactamente los 8 estados del ciclo de vida", () => {
+        expect(Object.values(SettlementStatusEnum).sort()).toEqual([
+            "CANCELLED",
+            "CREATED",
+            "FAILED",
+            "RETURNED",
+            "SCHEDULED",
+            "SENDING",
+            "SENT",
+            "SETTLED",
+        ]);
+        expect(SettlementStatusEnum.CREATED).toBe("CREATED");
+        expect(SettlementStatusEnum.SETTLED).toBe("SETTLED");
+    });
+
+    it("TransactionDetailStatusEnum tiene los 4 estados del detalle", () => {
+        expect(Object.values(TransactionDetailStatusEnum).sort()).toEqual([
+            "FAILED",
+            "PENDING_SETTLEMENT",
+            "RETURNED",
+            "SETTLED",
+        ]);
+        expect(TransactionDetailStatusEnum.PENDING_SETTLEMENT).toBe("PENDING_SETTLEMENT");
+    });
+
+    it("SpeiOrderStatusEnum refleja los códigos de STP más PENDING/UNKNOWN", () => {
+        expect(SpeiOrderStatusEnum.LQ).toBe("LQ");
+        expect(SpeiOrderStatusEnum.D).toBe("D");
+        expect(SpeiOrderStatusEnum.CN).toBe("CN");
+        expect(SpeiOrderStatusEnum.PENDING).toBe("PENDING");
+        expect(SpeiOrderStatusEnum.UNKNOWN).toBe("UNKNOWN");
+        expect(Object.values(SpeiOrderStatusEnum).sort()).toEqual(["CN", "D", "LQ", "PENDING", "UNKNOWN"]);
+    });
+});

package/_test_/unit/retailCatalog/backofficeRequests.test.ts

@@ -0,0 +1,283 @@
+import 'reflect-metadata';
+import { plainToInstance, type ClassConstructor } from 'class-transformer';
+import { validateSync, type ValidationError } from 'class-validator';
+import {
+  BackofficeCreateKitRequest,
+  BackofficeCreateProductRequest,
+  BackofficeCreateServiceRequest,
+  BackofficeCreateSkuPriceRequest,
+  BackofficeCreateTransferRequest,
+  BackofficeListTransfersQuery,
+  BackofficeRegisterAdjustmentRequest,
+  BackofficeRegisterEntryRequest,
+  BackofficeUpdateProductRequest,
+  ADJUSTMENT_REASONS,
+  InventoryMovementReasonEnum,
+  IsPieceRefConstraint,
+  NON_BUNDLE_CATEGORIES,
+  ProductCategoryEnum,
+  TrackingModeEnum,
+  TransferStateEnum,
+  type ListTransfersResponse,
+  type TransferResponse,
+} from '../../../src/retailCatalog';
+
+function paths(errors: ValidationError[], prefix = ''): string[] {
+  return errors.flatMap((e) => {
+    const p = prefix ? `${prefix}.${e.property}` : e.property;
+    return e.children && e.children.length > 0 ? paths(e.children, p) : [p];
+  });
+}
+
+function errorsOf<T extends object>(cls: ClassConstructor<T>, payload: object): string[] {
+  return paths(validateSync(plainToInstance(cls, payload) as object, { whitelist: true, forbidNonWhitelisted: true }));
+}
+
+function without<T extends object>(obj: T, key: keyof T): object {
+  return Object.fromEntries(Object.entries(obj).filter(([k]) => k !== key));
+}
+
+describe('BackofficeCreateProductRequest (backofficeCreateProduct)', () => {
+  const ok = {
+    sku: 'PH-A15',
+    category: ProductCategoryEnum.PHONE,
+    trackingMode: TrackingModeEnum.IMEI,
+    sellable: true,
+    showInSalesFlow: true,
+  };
+  it('acepta el mínimo', () => expect(errorsOf(BackofficeCreateProductRequest, ok)).toEqual([]));
+  it('acepta los datos descriptivos opcionales', () => {
+    const full = { ...ok, brand: 'Samsung', model: 'A15', capacity: '128GB', color: 'Negro', description: 'Gama media', imageUrl: 'https://x/y.png', tier: 'MID' };
+    expect(errorsOf(BackofficeCreateProductRequest, full)).toEqual([]);
+  });
+  it.each(['sku', 'category', 'trackingMode', 'sellable', 'showInSalesFlow'] as const)('rechaza sin %s', (key) => {
+    expect(errorsOf(BackofficeCreateProductRequest, without(ok, key))).toContain(key);
+  });
+  it('rechaza BUNDLE: el kit tiene su propio endpoint', () => {
+    expect(errorsOf(BackofficeCreateProductRequest, { ...ok, category: ProductCategoryEnum.BUNDLE })).toContain('category');
+  });
+  it('rechaza enums inválidos y booleanos como string', () => {
+    const errors = errorsOf(BackofficeCreateProductRequest, { ...ok, category: 'TABLET', trackingMode: 'RFID', sellable: 'true', tier: 'ULTRA' });
+    expect(errors).toEqual(expect.arrayContaining(['category', 'trackingMode', 'sellable', 'tier']));
+  });
+  it('rechaza sku con espacios y descripción en blanco', () => {
+    const errors = errorsOf(BackofficeCreateProductRequest, { ...ok, sku: '  ', description: '   ' });
+    expect(errors).toEqual(expect.arrayContaining(['sku', 'description']));
+  });
+});
+
+describe('BackofficeCreateKitRequest (backofficeCreateKit)', () => {
+  const ok = { sku: 'KIT-A15', sellable: true, showInSalesFlow: true, components: [{ sku: 'PH-A15', qty: 1 }, { sku: 'SIM-1', qty: 1 }] };
+  it('acepta un kit con componentes', () => expect(errorsOf(BackofficeCreateKitRequest, ok)).toEqual([]));
+  it.each(['sku', 'sellable', 'showInSalesFlow', 'components'] as const)('rechaza sin %s', (key) => {
+    expect(errorsOf(BackofficeCreateKitRequest, without(ok, key))).toContain(key);
+  });
+  it('rechaza un kit sin componentes', () => expect(errorsOf(BackofficeCreateKitRequest, { ...ok, components: [] })).toContain('components'));
+  it('valida cada componente', () => {
+    const errors = errorsOf(BackofficeCreateKitRequest, { ...ok, components: [{ sku: 'SIM 1', qty: 0 }] });
+    expect(errors).toEqual(expect.arrayContaining(['components.0.sku', 'components.0.qty']));
+  });
+  it('rechaza descripción en blanco', () => expect(errorsOf(BackofficeCreateKitRequest, { ...ok, description: ' ' })).toContain('description'));
+});
+
+describe('BackofficeCreateServiceRequest (backofficeCreateService)', () => {
+  const ok = { sku: 'TA-100', description: 'Tiempo aire 100', sellable: true, showInSalesFlow: true };
+  it('acepta un servicio', () => expect(errorsOf(BackofficeCreateServiceRequest, ok)).toEqual([]));
+  it.each(['sku', 'description', 'sellable', 'showInSalesFlow'] as const)('rechaza sin %s', (key) => {
+    expect(errorsOf(BackofficeCreateServiceRequest, without(ok, key))).toContain(key);
+  });
+  it('rechaza descripción en blanco y sellable no booleano', () => {
+    const errors = errorsOf(BackofficeCreateServiceRequest, { ...ok, description: '   ', sellable: 1 });
+    expect(errors).toEqual(expect.arrayContaining(['description', 'sellable']));
+  });
+});
+
+describe('BackofficeUpdateProductRequest (backofficeUpdateProduct)', () => {
+  it('acepta un cuerpo vacío (parcial)', () => expect(errorsOf(BackofficeUpdateProductRequest, {})).toEqual([]));
+  it('acepta flags, categoría, datos y componentes', () => {
+    const body = { sellable: false, showInSalesFlow: true, category: 'ACCESSORY', description: 'Funda', components: [{ sku: 'SIM-1', qty: 2 }] };
+    expect(errorsOf(BackofficeUpdateProductRequest, body)).toEqual([]);
+  });
+  it('rechaza pasar a BUNDLE y componentes inválidos', () => {
+    const errors = errorsOf(BackofficeUpdateProductRequest, { category: 'BUNDLE', components: [{ sku: 'SIM-1', qty: 0 }] });
+    expect(errors).toEqual(expect.arrayContaining(['category', 'components.0.qty']));
+  });
+  it('rechaza tipos incorrectos y texto en blanco', () => {
+    const errors = errorsOf(BackofficeUpdateProductRequest, { sellable: 'no', brand: '  ', tier: 'ULTRA' });
+    expect(errors).toEqual(expect.arrayContaining(['sellable', 'brand', 'tier']));
+  });
+  it('no expone itemType ni trackingMode (inmutables)', () => {
+    const dto = new BackofficeUpdateProductRequest();
+    expect('itemType' in dto || 'trackingMode' in dto).toBe(false);
+  });
+});
+
+describe('BackofficeCreateSkuPriceRequest (backofficeCreateSkuPrice)', () => {
+  const ok = { basePriceCents: 90000 };
+  it('acepta solo el precio base', () => expect(errorsOf(BackofficeCreateSkuPriceRequest, ok)).toEqual([]));
+  it('acepta lista y combo', () => {
+    expect(errorsOf(BackofficeCreateSkuPriceRequest, { ...ok, listPriceCents: 100000, comboPriceCents: 85000 })).toEqual([]);
+    expect(errorsOf(BackofficeCreateSkuPriceRequest, { ...ok, listPriceCents: null })).toEqual([]);
+  });
+  it('rechaza sin precio base', () => expect(errorsOf(BackofficeCreateSkuPriceRequest, {})).toContain('basePriceCents'));
+  it('rechaza negativos, decimales y strings', () => {
+    const errors = errorsOf(BackofficeCreateSkuPriceRequest, { basePriceCents: -1, listPriceCents: 10.5, comboPriceCents: '100' });
+    expect(errors).toEqual(expect.arrayContaining(['basePriceCents', 'listPriceCents', 'comboPriceCents']));
+  });
+});
+
+describe('BackofficeRegisterEntryRequest (backofficeRegisterEntry)', () => {
+  const ok = { storeId: 'st-1', sku: 'SIM-1', qty: 5 };
+  it('acepta una entrada por cantidad', () => expect(errorsOf(BackofficeRegisterEntryRequest, ok)).toEqual([]));
+  it('acepta una entrada con identificadores', () => {
+    expect(errorsOf(BackofficeRegisterEntryRequest, { ...ok, qty: 2, identifiers: ['356938035643809', '356938035643810'] })).toEqual([]);
+  });
+  it.each(['storeId', 'sku', 'qty'] as const)('rechaza sin %s', (key) => {
+    expect(errorsOf(BackofficeRegisterEntryRequest, without(ok, key))).toContain(key);
+  });
+  it('rechaza qty 0, storeId en blanco e identificadores vacíos, en blanco o repetidos', () => {
+    expect(errorsOf(BackofficeRegisterEntryRequest, { ...ok, qty: 0, storeId: '  ' })).toEqual(expect.arrayContaining(['qty', 'storeId']));
+    expect(errorsOf(BackofficeRegisterEntryRequest, { ...ok, identifiers: [] })).toContain('identifiers');
+    expect(errorsOf(BackofficeRegisterEntryRequest, { ...ok, identifiers: [' '] })).toContain('identifiers');
+    expect(errorsOf(BackofficeRegisterEntryRequest, { ...ok, identifiers: ['A1', 'A1'] })).toContain('identifiers');
+  });
+});
+
+describe('BackofficeRegisterAdjustmentRequest (backofficeRegisterAdjustment)', () => {
+  const ok = { storeId: 'st-1', sku: 'SIM-1', qty: 1, reason: InventoryMovementReasonEnum.SHRINKAGE };
+  it('acepta una merma', () => expect(errorsOf(BackofficeRegisterAdjustmentRequest, ok)).toEqual([]));
+  it('acepta ajuste y garantía con identificador', () => {
+    expect(errorsOf(BackofficeRegisterAdjustmentRequest, { ...ok, reason: 'ADJUSTMENT' })).toEqual([]);
+    expect(errorsOf(BackofficeRegisterAdjustmentRequest, { ...ok, reason: 'WARRANTY', identifiers: ['356938035643809'] })).toEqual([]);
+  });
+  it.each(['storeId', 'sku', 'qty', 'reason'] as const)('rechaza sin %s', (key) => {
+    expect(errorsOf(BackofficeRegisterAdjustmentRequest, without(ok, key))).toContain(key);
+  });
+  it('rechaza DAMAGED_RETURN (es de devoluciones) y motivos desconocidos', () => {
+    expect(errorsOf(BackofficeRegisterAdjustmentRequest, { ...ok, reason: 'DAMAGED_RETURN' })).toContain('reason');
+    expect(errorsOf(BackofficeRegisterAdjustmentRequest, { ...ok, reason: 'LOST' })).toContain('reason');
+  });
+  it('rechaza qty negativa y sku en blanco', () => {
+    expect(errorsOf(BackofficeRegisterAdjustmentRequest, { ...ok, qty: -2, sku: ' ' })).toEqual(expect.arrayContaining(['qty', 'sku']));
+  });
+});
+
+describe('BackofficeCreateTransferRequest (backofficeCreateTransfer)', () => {
+  const ok = { fromStoreId: 'st-1', toStoreId: 'st-2', sku: 'SIM-1', qty: 3 };
+  it('acepta un traspaso por cantidad', () => expect(errorsOf(BackofficeCreateTransferRequest, ok)).toEqual([]));
+  it('acepta un traspaso con identificadores', () => {
+    expect(errorsOf(BackofficeCreateTransferRequest, { ...ok, qty: 1, identifiers: ['356938035643809'] })).toEqual([]);
+  });
+  it('deja pasar misma tienda: la rechaza el dominio con SAME_STORE_TRANSFER', () => {
+    expect(errorsOf(BackofficeCreateTransferRequest, { ...ok, toStoreId: 'st-1' })).toEqual([]);
+  });
+  it.each(['fromStoreId', 'toStoreId', 'sku', 'qty'] as const)('rechaza sin %s', (key) => {
+    expect(errorsOf(BackofficeCreateTransferRequest, without(ok, key))).toContain(key);
+  });
+  it('rechaza tiendas en blanco, qty 0 e identificadores no string', () => {
+    const errors = errorsOf(BackofficeCreateTransferRequest, { ...ok, fromStoreId: ' ', qty: 0, identifiers: [123] });
+    expect(errors).toEqual(expect.arrayContaining(['fromStoreId', 'qty', 'identifiers']));
+  });
+});
+
+describe('BackofficeListTransfersQuery (backofficeListTransfers)', () => {
+  it('acepta state=OPEN y sin state', () => {
+    expect(errorsOf(BackofficeListTransfersQuery, { state: 'OPEN' })).toEqual([]);
+    expect(errorsOf(BackofficeListTransfersQuery, {})).toEqual([]);
+  });
+  it('rechaza un estado desconocido', () => expect(errorsOf(BackofficeListTransfersQuery, { state: 'PENDING' })).toContain('state'));
+});
+
+describe('TransferResponse y ListTransfersResponse', () => {
+  it('describen un traspaso abierto', () => {
+    const transfer: TransferResponse = {
+      transferId: 'trf-1',
+      fromStoreId: 'st-1',
+      toStoreId: 'st-2',
+      sku: 'PH-A15',
+      qty: 1,
+      identifiers: ['356938035643809'],
+      state: TransferStateEnum.OPEN,
+      createdBy: 'user-1',
+      updatedBy: 'user-1',
+      createdAt: '2026-09-24T10:00:00.000Z',
+      updatedAt: '2026-09-24T10:00:00.000Z',
+    };
+    const list: ListTransfersResponse = { items: [transfer] };
+    expect(list.items[0].state).toBe('OPEN');
+  });
+});
+
+describe('financiamiento, MDM y externalId en las altas y edición backoffice', () => {
+  const product = { sku: 'PH-A15', category: ProductCategoryEnum.PHONE, trackingMode: TrackingModeEnum.IMEI, sellable: true, showInSalesFlow: true };
+  const kit = { sku: 'KIT-A15', sellable: true, showInSalesFlow: true, components: [{ sku: 'PH-A15', qty: 1 }] };
+  const financed = { eligibleFinanciers: ['SUREKEEP'], mdmEnabled: true, mdmProvider: 'TRUSTONIC', mdmLockMode: 'ONDEMAND', externalId: 'ZC-1' };
+  const cases: [string, ClassConstructor<object>, object][] = [
+    ['BackofficeCreateProductRequest', BackofficeCreateProductRequest, product],
+    ['BackofficeUpdateProductRequest', BackofficeUpdateProductRequest, {}],
+  ];
+
+  describe.each(cases)('%s', (_name, cls, ok) => {
+    it('acepta sin los campos (opcionales)', () => expect(errorsOf(cls, ok)).toEqual([]));
+    it('acepta financieras, MDM coherente y externalId', () => {
+      expect(errorsOf(cls, { ...ok, ...financed })).toEqual([]);
+      expect(errorsOf(cls, { ...ok, eligibleFinanciers: [], mdmEnabled: false })).toEqual([]);
+    });
+    it('rechaza tipos incorrectos', () => {
+      const errors = errorsOf(cls, { ...ok, eligibleFinanciers: 'SUREKEEP', mdmEnabled: 'true', externalId: 5 });
+      expect(errors).toEqual(expect.arrayContaining(['eligibleFinanciers', 'mdmEnabled', 'externalId']));
+      expect(errorsOf(cls, { ...ok, eligibleFinanciers: ['  '], externalId: '  ' })).toEqual(expect.arrayContaining(['eligibleFinanciers', 'externalId']));
+    });
+    it('rechaza enums MDM inválidos', () => {
+      const errors = errorsOf(cls, { ...ok, ...financed, mdmProvider: 'KNOX', mdmLockMode: 'NEVER' });
+      expect(errors).toEqual(expect.arrayContaining(['mdmProvider', 'mdmLockMode']));
+    });
+    it('rechaza MDM incoherente', () => {
+      expect(errorsOf(cls, { ...ok, mdmEnabled: true })).toContain('mdmEnabled');
+      expect(errorsOf(cls, { ...ok, mdmEnabled: false, mdmProvider: 'TRUSTONIC', mdmLockMode: 'ONDEMAND' })).toContain('mdmEnabled');
+    });
+  });
+
+  describe('BackofficeCreateProductRequest con MDM a medias', () => {
+    it('rechaza mdmProvider o mdmLockMode sin mdmEnabled', () => {
+      expect(errorsOf(BackofficeCreateProductRequest, { ...product, mdmProvider: 'TRUSTONIC', mdmLockMode: 'ONDEMAND' })).toContain('mdmEnabled');
+      expect(errorsOf(BackofficeCreateProductRequest, { ...product, mdmProvider: 'TRUSTONIC' })).toContain('mdmEnabled');
+      expect(errorsOf(BackofficeCreateProductRequest, { ...product, mdmLockMode: 'ONDEMAND' })).toContain('mdmEnabled');
+    });
+    it('rechaza mdmEnabled false con proveedor', () => {
+      expect(errorsOf(BackofficeCreateProductRequest, { ...product, mdmEnabled: false, mdmProvider: 'TRUSTONIC' })).toContain('mdmEnabled');
+    });
+    it('acepta la config coherente y la ausencia total de MDM', () => {
+      expect(errorsOf(BackofficeCreateProductRequest, { ...product, mdmEnabled: true, mdmProvider: 'TRUSTONIC', mdmLockMode: 'ONDEMAND' })).toEqual([]);
+      expect(errorsOf(BackofficeCreateProductRequest, { ...product, mdmEnabled: false })).toEqual([]);
+      expect(errorsOf(BackofficeCreateProductRequest, product)).toEqual([]);
+    });
+  });
+
+  it('el kit lleva financieras y externalId, pero no MDM (sale del teléfono componente)', () => {
+    expect(errorsOf(BackofficeCreateKitRequest, { ...kit, eligibleFinanciers: ['SUREKEEP'], externalId: 'ZC-2' })).toEqual([]);
+    expect(errorsOf(BackofficeCreateKitRequest, { ...kit, eligibleFinanciers: 'SUREKEEP', externalId: ' ' })).toEqual(expect.arrayContaining(['eligibleFinanciers', 'externalId']));
+    expect(errorsOf(BackofficeCreateKitRequest, { ...kit, mdmEnabled: true })).toContain('mdmEnabled');
+    const dto = new BackofficeCreateKitRequest();
+    expect(['mdmEnabled', 'mdmProvider', 'mdmLockMode'].some((k) => k in dto)).toBe(false);
+  });
+
+  it('el servicio solo lleva externalId', () => {
+    const service = { sku: 'TA-100', description: 'Tiempo aire 100', sellable: true, showInSalesFlow: true };
+    expect(errorsOf(BackofficeCreateServiceRequest, { ...service, externalId: 'ZC-9' })).toEqual([]);
+    expect(errorsOf(BackofficeCreateServiceRequest, { ...service, externalId: ' ' })).toContain('externalId');
+    const dto = new BackofficeCreateServiceRequest();
+    expect(['eligibleFinanciers', 'mdmEnabled', 'mdmProvider', 'mdmLockMode'].some((k) => k in dto)).toBe(false);
+  });
+});
+
+describe('constantes y validadores compartidos del catálogo', () => {
+  it('NON_BUNDLE_CATEGORIES excluye BUNDLE', () => {
+    expect(NON_BUNDLE_CATEGORIES).not.toContain(ProductCategoryEnum.BUNDLE);
+    expect(NON_BUNDLE_CATEGORIES).toHaveLength(Object.values(ProductCategoryEnum).length - 1);
+  });
+  it('ADJUSTMENT_REASONS no incluye DAMAGED_RETURN', () => {
+    expect(ADJUSTMENT_REASONS).toEqual([InventoryMovementReasonEnum.SHRINKAGE, InventoryMovementReasonEnum.ADJUSTMENT, InventoryMovementReasonEnum.WARRANTY]);
+  });
+  it('IsPieceRefConstraint se exporta desde validators', () => expect(typeof IsPieceRefConstraint).toBe('function'));
+});