@fiado/type-kit 3.529.0 → 3.531.0

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

@@ -6,12 +6,22 @@ describe('barrel rewardsEligibility incluye el backoffice', () => {
         'CampaignRequest', 'CampaignStatusRequest', 'CampaignResponse', 'CampaignListResponse', 'QuotaUsageResponse', 'CampaignSummaryResponse',
         'EventTypeRequest', 'EventTypeResponse', 'EventTypeListResponse', 'EvaluationRequest', 'EvaluationStatusRequest', 'EvaluationResponse',
         'EvaluationListResponse', 'ResultTraceResponse', 'TraceGroupResponse', 'TraceConditionResponse', 'SimulateRequest', 'SimulateResponse',
-        'RuleCatalogResponse', 'RuleCatalogSourceResponse', 'RuleCatalogFieldResponse', 'PopulationSourceResponse', 'InputTypeResponse',
+        'RuleCatalogResponse', 'RuleCatalogSourceResponse', 'RuleCatalogFieldResponse', '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',
+        'SegmentParam', 'SegmentUsedColumn', 'SegmentLastTest', 'SegmentTestRequest', 'SegmentTestResponse', 'SegmentTestResultResponse',
+        'SegmentTestErrorResponse', 'SegmentSaveRequest', 'SegmentStatusRequest', 'SegmentVersionResponse', 'SegmentVersionSummaryResponse',
+        'SegmentListItemResponse', 'SegmentListResponse', 'SegmentVersionListResponse', 'SegmentSchemaResponse', 'SegmentSchemaTableResponse',
+        'SegmentTableSchemaResponse', 'SegmentColumnSchemaResponse', 'SegmentUsedByResponse', 'SegmentUsedByEvaluation', 'SegmentUsedByRun',
+        'PopulationPageMessage', 'EvaluateBatchMessage', 'EvaluateBatchSubject', 'GrantBatchMessage', 'ReleaseTrancheMessage', 'PrivateSegmentResponse',
+        'SegmentExecutionRequest', 'SegmentExecutionResponse', 'SegmentExecutionPageResponse', 'RunPopulationProgress', 'INPUT_KEY_PATTERN',
     ])('exporta %s', (name) => {
         expect((kit as Record<string, object | string | number | RegExp>)[name]).toBeDefined();
     });
+
+    it.each(['PopulationSourceResponse', 'PopulationRef'])('ya no exporta %s (reemplazado por segmentos)', (name) => {
+        expect((kit as Record<string, object | string | number | RegExp>)[name]).toBeUndefined();
+    });
 });

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

@@ -1,7 +1,6 @@
 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)', () => {
@@ -15,13 +14,8 @@ describe('DTOs de catálogos (forma)', () => {
         };
         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'],
-        };
+    it('un tipo de input', () => {
         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

@@ -3,6 +3,7 @@ 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 { EvaluationTrigger } from '../../../src/rewardsEligibility/dtos/EvaluationTrigger';
 import { SimulateRequest } from '../../../src/rewardsEligibility/dtos/backoffice/SimulateRequest';
 
 const parse = <T extends object>(cls: new () => T, value: object): T => plainToInstance(cls, value, { excludeExtraneousValues: true });
@@ -51,3 +52,9 @@ describe('EvaluationStatusRequest / SimulateRequest', () => {
         expect((await validate(parse(SimulateRequest, { evaluationId: 'x' }))).length).toBeGreaterThan(0);
     });
 });
+
+describe('EvaluationTrigger', () => {
+    it('ya no declara `population` (reemplazado por populationSegmentId de la evaluacion)', () => {
+        expect('population' in new EvaluationTrigger()).toBe(false);
+    });
+});

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

@@ -12,10 +12,10 @@ describe('CreateRunRequest', () => {
         expect(await validate(request)).toEqual([]);
         expect(request.inputs).toEqual({ buyerDirectoryId: 'd-1' });
     });
-    it('población: params anidados se conservan', async () => {
+    it('población: sin params (usa el segmento de la evaluación); params enviados se descartan', 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' });
+        expect(request.population && 'params' in request.population).toBe(false);
     });
     it.each([
         ['requestId corto', { requestId: 'a', mode: 'LIVE', inputs: {} }],

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

@@ -0,0 +1,29 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { SegmentSaveRequest, SegmentStatusRequest, SegmentTestRequest } from '../../../src/rewardsEligibility';
+
+const def = { baseTable: 'remittanceusers', match: 'ALL', groups: [{ match: 'ALL', conditions: [{ kind: 'COLUMN', table: 'remittanceusers', column: 'status', op: 'EQUALS', value: 'ACTIVE' }] }] };
+const ok = async <T extends object>(cls: new () => T, plain: object) => (await validate(plainToInstance(cls, plain, { excludeExtraneousValues: true }))).length === 0;
+
+describe('DTOs de segmentos del backoffice', () => {
+    it('SegmentTestRequest exige definition valida', async () => {
+        expect(await ok(SegmentTestRequest, { definition: def })).toBe(true);
+        expect(await ok(SegmentTestRequest, {})).toBe(false);
+        expect(await ok(SegmentTestRequest, { definition: { ...def, baseTable: 'X' } })).toBe(false);
+    });
+    it('SegmentSaveRequest: name, owner, testId y status DRAFT|ACTIVE (nunca ARCHIVED al guardar)', async () => {
+        const base = { name: 'Promotores', description: '', owner: 'growth', definition: def, testId: 't-1', status: 'ACTIVE' };
+        expect(await ok(SegmentSaveRequest, base)).toBe(true);
+        expect(await ok(SegmentSaveRequest, { ...base, status: 'ARCHIVED' })).toBe(false);
+        expect(await ok(SegmentSaveRequest, { ...base, name: '' })).toBe(false);
+        expect(await ok(SegmentSaveRequest, { ...base, testId: undefined })).toBe(false);
+        expect(await ok(SegmentSaveRequest, { ...base, testId: '#TEST#x' })).toBe(false);
+    });
+    it('SegmentStatusRequest: version opcional entera >= 1; status del enum', async () => {
+        expect(await ok(SegmentStatusRequest, { status: 'ARCHIVED' })).toBe(true);
+        expect(await ok(SegmentStatusRequest, { status: 'ACTIVE', version: 2 })).toBe(true);
+        expect(await ok(SegmentStatusRequest, { status: 'ACTIVE', version: 0 })).toBe(false);
+        expect(await ok(SegmentStatusRequest, { status: 'PAUSED' })).toBe(false);
+    });
+});

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

@@ -0,0 +1,46 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { PopulationSegmentDefinition, SegmentAggregateCondition, SegmentColumnCondition } from '../../../src/rewardsEligibility';
+
+interface PlainCondition {
+    kind: string;
+    [key: string]: string | number | object;
+}
+
+const valid = {
+    baseTable: 'remittanceusers', match: 'ALL',
+    groups: [{ match: 'ALL', conditions: [
+        { kind: 'COLUMN', table: 'remittanceusers', column: 'status', op: 'EQUALS', value: 'ACTIVE' },
+        { kind: 'AGGREGATE', table: 'remittancetransactions', fn: 'SUM', column: 'amountusd', op: 'GT', value: 100,
+          window: { dateColumn: 'createdat', days: 30 }, filters: [{ kind: 'COLUMN', table: 'remittancetransactions', column: 'status', op: 'EQUALS', value: 'PAYABLE' }] },
+    ] }],
+};
+const aggregate: PlainCondition = valid.groups[0].conditions[1];
+const errorsOf = async (plain: object): Promise<number> =>
+    (await validate(plainToInstance(PopulationSegmentDefinition, plain, { excludeExtraneousValues: true }))).length;
+
+describe('PopulationSegmentDefinition', () => {
+    it('acepta el ejemplo combinado de A§4.6 y deserializa cada condicion a su clase', async () => {
+        const def = plainToInstance(PopulationSegmentDefinition, valid, { excludeExtraneousValues: true });
+        expect(await validate(def)).toEqual([]);
+        expect(def.groups[0].conditions[0]).toBeInstanceOf(SegmentColumnCondition);
+        expect(def.groups[0].conditions[1]).toBeInstanceOf(SegmentAggregateCondition);
+    });
+    it.each([
+        ['tabla con mayusculas', { ...valid, baseTable: 'Users' }],
+        ['tabla con comilla', { ...valid, baseTable: 'a"b' }],
+        ['sin grupos', { ...valid, groups: [] }],
+        ['match invalido', { ...valid, match: 'XOR' }],
+        ['days 0', { ...valid, groups: [{ match: 'ALL', conditions: [{ ...aggregate, window: { dateColumn: 'createdat', days: 0 } }] }] }],
+        ['days 366', { ...valid, groups: [{ match: 'ALL', conditions: [{ ...aggregate, window: { dateColumn: 'createdat', days: 366 } }] }] }],
+        ['operador desconocido', { ...valid, groups: [{ match: 'ALL', conditions: [{ kind: 'COLUMN', table: 't', column: 'c', op: 'LIKE', value: 'x' }] }] }],
+        ['kind desconocido', { ...valid, groups: [{ match: 'ALL', conditions: [{ kind: 'RAW', sql: 'select 1' }] }] }],
+    ])('rechaza: %s', async (_name, plain) => {
+        expect(await errorsOf(plain)).toBeGreaterThan(0);
+    });
+    it('descarta propiedades extra (nadie cuela un campo "sql")', () => {
+        const def = plainToInstance(PopulationSegmentDefinition, { ...valid, sql: 'DROP TABLE x' }, { excludeExtraneousValues: true });
+        expect(Object.keys(def)).not.toContain('sql');
+    });
+});

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

@@ -0,0 +1,43 @@
+import 'reflect-metadata';
+import * as kit from '../../../src/rewardsEligibility';
+
+const identity = (e: Record<string, string>) => Object.entries(e).every(([k, v]) => k === v);
+
+describe('enums de segmentos', () => {
+    it('cada enum es identidad clave=valor (se persisten y viajan como string)', () => {
+        const enums: Record<string, Record<string, string>> = {
+            SegmentStatusEnum: kit.SegmentStatusEnum,
+            SegmentTestStatusEnum: kit.SegmentTestStatusEnum,
+            SegmentMatchEnum: kit.SegmentMatchEnum,
+            SegmentConditionKindEnum: kit.SegmentConditionKindEnum,
+            SegmentAggregateFnEnum: kit.SegmentAggregateFnEnum,
+            SegmentOperatorEnum: kit.SegmentOperatorEnum,
+            SegmentParamTypeEnum: kit.SegmentParamTypeEnum,
+            SegmentParamSourceEnum: kit.SegmentParamSourceEnum,
+            SegmentErrorCodeEnum: kit.SegmentErrorCodeEnum,
+            EligibilityMessageTypeEnum: kit.EligibilityMessageTypeEnum,
+        };
+        for (const e of Object.values(enums)) {
+            expect(e).toBeDefined();
+            expect(identity(e)).toBe(true);
+        }
+    });
+    it('valores exactos de la adenda (A§3.1, A§4.1, A§4.4, A§7)', () => {
+        expect(Object.values(kit.SegmentStatusEnum)).toEqual(['DRAFT', 'ACTIVE', 'ARCHIVED']);
+        expect(Object.values(kit.SegmentTestStatusEnum)).toEqual(['RUNNING', 'PASSED', 'FAILED']);
+        expect(Object.values(kit.SegmentParamSourceEnum)).toEqual(['LITERAL', 'REFERENCE_AT', 'REFERENCE_AT_MINUS_DAYS']);
+        expect(Object.values(kit.EligibilityMessageTypeEnum)).toEqual(['POPULATION_PAGE', 'EVALUATE_BATCH', 'GRANT_BATCH', 'RELEASE_TRANCHE']);
+        expect(Object.values(kit.SegmentOperatorEnum)).toEqual(expect.arrayContaining(['EQUALS', 'NOT_EQUALS', 'IN', 'NOT_IN', 'IS_NULL', 'IS_NOT_NULL', 'GT', 'GTE', 'LT', 'LTE', 'CONTAINS', 'ANY_IN', 'WITHIN_LAST_DAYS', 'NOT_WITHIN_LAST_DAYS']));
+    });
+    it('GRANT_FAILED no se duplica: sigue siendo de RewardsMessageTypeEnum', () => {
+        expect(Object.values(kit.EligibilityMessageTypeEnum)).not.toContain('GRANT_FAILED');
+    });
+    it('limites', () => {
+        expect(kit.SEGMENT_MAX_DAYS).toBe(365);
+        expect(kit.SEGMENT_MAX_PARAMS).toBe(40);
+        expect(kit.SEGMENT_IDENTIFIER_PATTERN.test('remittance_users')).toBe(true);
+        expect(kit.SEGMENT_IDENTIFIER_PATTERN.test('Users')).toBe(false);
+        expect(kit.SEGMENT_IDENTIFIER_PATTERN.test('a b')).toBe(false);
+        expect(kit.SEGMENT_IDENTIFIER_PATTERN.test('a"b')).toBe(false);
+    });
+});

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

@@ -0,0 +1,52 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import {
+    CreateRunRequest, EligibilityMessageTypeEnum as T, EvaluateBatchMessage, EvaluationRequest, GrantBatchMessage, INPUT_KEY_PATTERN,
+    PopulationPageMessage, PopulationRunRequest, ReleaseTrancheMessage, SegmentExecutionRequest,
+} from '../../../src/rewardsEligibility';
+
+const ok = async <C extends object>(cls: new () => C, plain: object) => (await validate(plainToInstance(cls, plain, { excludeExtraneousValues: true }))).length === 0;
+
+describe('mensajes de la cola de elegibilidad', () => {
+    it('POPULATION_PAGE / GRANT_BATCH / RELEASE_TRANCHE exigen su messageType', async () => {
+        expect(await ok(PopulationPageMessage, { messageType: T.POPULATION_PAGE, runId: 'r-1' })).toBe(true);
+        expect(await ok(PopulationPageMessage, { messageType: T.EVALUATE_BATCH, runId: 'r-1' })).toBe(false);
+        expect(await ok(GrantBatchMessage, { messageType: T.GRANT_BATCH, runId: 'r-1', batchId: 'r-1#p0#b0', part: 0 })).toBe(true);
+        expect(await ok(GrantBatchMessage, { messageType: T.GRANT_BATCH, runId: 'r-1', batchId: 'r-1#p0#b0', part: -1 })).toBe(false);
+        expect(await ok(ReleaseTrancheMessage, { messageType: T.RELEASE_TRANCHE, seq: 3 })).toBe(true);
+        expect(await ok(ReleaseTrancheMessage, { messageType: T.RELEASE_TRANCHE, seq: -1 })).toBe(false);
+    });
+    it('EVALUATE_BATCH: <= 100 sujetos, sin prefetchedFacts', async () => {
+        const subject = { subjectKey: 'd-1', inputs: { directoryId: 'd-1' } };
+        const base = { messageType: T.EVALUATE_BATCH, runId: 'r-1', batchId: 'r-1#p0#b0' };
+        expect(await ok(EvaluateBatchMessage, { ...base, subjects: [subject] })).toBe(true);
+        expect(await ok(EvaluateBatchMessage, { ...base, subjects: [] })).toBe(false);
+        expect(await ok(EvaluateBatchMessage, { ...base, subjects: Array.from({ length: 101 }, () => subject) })).toBe(false);
+        const parsed = plainToInstance(EvaluateBatchMessage, { ...base, subjects: [{ ...subject, prefetchedFacts: { a: 1 } }] }, { excludeExtraneousValues: true });
+        expect('prefetchedFacts' in parsed.subjects[0]).toBe(false);
+    });
+});
+describe('cambios a evaluacion y corrida manual', () => {
+    it('EvaluationRequest acepta populationSegmentId y populationInputKey opcionales', () => {
+        const parsed = plainToInstance(EvaluationRequest, { populationSegmentId: 'promotores', populationInputKey: 'directoryId' }, { excludeExtraneousValues: true });
+        expect(parsed.populationSegmentId).toBe('promotores');
+        expect(parsed.populationInputKey).toBe('directoryId');
+        expect(INPUT_KEY_PATTERN.test('directoryId')).toBe(true);
+        expect(INPUT_KEY_PATTERN.test('1abc')).toBe(false);
+    });
+    it('PopulationRunRequest vacio es valido y descarta params', async () => {
+        expect(plainToInstance(PopulationRunRequest, {}, { excludeExtraneousValues: true })).toBeInstanceOf(PopulationRunRequest);
+        const p = plainToInstance(PopulationRunRequest, { params: { window: '7d' } }, { excludeExtraneousValues: true });
+        expect('params' in p).toBe(false);
+        expect(await ok(CreateRunRequest, { requestId: 'req-12345678', mode: 'LIVE', population: {} })).toBe(true);
+    });
+});
+describe('SegmentExecutionRequest', () => {
+    it('version y referenceAt opcionales y validados', async () => {
+        expect(await ok(SegmentExecutionRequest, {})).toBe(true);
+        expect(await ok(SegmentExecutionRequest, { version: 2, referenceAt: '2026-10-12T10:00:00Z' })).toBe(true);
+        expect(await ok(SegmentExecutionRequest, { version: 0 })).toBe(false);
+        expect(await ok(SegmentExecutionRequest, { referenceAt: 'ayer' })).toBe(false);
+    });
+});

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

@@ -14,3 +14,5 @@ export declare const LIST_PAGE_MAX = 100;
 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;
+/** Llave de un input de una evaluacion (ej. `directoryId`). */
+export declare const INPUT_KEY_PATTERN: RegExp;

package/bin/rewardsEligibility/constants/BackofficeLimits.js

@@ -1,6 +1,6 @@
 "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;
+exports.INPUT_KEY_PATTERN = 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`). */
@@ -17,3 +17,5 @@ exports.LIST_PAGE_MAX = 100;
 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;
+/** Llave de un input de una evaluacion (ej. `directoryId`). */
+exports.INPUT_KEY_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]{0,63}$/;

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

@@ -0,0 +1,5 @@
+/** Identificador SQL permitido para tabla/columna (A§4.3 paso 1): minusculas, digitos y guion bajo; nunca texto libre. */
+export declare const SEGMENT_IDENTIFIER_PATTERN: RegExp;
+export declare const SEGMENT_MAX_DAYS = 365;
+export declare const SEGMENT_MAX_PARAMS = 40;
+export declare const SEGMENT_MAX_AGGREGATES = 8;

package/bin/rewardsEligibility/constants/SegmentLimits.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEGMENT_MAX_AGGREGATES = exports.SEGMENT_MAX_PARAMS = exports.SEGMENT_MAX_DAYS = exports.SEGMENT_IDENTIFIER_PATTERN = void 0;
+/** Identificador SQL permitido para tabla/columna (A§4.3 paso 1): minusculas, digitos y guion bajo; nunca texto libre. */
+exports.SEGMENT_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_]*$/;
+exports.SEGMENT_MAX_DAYS = 365;
+exports.SEGMENT_MAX_PARAMS = 40;
+exports.SEGMENT_MAX_AGGREGATES = 8;

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

@@ -1,6 +1,5 @@
 import { ApprovalModeEnum } from '../enums/ApprovalModeEnum';
 import { TriggerTypeEnum } from '../enums/TriggerTypeEnum';
-import { PopulationRef } from './PopulationRef';
 /** Disparador de una evaluacion (spec B 5.1). Una evaluacion tiene a lo sumo UN disparador `EVENT`. */
 export declare class EvaluationTrigger {
     type: TriggerTypeEnum;
@@ -9,6 +8,4 @@ export declare class EvaluationTrigger {
     eventKey?: string;
     /** Solo `CRON`: cron de 5 campos, granularidad de 15 minutos (fase 4). */
     schedule?: string;
-    /** Solo `CRON` (fase 4). */
-    population?: PopulationRef;
 }

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

@@ -38,8 +38,10 @@ __decorate([
 ], CreateRunRequest.prototype, "inputs", void 0);
 __decorate([
     (0, class_transformer_1.Expose)(),
-    (0, class_validator_1.IsOptional)(),
-    (0, class_validator_1.ValidateNested)(),
+    (0, class_validator_1.IsOptional)()
+    // `PopulationRunRequest` no tiene campos: class-validator rechaza validar anidado una clase sin metadatos, por eso `@IsObject()`.
+    ,
+    (0, class_validator_1.IsObject)(),
     (0, class_transformer_1.Type)(() => PopulationRunRequest_1.PopulationRunRequest),
     __metadata("design:type", PopulationRunRequest_1.PopulationRunRequest)
 ], CreateRunRequest.prototype, "population", void 0);

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

@@ -24,4 +24,8 @@ export declare class EvaluationRequest {
     reward: EvaluationReward;
     grantPolicy: GrantPolicy;
     triggers: EvaluationTrigger[];
+    /** Segmento de poblacion (version ACTIVE) que usan las corridas masivas de esta evaluacion. */
+    populationSegmentId?: string;
+    /** Llave del input `DIRECTORY` que recibe el `directoryid` de cada persona del segmento. */
+    populationInputKey?: string;
 }

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

@@ -84,3 +84,17 @@ __decorate([
     (0, class_validator_1.IsObject)({ each: true }),
     __metadata("design:type", Array)
 ], EvaluationRequest.prototype, "triggers", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.Matches)(BackofficeLimits_1.ELIGIBILITY_ID_PATTERN),
+    __metadata("design:type", String)
+], EvaluationRequest.prototype, "populationSegmentId", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.Matches)(BackofficeLimits_1.INPUT_KEY_PATTERN),
+    __metadata("design:type", String)
+], EvaluationRequest.prototype, "populationInputKey", void 0);

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

@@ -20,6 +20,8 @@ export declare class EvaluationResponse {
     reward: EvaluationReward;
     grantPolicy: GrantPolicy;
     triggers: EvaluationTrigger[];
+    populationSegmentId?: string;
+    populationInputKey?: string;
     createdAt: number;
     updatedAt: number;
     updatedBy: string;

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

@@ -1,5 +1,3 @@
-import { DynamicFormValue } from '../../../dynamicForm/types/DynamicFormValue';
-/** Corrida por población (fase 4): los `params` de la fuente para esta corrida. El lambda de la fase 3 la rechaza con `POPULATION_RUN_NOT_SUPPORTED`. */
+/** Sin override de params (A§7.3): cambiar la poblacion = version nueva del segmento. `population: {}` = "usa el segmento de la evaluacion". */
 export declare class PopulationRunRequest {
-    params: Record<string, DynamicFormValue>;
 }

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

@@ -1,24 +1,7 @@
 "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.PopulationRunRequest = void 0;
-const class_transformer_1 = require("class-transformer");
-const class_validator_1 = require("class-validator");
-const IsDynamicFormValues_1 = require("../../../dynamicForm/validators/IsDynamicFormValues");
-/** Corrida por población (fase 4): los `params` de la fuente para esta corrida. El lambda de la fase 3 la rechaza con `POPULATION_RUN_NOT_SUPPORTED`. */
+/** Sin override de params (A§7.3): cambiar la poblacion = version nueva del segmento. `population: {}` = "usa el segmento de la evaluacion". */
 class PopulationRunRequest {
 }
 exports.PopulationRunRequest = PopulationRunRequest;
-__decorate([
-    (0, class_transformer_1.Expose)(),
-    (0, class_validator_1.Validate)(IsDynamicFormValues_1.IsDynamicFormValues),
-    __metadata("design:type", Object)
-], PopulationRunRequest.prototype, "params", void 0);

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

@@ -0,0 +1,9 @@
+/** Avance de la corrida masiva: paginas, lotes y sujetos publicados. */
+export declare class RunPopulationProgress {
+    pagesPublished: number;
+    batchesPublished: number;
+    subjectsPublished: number;
+    exhausted: boolean;
+    stoppedReason?: string;
+    lastAdvanceAt: number;
+}

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunPopulationProgress = void 0;
+/** Avance de la corrida masiva: paginas, lotes y sujetos publicados. */
+class RunPopulationProgress {
+}
+exports.RunPopulationProgress = RunPopulationProgress;

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

@@ -4,6 +4,7 @@ import { RunStatusEnum } from '../../enums/RunStatusEnum';
 import { TriggerTypeEnum } from '../../enums/TriggerTypeEnum';
 import { RunCounts } from '../RunCounts';
 import { QuotaImpactResponse } from './QuotaImpactResponse';
+import { RunPopulationProgress } from './RunPopulationProgress';
 /** Corrida para el backoffice (spec 10). */
 export declare class RunResponse {
     id: string;
@@ -18,6 +19,24 @@ export declare class RunResponse {
     counts: RunCounts;
     /** Solo con `status: AWAITING_APPROVAL`: cuánto consumiría la corrida de cada cupo y cuánto queda. */
     quotaImpact?: QuotaImpactResponse[];
+    /** Corrida masiva: instante fijo (epoch ms) contra el que se resuelven las ventanas relativas del segmento. */
+    referenceAt?: number;
+    /** Corrida masiva: version del segmento congelada. */
+    segment?: {
+        segmentId: string;
+        version: number;
+    };
+    population?: RunPopulationProgress;
+    /** Fallos de entrega (`GRANT_FAILED`) que llegaron tarde, con la corrida ya cerrada. */
+    requestFailedLate?: number;
+    /** Motivo de una corrida `FAILED` que nunca llego a tener `population`. */
+    failureReason?: string;
+    /** Avance del drenaje de una aprobacion masiva. */
+    approvalDrain?: {
+        action: 'GRANT' | 'RELEASE' | 'CANCEL';
+        enqueued: number;
+        done: boolean;
+    };
     requestedBy: string;
     createdAt: number;
     updatedAt: number;

package/bin/rewardsEligibility/dtos/backoffice/segments/PopulationSegmentDefinition.d.ts

@@ -0,0 +1,8 @@
+import { SegmentMatchEnum } from '../../../enums/SegmentMatchEnum';
+import { SegmentGroup } from './SegmentGroup';
+/** El constructor tal cual (A§4.1): tabla ancla (una fila -> un directoryid), TODAS/ALGUNA global y grupos con su propio TODAS/ALGUNA. */
+export declare class PopulationSegmentDefinition {
+    baseTable: string;
+    match: SegmentMatchEnum;
+    groups: SegmentGroup[];
+}

package/bin/rewardsEligibility/dtos/backoffice/segments/PopulationSegmentDefinition.js

@@ -0,0 +1,40 @@
+"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.PopulationSegmentDefinition = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const SegmentLimits_1 = require("../../../constants/SegmentLimits");
+const SegmentMatchEnum_1 = require("../../../enums/SegmentMatchEnum");
+const SegmentGroup_1 = require("./SegmentGroup");
+/** El constructor tal cual (A§4.1): tabla ancla (una fila -> un directoryid), TODAS/ALGUNA global y grupos con su propio TODAS/ALGUNA. */
+class PopulationSegmentDefinition {
+}
+exports.PopulationSegmentDefinition = PopulationSegmentDefinition;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Matches)(SegmentLimits_1.SEGMENT_IDENTIFIER_PATTERN),
+    __metadata("design:type", String)
+], PopulationSegmentDefinition.prototype, "baseTable", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEnum)(SegmentMatchEnum_1.SegmentMatchEnum),
+    __metadata("design:type", String)
+], PopulationSegmentDefinition.prototype, "match", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayMinSize)(1),
+    (0, class_validator_1.ArrayMaxSize)(10),
+    (0, class_validator_1.ValidateNested)({ each: true }),
+    (0, class_transformer_1.Type)(() => SegmentGroup_1.SegmentGroup),
+    __metadata("design:type", Array)
+], PopulationSegmentDefinition.prototype, "groups", void 0);

package/bin/rewardsEligibility/dtos/backoffice/segments/PrivateSegmentResponse.d.ts

@@ -0,0 +1,11 @@
+import { PopulationSegmentDefinition } from './PopulationSegmentDefinition';
+import { SegmentParam } from './SegmentParam';
+/** Version de un segmento tal como la consumen otros servicios (con el SQL compilado). */
+export declare class PrivateSegmentResponse {
+    segmentId: string;
+    version: number;
+    name: string;
+    definition: PopulationSegmentDefinition;
+    sql: string;
+    params: SegmentParam[];
+}

package/bin/rewardsEligibility/dtos/backoffice/segments/PrivateSegmentResponse.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateSegmentResponse = void 0;
+/** Version de un segmento tal como la consumen otros servicios (con el SQL compilado). */
+class PrivateSegmentResponse {
+}
+exports.PrivateSegmentResponse = PrivateSegmentResponse;

package/bin/rewardsEligibility/dtos/backoffice/segments/SegmentAggregateCondition.d.ts

@@ -0,0 +1,18 @@
+import { SegmentAggregateFnEnum } from '../../../enums/SegmentAggregateFnEnum';
+import { SegmentConditionKindEnum } from '../../../enums/SegmentConditionKindEnum';
+import { SegmentOperatorEnum } from '../../../enums/SegmentOperatorEnum';
+import { SegmentColumnCondition } from './SegmentColumnCondition';
+import { SegmentWindow } from './SegmentWindow';
+/** (b) Agregado con ventana relativa sobre una tabla relacionada (existe / cuenta / suma). `filters` elige QUE cuenta (estados, moneda...). */
+export declare class SegmentAggregateCondition {
+    kind: SegmentConditionKindEnum.AGGREGATE;
+    table: string;
+    fn: SegmentAggregateFnEnum;
+    /** Solo SUM. */
+    column?: string;
+    /** COUNT y SUM; EXISTS no lleva. */
+    op?: SegmentOperatorEnum;
+    value?: number;
+    window: SegmentWindow;
+    filters: SegmentColumnCondition[];
+}

package/bin/rewardsEligibility/dtos/backoffice/segments/SegmentAggregateCondition.js

@@ -0,0 +1,71 @@
+"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.SegmentAggregateCondition = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const SegmentLimits_1 = require("../../../constants/SegmentLimits");
+const SegmentAggregateFnEnum_1 = require("../../../enums/SegmentAggregateFnEnum");
+const SegmentConditionKindEnum_1 = require("../../../enums/SegmentConditionKindEnum");
+const SegmentOperatorEnum_1 = require("../../../enums/SegmentOperatorEnum");
+const SegmentColumnCondition_1 = require("./SegmentColumnCondition");
+const SegmentWindow_1 = require("./SegmentWindow");
+/** (b) Agregado con ventana relativa sobre una tabla relacionada (existe / cuenta / suma). `filters` elige QUE cuenta (estados, moneda...). */
+class SegmentAggregateCondition {
+}
+exports.SegmentAggregateCondition = SegmentAggregateCondition;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Equals)(SegmentConditionKindEnum_1.SegmentConditionKindEnum.AGGREGATE),
+    __metadata("design:type", String)
+], SegmentAggregateCondition.prototype, "kind", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Matches)(SegmentLimits_1.SEGMENT_IDENTIFIER_PATTERN),
+    __metadata("design:type", String)
+], SegmentAggregateCondition.prototype, "table", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEnum)(SegmentAggregateFnEnum_1.SegmentAggregateFnEnum),
+    __metadata("design:type", String)
+], SegmentAggregateCondition.prototype, "fn", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.Matches)(SegmentLimits_1.SEGMENT_IDENTIFIER_PATTERN),
+    __metadata("design:type", String)
+], SegmentAggregateCondition.prototype, "column", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsEnum)(SegmentOperatorEnum_1.SegmentOperatorEnum),
+    __metadata("design:type", String)
+], SegmentAggregateCondition.prototype, "op", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsNumber)(),
+    __metadata("design:type", Number)
+], SegmentAggregateCondition.prototype, "value", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.ValidateNested)(),
+    (0, class_transformer_1.Type)(() => SegmentWindow_1.SegmentWindow),
+    __metadata("design:type", SegmentWindow_1.SegmentWindow)
+], SegmentAggregateCondition.prototype, "window", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayMaxSize)(10),
+    (0, class_validator_1.ValidateNested)({ each: true }),
+    (0, class_transformer_1.Type)(() => SegmentColumnCondition_1.SegmentColumnCondition),
+    __metadata("design:type", Array)
+], SegmentAggregateCondition.prototype, "filters", void 0);