@fiado/type-kit 3.509.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/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';

package/bin/benefitCenter/dtos/InputField.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InputField = void 0;
-class InputField {
-}
-exports.InputField = InputField;
+// Alias (D-E5): el origen vive en `dynamicForm`. No duplicar.
+var InputField_1 = require("../../dynamicForm/dtos/InputField");
+Object.defineProperty(exports, "InputField", { enumerable: true, get: function () { return InputField_1.InputField; } });

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

@@ -1,6 +1 @@
-import { InputField } from "./InputField";
-import { InputValidation } from "./InputValidation";
-export declare class InputSchema {
-    fields: InputField[];
-    validations?: Record<string, InputValidation>;
-}
+export { InputSchema } from '../../dynamicForm/dtos/InputSchema';

package/bin/benefitCenter/dtos/InputSchema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InputSchema = void 0;
-class InputSchema {
-}
-exports.InputSchema = InputSchema;
+// Alias (D-E5): el origen vive en `dynamicForm`. No duplicar.
+var InputSchema_1 = require("../../dynamicForm/dtos/InputSchema");
+Object.defineProperty(exports, "InputSchema", { enumerable: true, get: function () { return InputSchema_1.InputSchema; } });

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

@@ -1,8 +1 @@
-export declare class InputValidation {
-    pattern?: string;
-    maxLength?: number;
-    minLength?: number;
-    min?: number;
-    max?: number;
-    hasCheckDigit?: boolean;
-}
+export { InputValidation } from '../../dynamicForm/dtos/InputValidation';

package/bin/benefitCenter/dtos/InputValidation.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InputValidation = void 0;
-class InputValidation {
-}
-exports.InputValidation = InputValidation;
+// Alias (D-E5): el origen vive en `dynamicForm`. No duplicar.
+var InputValidation_1 = require("../../dynamicForm/dtos/InputValidation");
+Object.defineProperty(exports, "InputValidation", { enumerable: true, get: function () { return InputValidation_1.InputValidation; } });

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

@@ -1,4 +1 @@
-export declare class SelectOption {
-    value: string;
-    label: string;
-}
+export { SelectOption } from '../../dynamicForm/dtos/SelectOption';

package/bin/benefitCenter/dtos/SelectOption.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SelectOption = void 0;
-class SelectOption {
-}
-exports.SelectOption = SelectOption;
+// Alias (D-E5): el origen vive en `dynamicForm`. No duplicar.
+var SelectOption_1 = require("../../dynamicForm/dtos/SelectOption");
+Object.defineProperty(exports, "SelectOption", { enumerable: true, get: function () { return SelectOption_1.SelectOption; } });

package/bin/benefitCenter/enums/InputFieldTypeEnum.d.ts

@@ -1,10 +1 @@
-export declare enum InputFieldTypeEnum {
-    PHONE = "PHONE",
-    BARCODE = "BARCODE",
-    ACCOUNT_NUMBER = "ACCOUNT_NUMBER",
-    TEXT = "TEXT",
-    NUMBER = "NUMBER",
-    MONEY = "MONEY",
-    SELECT = "SELECT",
-    DATE = "DATE"
-}
+export { InputFieldTypeEnum } from '../../dynamicForm/enums/InputFieldTypeEnum';