@fiado/type-kit 3.508.0 → 3.510.0

package/_test_/unit/dynamicForm/dynamicForm.test.ts

@@ -0,0 +1,78 @@
+import 'reflect-metadata';
+import { ValidationArguments } from 'class-validator';
+import * as benefit from '../../../src/benefitCenter';
+import * as form from '../../../src/dynamicForm';
+import * as root from '../../../src';
+import { JsonValue } from '../../../src/common';
+
+const args = {} as ValidationArguments;
+
+describe('dynamicForm: alias con benefitCenter (D-E5)', () => {
+  it('benefitCenter reexporta las MISMAS clases y enum, sin copias', () => {
+    expect(benefit.InputField).toBe(form.InputField);
+    expect(benefit.InputSchema).toBe(form.InputSchema);
+    expect(benefit.InputValidation).toBe(form.InputValidation);
+    expect(benefit.SelectOption).toBe(form.SelectOption);
+    expect(benefit.InputFieldTypeEnum).toBe(form.InputFieldTypeEnum);
+  });
+
+  it('conserva los 8 tipos originales con exactamente los mismos valores', () => {
+    const originales = ['PHONE', 'BARCODE', 'ACCOUNT_NUMBER', 'TEXT', 'NUMBER', 'MONEY', 'SELECT', 'DATE'];
+    originales.forEach((valor) => {
+      expect(form.InputFieldTypeEnum[valor as keyof typeof form.InputFieldTypeEnum]).toBe(valor);
+    });
+  });
+
+  it('agrega DIRECTORY, ENTITY_REF, DATE_RANGE y BOOLEAN', () => {
+    expect(form.InputFieldTypeEnum.DIRECTORY).toBe('DIRECTORY');
+    expect(form.InputFieldTypeEnum.ENTITY_REF).toBe('ENTITY_REF');
+    expect(form.InputFieldTypeEnum.DATE_RANGE).toBe('DATE_RANGE');
+    expect(form.InputFieldTypeEnum.BOOLEAN).toBe('BOOLEAN');
+    expect(Object.values(form.InputFieldTypeEnum)).toHaveLength(12);
+  });
+
+  it('InputField acepta optionsSource (SELECT/ENTITY_REF con opciones desde un endpoint)', () => {
+    const campo: form.InputField = {
+      key: 'saleId',
+      type: form.InputFieldTypeEnum.ENTITY_REF,
+      label: 'Venta',
+      required: true,
+      optionsSource: '/phone-sales/backoffice/sales',
+    };
+    expect(campo.optionsSource).toBe('/phone-sales/backoffice/sales');
+  });
+
+  it('se expone en el barrel raíz como namespace DynamicForm', () => {
+    expect(root.DynamicForm.InputFieldTypeEnum.DIRECTORY).toBe('DIRECTORY');
+  });
+});
+
+describe('IsDynamicFormValues', () => {
+  const validator = new form.IsDynamicFormValues();
+  const ok = (value: JsonValue): boolean => validator.validate(value, args);
+
+  it('acepta string, number, boolean y rango de fechas', () => {
+    expect(ok({ a: 'x', b: 1, c: false, d: { from: '2026-10-01', to: '2026-10-07' } })).toBe(true);
+  });
+
+  it('acepta el mapa vacío', () => {
+    expect(ok({})).toBe(true);
+  });
+
+  it.each<[string, JsonValue]>([
+    ['hoja null', { a: null }],
+    ['hoja arreglo', { a: ['x'] }],
+    ['objeto que no es rango', { a: { x: 1 } }],
+    ['rango incompleto', { a: { from: '2026-10-01' } }],
+    ['rango con llave extra', { a: { from: 'a', to: 'b', extra: 'c' } }],
+    ['raíz arreglo', ['x']],
+    ['raíz string', 'x'],
+    ['raíz null', null],
+  ])('rechaza %s', (_nombre, value) => {
+    expect(ok(value)).toBe(false);
+  });
+
+  it('rechaza un number no finito', () => {
+    expect(ok({ a: Number.POSITIVE_INFINITY })).toBe(false);
+  });
+});

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

@@ -0,0 +1,49 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import {
+    PermissionScope,
+    RoleAssignmentsByScopeRefsRequest,
+    ROLE_ASSIGNMENTS_BY_SCOPE_REFS_MAX_BATCH,
+    ScopeRefLookupStatusEnum,
+} from '../../../../src/platformRbac';
+import type { RoleAssignmentsByScopeRefsResponse } from '../../../../src/platformRbac';
+
+describe('RoleAssignmentsByScopeRefsRequest', () => {
+    it('el tope del lote es 100', () => {
+        expect(ROLE_ASSIGNMENTS_BY_SCOPE_REFS_MAX_BATCH).toBe(100);
+    });
+
+    it('acepta una lista de scopeRefs y la vacía', async () => {
+        expect(await validate(plainToInstance(RoleAssignmentsByScopeRefsRequest, { scopeRefs: ['st-1'] }))).toEqual([]);
+        expect(await validate(plainToInstance(RoleAssignmentsByScopeRefsRequest, { scopeRefs: [] }))).toEqual([]);
+    });
+
+    it('rechaza 101 scopeRefs con arrayMaxSize', async () => {
+        const scopeRefs = Array.from({ length: 101 }, (_, i) => `st-${i}`);
+        const errors = await validate(plainToInstance(RoleAssignmentsByScopeRefsRequest, { scopeRefs }));
+        expect(errors[0].constraints?.arrayMaxSize).toBeDefined();
+    });
+
+    it('rechaza elementos que no son string', async () => {
+        const errors = await validate(plainToInstance(RoleAssignmentsByScopeRefsRequest, { scopeRefs: [7] }));
+        expect(errors[0].constraints?.isString).toBeDefined();
+    });
+});
+
+describe('RoleAssignmentsByScopeRefsResponse', () => {
+    it('lleva un item por scopeRef con su estado y asignaciones', () => {
+        const response: RoleAssignmentsByScopeRefsResponse = {
+            items: [
+                {
+                    scopeRef: 'st-1',
+                    status: ScopeRefLookupStatusEnum.OK,
+                    assignments: [{ cognitoSub: 'sub-1', roleId: 'store_manager', roleName: 'Encargado', scope: PermissionScope.LEVEL_3 }],
+                },
+                { scopeRef: 'st-2', status: ScopeRefLookupStatusEnum.UNAVAILABLE, assignments: [] },
+            ],
+        };
+        expect(Object.values(ScopeRefLookupStatusEnum)).toEqual(['OK', 'UNAVAILABLE']);
+        expect(response.items).toHaveLength(2);
+    });
+});

package/_test_/unit/retailOrg/dtos/sellerTableSources.test.ts

@@ -60,3 +60,20 @@ describe('shapes de los privados del padrón', () => {
     expect([store.managerRetailUserId, seller.phone, goals.goals.length]).toEqual(['u-1', null, 1]);
   });
 });
+
+describe('PrivateSellerDto.cognitoSub y createdAt', () => {
+  it('lleva la cuenta de RBAC y la fecha de alta, ambas nulables', () => {
+    const seller: PrivateSellerDto = {
+      sellerId: 'u-1',
+      displayName: 'Ana',
+      homeStoreId: null,
+      commissionTier: 'BASE',
+      status: 'ACTIVE' as never,
+      cognitoSub: 'sub-1',
+      createdAt: '2026-01-02T03:04:05.000Z',
+    };
+    const orphan: PrivateSellerDto = { ...seller, cognitoSub: null, createdAt: null };
+    expect(seller.cognitoSub).toBe('sub-1');
+    expect(orphan.createdAt).toBeNull();
+  });
+});

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

@@ -5,7 +5,7 @@ import {
 } from '../../../src/retailWizard';
 
 describe('BackofficeSellerTableResponse', () => {
-  it('declara las tres fuentes y una fila completa', () => {
+  it('declara las cinco fuentes y una fila completa', () => {
     const response: BackofficeSellerTableResponse = {
       from: '2026-09-07T06:00:00.000Z',
       to: '2026-10-07T05:59:59.999Z',
@@ -14,6 +14,8 @@ describe('BackofficeSellerTableResponse', () => {
         roster: SellerTableSourceStatusEnum.OK,
         goals: SellerTableSourceStatusEnum.UNAVAILABLE,
         commission: SellerTableSourceStatusEnum.OK,
+        rbac: SellerTableSourceStatusEnum.UNAVAILABLE,
+        lake: SellerTableSourceStatusEnum.DISABLED,
       },
       commissionPeriod: { periodId: '2026-09-28', from: '2026-09-28', to: '2026-10-04' },
       items: [
@@ -34,10 +36,15 @@ describe('BackofficeSellerTableResponse', () => {
           goalCents: null,
           commissionCents: null,
           npiM30Pct: null,
+          roles: [{ key: 'store_manager', name: 'Encargado de tienda' }],
+          email: null,
+          customersServed: 0,
+          memberSince: '2026-01-02T03:04:05.000Z',
+          weeklyPlacedCents: null,
         },
       ],
     };
-    expect(Object.values(SellerTableSourceStatusEnum)).toEqual(['OK', 'UNAVAILABLE']);
+    expect(Object.values(SellerTableSourceStatusEnum)).toEqual(['OK', 'UNAVAILABLE', 'DISABLED']);
     expect(response.items[0].npiM30Pct).toBeNull();
   });
 });

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

@@ -0,0 +1,87 @@
+import 'reflect-metadata';
+import {
+  RewardsMessageTypeEnum,
+  GrantStatusEnum,
+  GrantItemStatusEnum,
+  GrantRejectReasonEnum,
+  GrantFailedReasonEnum,
+  ItemErrorCategoryEnum,
+  RewardStatusEnum,
+  DependencyIfMissingEnum,
+  RewardsErrorCodeEnum,
+  RewardCost,
+  RewardChargeTo,
+  RewardDependency,
+  RewardInputs,
+} from '../../../src/rewards';
+import { InputFieldTypeEnum } from '../../../src/dynamicForm';
+import { CurrencyId } from '../../../src/currency';
+
+describe('rewards: enums (los valores viajan por cola y por HTTP: no se renombran)', () => {
+  it('RewardsMessageTypeEnum', () => {
+    expect(Object.values(RewardsMessageTypeEnum).sort()).toEqual(['GRANT_FAILED', 'GRANT_REQUESTED']);
+  });
+
+  it('GrantStatusEnum coincide con spec A 7.1', () => {
+    expect(Object.values(GrantStatusEnum).sort()).toEqual(
+      ['COMPLETED', 'FAILED', 'IN_PROGRESS', 'PARTIAL', 'PENDING', 'REJECTED'],
+    );
+  });
+
+  it('GrantItemStatusEnum coincide con spec A 7.1', () => {
+    expect(Object.values(GrantItemStatusEnum).sort()).toEqual(['FAILED', 'GRANTED', 'PENDING', 'SKIPPED']);
+  });
+
+  it('ItemErrorCategoryEnum coincide con spec A §8', () => {
+    expect(Object.values(ItemErrorCategoryEnum).sort()).toEqual([
+      'INPUT_UNRESOLVABLE', 'INTERNAL_ERROR', 'PROVIDER_REJECTED', 'PROVIDER_UNAVAILABLE', 'REQUEST_INVALID',
+    ]);
+  });
+
+  it('GrantFailedReasonEnum incluye todas las razones de rechazo más ITEMS_FAILED', () => {
+    Object.values(GrantRejectReasonEnum).forEach((razon) => {
+      expect(Object.values(GrantFailedReasonEnum)).toContain(razon);
+    });
+    expect(GrantFailedReasonEnum.ITEMS_FAILED).toBe('ITEMS_FAILED');
+    expect(Object.values(GrantFailedReasonEnum)).toHaveLength(4);
+  });
+
+  it('RewardStatusEnum, DependencyIfMissingEnum y RewardsErrorCodeEnum', () => {
+    expect(Object.values(RewardStatusEnum).sort()).toEqual(['ACTIVE', 'INACTIVE']);
+    expect(Object.values(DependencyIfMissingEnum).sort()).toEqual(['REJECT', 'SKIP']);
+    expect(Object.values(RewardsErrorCodeEnum).sort()).toEqual(['GRANT_NOT_FOUND', 'PACKAGE_NOT_FOUND']);
+  });
+});
+
+describe('rewards: tipos de valor', () => {
+  it('RewardCost usa CurrencyId del dominio currency (no un string libre)', () => {
+    const costo: RewardCost = { amount: 50, currency: CurrencyId.MXN };
+    expect(costo.currency).toBe('MXN');
+  });
+
+  it('RewardChargeTo exige partnerId y partnerName', () => {
+    const aliado: RewardChargeTo = { partnerId: 'ALIADO-001', partnerName: 'Aliado de ejemplo' };
+    expect(aliado.partnerId).toBe('ALIADO-001');
+  });
+
+  it('RewardDependency es un InputField con los campos propios de rewards (spec A 5.1)', () => {
+    const dependencia: RewardDependency = {
+      key: 'referenceId',
+      type: InputFieldTypeEnum.TEXT,
+      label: 'Referencia del destinatario',
+      required: false,
+      requiredWhen: 'useAccountReference == false',
+      ifMissing: DependencyIfMissingEnum.SKIP,
+      resolvedFrom: 'directory.referenceId (cuando useAccountReference == true)',
+      description: 'Referencia a usar cuando no es la de la cuenta.',
+    };
+    expect(dependencia.ifMissing).toBe('SKIP');
+  });
+
+  it('RewardInputs mapea itemKey → inputKey → valor', () => {
+    const inputs: RewardInputs = {
+      exampleItem: { useAccountReference: false, referenceId: 'REF-001' },
+    };
+    expect(inputs.exampleItem.useAccountReference).toBe(false);
+  });
+});

package/_test_/unit/rewards/grantMessages.test.ts

@@ -0,0 +1,123 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { JsonValue } from '../../../src/common';
+import {
+  GrantRequestedMessage,
+  GrantFailedMessage,
+  GrantFailedReasonEnum,
+  RewardsMessageTypeEnum,
+  REWARD_TAGS_MAX_KEYS,
+} from '../../../src/rewards';
+
+const base = {
+  messageType: 'GRANT_REQUESTED',
+  directoryId: 'd-1',
+  packageId: 'paquete-1',
+  source: { service: 'rewards-eligibility', reference: 'run-1', tags: { campaignId: 'referidos-q4' } },
+  idempotencyKey: 'elig:ev-9:d-1:ONCE:r1',
+  inputs: { exampleItem: { useAccountReference: false, referenceId: 'REF-001' } },
+};
+
+const requested = (raw: Record<string, JsonValue>): GrantRequestedMessage =>
+  plainToInstance(GrantRequestedMessage, raw, { excludeExtraneousValues: true });
+
+const errorProps = async (dto: object): Promise<string[]> =>
+  (await validate(dto)).map((e) => e.property);
+
+describe('GrantRequestedMessage (spec A 6.1)', () => {
+  it('valida el mensaje de ejemplo del spec', async () => {
+    const dto = requested(base);
+    expect(await validate(dto)).toHaveLength(0);
+    expect(dto.messageType).toBe(RewardsMessageTypeEnum.GRANT_REQUESTED);
+    expect(dto.inputs.exampleItem.referenceId).toBe('REF-001');
+  });
+
+  it('acepta inputs vacío (paquete sin dependencias) y source sin tags', async () => {
+    const dto = requested({ ...base, inputs: {}, source: { service: 'x', reference: 'y' } });
+    expect(await validate(dto)).toHaveLength(0);
+  });
+
+  it('rechaza un messageType ajeno o ausente (se rutea por messageType, no por forma)', async () => {
+    expect(await errorProps(requested({ ...base, messageType: 'GRANT_FAILED' }))).toContain('messageType');
+    const { messageType: _omitido, ...sinTipo } = base;
+    expect(await errorProps(requested(sinTipo))).toContain('messageType');
+  });
+
+  it.each(['directoryId', 'packageId', 'idempotencyKey'])('rechaza %s vacío', async (campo) => {
+    expect(await errorProps(requested({ ...base, [campo]: '' }))).toContain(campo);
+  });
+
+  it('rechaza source.service o source.reference vacíos', async () => {
+    const dto = requested({ ...base, source: { service: '', reference: 'run-1' } });
+    expect(await errorProps(dto)).toContain('source');
+    const dto2 = requested({ ...base, source: { service: 'x', reference: '' } });
+    expect(await errorProps(dto2)).toContain('source');
+  });
+
+  it(`rechaza más de ${REWARD_TAGS_MAX_KEYS} tags (spec A 5.3)`, async () => {
+    const tags: Record<string, string> = {};
+    for (let i = 0; i <= REWARD_TAGS_MAX_KEYS; i += 1) tags[`k${i}`] = 'v';
+    expect(await errorProps(requested({ ...base, source: { service: 'x', reference: 'y', tags } }))).toContain('source');
+  });
+
+  it('acepta exactamente el máximo de tags', async () => {
+    const tags: Record<string, string> = {};
+    for (let i = 0; i < REWARD_TAGS_MAX_KEYS; i += 1) tags[`k${i}`] = 'v';
+    expect(await validate(requested({ ...base, source: { service: 'x', reference: 'y', tags } }))).toHaveLength(0);
+  });
+
+  it('rechaza tags con valores que no son string', async () => {
+    const dto = requested({ ...base, source: { service: 'x', reference: 'y', tags: { n: 1 } } });
+    expect(await errorProps(dto)).toContain('source');
+  });
+
+  it.each<[string, JsonValue]>([
+    ['hoja null', { exampleItem: { referenceId: null } }],
+    ['hoja arreglo', { exampleItem: { referenceId: ['REF-001'] } }],
+    ['anidación de 3 niveles', { exampleItem: { referenceId: { a: { b: 'c' } } } }],
+    ['itemKey con valor escalar', { exampleItem: 'EXAMPLE' }],
+    ['raíz arreglo', [{ exampleItem: 'x' }]],
+  ])('rechaza inputs inválido: %s', async (_nombre, inputs) => {
+    expect(await errorProps(requested({ ...base, inputs }))).toContain('inputs');
+  });
+
+  it('descarta campos extra: el grantId NO viaja y cualquier otro campo se ignora (excludeExtraneousValues)', () => {
+    const dto = requested({ ...base, grantId: 'forjado', prefetchedFacts: [{ value: 1 }] });
+    expect('grantId' in dto).toBe(false);
+    expect('prefetchedFacts' in dto).toBe(false);
+  });
+});
+
+describe('GrantFailedMessage (spec A 6.5)', () => {
+  const baseFailed = {
+    messageType: 'GRANT_FAILED',
+    idempotencyKey: 'elig:ev-9:d-1:ONCE:r1',
+    grantId: 'g-123',
+    reason: 'PACKAGE_INACTIVE',
+  };
+  const failed = (raw: Record<string, JsonValue>): GrantFailedMessage =>
+    plainToInstance(GrantFailedMessage, raw, { excludeExtraneousValues: true });
+
+  it('valida el ejemplo del spec', async () => {
+    const dto = failed(baseFailed);
+    expect(await validate(dto)).toHaveLength(0);
+    expect(dto.reason).toBe(GrantFailedReasonEnum.PACKAGE_INACTIVE);
+  });
+
+  it.each(Object.values(GrantFailedReasonEnum))('acepta la razón %s', async (reason) => {
+    expect(await validate(failed({ ...baseFailed, reason }))).toHaveLength(0);
+  });
+
+  it('rechaza una razón desconocida', async () => {
+    expect(await errorProps(failed({ ...baseFailed, reason: 'OTRA' }))).toContain('reason');
+  });
+
+  it('rechaza messageType GRANT_REQUESTED (no se confunde un tipo con el otro)', async () => {
+    expect(await errorProps(failed({ ...baseFailed, messageType: 'GRANT_REQUESTED' }))).toContain('messageType');
+  });
+
+  it.each(['idempotencyKey', 'grantId'])('rechaza %s vacío', async (campo) => {
+    expect(await errorProps(failed({ ...baseFailed, [campo]: '' }))).toContain(campo);
+  });
+});

package/_test_/unit/rewards/readResponses.test.ts

@@ -0,0 +1,136 @@
+import 'reflect-metadata';
+import {
+  PackageContractResponse,
+  GrantResponse,
+  GrantAttemptResponse,
+  RewardStatusEnum,
+  GrantStatusEnum,
+  GrantItemStatusEnum,
+  GrantRejectReasonEnum,
+  ItemErrorCategoryEnum,
+} from '../../../src/rewards';
+import { InputFieldTypeEnum } from '../../../src/dynamicForm';
+import { CurrencyId } from '../../../src/currency';
+
+describe('PackageContractResponse (GET /packages/{id}, spec A 6.3)', () => {
+  const paquete: PackageContractResponse = {
+    id: 'paquete-referido',
+    name: 'Paquete referido',
+    status: RewardStatusEnum.ACTIVE,
+    version: 2,
+    items: [
+      {
+        itemKey: 'exampleItem',
+        catalogItemId: 'example-reward-a',
+        name: 'Recompensa de ejemplo A',
+        description: 'Recompensa genérica de ejemplo por $50.',
+        cost: { amount: 50, currency: CurrencyId.MXN },
+        dependencies: [
+          {
+            key: 'useAccountReference',
+            type: InputFieldTypeEnum.BOOLEAN,
+            label: 'Usar la referencia de la cuenta',
+            required: true,
+            description: 'Indica si se usa la referencia de la cuenta del usuario para esta recompensa.',
+          },
+        ],
+      },
+    ],
+    totalCost: [{ amount: 50, currency: CurrencyId.MXN }],
+  };
+
+  it('sobrevive a un viaje JSON sin perder campos', () => {
+    expect(JSON.parse(JSON.stringify(paquete))).toEqual(paquete);
+  });
+
+  it('totalCost es una lista por moneda (un paquete puede mezclar monedas)', () => {
+    const mixto: PackageContractResponse = {
+      ...paquete,
+      totalCost: [
+        { amount: 50, currency: CurrencyId.MXN },
+        { amount: 3, currency: CurrencyId.USD },
+      ],
+    };
+    expect(mixto.totalCost.map((c) => c.currency)).toEqual(['MXN', 'USD']);
+  });
+});
+
+describe('GrantResponse (GET /grants/{id}, spec A 6.4)', () => {
+  const intento: GrantAttemptResponse = {
+    attempt: 2,
+    startedAt: 1760000000000,
+    finishedAt: 1760000001000,
+    errorCategory: ItemErrorCategoryEnum.REQUEST_INVALID,
+    errorCode: 'BAD_PRODUCT',
+    httpStatus: 400,
+  };
+
+  const entrega: GrantResponse = {
+    id: 'g-123',
+    directoryId: 'd-1',
+    packageId: 'paquete-referido',
+    packageVersion: 2,
+    source: { service: 'rewards-eligibility', reference: 'run-1', tags: { campaignId: 'referidos-q4' } },
+    status: GrantStatusEnum.PARTIAL,
+    items: [
+      {
+        itemKey: 'exampleItem',
+        catalogItemId: 'example-reward-a',
+        status: GrantItemStatusEnum.FAILED,
+        chargeTo: { partnerId: 'ALIADO-001', partnerName: 'Aliado de ejemplo' },
+        cost: { amount: 50, currency: CurrencyId.MXN },
+        attemptCount: 2,
+        externalRef: { transactionNumber: 'RW-g-123-exampleItem' },
+        attempts: [intento],
+      },
+      {
+        itemKey: 'exampleItemB',
+        catalogItemId: 'example-reward-b',
+        status: GrantItemStatusEnum.GRANTED,
+        chargeTo: { partnerId: 'ALIADO-001', partnerName: 'Aliado de ejemplo' },
+        cost: { amount: 20, currency: CurrencyId.MXN },
+        attemptCount: 1,
+        grantedAt: 1760000002000,
+        attempts: [],
+      },
+    ],
+    createdAt: 1760000000000,
+    updatedAt: 1760000002000,
+  };
+
+  it('sobrevive a un viaje JSON', () => {
+    expect(JSON.parse(JSON.stringify(entrega))).toEqual(entrega);
+  });
+
+  it('una entrega REJECTED lleva rejectReason y no tiene ítems ejecutados', () => {
+    const rechazada: GrantResponse = {
+      ...entrega,
+      status: GrantStatusEnum.REJECTED,
+      rejectReason: GrantRejectReasonEnum.PACKAGE_INACTIVE,
+      items: [],
+    };
+    expect(rechazada.rejectReason).toBe('PACKAGE_INACTIVE');
+  });
+
+  it('un INPUT_INVALID expone la lista de campos inválidos (spec A 6.2)', () => {
+    const invalida: GrantResponse = {
+      ...entrega,
+      status: GrantStatusEnum.REJECTED,
+      rejectReason: GrantRejectReasonEnum.INPUT_INVALID,
+      invalidFields: ['exampleItem.referenceId'],
+      items: [],
+    };
+    expect(JSON.parse(JSON.stringify(invalida)).invalidFields).toEqual(['exampleItem.referenceId']);
+  });
+
+  it('el intento NO expone datos sensibles (R2): providerResponse/requestSnapshot no existen en el contrato', () => {
+    const conSensibles: GrantAttemptResponse = {
+      attempt: 1,
+      startedAt: 1,
+      finishedAt: 2,
+      // @ts-expect-error requestSnapshot puede contener datos del destinatario: solo backoffice
+      requestSnapshot: { referenceId: 'REF-001' },
+    };
+    expect(conSensibles.attempt).toBe(1);
+  });
+});

package/_test_/unit/rewardsEligibility/events.test.ts

@@ -0,0 +1,130 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { JsonValue } from '../../../src/common';
+import {
+  PostEventRequest,
+  PostEventResponse,
+  GetRunResponse,
+  EvaluationOutcomeEnum,
+  GrantRequestStatusEnum,
+  RunStatusEnum,
+  RunModeEnum,
+  TriggerTypeEnum,
+  RewardsEligibilityErrorCodeEnum,
+} from '../../../src/rewardsEligibility';
+
+const base = {
+  eventKey: 'PHONE_SALES_CODE_REDEEMED',
+  idempotencyKey: 'redeem:s-9',
+  source: { service: 'phone-sales', reference: 's-9' },
+  inputs: { buyerDirectoryId: 'd-1', redeemerDirectoryId: 'd-2', saleId: 's-9' },
+};
+
+const parse = (raw: Record<string, JsonValue>): PostEventRequest =>
+  plainToInstance(PostEventRequest, raw, { excludeExtraneousValues: true });
+
+const errorProps = async (dto: object): Promise<string[]> => (await validate(dto)).map((e) => e.property);
+
+describe('PostEventRequest (POST /events, spec B 6.1)', () => {
+  it('valida el ejemplo del spec', async () => {
+    const dto = parse(base);
+    expect(await validate(dto)).toHaveLength(0);
+    expect(dto.inputs.saleId).toBe('s-9');
+  });
+
+  it.each(['eventKey', 'idempotencyKey'])('rechaza %s vacío', async (campo) => {
+    expect(await errorProps(parse({ ...base, [campo]: '' }))).toContain(campo);
+  });
+
+  it('rechaza source sin service o sin reference', async () => {
+    expect(await errorProps(parse({ ...base, source: { service: '', reference: 's-9' } }))).toContain('source');
+    expect(await errorProps(parse({ ...base, source: { service: 'phone-sales', reference: '' } }))).toContain('source');
+  });
+
+  it.each<[string, JsonValue]>([
+    ['hoja null', { saleId: null }],
+    ['hoja arreglo', { saleId: ['s-9'] }],
+    ['objeto que no es rango', { saleId: { id: 's-9' } }],
+    ['raíz arreglo', ['s-9']],
+  ])('rechaza inputs inválido: %s', async (_nombre, inputs) => {
+    expect(await errorProps(parse({ ...base, inputs }))).toContain('inputs');
+  });
+
+  it('un emisor NO puede declarar hechos: prefetchedFacts y cualquier campo extra se descartan (E3)', () => {
+    const dto = parse({
+      ...base,
+      prefetchedFacts: [{ source: 'transactions', field: 'sumAmount', value: 9999 }],
+      outcome: 'MATCH',
+    });
+    expect('prefetchedFacts' in dto).toBe(false);
+    expect('outcome' in dto).toBe(false);
+  });
+});
+
+describe('enums de rewardsEligibility (valores que viajan por HTTP)', () => {
+  it('coinciden con spec B 5.4, 7.5 y 6.1', () => {
+    expect(Object.values(EvaluationOutcomeEnum).sort()).toEqual(
+      ['ALREADY_GRANTED', 'ERROR', 'EXCLUDED', 'MATCH', 'NO_MATCH', 'QUOTA_EXHAUSTED'],
+    );
+    expect(Object.values(GrantRequestStatusEnum).sort()).toEqual(
+      ['CANCELLED', 'NOT_APPLICABLE', 'PENDING_APPROVAL', 'QUEUED', 'REQUESTED', 'REQUEST_FAILED'],
+    );
+    expect(Object.values(RunStatusEnum).sort()).toEqual(
+      ['AWAITING_APPROVAL', 'COMPLETED', 'FAILED', 'PARTIAL', 'PUBLISHING', 'REJECTED', 'RUNNING'],
+    );
+    expect(Object.values(RunModeEnum).sort()).toEqual(['LIVE', 'SIMULATION']);
+    expect(Object.values(TriggerTypeEnum).sort()).toEqual(['CRON', 'EVENT', 'MANUAL']);
+    expect(Object.values(RewardsEligibilityErrorCodeEnum).sort()).toEqual(
+      ['EVENT_TYPE_NOT_FOUND', 'INPUT_INVALID', 'RUN_NOT_FOUND'],
+    );
+  });
+});
+
+describe('respuestas', () => {
+  it('PostEventResponse: ejemplo del spec y runs vacío cuando nadie escucha el evento', () => {
+    const respuesta: PostEventResponse = {
+      runs: [
+        {
+          evaluationId: 'phone-sales-referido-cuenta-nueva',
+          runId: 'r-1',
+          outcome: EvaluationOutcomeEnum.MATCH,
+          grantStatus: GrantRequestStatusEnum.REQUESTED,
+          idempotentReplay: false,
+        },
+      ],
+    };
+    const vacia: PostEventResponse = { runs: [] };
+    expect(JSON.parse(JSON.stringify(respuesta))).toEqual(respuesta);
+    expect(vacia.runs).toHaveLength(0);
+  });
+
+  it('GetRunResponse: cabecera + conteos + resultados paginados, sin traza', () => {
+    const corrida: GetRunResponse = {
+      runId: 'r-1',
+      evaluationId: 'phone-sales-referido-cuenta-nueva',
+      trigger: TriggerTypeEnum.EVENT,
+      mode: RunModeEnum.LIVE,
+      status: RunStatusEnum.COMPLETED,
+      counts: {
+        evaluated: 1, match: 1, noMatch: 0, error: 0, alreadyGranted: 0,
+        quotaExhausted: 0, excluded: 0, requested: 1, requestFailed: 0,
+      },
+      results: [
+        {
+          subjectKey: '5f1c9e0a2b',
+          beneficiaryDirectoryId: 'd-1',
+          campaignId: 'referidos-q4',
+          evaluationId: 'phone-sales-referido-cuenta-nueva',
+          packageId: 'paquete-referido',
+          outcome: EvaluationOutcomeEnum.MATCH,
+          grantStatus: GrantRequestStatusEnum.REQUESTED,
+          grantId: 'g-123',
+        },
+      ],
+      createdAt: 1760000000000,
+      updatedAt: 1760000001000,
+    };
+    expect(JSON.parse(JSON.stringify(corrida))).toEqual(corrida);
+  });
+});

package/bin/benefitCenter/dtos/InputField.d.ts

@@ -1,13 +1 @@
-import { InputFieldTypeEnum } from "../enums/InputFieldTypeEnum";
-import { SelectOption } from "./SelectOption";
-export declare class InputField {
-    key: string;
-    type: InputFieldTypeEnum;
-    label: string;
-    required: boolean;
-    placeholder?: string;
-    helpImage?: string;
-    showHelp?: boolean;
-    options?: SelectOption[];
-    dependsOn?: string;
-}
+export { InputField } from '../../dynamicForm/dtos/InputField';