@fiado/type-kit 3.464.0 → 3.466.0

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'));
+});

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

@@ -13,6 +13,7 @@ describe('retailCatalog — enums del inventario multi-item', () => {
   it('expone los tipos de movimiento', () => {
     expect(Object.values(RetailCatalog.InventoryMovementTypeEnum)).toEqual([
       'ENTRY', 'RESERVATION', 'RELEASE', 'SALE', 'RETURN', 'ADJUSTMENT',
+      'TRANSFER_OUT', 'TRANSFER_IN', 'TRANSFER_CANCEL',
     ]);
   });
 
@@ -24,7 +25,7 @@ describe('retailCatalog — enums del inventario multi-item', () => {
   });
 
   it('expone el origen del precio y los periodos del lente', () => {
-    expect(Object.values(RetailCatalog.PriceSourceEnum)).toEqual(['ZENTRAL_SYNC']);
+    expect(Object.values(RetailCatalog.PriceSourceEnum)).toEqual(['ZENTRAL_SYNC', 'BACKOFFICE']);
     expect(Object.values(RetailCatalog.InventoryLensPeriodEnum)).toEqual(['7d', '30d', '90d', 'all']);
   });
 
@@ -32,3 +33,29 @@ describe('retailCatalog — enums del inventario multi-item', () => {
     expect(Object.values(RetailCatalog.InventoryLensFilterEnum)).toEqual(['critical', 'stale', 'gap', 'transfers', 'list']);
   });
 });
+
+describe('retailCatalog — enums de la operación independiente', () => {
+  it('expone el tipo de ítem', () => {
+    expect(Object.values(RetailCatalog.ItemTypeEnum)).toEqual(['PRODUCT', 'SERVICE']);
+  });
+
+  it('agrega IN_TRANSIT al estado de pieza sin quitar los existentes', () => {
+    expect(Object.values(RetailCatalog.InventoryItemStatusEnum)).toEqual([
+      'AVAILABLE', 'RESERVED', 'SOLD', 'RETURNED', 'DAMAGED', 'IN_TRANSIT',
+    ]);
+  });
+
+  it('expone la condición de una devolución', () => {
+    expect(Object.values(RetailCatalog.ReturnConditionEnum)).toEqual(['GOOD', 'DAMAGED']);
+  });
+
+  it('expone el estado de un traspaso', () => {
+    expect(Object.values(RetailCatalog.TransferStateEnum)).toEqual(['OPEN', 'RECEIVED', 'CANCELLED']);
+  });
+
+  it('expone el motivo de un movimiento', () => {
+    expect(Object.values(RetailCatalog.InventoryMovementReasonEnum)).toEqual([
+      'SHRINKAGE', 'ADJUSTMENT', 'WARRANTY', 'DAMAGED_RETURN',
+    ]);
+  });
+});

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

@@ -0,0 +1,53 @@
+import 'reflect-metadata';
+import * as RetailCatalog from '../../../src/retailCatalog';
+
+// ts-jest compila con type-check: si un campo nuevo no existe en el tipo, la suite no compila.
+describe('retailCatalog — campos nuevos opcionales en respuestas', () => {
+  it('Product y ProductResponse aceptan itemType y siguen válidos sin él', () => {
+    const product = new RetailCatalog.Product();
+    product.itemType = RetailCatalog.ItemTypeEnum.SERVICE;
+    const response: RetailCatalog.ProductResponse = product;
+    expect(response.itemType).toBe('SERVICE');
+    expect(new RetailCatalog.Product().itemType).toBeUndefined();
+  });
+
+  it('StoreCatalogItem acepta itemType', () => {
+    const item: Pick<RetailCatalog.StoreCatalogItem, 'sku' | 'itemType'> = {
+      sku: 'SKU-1',
+      itemType: RetailCatalog.ItemTypeEnum.PRODUCT,
+    };
+    expect(item.itemType).toBe('PRODUCT');
+  });
+
+  it('la fila del lente en modo lista acepta itemType', () => {
+    const row: Pick<RetailCatalog.InventoryLensListItem, 'sku' | 'itemType'> = {
+      sku: 'SKU-1',
+      itemType: RetailCatalog.ItemTypeEnum.SERVICE,
+    };
+    expect(row.itemType).toBe('SERVICE');
+  });
+
+  it('ReservedComponent acepta priceCents y sigue válido sin él', () => {
+    const base: RetailCatalog.ReservedComponent = {
+      sku: 'SKU-1',
+      qty: 1,
+      category: RetailCatalog.ProductCategoryEnum.PHONE,
+      trackingMode: RetailCatalog.TrackingModeEnum.IMEI,
+    };
+    const priced: RetailCatalog.ReservedComponent = { ...base, priceCents: 150000 };
+    expect(base.priceCents).toBeUndefined();
+    expect(priced.priceCents).toBe(150000);
+  });
+
+  it('SkuPriceEntry acepta comboPriceCents y el origen BACKOFFICE', () => {
+    const entry: RetailCatalog.SkuPriceEntry = {
+      effectiveFrom: '2026-09-24T00:00:00.000Z',
+      listPriceCents: null,
+      basePriceCents: 200000,
+      comboPriceCents: 180000,
+      source: RetailCatalog.PriceSourceEnum.BACKOFFICE,
+      createdBy: 'system',
+    };
+    expect(entry.comboPriceCents).toBe(180000);
+  });
+});

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

@@ -0,0 +1,64 @@
+import 'reflect-metadata';
+import { plainToInstance, type ClassConstructor } from 'class-transformer';
+import { validateSync, type ValidationError } from 'class-validator';
+import { ReturnConditionEnum, ReturnPieceCondition, ReturnStockLine, ReturnStockRequest } 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 }));
+}
+
+describe('ReturnPieceCondition', () => {
+  it('una pieza con identificador y sin condición queda GOOD', () => {
+    const dto = plainToInstance(ReturnPieceCondition, { sku: 'PH-A15', identifier: '356938035643809' });
+    expect(dto.condition).toBe(ReturnConditionEnum.GOOD);
+    expect(validateSync(dto)).toEqual([]);
+  });
+  it('acepta un accesorio por cantidad dañado con motivo', () => {
+    expect(errorsOf(ReturnPieceCondition, { sku: 'FUNDA-1', qty: 2, condition: 'DAMAGED', reason: 'Rota' })).toEqual([]);
+  });
+  it('DAMAGED exige motivo; GOOD no', () => {
+    expect(errorsOf(ReturnPieceCondition, { sku: 'FUNDA-1', qty: 1, condition: 'DAMAGED' })).toContain('reason');
+    expect(errorsOf(ReturnPieceCondition, { sku: 'FUNDA-1', qty: 1, condition: 'DAMAGED', reason: '   ' })).toContain('reason');
+    expect(errorsOf(ReturnPieceCondition, { sku: 'PH-A15', identifier: '356938035643809', condition: 'DAMAGED', reason: 'Pantalla rota' })).toEqual([]);
+    expect(errorsOf(ReturnPieceCondition, { sku: 'PH-A15', identifier: '356938035643809', condition: 'GOOD' })).toEqual([]);
+  });
+  it('rechaza sin sku, sin identifier ni qty, y con ambos', () => {
+    expect(errorsOf(ReturnPieceCondition, { identifier: 'A1' })).toContain('sku');
+    expect(errorsOf(ReturnPieceCondition, { sku: 'FUNDA-1' })).toContain('identifier');
+    expect(errorsOf(ReturnPieceCondition, { sku: 'FUNDA-1', identifier: 'A1', qty: 1 })).toContain('identifier');
+  });
+  it('rechaza condición desconocida, qty 0, identificador y motivo en blanco', () => {
+    const errors = errorsOf(ReturnPieceCondition, { sku: 'FUNDA-1', qty: 0, condition: 'BROKEN', reason: '   ' });
+    expect(errors).toEqual(expect.arrayContaining(['qty', 'condition', 'reason']));
+    expect(errorsOf(ReturnPieceCondition, { sku: 'PH-1', identifier: '  ' })).toContain('identifier');
+  });
+});
+
+describe('ReturnStockRequest con condición por pieza', () => {
+  const line = { lineId: 'L1', sku: 'KIT-1', qty: 1, components: [{ sku: 'PH-A15', qty: 1, identifiers: ['356938035643809'] }, { sku: 'FUNDA-1', qty: 2, identifiers: [] }] };
+  const base = { saleId: 'sale', retailerId: 'ret', soldAt: '2026-09-23T10:00:00.000Z' };
+  it('un consumidor viejo sin condiciones sigue validando', () => {
+    expect(errorsOf(ReturnStockRequest, { ...base, lines: [line] })).toEqual([]);
+  });
+  it('acepta condiciones por pieza y por cantidad', () => {
+    const conditions = [
+      { sku: 'PH-A15', identifier: '356938035643809', condition: 'DAMAGED', reason: 'Pantalla rota' },
+      { sku: 'FUNDA-1', qty: 1, condition: 'DAMAGED', reason: 'Descosida' },
+    ];
+    const dto = plainToInstance(ReturnStockRequest, { ...base, lines: [{ ...line, conditions }] });
+    expect(dto.lines[0]).toBeInstanceOf(ReturnStockLine);
+    expect(dto.lines[0].conditions?.[0]).toBeInstanceOf(ReturnPieceCondition);
+    expect(validateSync(dto)).toEqual([]);
+  });
+  it('valida cada condición anidada', () => {
+    const conditions = [{ sku: 'PH-A15', identifier: '356938035643809', condition: 'LOST' }];
+    expect(errorsOf(ReturnStockRequest, { ...base, lines: [{ ...line, conditions }] })).toContain('lines.0.conditions.0.condition');
+  });
+});

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

@@ -0,0 +1,41 @@
+import 'reflect-metadata';
+import { plainToInstance, type ClassConstructor } from 'class-transformer';
+import { validateSync, type ValidationError } from 'class-validator';
+import { ReturnPieceCondition } from '../../../src/retailCatalog';
+import { BackofficeCancelSaleRequest, CancelSaleRequest } from '../../../src/retailWizard';
+
+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, { excludeExtraneousValues: true }) as object));
+}
+
+const conditions = [
+  { sku: 'PH-A15', identifier: '356938035643809', condition: 'DAMAGED', reason: 'Pantalla rota' },
+  { sku: 'FUNDA-1', qty: 1 },
+];
+
+describe.each([
+  ['CancelSaleRequest', CancelSaleRequest, { reason: 'Cliente se arrepintió' }],
+  ['BackofficeCancelSaleRequest', BackofficeCancelSaleRequest, { reason: 'Cliente se arrepintió' }],
+] as const)('%s con condición por pieza', (_name, cls, base) => {
+  it('sin returnConditions sigue validando', () => expect(errorsOf(cls, base)).toEqual([]));
+  it('acepta condiciones y las hidrata aun con excludeExtraneousValues', () => {
+    const dto = plainToInstance(cls, { ...base, returnConditions: conditions }, { excludeExtraneousValues: true });
+    expect(validateSync(dto)).toEqual([]);
+    expect(dto.returnConditions?.[0]).toBeInstanceOf(ReturnPieceCondition);
+    expect(dto.returnConditions?.[0].reason).toBe('Pantalla rota');
+    expect(dto.returnConditions?.[1].condition).toBe('GOOD');
+  });
+  it('valida cada condición y rechaza un no-arreglo', () => {
+    expect(errorsOf(cls, { ...base, returnConditions: [{ sku: 'FUNDA-1', condition: 'LOST' }] })).toEqual(
+      expect.arrayContaining(['returnConditions.0.condition', 'returnConditions.0.identifier']),
+    );
+    expect(errorsOf(cls, { ...base, returnConditions: 'GOOD' })).toContain('returnConditions');
+  });
+});

package/bin/remittance/enums/RemittanceCorridor.d.ts

@@ -1,16 +1,17 @@
 /**
  * Corredores de remesa soportados (Dashboard Ops · Variables Operativas).
  *
- * D-PB-3: nomenclatura por MONEDA ISO-4217 (`USD-<destino>`). `USD_SVC` es un
- * símbolo para El Salvador (su payout real es USD; usar la moneda colisionaría
- * como "USD-USD"). Por eso el destino real vive en CORRIDOR_INFO y el filtro de
- * transacciones usa countryISO (no ambiguo).
+ * D-PB-3: nomenclatura por MONEDA ISO-4217 (`USD-<destino>`). `USD_SVC` (El Salvador)
+ * y `USD_NIC` (Nicaragua) son símbolos: su payout real es USD y usar la moneda
+ * colisionaría como "USD-USD". Por eso el destino real vive en CORRIDOR_INFO y el
+ * filtro de transacciones usa countryISO (no ambiguo).
  */
 export declare enum RemittanceCorridor {
     USD_GTQ = "USD-GTQ",
     USD_MXN = "USD-MXN",
     USD_HNL = "USD-HNL",
-    USD_SVC = "USD-SVC"
+    USD_SVC = "USD-SVC",
+    USD_NIC = "USD-NIC"
 }
 /** Destino real del corredor. El filtro de tx usa countryISO; currencyISO es el payout. */
 export declare const CORRIDOR_INFO: Record<RemittanceCorridor, {

package/bin/remittance/enums/RemittanceCorridor.js

@@ -4,10 +4,10 @@ exports.CORRIDOR_INFO = exports.RemittanceCorridor = void 0;
 /**
  * Corredores de remesa soportados (Dashboard Ops · Variables Operativas).
  *
- * D-PB-3: nomenclatura por MONEDA ISO-4217 (`USD-<destino>`). `USD_SVC` es un
- * símbolo para El Salvador (su payout real es USD; usar la moneda colisionaría
- * como "USD-USD"). Por eso el destino real vive en CORRIDOR_INFO y el filtro de
- * transacciones usa countryISO (no ambiguo).
+ * D-PB-3: nomenclatura por MONEDA ISO-4217 (`USD-<destino>`). `USD_SVC` (El Salvador)
+ * y `USD_NIC` (Nicaragua) son símbolos: su payout real es USD y usar la moneda
+ * colisionaría como "USD-USD". Por eso el destino real vive en CORRIDOR_INFO y el
+ * filtro de transacciones usa countryISO (no ambiguo).
  */
 var RemittanceCorridor;
 (function (RemittanceCorridor) {
@@ -15,6 +15,7 @@ var RemittanceCorridor;
     RemittanceCorridor["USD_MXN"] = "USD-MXN";
     RemittanceCorridor["USD_HNL"] = "USD-HNL";
     RemittanceCorridor["USD_SVC"] = "USD-SVC";
+    RemittanceCorridor["USD_NIC"] = "USD-NIC";
 })(RemittanceCorridor || (exports.RemittanceCorridor = RemittanceCorridor = {}));
 /** Destino real del corredor. El filtro de tx usa countryISO; currencyISO es el payout. */
 exports.CORRIDOR_INFO = {
@@ -22,4 +23,5 @@ exports.CORRIDOR_INFO = {
     [RemittanceCorridor.USD_MXN]: { countryISO: "MX", currencyISO: "MXN" },
     [RemittanceCorridor.USD_HNL]: { countryISO: "HN", currencyISO: "HNL" },
     [RemittanceCorridor.USD_SVC]: { countryISO: "SV", currencyISO: "USD" },
+    [RemittanceCorridor.USD_NIC]: { countryISO: "NI", currencyISO: "USD" },
 };

package/bin/retailCatalog/constants/AdjustmentReasons.d.ts

@@ -0,0 +1,3 @@
+import { InventoryMovementReasonEnum } from '../enums/InventoryMovementReasonEnum';
+/** Motivos que el admin puede registrar en un ajuste; DAMAGED_RETURN lo genera la devolución. */
+export declare const ADJUSTMENT_REASONS: InventoryMovementReasonEnum[];

package/bin/retailCatalog/constants/AdjustmentReasons.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADJUSTMENT_REASONS = void 0;
+const InventoryMovementReasonEnum_1 = require("../enums/InventoryMovementReasonEnum");
+/** Motivos que el admin puede registrar en un ajuste; DAMAGED_RETURN lo genera la devolución. */
+exports.ADJUSTMENT_REASONS = [
+    InventoryMovementReasonEnum_1.InventoryMovementReasonEnum.SHRINKAGE,
+    InventoryMovementReasonEnum_1.InventoryMovementReasonEnum.ADJUSTMENT,
+    InventoryMovementReasonEnum_1.InventoryMovementReasonEnum.WARRANTY,
+];

package/bin/retailCatalog/constants/NonBundleCategories.d.ts

@@ -0,0 +1,3 @@
+import { ProductCategoryEnum } from '../enums/ProductCategoryEnum';
+/** Categorías que admite el alta y la edición de producto; el kit (BUNDLE) tiene su propio endpoint. */
+export declare const NON_BUNDLE_CATEGORIES: (ProductCategoryEnum.PHONE | ProductCategoryEnum.SIM | ProductCategoryEnum.MODEM | ProductCategoryEnum.ACCESSORY)[];

package/bin/retailCatalog/constants/NonBundleCategories.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NON_BUNDLE_CATEGORIES = void 0;
+const ProductCategoryEnum_1 = require("../enums/ProductCategoryEnum");
+/** Categorías que admite el alta y la edición de producto; el kit (BUNDLE) tiene su propio endpoint. */
+exports.NON_BUNDLE_CATEGORIES = Object.values(ProductCategoryEnum_1.ProductCategoryEnum).filter((c) => c !== ProductCategoryEnum_1.ProductCategoryEnum.BUNDLE);

package/bin/retailCatalog/dtos/Product.d.ts

@@ -4,6 +4,7 @@ import { ProductStatusEnum } from '../enums/ProductStatusEnum';
 import { ProductTierEnum } from '../enums/ProductTierEnum';
 import { ProductCategoryEnum } from '../enums/ProductCategoryEnum';
 import { TrackingModeEnum } from '../enums/TrackingModeEnum';
+import { ItemTypeEnum } from '../enums/ItemTypeEnum';
 import { ProductComponent } from './ProductComponent';
 /**
  * Product — aggregate root del catálogo del dominio `retailCatalog`
@@ -45,4 +46,6 @@ export declare class Product {
     components?: ProductComponent[] | null;
     /** Llave del registro PRICE# del que salen basePriceCents y listPriceCents. */
     currentPriceSk?: string | null;
+    /** Producto físico o servicio; inmutable tras el alta. Ausente = PRODUCT. */
+    itemType?: ItemTypeEnum;
 }

package/bin/retailCatalog/dtos/requests/BackofficeCreateKitRequest.d.ts

@@ -0,0 +1,14 @@
+import { ProductComponent } from '../ProductComponent';
+/** Body de POST /backoffice/catalog/kits (backofficeCreateKit); category BUNDLE y origen BACKOFFICE los fija el servidor. */
+export declare class BackofficeCreateKitRequest {
+    sku: string;
+    sellable: boolean;
+    showInSalesFlow: boolean;
+    components: ProductComponent[];
+    description?: string;
+    imageUrl?: string;
+    /** Id del SKU en el sistema del retailer. */
+    externalId?: string;
+    /** Financieras que pueden financiar este SKU; vacío = no financiable. */
+    eligibleFinanciers?: string[];
+}