@fiado/type-kit 3.460.0 → 3.462.0

package/_test_/unit/loanCredit/customerPaymentDtos.test.ts

@@ -0,0 +1,87 @@
+import 'reflect-metadata';
+import {
+    LoanAdHocChargeKindEnum,
+    LoanAdHocChargeRequested,
+    LoanCustomerPaymentOptions,
+    LoanCustomerPaymentResult,
+    LoanCustomerPaymentTypeEnum,
+    LoanNextInstallmentModeEnum,
+    LoanPaymentOptionUnavailableReasonEnum,
+} from '../../../src/loanCredit/index';
+import { CollectionResultStatus } from '../../../src/collection/enums/CollectionResultStatus';
+
+describe('loanCredit — opciones y resultado del pago del cliente', () => {
+    it('la liquidación trae su cotización y el monto es el de la cotización', () => {
+        const options: LoanCustomerPaymentOptions = {
+            creditId: 'CR-1',
+            nextInstallment: {
+                available: true,
+                amountCents: 105000,
+                mode: LoanNextInstallmentModeEnum.ADVANCE,
+                installmentNumber: 4,
+                dueDate: '2026-10-01',
+            },
+            advance: { available: false, unavailableReason: LoanPaymentOptionUnavailableReasonEnum.NOT_AVAILABLE_YET },
+            settlement: {
+                available: true,
+                amountCents: 912345,
+                quote: {
+                    creditId: 'CR-1',
+                    overdueInstallmentsCents: 0,
+                    outstandingCapitalCents: 890000,
+                    currentPeriodInterestCents: 19263,
+                    currentPeriodInterestIvaCents: 3082,
+                    elapsedDays: 3,
+                    periodDays: 7,
+                    settlementAmountCents: 912345,
+                    quotedAt: '2026-09-24T15:00:00.000Z',
+                },
+                savingsCents: 32655,
+            },
+        };
+
+        expect(options.settlement.quote?.settlementAmountCents).toBe(options.settlement.amountCents);
+        expect(options.pendingCharge).toBeUndefined();
+    });
+
+    it('un cargo en curso se informa con su tipo y su monto', () => {
+        const blocked = { available: false, unavailableReason: LoanPaymentOptionUnavailableReasonEnum.PAYMENT_IN_PROGRESS };
+        const options: LoanCustomerPaymentOptions = {
+            creditId: 'CR-1',
+            pendingCharge: { kind: LoanAdHocChargeKindEnum.ADVANCE, amountCents: 105000 },
+            nextInstallment: blocked,
+            advance: blocked,
+            settlement: blocked,
+        };
+
+        expect(options.pendingCharge?.kind).toBe('ADVANCE');
+        expect(options.nextInstallment.amountCents).toBeUndefined();
+    });
+
+    it('el resultado del pago puede venir sin la respuesta del motor', () => {
+        const result: LoanCustomerPaymentResult = {
+            creditId: 'CR-1',
+            type: LoanCustomerPaymentTypeEnum.NEXT_INSTALLMENT,
+            chargeId: 'CR-1#ADVANCE#1',
+            amountCents: 105000,
+        };
+
+        expect(result.collection).toBeUndefined();
+    });
+
+    it('el 202 del cargo ad hoc suma la respuesta del motor como campo opcional', () => {
+        const withoutCollection: LoanAdHocChargeRequested = {
+            creditId: 'CR-1',
+            chargeKind: LoanAdHocChargeKindEnum.ADVANCE,
+            chargeId: 'CR-1#ADVANCE#1',
+            amountCents: 105000,
+        };
+        const withCollection: LoanAdHocChargeRequested = {
+            ...withoutCollection,
+            collection: { status: CollectionResultStatus.PARTIAL, amountCollectedCents: 50000 },
+        };
+
+        expect(withoutCollection.collection).toBeUndefined();
+        expect(withCollection.collection?.amountCollectedCents).toBe(50000);
+    });
+});

package/_test_/unit/loanCredit/dtos/createCustomerPaymentRequest.test.ts

@@ -0,0 +1,78 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { LoanCredit } from '../../../../src/index';
+import {
+    CreateCustomerPaymentRequest,
+    LoanCustomerPaymentTypeEnum,
+    LoanNextInstallmentModeEnum,
+    LoanPaymentOptionUnavailableReasonEnum,
+} from '../../../../src/loanCredit/index';
+
+const sortedValues = (enumObject: Record<string, string>) => Object.values(enumObject).sort();
+
+const errorProperties = async (body: object): Promise<string[]> => {
+    const dto = plainToInstance(CreateCustomerPaymentRequest, body);
+    const errors = await validate(dto, { whitelist: true, forbidNonWhitelisted: false });
+    return errors.map(error => error.property);
+};
+
+const VALID = {
+    type: LoanCustomerPaymentTypeEnum.SETTLEMENT,
+    expectedAmountCents: 912345,
+    idempotencyKey: '3f1c2a9e-8b7d-4c6e-9f10-2a3b4c5d6e7f',
+};
+
+describe.each([
+    ['LoanCustomerPaymentTypeEnum', LoanCustomerPaymentTypeEnum, ['NEXT_INSTALLMENT', 'SETTLEMENT']],
+    ['LoanNextInstallmentModeEnum', LoanNextInstallmentModeEnum, ['ADVANCE', 'COLLECT_DUE']],
+    [
+        'LoanPaymentOptionUnavailableReasonEnum',
+        LoanPaymentOptionUnavailableReasonEnum,
+        ['PAYMENT_IN_PROGRESS', 'CREDIT_NOT_CURRENT', 'USE_SETTLEMENT', 'NOT_AVAILABLE_YET', 'CREDIT_CLOSED'],
+    ],
+])('%s', (_name, enumObject, expected) => {
+    it('tiene exactamente los valores del contrato', () => {
+        expect(sortedValues(enumObject)).toEqual([...expected].sort());
+    });
+
+    it('cada clave es igual a su valor', () => {
+        for (const [key, value] of Object.entries(enumObject)) {
+            expect(key).toBe(value);
+        }
+    });
+});
+
+describe('CreateCustomerPaymentRequest', () => {
+    it.each([[LoanCustomerPaymentTypeEnum.NEXT_INSTALLMENT], [LoanCustomerPaymentTypeEnum.SETTLEMENT]])(
+        'acepta el tipo %s',
+        async type => {
+            expect(await errorProperties({ ...VALID, type })).toEqual([]);
+        },
+    );
+
+    it('exige tipo, monto esperado y llave de idempotencia', async () => {
+        expect(await errorProperties({})).toEqual(
+            expect.arrayContaining(['type', 'expectedAmountCents', 'idempotencyKey']),
+        );
+    });
+
+    it.each([['ADVANCE'], ['PARTIAL']])('rechaza el tipo %s', async type => {
+        expect(await errorProperties({ ...VALID, type })).toEqual(['type']);
+    });
+
+    it.each([[0], [-100], [10.5], ['912345']])('rechaza el monto %p', async expectedAmountCents => {
+        expect(await errorProperties({ ...VALID, expectedAmountCents })).toEqual(['expectedAmountCents']);
+    });
+
+    it.each([['abc'], [''], [123]])('rechaza la llave %p', async idempotencyKey => {
+        expect(await errorProperties({ ...VALID, idempotencyKey })).toEqual(['idempotencyKey']);
+    });
+});
+
+describe('export por el index raíz', () => {
+    it('expone el request y sus enums en el namespace LoanCredit', () => {
+        expect(LoanCredit.CreateCustomerPaymentRequest).toBeDefined();
+        expect(LoanCredit.LoanCustomerPaymentTypeEnum.SETTLEMENT).toBe('SETTLEMENT');
+    });
+});

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

@@ -0,0 +1,34 @@
+import 'reflect-metadata';
+import * as RetailCatalog from '../../../src/retailCatalog';
+
+describe('retailCatalog — enums del inventario multi-item', () => {
+  it('expone las categorías de producto', () => {
+    expect(Object.values(RetailCatalog.ProductCategoryEnum)).toEqual(['PHONE', 'SIM', 'MODEM', 'ACCESSORY', 'BUNDLE']);
+  });
+
+  it('expone los modos de rastreo', () => {
+    expect(Object.values(RetailCatalog.TrackingModeEnum)).toEqual(['IMEI', 'SERIAL', 'QUANTITY']);
+  });
+
+  it('expone los tipos de movimiento', () => {
+    expect(Object.values(RetailCatalog.InventoryMovementTypeEnum)).toEqual([
+      'ENTRY', 'RESERVATION', 'RELEASE', 'SALE', 'RETURN', 'ADJUSTMENT',
+    ]);
+  });
+
+  it('expone el resultado por ítem de la puerta de entrada y sus códigos de rechazo', () => {
+    expect(Object.values(RetailCatalog.InventorySyncResultStatusEnum)).toEqual(['APPLIED', 'NOOP', 'REJECTED']);
+    expect(Object.values(RetailCatalog.InventorySyncRejectionCodeEnum)).toEqual([
+      'DUPLICATE_IDENTIFIER', 'ADJUSTMENT_EXCEEDS_AVAILABLE', 'FUTURE_PRICE_NOT_SUPPORTED',
+    ]);
+  });
+
+  it('expone el origen del precio y los periodos del lente', () => {
+    expect(Object.values(RetailCatalog.PriceSourceEnum)).toEqual(['ZENTRAL_SYNC']);
+    expect(Object.values(RetailCatalog.InventoryLensPeriodEnum)).toEqual(['7d', '30d', '90d', 'all']);
+  });
+
+  it('agrega el modo lista al filtro del lente sin quitar los existentes', () => {
+    expect(Object.values(RetailCatalog.InventoryLensFilterEnum)).toEqual(['critical', 'stale', 'gap', 'transfers', 'list']);
+  });
+});

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

@@ -0,0 +1,156 @@
+import 'reflect-metadata';
+import { plainToInstance, type ClassConstructor } from 'class-transformer';
+import { validateSync, type ValidationError } from 'class-validator';
+import {
+  GetInventorySkuQuery,
+  InventoryLensFilterEnum,
+  InventoryLensQuery,
+  MdmLockModeEnum,
+  MdmProviderEnum,
+  ProductCategoryEnum,
+  ReleaseStockRequest,
+  RenewReservationsRequest,
+  ReserveStockRequest,
+  ReturnStockRequest,
+  SellStockRequest,
+  SuggestPiecesQuery,
+  SyncInventoryRequest,
+  TrackingModeEnum,
+} 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));
+}
+
+const saleLine = { lineId: 'L1', sku: 'KIT-1', qty: 1, components: [{ sku: 'SIM-1', qty: 1, identifiers: ['8952'] }] };
+
+describe('ReserveStockRequest', () => {
+  const ok = { sessionId: 's', lineId: 'L1', reservationId: 'r', retailerId: 'ret', sku: 'SKU-1', qty: 2 };
+  it('acepta un request completo', () => expect(errorsOf(ReserveStockRequest, ok)).toEqual([]));
+  it('rechaza qty menor a 1', () => expect(errorsOf(ReserveStockRequest, { ...ok, qty: 0 })).toContain('qty'));
+  it('rechaza sin reservationId', () => {
+    const { reservationId: _omit, ...rest } = ok;
+    expect(errorsOf(ReserveStockRequest, rest)).toContain('reservationId');
+  });
+});
+
+describe('RenewReservationsRequest y ReleaseStockRequest', () => {
+  it('acepta líneas con lineId y reservationId', () => {
+    expect(errorsOf(RenewReservationsRequest, { sessionId: 's', lines: [{ lineId: 'L1', reservationId: 'r' }] })).toEqual([]);
+  });
+  it('valida cada línea anidada', () => {
+    expect(errorsOf(RenewReservationsRequest, { sessionId: 's', lines: [{ lineId: 'L1' }] })).toContain('lines.0.reservationId');
+  });
+  it('release exige onlyExpired booleano', () => {
+    const base = { sessionId: 's', lines: [{ lineId: 'L1', reservationId: 'r' }] };
+    expect(errorsOf(ReleaseStockRequest, { ...base, onlyExpired: false })).toEqual([]);
+    expect(errorsOf(ReleaseStockRequest, base)).toContain('onlyExpired');
+  });
+});
+
+describe('SuggestPiecesQuery', () => {
+  it('acepta un prefijo de 4 caracteres', () => expect(errorsOf(SuggestPiecesQuery, { sku: 'SKU-1', prefix: '3569' })).toEqual([]));
+  it('rechaza un prefijo corto', () => expect(errorsOf(SuggestPiecesQuery, { sku: 'SKU-1', prefix: '356' })).toContain('prefix'));
+});
+
+describe('SellStockRequest y ReturnStockRequest', () => {
+  it('acepta una venta con componentes e identificadores', () => {
+    expect(errorsOf(SellStockRequest, { sessionId: 's', retailerId: 'ret', lines: [saleLine] })).toEqual([]);
+  });
+  it('valida los identificadores del componente', () => {
+    const bad = { ...saleLine, components: [{ sku: 'SIM-1', qty: 1, identifiers: [123] }] };
+    expect(errorsOf(SellStockRequest, { sessionId: 's', retailerId: 'ret', lines: [bad] })).toContain('lines.0.components.0.identifiers');
+  });
+  it('devolución exige saleId y soldAt ISO', () => {
+    const ok = { saleId: 'sale', retailerId: 'ret', soldAt: '2026-09-23T10:00:00.000Z', lines: [saleLine] };
+    expect(errorsOf(ReturnStockRequest, ok)).toEqual([]);
+    expect(errorsOf(ReturnStockRequest, { ...ok, soldAt: 'ayer' })).toContain('soldAt');
+  });
+});
+
+describe('SyncInventoryRequest', () => {
+  const product = {
+    sku: 'KIT-1',
+    category: ProductCategoryEnum.BUNDLE,
+    trackingMode: TrackingModeEnum.QUANTITY,
+    sellable: true,
+    showInSalesFlow: true,
+    eligibleFinanciers: ['SUREKEEP'],
+    components: [{ sku: 'SIM-1', qty: 1 }],
+    tier: null,
+    price: { listPriceCents: 100000, basePriceCents: 90000, effectiveFrom: '2026-09-23T00:00:00.000Z' },
+  };
+  it('acepta productos y stock por cantidad o por identificadores', () => {
+    const stock = [{ storeId: 'st', sku: 'SIM-1', qty: 5 }, { storeId: 'st', sku: 'PH-1', identifiers: ['356938035643809'] }];
+    expect(errorsOf(SyncInventoryRequest, { products: [product], stock })).toEqual([]);
+  });
+  it('rechaza categoría desconocida y precio sin vigencia', () => {
+    const bad = { ...product, category: 'TABLET', price: { basePriceCents: 1 } };
+    const errors = errorsOf(SyncInventoryRequest, { products: [bad], stock: [] });
+    expect(errors).toEqual(expect.arrayContaining(['products.0.category', 'products.0.price.effectiveFrom']));
+  });
+  it('valida los componentes del kit', () => {
+    const bad = { ...product, components: [{ sku: 'SIM-1', qty: 0 }] };
+    expect(errorsOf(SyncInventoryRequest, { products: [bad], stock: [] })).toContain('products.0.components.0.qty');
+  });
+  it('acepta los datos descriptivos y MDM del producto nuevo', () => {
+    const full = {
+      ...product,
+      brand: 'Samsung',
+      model: 'A15',
+      capacity: '128GB',
+      color: 'Negro',
+      description: 'Equipo de gama media',
+      imageUrl: 'https://cdn.example.com/a15.png',
+      mdmEnabled: true,
+      mdmProvider: MdmProviderEnum.TRUSTONIC,
+      mdmLockMode: MdmLockModeEnum.ONDEMAND,
+    };
+    expect(errorsOf(SyncInventoryRequest, { products: [full], stock: [] })).toEqual([]);
+  });
+  it('acepta mdmProvider y mdmLockMode en null', () => {
+    const noMdm = { ...product, mdmEnabled: false, mdmProvider: null, mdmLockMode: null };
+    expect(errorsOf(SyncInventoryRequest, { products: [noMdm], stock: [] })).toEqual([]);
+  });
+  it('rechaza tipos incorrectos en los datos descriptivos y MDM', () => {
+    const bad = {
+      ...product,
+      brand: 1,
+      model: 2,
+      capacity: 3,
+      color: 4,
+      description: 5,
+      imageUrl: 6,
+      mdmEnabled: 'yes',
+      mdmProvider: 'ACME',
+      mdmLockMode: 'NEVER',
+    };
+    const errors = errorsOf(SyncInventoryRequest, { products: [bad], stock: [] });
+    const fields = ['brand', 'model', 'capacity', 'color', 'description', 'imageUrl', 'mdmEnabled', 'mdmProvider', 'mdmLockMode'];
+    expect(errors).toEqual(expect.arrayContaining(fields.map((f) => `products.0.${f}`)));
+  });
+});
+
+describe('InventoryLensQuery en modo lista', () => {
+  it('acepta filter=list con period y storeId', () => {
+    expect(errorsOf(InventoryLensQuery, { filter: InventoryLensFilterEnum.LIST, period: '30d', storeId: 'st' })).toEqual([]);
+  });
+  it('sigue aceptando filter solo', () => expect(errorsOf(InventoryLensQuery, { filter: 'critical' })).toEqual([]));
+  it('rechaza un periodo desconocido', () => expect(errorsOf(InventoryLensQuery, { filter: 'list', period: '15d' })).toContain('period'));
+});
+
+describe('GetInventorySkuQuery', () => {
+  it('convierte limit del query string a número', () => {
+    const dto = plainToInstance(GetInventorySkuQuery, { limit: '20', period: '7d' });
+    expect(dto.limit).toBe(20);
+    expect(validateSync(dto)).toEqual([]);
+  });
+  it('rechaza limit fuera de rango', () => expect(errorsOf(GetInventorySkuQuery, { limit: '0' })).toContain('limit'));
+});

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

@@ -0,0 +1,128 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { RetailLoan } from '../../../src/index';
+import {
+    CreateMyPaymentRequest,
+    CreateMyPaymentResponse,
+    MyCollectionOutcomeEnum,
+    MyNextInstallmentModeEnum,
+    MyPaymentOptions,
+    MyPaymentTypeEnum,
+    MyPaymentUnavailableReasonEnum,
+} from '../../../src/retailLoan/index';
+import { LoanNextInstallmentModeEnum, LoanPaymentOptionUnavailableReasonEnum } from '../../../src/loanCredit/index';
+
+const sortedValues = (enumObject: Record<string, string>) => Object.values(enumObject).sort();
+
+const errorProperties = async (body: object): Promise<string[]> => {
+    const dto = plainToInstance(CreateMyPaymentRequest, body);
+    const errors = await validate(dto, { whitelist: true, forbidNonWhitelisted: false });
+    return errors.map(error => error.property);
+};
+
+describe.each([
+    ['MyPaymentTypeEnum', MyPaymentTypeEnum, ['NEXT_INSTALLMENT', 'ADVANCE', 'SETTLEMENT']],
+    ['MyNextInstallmentModeEnum', MyNextInstallmentModeEnum, ['ADVANCE', 'COLLECT_DUE']],
+    [
+        'MyPaymentUnavailableReasonEnum',
+        MyPaymentUnavailableReasonEnum,
+        ['PAYMENT_IN_PROGRESS', 'CREDIT_NOT_CURRENT', 'USE_SETTLEMENT', 'NOT_AVAILABLE_YET', 'CREDIT_CLOSED'],
+    ],
+    ['MyCollectionOutcomeEnum', MyCollectionOutcomeEnum, ['COLLECTED', 'PARTIAL', 'NOT_COLLECTED', 'UNKNOWN']],
+])('%s', (_name, enumObject, expected) => {
+    it('tiene exactamente los valores del contrato', () => {
+        expect(sortedValues(enumObject)).toEqual([...expected].sort());
+    });
+
+    it('cada clave es igual a su valor', () => {
+        for (const [key, value] of Object.entries(enumObject)) {
+            expect(key).toBe(value);
+        }
+    });
+});
+
+describe('paridad con el contrato privado de loan-credit', () => {
+    it('los motivos de no disponible son los mismos', () => {
+        expect(sortedValues(MyPaymentUnavailableReasonEnum)).toEqual(sortedValues(LoanPaymentOptionUnavailableReasonEnum));
+    });
+
+    it('los modos de la siguiente cuota son los mismos', () => {
+        expect(sortedValues(MyNextInstallmentModeEnum)).toEqual(sortedValues(LoanNextInstallmentModeEnum));
+    });
+});
+
+describe('CreateMyPaymentRequest', () => {
+    it.each([
+        [{ type: MyPaymentTypeEnum.NEXT_INSTALLMENT, expectedAmount: 1050 }],
+        [{ type: MyPaymentTypeEnum.SETTLEMENT, expectedAmount: 9123.45 }],
+        [{ type: MyPaymentTypeEnum.ADVANCE, expectedAmount: 2100.5 }],
+    ])('acepta %j', async body => {
+        expect(await errorProperties(body)).toEqual([]);
+    });
+
+    it('exige tipo y monto esperado', async () => {
+        expect(await errorProperties({})).toEqual(expect.arrayContaining(['type', 'expectedAmount']));
+    });
+
+    it('rechaza un tipo fuera del enum', async () => {
+        expect(await errorProperties({ type: 'PARTIAL', expectedAmount: 1050 })).toEqual(['type']);
+    });
+
+    it.each([[0], [-1050], [10.123], ['1050']])('rechaza el monto %p', async expectedAmount => {
+        expect(await errorProperties({ type: MyPaymentTypeEnum.SETTLEMENT, expectedAmount })).toEqual(['expectedAmount']);
+    });
+});
+
+describe('retailLoan — opciones y respuesta del pago', () => {
+    it('la liquidación trae su desglose y su ahorro en pesos', () => {
+        const options: MyPaymentOptions = {
+            nextInstallment: {
+                available: true,
+                amount: 1050,
+                mode: MyNextInstallmentModeEnum.ADVANCE,
+                installmentNumber: 4,
+                dueDate: '2026-10-01',
+            },
+            advance: { available: false, unavailableReason: MyPaymentUnavailableReasonEnum.NOT_AVAILABLE_YET },
+            settlement: {
+                available: true,
+                amount: 9123.45,
+                breakdown: { overdue: 0, capital: 8900, interest: 192.63, iva: 30.82 },
+                savings: 326.55,
+                quotedAt: '2026-09-24T15:00:00.000Z',
+            },
+        };
+
+        expect(options.settlement.breakdown?.capital).toBe(8900);
+        expect(options.pendingPayment).toBeUndefined();
+    });
+
+    it('un pago en curso se informa con su tipo y su monto', () => {
+        const blocked = { available: false, unavailableReason: MyPaymentUnavailableReasonEnum.PAYMENT_IN_PROGRESS };
+        const options: MyPaymentOptions = {
+            pendingPayment: { type: MyPaymentTypeEnum.NEXT_INSTALLMENT, amount: 1050 },
+            nextInstallment: blocked,
+            advance: blocked,
+            settlement: blocked,
+        };
+
+        expect(options.pendingPayment?.type).toBe('NEXT_INSTALLMENT');
+    });
+
+    it('la respuesta del pago siempre trae el desenlace del cobro', () => {
+        const response: CreateMyPaymentResponse = {
+            creditId: 'CR-1',
+            type: MyPaymentTypeEnum.SETTLEMENT,
+            amount: 9123.45,
+            collection: MyCollectionOutcomeEnum.UNKNOWN,
+        };
+
+        expect(response.collection).toBe('UNKNOWN');
+    });
+
+    it('expone el request en el namespace RetailLoan del index raíz', () => {
+        expect(RetailLoan.CreateMyPaymentRequest).toBeDefined();
+        expect(RetailLoan.MyCollectionOutcomeEnum.NOT_COLLECTED).toBe('NOT_COLLECTED');
+    });
+});

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

@@ -0,0 +1,114 @@
+import 'reflect-metadata';
+import { plainToInstance, type ClassConstructor } from 'class-transformer';
+import { validateSync, type ValidationError } from 'class-validator';
+import {
+  AddProductRequest,
+  CompleteSaleRequest,
+  DeleteProductRequest,
+  QuoteRequest,
+  SuggestIdentifiersQuery,
+} 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 toDto<T extends object>(cls: ClassConstructor<T>, payload: object): T {
+  return plainToInstance(cls, payload, { excludeExtraneousValues: true });
+}
+
+function errorsOf<T extends object>(cls: ClassConstructor<T>, payload: object): string[] {
+  return paths(validateSync(toDto(cls, payload) as object));
+}
+
+describe('AddProductRequest — qty por línea', () => {
+  it('acepta solo el sku (qty ausente = 1 lo resuelve el silo)', () => {
+    expect(errorsOf(AddProductRequest, { sku: 'SKU-1' })).toEqual([]);
+  });
+  it('acepta qty explícita', () => {
+    expect(errorsOf(AddProductRequest, { sku: 'SKU-1', qty: 3 })).toEqual([]);
+    expect(toDto(AddProductRequest, { sku: 'SKU-1', qty: 3 }).qty).toBe(3);
+  });
+  it('rechaza qty menor a 1', () => {
+    expect(errorsOf(AddProductRequest, { sku: 'SKU-1', qty: 0 })).toContain('qty');
+  });
+  it('rechaza qty no entera', () => {
+    expect(errorsOf(AddProductRequest, { sku: 'SKU-1', qty: 1.5 })).toContain('qty');
+  });
+});
+
+describe('DeleteProductRequest — quitar por lineId', () => {
+  it('acepta lineId', () => {
+    expect(errorsOf(DeleteProductRequest, { lineId: 'L1' })).toEqual([]);
+    expect(toDto(DeleteProductRequest, { lineId: 'L1' }).lineId).toBe('L1');
+  });
+  it('sigue aceptando el request vacío', () => {
+    expect(errorsOf(DeleteProductRequest, {})).toEqual([]);
+  });
+  it('rechaza lineId que no es string', () => {
+    expect(errorsOf(DeleteProductRequest, { lineId: 7 })).toContain('lineId');
+  });
+});
+
+describe('QuoteRequest — financedLineId', () => {
+  const base = { downPaymentCents: 1000, termWeeks: 12 };
+  it('acepta sin financedLineId (compat)', () => {
+    expect(errorsOf(QuoteRequest, base)).toEqual([]);
+  });
+  it('acepta financedLineId', () => {
+    expect(errorsOf(QuoteRequest, { ...base, financedLineId: 'L2' })).toEqual([]);
+    expect(toDto(QuoteRequest, { ...base, financedLineId: 'L2' }).financedLineId).toBe('L2');
+  });
+  it('rechaza financedLineId vacío', () => {
+    expect(errorsOf(QuoteRequest, { ...base, financedLineId: '' })).toContain('financedLineId');
+  });
+});
+
+describe('CompleteSaleRequest — líneas con identificadores por componente', () => {
+  const ok = {
+    lines: [
+      { lineId: 'L1', components: [{ sku: 'PHONE-1', identifiers: ['356938035643809'] }] },
+      { lineId: 'L2', components: [{ sku: 'SIM-1', identifiers: ['8952140'] }, { sku: 'CASE-1', identifiers: [] }] },
+    ],
+  };
+  it('acepta un request completo', () => {
+    expect(errorsOf(CompleteSaleRequest, ok)).toEqual([]);
+    const dto = toDto(CompleteSaleRequest, ok);
+    expect(dto.lines[1].components[0].identifiers).toEqual(['8952140']);
+  });
+  it('acepta lista de líneas vacía (venta solo por cantidad)', () => {
+    expect(errorsOf(CompleteSaleRequest, { lines: [] })).toEqual([]);
+  });
+  it('acepta sin lines (front sin body)', () => {
+    expect(errorsOf(CompleteSaleRequest, {})).toEqual([]);
+  });
+  it('rechaza lines que no es arreglo', () => {
+    expect(errorsOf(CompleteSaleRequest, { lines: 'L1' })).toContain('lines');
+  });
+  it('rechaza una línea sin lineId', () => {
+    expect(errorsOf(CompleteSaleRequest, { lines: [{ components: [] }] })).toContain('lines.0.lineId');
+  });
+  it('rechaza un identificador que no es string', () => {
+    const bad = { lines: [{ lineId: 'L1', components: [{ sku: 'SIM-1', identifiers: [123] }] }] };
+    expect(errorsOf(CompleteSaleRequest, bad)).toContain('lines.0.components.0.identifiers');
+  });
+  it('rechaza un componente sin sku', () => {
+    const bad = { lines: [{ lineId: 'L1', components: [{ identifiers: ['x'] }] }] };
+    expect(errorsOf(CompleteSaleRequest, bad)).toContain('lines.0.components.0.sku');
+  });
+});
+
+describe('SuggestIdentifiersQuery — prefijo mínimo 4', () => {
+  it('acepta sku y prefijo de 4', () => {
+    expect(errorsOf(SuggestIdentifiersQuery, { sku: 'SIM-1', prefix: '8952' })).toEqual([]);
+  });
+  it('rechaza prefijo corto', () => {
+    expect(errorsOf(SuggestIdentifiersQuery, { sku: 'SIM-1', prefix: '895' })).toContain('prefix');
+  });
+  it('rechaza sin sku', () => {
+    expect(errorsOf(SuggestIdentifiersQuery, { prefix: '8952' })).toContain('sku');
+  });
+});