@fiado/type-kit 3.516.0 → 3.518.0

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

@@ -0,0 +1,17 @@
+import 'reflect-metadata';
+import * as kit from '../../../src/rewardsEligibility';
+
+describe('barrel rewardsEligibility incluye el backoffice', () => {
+    it.each([
+        'CampaignRequest', 'CampaignStatusRequest', 'CampaignResponse', 'CampaignListResponse', 'QuotaUsageResponse', 'CampaignSummaryResponse',
+        'EventTypeRequest', 'EventTypeResponse', 'EventTypeListResponse', 'EvaluationRequest', 'EvaluationStatusRequest', 'EvaluationResponse',
+        'EvaluationListResponse', 'ResultTraceResponse', 'TraceGroupResponse', 'TraceConditionResponse', 'SimulateRequest', 'SimulateResponse',
+        'RuleCatalogResponse', 'RuleCatalogSourceResponse', 'RuleCatalogFieldResponse', 'PopulationSourceResponse', 'InputTypeResponse',
+        'CreateRunRequest', 'PopulationRunRequest', 'ApproveRunRequest', 'QuotaImpactResponse', 'RunResponse', 'RunListResponse',
+        'RunResultResponse', 'RunResultListResponse', 'CreateRunResponse', 'MetricsPointResponse', 'FailedConditionStatResponse', 'MetricsQuery',
+        'MetricsDimensionEnum', 'RuleValueTypeEnum', 'ELIGIBILITY_ID_PATTERN', 'EVENT_KEY_PATTERN', 'REQUEST_ID_PATTERN', 'MAX_QUOTAS_PER_CAMPAIGN',
+        'RulesChatRoleEnum', 'RulesChatTurn', 'GenerateRulesRequest', 'GenerateRulesResponse', 'RULES_CHAT_TURN_MAX_LENGTH', 'RULES_CHAT_MAX_TURNS_HARD',
+    ])('exporta %s', (name) => {
+        expect((kit as Record<string, object | string | number | RegExp>)[name]).toBeDefined();
+    });
+});

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

@@ -0,0 +1,52 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { CampaignRequest } from '../../../src/rewardsEligibility/dtos/backoffice/CampaignRequest';
+import { CampaignStatusRequest } from '../../../src/rewardsEligibility/dtos/backoffice/CampaignStatusRequest';
+import { EventTypeRequest } from '../../../src/rewardsEligibility/dtos/backoffice/EventTypeRequest';
+
+const parse = <T extends object>(cls: new () => T, value: object): T => plainToInstance(cls, value, { excludeExtraneousValues: true });
+const valid = {
+    id: 'referidos-q4', name: 'Referidos Q4', objective: 'Que cada venta traiga una cuenta nueva.',
+    startsAt: '2026-10-15', endsAt: '2026-12-31',
+    quotas: [{ id: 'primeros-500', limit: 500, period: 'TOTAL' }, { id: 'semanal', limit: 100, period: 'WEEK' }],
+    onExhausted: 'PAUSE_CAMPAIGN', alerts: { thresholds: [0.8, 1] },
+};
+
+describe('CampaignRequest', () => {
+    it('un cuerpo válido pasa y conserva los cupos anidados', async () => {
+        const request = parse(CampaignRequest, { ...valid, hack: true });
+        expect(await validate(request)).toEqual([]);
+        expect(request.quotas).toHaveLength(2);
+        expect(request.quotas[0]).toMatchObject({ id: 'primeros-500', limit: 500, period: 'TOTAL' });
+        expect(Object.keys(request)).not.toContain('hack');
+    });
+    it.each([
+        ['id con #', { ...valid, id: 'a#b' }],
+        ['fecha mal formada', { ...valid, startsAt: '15/10/2026' }],
+        ['cupo inválido anidado', { ...valid, quotas: [{ id: 'x', limit: 0, period: 'TOTAL' }] }],
+        ['más de 9 cupos', { ...valid, quotas: Array.from({ length: 10 }, (_, i) => ({ id: `q${i}`, limit: 1, period: 'TOTAL' })) }],
+        ['onExhausted desconocido', { ...valid, onExhausted: 'DELETE' }],
+        ['sin alerts', { ...valid, alerts: undefined }],
+    ])('rechaza: %s', async (_name, value) => {
+        expect((await validate(parse(CampaignRequest, value))).length).toBeGreaterThan(0);
+    });
+});
+
+describe('CampaignStatusRequest / EventTypeRequest', () => {
+    it('status válido e inválido', async () => {
+        expect(await validate(parse(CampaignStatusRequest, { status: 'PAUSED' }))).toEqual([]);
+        expect((await validate(parse(CampaignStatusRequest, { status: 'BORRAR' }))).length).toBeGreaterThan(0);
+    });
+    it('un tipo de evento válido conserva sus fields (objetos sin clase) y rechaza eventKey en minúsculas', async () => {
+        const body = {
+            eventKey: 'PHONE_SALES_CODE_REDEEMED', name: 'Canje', description: 'd', emitter: 'phone-sales', status: 'ACTIVE',
+            fields: [{ key: 'saleId', type: 'ENTITY_REF', label: 'Venta', required: true }],
+        };
+        const ok = parse(EventTypeRequest, body);
+        expect(await validate(ok)).toEqual([]);
+        expect(ok.fields[0]).toMatchObject({ key: 'saleId', type: 'ENTITY_REF', label: 'Venta', required: true });
+        expect((await validate(parse(EventTypeRequest, { ...body, eventKey: 'phone' }))).length).toBeGreaterThan(0);
+        expect((await validate(parse(EventTypeRequest, { ...body, fields: 'x' }))).length).toBeGreaterThan(0);
+    });
+});

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

@@ -0,0 +1,49 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { CampaignAlerts } from '../../../src/rewardsEligibility/dtos/CampaignAlerts';
+import { CampaignQuota } from '../../../src/rewardsEligibility/dtos/CampaignQuota';
+import { MetricsDimensionEnum } from '../../../src/rewardsEligibility/enums/MetricsDimensionEnum';
+import { RewardsEligibilityErrorCodeEnum } from '../../../src/rewardsEligibility/enums/RewardsEligibilityErrorCodeEnum';
+import { ELIGIBILITY_ID_PATTERN, EVENT_KEY_PATTERN, MAX_QUOTAS_PER_CAMPAIGN } from '../../../src/rewardsEligibility/constants/BackofficeLimits';
+
+const parse = <T extends object>(cls: new () => T, value: object): T => plainToInstance(cls, value, { excludeExtraneousValues: true });
+
+describe('CampaignQuota / CampaignAlerts validables', () => {
+    it('un cupo válido pasa y descarta campos extra', async () => {
+        const quota = parse(CampaignQuota, { id: 'primeros-500', limit: 500, period: 'TOTAL', extra: 1 });
+        expect(await validate(quota)).toEqual([]);
+        expect(Object.keys(quota).sort()).toEqual(['id', 'limit', 'period']);
+    });
+
+    it.each([
+        [{ id: 'con#almohadilla', limit: 5, period: 'TOTAL' }],
+        [{ id: 'ok', limit: 0, period: 'TOTAL' }],
+        [{ id: 'ok', limit: 1.5, period: 'TOTAL' }],
+        [{ id: 'ok', limit: 5, period: 'YEAR' }],
+    ])('un cupo inválido falla: %j', async (value) => {
+        expect((await validate(parse(CampaignQuota, value))).length).toBeGreaterThan(0);
+    });
+
+    it('umbrales de alerta: entre 0 y 1, hasta 5', async () => {
+        expect(await validate(parse(CampaignAlerts, { thresholds: [0.8, 1] }))).toEqual([]);
+        expect((await validate(parse(CampaignAlerts, { thresholds: [1.5] }))).length).toBeGreaterThan(0);
+        expect((await validate(parse(CampaignAlerts, { thresholds: [0.1, 0.2, 0.3, 0.4, 0.5, 0.6] }))).length).toBeGreaterThan(0);
+    });
+});
+
+describe('constantes y enums del backoffice', () => {
+    it('patrones de id', () => {
+        expect(ELIGIBILITY_ID_PATTERN.test('referidos-q4')).toBe(true);
+        expect(ELIGIBILITY_ID_PATTERN.test('a#b')).toBe(false);
+        expect(ELIGIBILITY_ID_PATTERN.test('A:b')).toBe(false);
+        expect(EVENT_KEY_PATTERN.test('PHONE_SALES_CODE_REDEEMED')).toBe(true);
+        expect(EVENT_KEY_PATTERN.test('phone')).toBe(false);
+        expect(MAX_QUOTAS_PER_CAMPAIGN).toBe(9);
+    });
+    it('dimensiones y códigos', () => {
+        expect(Object.values(MetricsDimensionEnum)).toEqual(['CAMPAIGN', 'EVALUATION', 'PACKAGE', 'TRIGGER', 'ALL']);
+        expect(RewardsEligibilityErrorCodeEnum.EVALUATION_INVALID).toBe('EVALUATION_INVALID');
+        expect(RewardsEligibilityErrorCodeEnum.INPUT_INVALID).toBe('INPUT_INVALID');
+    });
+});

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

@@ -0,0 +1,27 @@
+import { RuleValueTypeEnum } from '../../../src/rewardsEligibility/enums/RuleValueTypeEnum';
+import { InputFieldTypeEnum } from '../../../src/dynamicForm/enums/InputFieldTypeEnum';
+import type { RuleCatalogResponse } from '../../../src/rewardsEligibility/dtos/backoffice/RuleCatalogResponse';
+import type { PopulationSourceResponse } from '../../../src/rewardsEligibility/dtos/backoffice/PopulationSourceResponse';
+import type { InputTypeResponse } from '../../../src/rewardsEligibility/dtos/backoffice/InputTypeResponse';
+
+describe('DTOs de catálogos (forma)', () => {
+    it('un catálogo de reglas se puede armar con la forma pública', () => {
+        const catalog: RuleCatalogResponse = {
+            sources: [{
+                source: 'directory', label: 'Directorio', description: 'Datos del usuario',
+                fields: [{ field: 'accountAgeDays', label: 'Antigüedad', valueType: RuleValueTypeEnum.NUMBER, operators: ['GT', 'LTE'] }],
+            }],
+            operators: { GT: '>', LTE: '≤' },
+        };
+        expect(catalog.sources[0]?.fields[0]?.valueType).toBe('NUMBER');
+    });
+    it('una fuente de población y un tipo de input', () => {
+        const source: PopulationSourceResponse = {
+            source: 'TX_ACTIVE_IN_WINDOW', label: 'Con transacciones', description: 'd',
+            paramsSchema: [{ key: 'window', type: InputFieldTypeEnum.TEXT, label: 'Ventana', required: true }], provides: ['directoryId'],
+        };
+        const type: InputTypeResponse = { type: InputFieldTypeEnum.DIRECTORY, label: 'Usuario' };
+        expect(source.provides).toEqual(['directoryId']);
+        expect(type.type).toBe('DIRECTORY');
+    });
+});

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

@@ -0,0 +1,53 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { EvaluationRequest } from '../../../src/rewardsEligibility/dtos/backoffice/EvaluationRequest';
+import { EvaluationStatusRequest } from '../../../src/rewardsEligibility/dtos/backoffice/EvaluationStatusRequest';
+import { SimulateRequest } from '../../../src/rewardsEligibility/dtos/backoffice/SimulateRequest';
+
+const parse = <T extends object>(cls: new () => T, value: object): T => plainToInstance(cls, value, { excludeExtraneousValues: true });
+const evaluation = {
+    id: 'phone-sales-referido', campaignId: 'referidos-q4', name: 'Premio', description: 'd',
+    inputs: [{ key: 'buyerDirectoryId', type: 'DIRECTORY', label: 'Comprador', required: true }],
+    rules: { match: 'ALL', groups: [{ match: 'ALL', conditions: [{ source: 'directory', subject: 'buyerDirectoryId', field: 'accountAgeDays', op: 'LTE', value: 7 }] }] },
+    beneficiaryInput: 'buyerDirectoryId',
+    reward: { packageId: 'paquete-referido', inputs: { topup: { accountNumberMatchesOperator: { const: true } } } },
+    grantPolicy: { mode: 'ONCE' },
+    triggers: [{ type: 'MANUAL', approval: 'AUTO' }],
+};
+
+describe('EvaluationRequest', () => {
+    it('válida: conserva rules, reward, grantPolicy y triggers anidados (objetos sin clase)', async () => {
+        const request = parse(EvaluationRequest, { ...evaluation, extra: 1 });
+        expect(await validate(request)).toEqual([]);
+        expect(request.rules).toEqual(evaluation.rules);
+        expect(request.reward).toEqual(evaluation.reward);
+        expect(request.grantPolicy).toEqual({ mode: 'ONCE' });
+        expect(request.triggers).toEqual(evaluation.triggers);
+        expect(Object.keys(request)).not.toContain('extra');
+    });
+    it.each([
+        ['id con :', { ...evaluation, id: 'a:b' }],
+        ['inputs no es arreglo', { ...evaluation, inputs: {} }],
+        ['rules no es objeto', { ...evaluation, rules: 'x' }],
+        ['triggers vacío', { ...evaluation, triggers: [] }],
+        ['sin beneficiaryInput', { ...evaluation, beneficiaryInput: '' }],
+    ])('rechaza: %s', async (_name, value) => {
+        expect((await validate(parse(EvaluationRequest, value))).length).toBeGreaterThan(0);
+    });
+});
+
+describe('EvaluationStatusRequest / SimulateRequest', () => {
+    it('status', async () => {
+        expect(await validate(parse(EvaluationStatusRequest, { status: 'ACTIVE' }))).toEqual([]);
+        expect((await validate(parse(EvaluationStatusRequest, { status: 'ENDED' }))).length).toBeGreaterThan(0);
+    });
+    it('simulate: evaluationId o borrador, con inputs', async () => {
+        expect(await validate(parse(SimulateRequest, { evaluationId: 'phone-sales-referido', inputs: { buyerDirectoryId: 'd-1' } }))).toEqual([]);
+        const draft = parse(SimulateRequest, { evaluation, inputs: { buyerDirectoryId: 'd-1' } });
+        expect(await validate(draft)).toEqual([]);
+        expect(draft.evaluation?.id).toBe('phone-sales-referido');
+        expect((await validate(parse(SimulateRequest, { evaluationId: 'x', inputs: { a: { nested: true } } }))).length).toBeGreaterThan(0);
+        expect((await validate(parse(SimulateRequest, { evaluationId: 'x' }))).length).toBeGreaterThan(0);
+    });
+});

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

@@ -75,9 +75,9 @@ describe('enums de rewardsEligibility (valores que viajan por HTTP)', () => {
     );
     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'],
-    );
+    const codes = Object.values(RewardsEligibilityErrorCodeEnum);
+    expect(codes).toEqual(expect.arrayContaining(['EVENT_TYPE_NOT_FOUND', 'INPUT_INVALID', 'RUN_NOT_FOUND']));
+    expect(codes).toHaveLength(35);
   });
 });
 

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

@@ -0,0 +1,50 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { InputFieldTypeEnum } from '../../../src/dynamicForm/enums/InputFieldTypeEnum';
+import { GenerateRulesRequest } from '../../../src/rewardsEligibility/dtos/backoffice/GenerateRulesRequest';
+
+const parse = async (body: object) => {
+    const value = plainToInstance(GenerateRulesRequest, body, { excludeExtraneousValues: true });
+    return { value, errors: await validate(value) };
+};
+const input = { key: 'buyerDirectoryId', type: InputFieldTypeEnum.DIRECTORY, label: 'Comprador', required: true };
+const turn = (content: string, role = 'user') => ({ role, content });
+const valid = { history: [turn('cuentas de menos de 7 días')], inputs: [input] };
+
+describe('GenerateRulesRequest', () => {
+    it('acepta un chat con reglas actuales y el contrato de entrada', async () => {
+        const { errors, value } = await parse({ ...valid, currentRules: { match: 'ALL', groups: [] } });
+        expect(errors).toEqual([]);
+        expect(value.history[0]?.content).toBe('cuentas de menos de 7 días');
+        expect(value.currentRules).toEqual({ match: 'ALL', groups: [] });
+    });
+
+    it('acepta historial vacío y contrato vacío (el lambda decide con AI_CHAT_HISTORY_EMPTY)', async () => {
+        expect((await parse({ history: [], inputs: [] })).errors).toEqual([]);
+    });
+
+    it('rechaza un rol inventado', async () => {
+        expect((await parse({ ...valid, history: [turn('hola', 'system')] })).errors.length).toBeGreaterThan(0);
+    });
+
+    it('rechaza un turno vacío y uno de más de 4000 caracteres', async () => {
+        expect((await parse({ ...valid, history: [turn('')] })).errors.length).toBeGreaterThan(0);
+        expect((await parse({ ...valid, history: [turn('x'.repeat(4001))] })).errors.length).toBeGreaterThan(0);
+        expect((await parse({ ...valid, history: [turn('x'.repeat(4000))] })).errors).toEqual([]);
+    });
+
+    it('rechaza más de 50 turnos (tope de seguridad del DTO)', async () => {
+        expect((await parse({ ...valid, history: Array.from({ length: 51 }, () => turn('a')) })).errors.length).toBeGreaterThan(0);
+    });
+
+    it('rechaza inputs que no es un arreglo y currentRules que no es un objeto', async () => {
+        expect((await parse({ ...valid, inputs: 'x' })).errors.length).toBeGreaterThan(0);
+        expect((await parse({ ...valid, currentRules: 'x' })).errors.length).toBeGreaterThan(0);
+    });
+
+    it('descarta propiedades que no son del contrato', async () => {
+        const { value } = await parse({ ...valid, hack: true });
+        expect('hack' in value).toBe(false);
+    });
+});

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

@@ -0,0 +1,12 @@
+import type { GenerateRulesResponse } from '../../../src/rewardsEligibility/dtos/backoffice/GenerateRulesResponse';
+
+describe('GenerateRulesResponse (forma pública)', () => {
+    it('las tres salidas posibles del chat se pueden armar con la forma pública', () => {
+        const ready: GenerateRulesResponse = { explanation: 'Cuentas de hasta 7 días.', rules: { match: 'ALL', groups: [] }, valid: true };
+        const question: GenerateRulesResponse = { explanation: '¿A qué grupo te refieres?', valid: true };
+        const failed: GenerateRulesResponse = { explanation: 'No pude.', valid: false, problems: ['rules.groups[0].conditions[0].field: campo desconocido'] };
+        expect(ready.rules).toBeDefined();
+        expect(question.rules).toBeUndefined();
+        expect(failed.problems).toHaveLength(1);
+    });
+});

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

@@ -0,0 +1,17 @@
+import { MetricsDimensionEnum } from '../../../src/rewardsEligibility/enums/MetricsDimensionEnum';
+import type { FailedConditionStatResponse } from '../../../src/rewardsEligibility/dtos/backoffice/FailedConditionStatResponse';
+import type { MetricsPointResponse } from '../../../src/rewardsEligibility/dtos/backoffice/MetricsPointResponse';
+import type { MetricsQuery } from '../../../src/rewardsEligibility/dtos/backoffice/MetricsQuery';
+
+describe('DTOs de métricas (forma)', () => {
+    it('un punto diario trae los 9 contadores del spec 5.7', () => {
+        const point: MetricsPointResponse = { date: '2026-10-08', evaluated: 3, match: 2, noMatch: 1, error: 0, alreadyGranted: 0, quotaExhausted: 0, excluded: 0, requested: 2, requestFailed: 0 };
+        expect(Object.keys(point)).toHaveLength(10);
+    });
+    it('ranking y query', () => {
+        const stat: FailedConditionStatResponse = { key: 'directory.accountAgeDays', label: 'Antigüedad de la cuenta', count: 7 };
+        const query: MetricsQuery = { dimension: MetricsDimensionEnum.CAMPAIGN, value: 'referidos-q4', from: '2026-10-01', to: '2026-10-08' };
+        expect(stat.count).toBe(7);
+        expect(query.dimension).toBe('CAMPAIGN');
+    });
+});

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

@@ -0,0 +1,18 @@
+import { RuleValueTypeEnum } from '../../../src/rewardsEligibility/enums/RuleValueTypeEnum';
+import type { RuleCatalogFieldResponse } from '../../../src/rewardsEligibility/dtos/backoffice/RuleCatalogResponse';
+
+describe('RuleCatalogFieldResponse enriquecido', () => {
+    it('un campo puede traer descripción, frases de ejemplo y descripción por opción', () => {
+        const field: RuleCatalogFieldResponse = {
+            field: 'status', label: 'Estado de la cuenta', valueType: RuleValueTypeEnum.STRING, operators: ['EQUALS'],
+            description: 'Estado operativo del directorio del usuario.',
+            examplePhrases: ['usuarios activos'],
+            options: [{ value: 'ACTIVE', label: 'ACTIVE', description: 'cuenta operativa' }],
+        };
+        expect(field.options?.[0]?.description).toBe('cuenta operativa');
+    });
+    it('sigue siendo válido sin los campos nuevos', () => {
+        const field: RuleCatalogFieldResponse = { field: 'x', label: 'x', valueType: RuleValueTypeEnum.NUMBER, operators: ['GT'] };
+        expect(field.description).toBeUndefined();
+    });
+});

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

@@ -0,0 +1,15 @@
+import { RewardsEligibilityErrorCodeEnum } from '../../../src/rewardsEligibility/enums/RewardsEligibilityErrorCodeEnum';
+import { RulesChatRoleEnum } from '../../../src/rewardsEligibility/enums/RulesChatRoleEnum';
+
+describe('enums de la generación de reglas con IA', () => {
+    it('los roles del chat son user y assistant (los mismos del prompt de benefits)', () => {
+        expect(Object.values(RulesChatRoleEnum)).toEqual(['user', 'assistant']);
+    });
+
+    it.each(['AI_CHAT_HISTORY_EMPTY', 'AI_CHAT_HISTORY_TOO_LONG', 'AI_GENERATION_FAILED', 'AI_RESPONSE_UNPARSEABLE', 'AI_GENERATION_TIMEOUT'] as const)(
+        'el código %s existe y su valor es su nombre',
+        (code) => {
+            expect(RewardsEligibilityErrorCodeEnum[code]).toBe(code);
+        },
+    );
+});

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

@@ -0,0 +1,36 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { ApproveRunRequest } from '../../../src/rewardsEligibility/dtos/backoffice/ApproveRunRequest';
+import { CreateRunRequest } from '../../../src/rewardsEligibility/dtos/backoffice/CreateRunRequest';
+
+const parse = <T extends object>(cls: new () => T, value: object): T => plainToInstance(cls, value, { excludeExtraneousValues: true });
+
+describe('CreateRunRequest', () => {
+    it('un sujeto: requestId, mode e inputs', async () => {
+        const request = parse(CreateRunRequest, { requestId: 'req-12345678', mode: 'LIVE', inputs: { buyerDirectoryId: 'd-1' }, x: 1 });
+        expect(await validate(request)).toEqual([]);
+        expect(request.inputs).toEqual({ buyerDirectoryId: 'd-1' });
+    });
+    it('población: params anidados se conservan', async () => {
+        const request = parse(CreateRunRequest, { requestId: 'req-12345678', mode: 'SIMULATION', population: { params: { window: '7d' } } });
+        expect(await validate(request)).toEqual([]);
+        expect(request.population?.params).toEqual({ window: '7d' });
+    });
+    it.each([
+        ['requestId corto', { requestId: 'a', mode: 'LIVE', inputs: {} }],
+        ['mode desconocido', { requestId: 'req-12345678', mode: 'DRY', inputs: {} }],
+        ['inputs con objeto anidado', { requestId: 'req-12345678', mode: 'LIVE', inputs: { a: { b: { c: 1 } } } }],
+    ])('rechaza: %s', async (_name, value) => {
+        expect((await validate(parse(CreateRunRequest, value))).length).toBeGreaterThan(0);
+    });
+});
+
+describe('ApproveRunRequest', () => {
+    it('excludeSubjectKeys es opcional y acotado', async () => {
+        expect(await validate(parse(ApproveRunRequest, {}))).toEqual([]);
+        expect(await validate(parse(ApproveRunRequest, { excludeSubjectKeys: ['a1b2c3d4e5f60718'] }))).toEqual([]);
+        expect((await validate(parse(ApproveRunRequest, { excludeSubjectKeys: [5] }))).length).toBeGreaterThan(0);
+        expect((await validate(parse(ApproveRunRequest, { excludeSubjectKeys: Array.from({ length: 1001 }, () => 'a1b2c3d4e5f60718') }))).length).toBeGreaterThan(0);
+    });
+});

package/bin/rewardsEligibility/constants/BackofficeLimits.d.ts

@@ -0,0 +1,16 @@
+/** Id de campaña, evaluación (minúsculas, dígitos y guion; 2 a 64; sin `#` ni `:` porque entran en llaves compuestas y en la idempotencyKey). */
+export declare const ELIGIBILITY_ID_PATTERN: RegExp;
+/** `eventKey` de un tipo de evento: MAYÚSCULAS con guion bajo (ej. `PHONE_SALES_CODE_REDEEMED`). */
+export declare const EVENT_KEY_PATTERN: RegExp;
+/** Fecha de vigencia de una campaña (UTC, inclusiva). */
+export declare const DATE_PATTERN: RegExp;
+/** Id de solicitud que genera el backoffice al abrir el formulario de una corrida manual (llave de idempotencia). */
+export declare const REQUEST_ID_PATTERN: RegExp;
+/** Cupos por campaña que caben junto a las reservas de una transacción (100 − 90 − registro del lote). */
+export declare const MAX_QUOTAS_PER_CAMPAIGN = 9;
+/** Tope de `limit` de los listados paginados. */
+export declare const LIST_PAGE_MAX = 100;
+/** Largo máximo del texto de un turno del chat que genera reglas. */
+export declare const RULES_CHAT_TURN_MAX_LENGTH = 4000;
+/** Tope de seguridad de turnos que acepta el DTO (el límite funcional, 10, lo aplica el lambda con `AI_CHAT_HISTORY_TOO_LONG`). */
+export declare const RULES_CHAT_MAX_TURNS_HARD = 50;

package/bin/rewardsEligibility/constants/BackofficeLimits.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULES_CHAT_MAX_TURNS_HARD = exports.RULES_CHAT_TURN_MAX_LENGTH = exports.LIST_PAGE_MAX = exports.MAX_QUOTAS_PER_CAMPAIGN = exports.REQUEST_ID_PATTERN = exports.DATE_PATTERN = exports.EVENT_KEY_PATTERN = exports.ELIGIBILITY_ID_PATTERN = void 0;
+/** Id de campaña, evaluación (minúsculas, dígitos y guion; 2 a 64; sin `#` ni `:` porque entran en llaves compuestas y en la idempotencyKey). */
+exports.ELIGIBILITY_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$/;
+/** `eventKey` de un tipo de evento: MAYÚSCULAS con guion bajo (ej. `PHONE_SALES_CODE_REDEEMED`). */
+exports.EVENT_KEY_PATTERN = /^[A-Z][A-Z0-9_]{2,63}$/;
+/** Fecha de vigencia de una campaña (UTC, inclusiva). */
+exports.DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+/** Id de solicitud que genera el backoffice al abrir el formulario de una corrida manual (llave de idempotencia). */
+exports.REQUEST_ID_PATTERN = /^[A-Za-z0-9_-]{8,64}$/;
+/** Cupos por campaña que caben junto a las reservas de una transacción (100 − 90 − registro del lote). */
+exports.MAX_QUOTAS_PER_CAMPAIGN = 9;
+/** Tope de `limit` de los listados paginados. */
+exports.LIST_PAGE_MAX = 100;
+/** Largo máximo del texto de un turno del chat que genera reglas. */
+exports.RULES_CHAT_TURN_MAX_LENGTH = 4000;
+/** Tope de seguridad de turnos que acepta el DTO (el límite funcional, 10, lo aplica el lambda con `AI_CHAT_HISTORY_TOO_LONG`). */
+exports.RULES_CHAT_MAX_TURNS_HARD = 50;

package/bin/rewardsEligibility/dtos/CampaignAlerts.js

@@ -1,7 +1,27 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CampaignAlerts = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
 /** Umbrales de consumo (0 a 1) que avisan a los operadores (spec B 5.6). */
 class CampaignAlerts {
 }
 exports.CampaignAlerts = CampaignAlerts;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayMaxSize)(5),
+    (0, class_validator_1.IsNumber)({}, { each: true }),
+    (0, class_validator_1.Min)(0.01, { each: true }),
+    (0, class_validator_1.Max)(1, { each: true }),
+    __metadata("design:type", Array)
+], CampaignAlerts.prototype, "thresholds", void 0);

package/bin/rewardsEligibility/dtos/CampaignQuota.d.ts

@@ -1,7 +1,7 @@
 import { QuotaPeriodEnum } from '../enums/QuotaPeriodEnum';
 /** Un cupo de campania: cantidad maxima de premios (no dinero) en un periodo (spec B 5.6). */
 export declare class CampaignQuota {
-    /** Unico dentro de la campania (ej. `primeros-500`). Entra en la llave del consumo (`{id}#{periodo}`). */
+    /** Unico dentro de la campania (ej. `primeros-500`). Entra en la llave del consumo (`{id}#{periodo}`): sin `#`. */
     id: string;
     limit: number;
     period: QuotaPeriodEnum;

package/bin/rewardsEligibility/dtos/CampaignQuota.js

@@ -1,7 +1,36 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CampaignQuota = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const QuotaPeriodEnum_1 = require("../enums/QuotaPeriodEnum");
 /** Un cupo de campania: cantidad maxima de premios (no dinero) en un periodo (spec B 5.6). */
 class CampaignQuota {
 }
 exports.CampaignQuota = CampaignQuota;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.Matches)(/^[a-z0-9][a-z0-9-]{0,62}$/),
+    __metadata("design:type", String)
+], CampaignQuota.prototype, "id", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(1),
+    __metadata("design:type", Number)
+], CampaignQuota.prototype, "limit", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEnum)(QuotaPeriodEnum_1.QuotaPeriodEnum),
+    __metadata("design:type", String)
+], CampaignQuota.prototype, "period", void 0);

package/bin/rewardsEligibility/dtos/backoffice/ApproveRunRequest.d.ts

@@ -0,0 +1,4 @@
+/** `POST /runs/{id}/approve`: aprueba todo salvo los sujetos excluidos (`subjectKey`). */
+export declare class ApproveRunRequest {
+    excludeSubjectKeys?: string[];
+}

package/bin/rewardsEligibility/dtos/backoffice/ApproveRunRequest.js

@@ -0,0 +1,27 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApproveRunRequest = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+/** `POST /runs/{id}/approve`: aprueba todo salvo los sujetos excluidos (`subjectKey`). */
+class ApproveRunRequest {
+}
+exports.ApproveRunRequest = ApproveRunRequest;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayMaxSize)(1000),
+    (0, class_validator_1.IsString)({ each: true }),
+    (0, class_validator_1.Matches)(/^[A-Za-z0-9_-]{8,128}$/, { each: true }),
+    __metadata("design:type", Array)
+], ApproveRunRequest.prototype, "excludeSubjectKeys", void 0);

package/bin/rewardsEligibility/dtos/backoffice/CampaignListResponse.d.ts

@@ -0,0 +1,6 @@
+import { CampaignResponse } from './CampaignResponse';
+export declare class CampaignListResponse {
+    items: CampaignResponse[];
+    /** Cursor opaco de la página siguiente; ausente en la última. */
+    nextCursor?: string;
+}

package/bin/rewardsEligibility/dtos/backoffice/CampaignListResponse.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CampaignListResponse = void 0;
+class CampaignListResponse {
+}
+exports.CampaignListResponse = CampaignListResponse;

package/bin/rewardsEligibility/dtos/backoffice/CampaignRequest.d.ts

@@ -0,0 +1,16 @@
+import { QuotaExhaustedActionEnum } from '../../enums/QuotaExhaustedActionEnum';
+import { CampaignAlerts } from '../CampaignAlerts';
+import { CampaignQuota } from '../CampaignQuota';
+/** Crear (POST) o reemplazar (PUT) una campaña. `status`, `pausedReason` y las fechas de auditoría las pone el servidor (el estado cambia con `POST /campaigns/{id}/status`). */
+export declare class CampaignRequest {
+    id: string;
+    name: string;
+    /** Qué se quiere lograr (texto libre). */
+    objective: string;
+    /** `AAAA-MM-DD` (UTC, inclusiva). */
+    startsAt: string;
+    endsAt: string;
+    quotas: CampaignQuota[];
+    onExhausted: QuotaExhaustedActionEnum;
+    alerts: CampaignAlerts;
+}