@fiado/type-kit 3.529.0 → 3.531.0

package/src/rewardsEligibility/dtos/backoffice/CreateRunRequest.ts

@@ -1,5 +1,5 @@
 import { Expose, Type } from 'class-transformer';
-import { IsEnum, IsOptional, Matches, Validate, ValidateNested } from 'class-validator';
+import { IsEnum, IsObject, IsOptional, Matches, Validate } from 'class-validator';
 import { DynamicFormValue } from '../../../dynamicForm/types/DynamicFormValue';
 import { IsDynamicFormValues } from '../../../dynamicForm/validators/IsDynamicFormValues';
 import { REQUEST_ID_PATTERN } from '../../constants/BackofficeLimits';
@@ -24,7 +24,8 @@ export class CreateRunRequest {
 
     @Expose()
     @IsOptional()
-    @ValidateNested()
+    // `PopulationRunRequest` no tiene campos: class-validator rechaza validar anidado una clase sin metadatos, por eso `@IsObject()`.
+    @IsObject()
     @Type(() => PopulationRunRequest)
     population?: PopulationRunRequest;
 }

package/src/rewardsEligibility/dtos/backoffice/EvaluationRequest.ts

@@ -1,8 +1,8 @@
 import { Expose } from 'class-transformer';
-import { ArrayMaxSize, ArrayMinSize, IsArray, IsNotEmpty, IsObject, IsString, Matches, MaxLength } from 'class-validator';
+import { ArrayMaxSize, ArrayMinSize, IsArray, IsNotEmpty, IsObject, IsOptional, IsString, Matches, MaxLength } from 'class-validator';
 import { JsonValue } from '../../../common';
 import { InputField } from '../../../dynamicForm/dtos/InputField';
-import { ELIGIBILITY_ID_PATTERN } from '../../constants/BackofficeLimits';
+import { ELIGIBILITY_ID_PATTERN, INPUT_KEY_PATTERN } from '../../constants/BackofficeLimits';
 import { EvaluationReward } from '../EvaluationReward';
 import { EvaluationTrigger } from '../EvaluationTrigger';
 import { GrantPolicy } from '../GrantPolicy';
@@ -66,4 +66,18 @@ export class EvaluationRequest {
     @ArrayMaxSize(10)
     @IsObject({ each: true })
     triggers: EvaluationTrigger[];
+
+    /** Segmento de poblacion (version ACTIVE) que usan las corridas masivas de esta evaluacion. */
+    @Expose()
+    @IsOptional()
+    @IsString()
+    @Matches(ELIGIBILITY_ID_PATTERN)
+    populationSegmentId?: string;
+
+    /** Llave del input `DIRECTORY` que recibe el `directoryid` de cada persona del segmento. */
+    @Expose()
+    @IsOptional()
+    @IsString()
+    @Matches(INPUT_KEY_PATTERN)
+    populationInputKey?: string;
 }

package/src/rewardsEligibility/dtos/backoffice/EvaluationResponse.ts

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

package/src/rewardsEligibility/dtos/backoffice/PopulationRunRequest.ts

@@ -1,11 +1,2 @@
-import { Expose } from 'class-transformer';
-import { Validate } from 'class-validator';
-import { DynamicFormValue } from '../../../dynamicForm/types/DynamicFormValue';
-import { IsDynamicFormValues } from '../../../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`. */
-export class PopulationRunRequest {
-    @Expose()
-    @Validate(IsDynamicFormValues)
-    params: Record<string, DynamicFormValue>;
-}
+/** Sin override de params (A§7.3): cambiar la poblacion = version nueva del segmento. `population: {}` = "usa el segmento de la evaluacion". */
+export class PopulationRunRequest {}

package/src/rewardsEligibility/dtos/backoffice/RunPopulationProgress.ts

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

package/src/rewardsEligibility/dtos/backoffice/RunResponse.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 class RunResponse {
@@ -19,6 +20,17 @@ export 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/src/rewardsEligibility/dtos/backoffice/segments/PopulationSegmentDefinition.ts

@@ -0,0 +1,12 @@
+import { Expose, Type } from 'class-transformer';
+import { ArrayMaxSize, ArrayMinSize, IsArray, IsEnum, Matches, ValidateNested } from 'class-validator';
+import { SEGMENT_IDENTIFIER_PATTERN } from '../../../constants/SegmentLimits';
+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 class PopulationSegmentDefinition {
+    @Expose() @Matches(SEGMENT_IDENTIFIER_PATTERN) baseTable: string;
+    @Expose() @IsEnum(SegmentMatchEnum) match: SegmentMatchEnum;
+    @Expose() @IsArray() @ArrayMinSize(1) @ArrayMaxSize(10) @ValidateNested({ each: true }) @Type(() => SegmentGroup) groups: SegmentGroup[];
+}

package/src/rewardsEligibility/dtos/backoffice/segments/PrivateSegmentResponse.ts

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

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentAggregateCondition.ts

@@ -0,0 +1,22 @@
+import { Expose, Type } from 'class-transformer';
+import { ArrayMaxSize, Equals, IsArray, IsEnum, IsNumber, IsOptional, Matches, ValidateNested } from 'class-validator';
+import { SEGMENT_IDENTIFIER_PATTERN } from '../../../constants/SegmentLimits';
+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 class SegmentAggregateCondition {
+    @Expose() @Equals(SegmentConditionKindEnum.AGGREGATE) kind: SegmentConditionKindEnum.AGGREGATE;
+    @Expose() @Matches(SEGMENT_IDENTIFIER_PATTERN) table: string;
+    @Expose() @IsEnum(SegmentAggregateFnEnum) fn: SegmentAggregateFnEnum;
+    /** Solo SUM. */
+    @Expose() @IsOptional() @Matches(SEGMENT_IDENTIFIER_PATTERN) column?: string;
+    /** COUNT y SUM; EXISTS no lleva. */
+    @Expose() @IsOptional() @IsEnum(SegmentOperatorEnum) op?: SegmentOperatorEnum;
+    @Expose() @IsOptional() @IsNumber() value?: number;
+    @Expose() @ValidateNested() @Type(() => SegmentWindow) window: SegmentWindow;
+    @Expose() @IsArray() @ArrayMaxSize(10) @ValidateNested({ each: true }) @Type(() => SegmentColumnCondition) filters: SegmentColumnCondition[];
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentColumnCondition.ts

@@ -0,0 +1,15 @@
+import { Expose } from 'class-transformer';
+import { Equals, IsEnum, IsOptional, Matches } from 'class-validator';
+import { JsonValue } from '../../../../common';
+import { SEGMENT_IDENTIFIER_PATTERN } from '../../../constants/SegmentLimits';
+import { SegmentConditionKindEnum } from '../../../enums/SegmentConditionKindEnum';
+import { SegmentOperatorEnum } from '../../../enums/SegmentOperatorEnum';
+
+/** (a) Columna de una tabla unida por `directoryid`. El tipo de `value` (escalar, lista o `{days}`) lo valida el compilador contra el tipo de Glue. */
+export class SegmentColumnCondition {
+    @Expose() @Equals(SegmentConditionKindEnum.COLUMN) kind: SegmentConditionKindEnum.COLUMN;
+    @Expose() @Matches(SEGMENT_IDENTIFIER_PATTERN) table: string;
+    @Expose() @Matches(SEGMENT_IDENTIFIER_PATTERN) column: string;
+    @Expose() @IsEnum(SegmentOperatorEnum) op: SegmentOperatorEnum;
+    @Expose() @IsOptional() value?: JsonValue;
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentExecutionPageResponse.ts

@@ -0,0 +1,8 @@
+export class SegmentExecutionPageResponse {
+    executionId: string;
+    status: string;
+    /** Hasta 1000 `directoryid`. */
+    ids: string[];
+    nextToken?: string;
+    reason?: string;
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentExecutionRequest.ts

@@ -0,0 +1,17 @@
+import { Expose } from 'class-transformer';
+import { IsInt, IsISO8601, IsOptional, Min } from 'class-validator';
+
+/** Ejecucion de un segmento desde otro servicio (endpoint privado). */
+export class SegmentExecutionRequest {
+    @Expose()
+    @IsOptional()
+    @IsInt()
+    @Min(1)
+    version?: number;
+
+    /** ISO-8601 UTC; por defecto, ahora. Fija la ventana relativa del segmento. */
+    @Expose()
+    @IsOptional()
+    @IsISO8601({ strict: true })
+    referenceAt?: string;
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentExecutionResponse.ts

@@ -0,0 +1,7 @@
+export class SegmentExecutionResponse {
+    executionId: string;
+    segmentId: string;
+    version: number;
+    referenceAt: string;
+    status: string;
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentGroup.ts

@@ -0,0 +1,27 @@
+import { Expose, Type } from 'class-transformer';
+import { ArrayMaxSize, ArrayMinSize, IsArray, IsEnum, ValidateNested } from 'class-validator';
+import { SegmentConditionKindEnum } from '../../../enums/SegmentConditionKindEnum';
+import { SegmentMatchEnum } from '../../../enums/SegmentMatchEnum';
+import { SegmentAggregateCondition } from './SegmentAggregateCondition';
+import { SegmentColumnCondition } from './SegmentColumnCondition';
+
+export type SegmentCondition = SegmentColumnCondition | SegmentAggregateCondition;
+
+export class SegmentGroup {
+    @Expose() @IsEnum(SegmentMatchEnum) match: SegmentMatchEnum;
+
+    /** `kind` decide la clase; un `kind` desconocido NO se instancia y la validacion lo rechaza (el objeto queda sin `@Equals` valido). */
+    @Expose()
+    @IsArray() @ArrayMinSize(1) @ArrayMaxSize(20) @ValidateNested({ each: true })
+    @Type(() => Object, {
+        keepDiscriminatorProperty: true,
+        discriminator: {
+            property: 'kind',
+            subTypes: [
+                { value: SegmentColumnCondition, name: SegmentConditionKindEnum.COLUMN },
+                { value: SegmentAggregateCondition, name: SegmentConditionKindEnum.AGGREGATE },
+            ],
+        },
+    })
+    conditions: SegmentCondition[];
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentLastTest.ts

@@ -0,0 +1,8 @@
+export class SegmentLastTest {
+    testedAt: string;
+    count: number;
+    bytesScanned: number;
+    durationMs: number;
+    referenceAt: string;
+    queryExecutionId: string;
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentListResponse.ts

@@ -0,0 +1,11 @@
+import { SegmentVersionResponse } from './SegmentVersionResponse';
+
+export class SegmentListItemResponse extends SegmentVersionResponse {
+    /** Evaluaciones de rewards que lo usan (los consumidores externos del endpoint privado NO cuentan). */
+    usedByCount: number;
+}
+
+export class SegmentListResponse {
+    items: SegmentListItemResponse[];
+    nextCursor?: string;
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentParam.ts

@@ -0,0 +1,11 @@
+import { SegmentParamSourceEnum } from '../../../enums/SegmentParamSourceEnum';
+import { SegmentParamTypeEnum } from '../../../enums/SegmentParamTypeEnum';
+
+/** Un `?` del SQL, en orden. LITERAL lleva `value` como texto canonico; REFERENCE_AT_MINUS_DAYS lleva `days`. */
+export class SegmentParam {
+    name: string;
+    type: SegmentParamTypeEnum;
+    source: SegmentParamSourceEnum;
+    value?: string;
+    days?: number;
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentSaveRequest.ts

@@ -0,0 +1,16 @@
+import { Expose, Type } from 'class-transformer';
+import { IsDefined, IsIn, IsNotEmpty, IsString, Matches, MaxLength, ValidateNested } from 'class-validator';
+import { SegmentStatusEnum } from '../../../enums/SegmentStatusEnum';
+import { PopulationSegmentDefinition } from './PopulationSegmentDefinition';
+
+/** POST /population-segments y PUT /population-segments/{segmentId}. */
+export class SegmentSaveRequest {
+    @Expose() @IsString() @IsNotEmpty() @MaxLength(160) name: string;
+    @Expose() @IsString() @MaxLength(500) description: string;
+    /** Responsable del segmento (usuario o equipo, texto). */
+    @Expose() @IsString() @IsNotEmpty() @MaxLength(120) owner: string;
+    @Expose() @IsDefined() @ValidateNested() @Type(() => PopulationSegmentDefinition) definition: PopulationSegmentDefinition;
+    /** `testId` de `POST /population-segments/test`: el servidor exige que sea PASSED, vigente y de ESTA definicion. */
+    @Expose() @IsString() @Matches(/^[A-Za-z0-9-]{1,64}$/) testId: string;
+    @Expose() @IsIn([SegmentStatusEnum.DRAFT, SegmentStatusEnum.ACTIVE]) status: SegmentStatusEnum.DRAFT | SegmentStatusEnum.ACTIVE;
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentSchemaResponse.ts

@@ -0,0 +1,11 @@
+export class SegmentSchemaTableResponse {
+    table: string;
+    joinKey: string;
+    columnCount: number;
+}
+
+/** `available: false` = ambiente sin datalake accesible: el constructor muestra "no disponible". */
+export class SegmentSchemaResponse {
+    available: boolean;
+    tables: SegmentSchemaTableResponse[];
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentStatusRequest.ts

@@ -0,0 +1,9 @@
+import { Expose } from 'class-transformer';
+import { IsEnum, IsInt, IsOptional, Min } from 'class-validator';
+import { SegmentStatusEnum } from '../../../enums/SegmentStatusEnum';
+
+/** POST /population-segments/{segmentId}/status: activar un DRAFT (con `version`) o archivar el segmento completo. */
+export class SegmentStatusRequest {
+    @Expose() @IsOptional() @IsInt() @Min(1) version?: number;
+    @Expose() @IsEnum(SegmentStatusEnum) status: SegmentStatusEnum;
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentTableSchemaResponse.ts

@@ -0,0 +1,14 @@
+import { SegmentOperatorEnum } from '../../../enums/SegmentOperatorEnum';
+
+export class SegmentColumnSchemaResponse {
+    name: string;
+    type: string;
+    isDate: boolean;
+    operators: SegmentOperatorEnum[];
+}
+
+export class SegmentTableSchemaResponse {
+    table: string;
+    joinKey: string;
+    columns: SegmentColumnSchemaResponse[];
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentTestRequest.ts

@@ -0,0 +1,7 @@
+import { Expose, Type } from 'class-transformer';
+import { IsDefined, ValidateNested } from 'class-validator';
+import { PopulationSegmentDefinition } from './PopulationSegmentDefinition';
+
+export class SegmentTestRequest {
+    @Expose() @IsDefined() @ValidateNested() @Type(() => PopulationSegmentDefinition) definition: PopulationSegmentDefinition;
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentTestResponse.ts

@@ -0,0 +1,29 @@
+import { SegmentErrorCodeEnum } from '../../../enums/SegmentErrorCodeEnum';
+import { SegmentTestStatusEnum } from '../../../enums/SegmentTestStatusEnum';
+import { SegmentParam } from './SegmentParam';
+
+export class SegmentTestResultResponse {
+    count: number;
+    /** Ids parciales (`a41f...09c2`), hasta 20. */
+    sampleIds: string[];
+    bytesScanned: number;
+    durationMs: number;
+}
+
+export class SegmentTestErrorResponse {
+    code: SegmentErrorCodeEnum;
+    message: string;
+}
+
+export class SegmentTestResponse {
+    testId: string;
+    status: SegmentTestStatusEnum;
+    referenceAt: string;
+    /** Resumen en lenguaje normal generado de forma determinista (sin IA). */
+    humanSummary: string;
+    /** SQL de solo lectura + params separados (la UI no deja editarlos). */
+    sql: string;
+    params: SegmentParam[];
+    result?: SegmentTestResultResponse;
+    errors?: SegmentTestErrorResponse[];
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentUsedByResponse.ts

@@ -0,0 +1,24 @@
+import { EvaluationStatusEnum } from '../../../enums/EvaluationStatusEnum';
+import { RunStatusEnum } from '../../../enums/RunStatusEnum';
+import { TriggerTypeEnum } from '../../../enums/TriggerTypeEnum';
+
+export class SegmentUsedByEvaluation {
+    id: string;
+    name: string;
+    campaignId: string;
+    status: EvaluationStatusEnum;
+    triggers: TriggerTypeEnum[];
+}
+
+export class SegmentUsedByRun {
+    runId: string;
+    evaluationId: string;
+    segmentVersion: number;
+    status: RunStatusEnum;
+    createdAt: number;
+}
+
+export class SegmentUsedByResponse {
+    evaluations: SegmentUsedByEvaluation[];
+    runs: SegmentUsedByRun[];
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentUsedColumn.ts

@@ -0,0 +1,5 @@
+export class SegmentUsedColumn {
+    table: string;
+    column: string;
+    type: string;
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentVersionListResponse.ts

@@ -0,0 +1,5 @@
+import { SegmentVersionSummaryResponse } from './SegmentVersionSummaryResponse';
+
+export class SegmentVersionListResponse {
+    items: SegmentVersionSummaryResponse[];
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentVersionResponse.ts

@@ -0,0 +1,25 @@
+import { SegmentStatusEnum } from '../../../enums/SegmentStatusEnum';
+import { PopulationSegmentDefinition } from './PopulationSegmentDefinition';
+import { SegmentLastTest } from './SegmentLastTest';
+import { SegmentParam } from './SegmentParam';
+import { SegmentUsedColumn } from './SegmentUsedColumn';
+
+export class SegmentVersionResponse {
+    segmentId: string;
+    version: number;
+    name: string;
+    description: string;
+    owner: string;
+    status: SegmentStatusEnum;
+    definition: PopulationSegmentDefinition;
+    definitionHash: string;
+    sql: string;
+    params: SegmentParam[];
+    usedColumns: SegmentUsedColumn[];
+    humanSummary: string;
+    lastTest?: SegmentLastTest;
+    createdBy: string;
+    createdAt: string;
+    updatedBy: string;
+    updatedAt: string;
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentVersionSummaryResponse.ts

@@ -0,0 +1,13 @@
+import { SegmentStatusEnum } from '../../../enums/SegmentStatusEnum';
+import { SegmentLastTest } from './SegmentLastTest';
+
+/** Igual que SegmentVersionResponse sin definition/sql/params/usedColumns/humanSummary. */
+export class SegmentVersionSummaryResponse {
+    segmentId: string;
+    version: number;
+    status: SegmentStatusEnum;
+    lastTest?: SegmentLastTest;
+    createdBy: string;
+    createdAt: string;
+    updatedAt: string;
+}

package/src/rewardsEligibility/dtos/backoffice/segments/SegmentWindow.ts

@@ -0,0 +1,9 @@
+import { Expose } from 'class-transformer';
+import { IsInt, Matches, Max, Min } from 'class-validator';
+import { SEGMENT_IDENTIFIER_PATTERN, SEGMENT_MAX_DAYS } from '../../../constants/SegmentLimits';
+
+/** Ventana relativa [referenceAt - days, referenceAt) sobre una columna de fecha (A§4.1). */
+export class SegmentWindow {
+    @Expose() @Matches(SEGMENT_IDENTIFIER_PATTERN) dateColumn: string;
+    @Expose() @IsInt() @Min(1) @Max(SEGMENT_MAX_DAYS) days: number;
+}

package/src/rewardsEligibility/dtos/messages/EvaluateBatchMessage.ts

@@ -0,0 +1,42 @@
+import { Expose, Type } from 'class-transformer';
+import { ArrayMaxSize, ArrayMinSize, Equals, IsArray, IsNotEmpty, IsString, Validate, ValidateNested } from 'class-validator';
+import { DynamicFormValue } from '../../../dynamicForm/types/DynamicFormValue';
+import { IsDynamicFormValues } from '../../../dynamicForm/validators/IsDynamicFormValues';
+import { EligibilityMessageTypeEnum } from '../../enums/EligibilityMessageTypeEnum';
+
+/** Un sujeto del lote. No lleva hechos precargados: la evaluacion siempre es en vivo. */
+export class EvaluateBatchSubject {
+    @Expose()
+    @IsString()
+    @IsNotEmpty()
+    subjectKey: string;
+
+    @Expose()
+    @Validate(IsDynamicFormValues)
+    inputs: Record<string, DynamicFormValue>;
+}
+
+/** Lote de hasta 100 sujetos a evaluar en una corrida masiva. */
+export class EvaluateBatchMessage {
+    @Expose()
+    @Equals(EligibilityMessageTypeEnum.EVALUATE_BATCH)
+    messageType: EligibilityMessageTypeEnum.EVALUATE_BATCH;
+
+    @Expose()
+    @IsString()
+    @IsNotEmpty()
+    runId: string;
+
+    @Expose()
+    @IsString()
+    @IsNotEmpty()
+    batchId: string;
+
+    @Expose()
+    @IsArray()
+    @ArrayMinSize(1)
+    @ArrayMaxSize(100)
+    @ValidateNested({ each: true })
+    @Type(() => EvaluateBatchSubject)
+    subjects: EvaluateBatchSubject[];
+}

package/src/rewardsEligibility/dtos/messages/GrantBatchMessage.ts

@@ -0,0 +1,25 @@
+import { Expose } from 'class-transformer';
+import { Equals, IsInt, IsNotEmpty, IsString, Min } from 'class-validator';
+import { EligibilityMessageTypeEnum } from '../../enums/EligibilityMessageTypeEnum';
+
+/** Publica las entregas (grants) de una parte de un lote de la corrida masiva. */
+export class GrantBatchMessage {
+    @Expose()
+    @Equals(EligibilityMessageTypeEnum.GRANT_BATCH)
+    messageType: EligibilityMessageTypeEnum.GRANT_BATCH;
+
+    @Expose()
+    @IsString()
+    @IsNotEmpty()
+    runId: string;
+
+    @Expose()
+    @IsString()
+    @IsNotEmpty()
+    batchId: string;
+
+    @Expose()
+    @IsInt()
+    @Min(0)
+    part: number;
+}

package/src/rewardsEligibility/dtos/messages/PopulationPageMessage.ts

@@ -0,0 +1,15 @@
+import { Expose } from 'class-transformer';
+import { Equals, IsNotEmpty, IsString } from 'class-validator';
+import { EligibilityMessageTypeEnum } from '../../enums/EligibilityMessageTypeEnum';
+
+/** Pide la siguiente pagina de ids del segmento de una corrida masiva. */
+export class PopulationPageMessage {
+    @Expose()
+    @Equals(EligibilityMessageTypeEnum.POPULATION_PAGE)
+    messageType: EligibilityMessageTypeEnum.POPULATION_PAGE;
+
+    @Expose()
+    @IsString()
+    @IsNotEmpty()
+    runId: string;
+}

package/src/rewardsEligibility/dtos/messages/ReleaseTrancheMessage.ts

@@ -0,0 +1,15 @@
+import { Expose } from 'class-transformer';
+import { Equals, IsInt, Min } from 'class-validator';
+import { EligibilityMessageTypeEnum } from '../../enums/EligibilityMessageTypeEnum';
+
+/** Libera el tramo `seq` de la publicacion por tramos (RELEASER). */
+export class ReleaseTrancheMessage {
+    @Expose()
+    @Equals(EligibilityMessageTypeEnum.RELEASE_TRANCHE)
+    messageType: EligibilityMessageTypeEnum.RELEASE_TRANCHE;
+
+    @Expose()
+    @IsInt()
+    @Min(0)
+    seq: number;
+}

package/src/rewardsEligibility/enums/EligibilityMessageTypeEnum.ts

@@ -0,0 +1,7 @@
+// GRANT_FAILED sigue en RewardsMessageTypeEnum del dominio rewards.
+export enum EligibilityMessageTypeEnum {
+    POPULATION_PAGE = 'POPULATION_PAGE',
+    EVALUATE_BATCH = 'EVALUATE_BATCH',
+    GRANT_BATCH = 'GRANT_BATCH',
+    RELEASE_TRANCHE = 'RELEASE_TRANCHE',
+}

package/src/rewardsEligibility/enums/SegmentAggregateFnEnum.ts

@@ -0,0 +1,5 @@
+export enum SegmentAggregateFnEnum {
+    EXISTS = 'EXISTS',
+    COUNT = 'COUNT',
+    SUM = 'SUM',
+}

package/src/rewardsEligibility/enums/SegmentConditionKindEnum.ts

@@ -0,0 +1,4 @@
+export enum SegmentConditionKindEnum {
+    COLUMN = 'COLUMN',
+    AGGREGATE = 'AGGREGATE',
+}

package/src/rewardsEligibility/enums/SegmentErrorCodeEnum.ts

@@ -0,0 +1,16 @@
+export enum SegmentErrorCodeEnum {
+    SEGMENT_NOT_FOUND = 'SEGMENT_NOT_FOUND',
+    SEGMENT_INVALID = 'SEGMENT_INVALID',
+    SEGMENT_TEST_REQUIRED = 'SEGMENT_TEST_REQUIRED',
+    SEGMENT_IN_USE = 'SEGMENT_IN_USE',
+    SEGMENT_NOT_ACTIVE = 'SEGMENT_NOT_ACTIVE',
+    SEGMENT_BLOCKED_COLUMN = 'SEGMENT_BLOCKED_COLUMN',
+    SEGMENT_SCHEMA_DRIFT = 'SEGMENT_SCHEMA_DRIFT',
+    SEGMENT_BYTES_EXCEEDED = 'SEGMENT_BYTES_EXCEEDED',
+    SEGMENT_QUERY_FAILED = 'SEGMENT_QUERY_FAILED',
+    SEGMENT_DATALAKE_UNAVAILABLE = 'SEGMENT_DATALAKE_UNAVAILABLE',
+    SEGMENT_DATALAKE_UNAVAILABLE_IN_ENV = 'SEGMENT_DATALAKE_UNAVAILABLE_IN_ENV',
+    SEGMENT_VERSION_CONFLICT = 'SEGMENT_VERSION_CONFLICT',
+    SEGMENT_STATUS_TRANSITION_INVALID = 'SEGMENT_STATUS_TRANSITION_INVALID',
+    SEGMENT_EXECUTION_NOT_FOUND = 'SEGMENT_EXECUTION_NOT_FOUND',
+}

package/src/rewardsEligibility/enums/SegmentMatchEnum.ts

@@ -0,0 +1,4 @@
+export enum SegmentMatchEnum {
+    ALL = 'ALL',
+    ANY = 'ANY',
+}

package/src/rewardsEligibility/enums/SegmentOperatorEnum.ts

@@ -0,0 +1,16 @@
+export enum SegmentOperatorEnum {
+    EQUALS = 'EQUALS',
+    NOT_EQUALS = 'NOT_EQUALS',
+    IN = 'IN',
+    NOT_IN = 'NOT_IN',
+    IS_NULL = 'IS_NULL',
+    IS_NOT_NULL = 'IS_NOT_NULL',
+    GT = 'GT',
+    GTE = 'GTE',
+    LT = 'LT',
+    LTE = 'LTE',
+    CONTAINS = 'CONTAINS',
+    ANY_IN = 'ANY_IN',
+    WITHIN_LAST_DAYS = 'WITHIN_LAST_DAYS',
+    NOT_WITHIN_LAST_DAYS = 'NOT_WITHIN_LAST_DAYS',
+}

package/src/rewardsEligibility/enums/SegmentParamSourceEnum.ts

@@ -0,0 +1,5 @@
+export enum SegmentParamSourceEnum {
+    LITERAL = 'LITERAL',
+    REFERENCE_AT = 'REFERENCE_AT',
+    REFERENCE_AT_MINUS_DAYS = 'REFERENCE_AT_MINUS_DAYS',
+}