@fiado/type-kit 3.528.0 → 3.530.0

package/_test_/unit/emailVerification/dtos/EmailSetTrustedRequest.test.ts

@@ -50,4 +50,20 @@ describe('EmailSetTrustedRequest', () => {
         const errors = await validate(dto);
         expect(errors.some(e => e.property === 'type')).toBe(true);
     });
+
+    it('acepta isPrincipal en true', async () => {
+        const dto = plainToInstance(EmailSetTrustedRequest, { ...valid, isPrincipal: true });
+        const errors = await validate(dto);
+        expect(errors).toEqual([]);
+        expect(dto.isPrincipal).toBe(true);
+    });
+
+    it('falla si isPrincipal no es booleano', async () => {
+        const dto = plainToInstance(EmailSetTrustedRequest, {
+            ...valid,
+            isPrincipal: 'si' as unknown as boolean,
+        });
+        const errors = await validate(dto);
+        expect(errors.some(e => e.property === 'isPrincipal')).toBe(true);
+    });
 });

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

@@ -0,0 +1,53 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validateSync } from 'class-validator';
+import { SendEmailOtpRequest } from '../../../src/retailWizard/dtos/requests/SendEmailOtpRequest';
+import { VerifyEmailOtpRequest } from '../../../src/retailWizard/dtos/requests/VerifyEmailOtpRequest';
+import { EmailStateEnum } from '../../../src/retailWizard/enums/EmailStateEnum';
+import { EmailTypeEnum } from '../../../src/emailVerification/enums/EmailTypeEnum';
+import * as RetailWizard from '../../../src/retailWizard';
+
+function errorsOf<T extends object>(cls: new () => T, payload: Record<string, unknown>): string[] {
+  const dto = plainToInstance(cls, payload, { excludeExtraneousValues: true });
+  return validateSync(dto).map((e) => e.property);
+}
+
+describe('SendEmailOtpRequest', () => {
+  it('acepta correo y tipo válidos', () => {
+    expect(errorsOf(SendEmailOtpRequest, { email: 'cliente@correo.com', type: EmailTypeEnum.PERSONAL })).toEqual([]);
+  });
+
+  it('rechaza un correo mal formado', () => {
+    expect(errorsOf(SendEmailOtpRequest, { email: 'no-es-correo', type: EmailTypeEnum.PERSONAL })).toContain('email');
+  });
+
+  it('rechaza un tipo fuera del enum', () => {
+    expect(errorsOf(SendEmailOtpRequest, { email: 'cliente@correo.com', type: 'WORK' })).toContain('type');
+  });
+
+  it('exige el tipo', () => {
+    expect(errorsOf(SendEmailOtpRequest, { email: 'cliente@correo.com' })).toContain('type');
+  });
+});
+
+describe('VerifyEmailOtpRequest', () => {
+  it('acepta un código de 4 dígitos', () => {
+    expect(errorsOf(VerifyEmailOtpRequest, { code: '1234' })).toEqual([]);
+  });
+
+  it('rechaza un código vacío', () => {
+    expect(errorsOf(VerifyEmailOtpRequest, { code: '' })).toContain('code');
+  });
+});
+
+describe('EmailStateEnum', () => {
+  it('tiene los tres estados del correo de la sesión', () => {
+    expect(Object.values(EmailStateEnum)).toEqual(['EXISTING', 'CAPTURED', 'PENDING']);
+  });
+
+  it('se exporta desde el índice de retailWizard junto con los requests', () => {
+    expect(RetailWizard.EmailStateEnum).toBe(EmailStateEnum);
+    expect(RetailWizard.SendEmailOtpRequest).toBe(SendEmailOtpRequest);
+    expect(RetailWizard.VerifyEmailOtpRequest).toBe(VerifyEmailOtpRequest);
+  });
+});

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

@@ -0,0 +1,22 @@
+import type { WizardSession } from '../../../src/retailWizard/dtos/WizardSession';
+import { EmailStateEnum } from '../../../src/retailWizard/enums/EmailStateEnum';
+import { EmailTypeEnum } from '../../../src/emailVerification/enums/EmailTypeEnum';
+
+type SessionEmail = Pick<WizardSession, 'emailState' | 'emailType' | 'emailMasked' | 'email'>;
+
+describe('WizardSession — correo del paso 01', () => {
+  it('declara los cuatro campos del correo', () => {
+    const captured: SessionEmail = {
+      emailState: EmailStateEnum.CAPTURED,
+      emailType: EmailTypeEnum.PERSONAL,
+      emailMasked: 'ju•••••@gmail.com',
+      email: 'juan@gmail.com',
+    };
+    expect(captured.emailState).toBe('CAPTURED');
+  });
+
+  it('los cuatro son opcionales: una sesión vieja no los trae', () => {
+    const legacy: SessionEmail = {};
+    expect(legacy).toEqual({});
+  });
+});

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

@@ -11,6 +11,12 @@ describe('barrel rewardsEligibility incluye el backoffice', () => {
         '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();
     });

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/emailVerification/dtos/EmailSetTrustedRequest.d.ts

@@ -7,4 +7,6 @@ export declare class EmailSetTrustedRequest {
     directoryId: string;
     email: string;
     type: EmailTypeEnum;
+    /** En true, el correo queda como principal del directorio. Sin el campo, no cambia el principal. */
+    isPrincipal?: boolean;
 }

package/bin/emailVerification/dtos/EmailSetTrustedRequest.js

@@ -35,3 +35,9 @@ __decorate([
     (0, class_validator_1.IsEnum)(EmailTypeEnum_1.EmailTypeEnum),
     __metadata("design:type", String)
 ], EmailSetTrustedRequest.prototype, "type", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], EmailSetTrustedRequest.prototype, "isPrincipal", void 0);

package/bin/retailWizard/dtos/WizardSession.d.ts

@@ -15,6 +15,8 @@ import type { WizardReservedLine } from './WizardReservedLine';
 import type { WizardResumeTarget } from './WizardResumeTarget';
 import type { WizardWelcome } from './WizardWelcome';
 import type { WizardCreditPromotionBonus } from './WizardCreditPromotionBonus';
+import type { EmailStateEnum } from '../enums/EmailStateEnum';
+import type { EmailTypeEnum } from '../../emailVerification/enums/EmailTypeEnum';
 /** Modalidad de captura del KYC (M1 §213-329). */
 export type KycModality = 'CUSTOMER_LINK' | 'STORE_DEVICE' | 'MANUAL';
 /** Estado de la apertura de cuenta async (D35) — espejo de `RetailCustomer.accountStatus`. */
@@ -64,6 +66,14 @@ export interface WizardSession {
      */
     resumeTarget?: WizardResumeTarget | null;
     consents: WizardConsents | null;
+    /** Estado del correo del cliente en el paso 01. Ausente en sesiones anteriores al correo. */
+    emailState?: EmailStateEnum;
+    /** Tipo del correo: personal o corporativo. */
+    emailType?: EmailTypeEnum;
+    /** Correo enmascarado (`ju•••••@gmail.com`); viaja siempre que la sesión tenga correo. */
+    emailMasked?: string;
+    /** Correo completo: solo con `emailState` CAPTURED, porque lo tecleó el vendedor. */
+    email?: string;
     /** Espejo del estado KYC (fuente = customer). */
     kycStatus: string | null;
     kycModality: KycModality | null;

package/bin/retailWizard/dtos/requests/SendEmailOtpRequest.d.ts

@@ -0,0 +1,6 @@
+import { EmailTypeEnum } from '../../../emailVerification/enums/EmailTypeEnum';
+/** POST /wizard/sessions/:id/email/otp/send — manda el código al correo que capturó el vendedor. */
+export declare class SendEmailOtpRequest {
+    email: string;
+    type: EmailTypeEnum;
+}

package/bin/retailWizard/dtos/requests/SendEmailOtpRequest.js

@@ -0,0 +1,29 @@
+"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.SendEmailOtpRequest = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const EmailTypeEnum_1 = require("../../../emailVerification/enums/EmailTypeEnum");
+/** POST /wizard/sessions/:id/email/otp/send — manda el código al correo que capturó el vendedor. */
+class SendEmailOtpRequest {
+}
+exports.SendEmailOtpRequest = SendEmailOtpRequest;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEmail)(),
+    __metadata("design:type", String)
+], SendEmailOtpRequest.prototype, "email", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEnum)(EmailTypeEnum_1.EmailTypeEnum),
+    __metadata("design:type", String)
+], SendEmailOtpRequest.prototype, "type", void 0);

package/bin/retailWizard/dtos/requests/VerifyEmailOtpRequest.d.ts

@@ -0,0 +1,4 @@
+/** POST /wizard/sessions/:id/email/otp/verify — verifica el código que llegó al correo. */
+export declare class VerifyEmailOtpRequest {
+    code: string;
+}

package/bin/retailWizard/dtos/requests/VerifyEmailOtpRequest.js

@@ -0,0 +1,24 @@
+"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.VerifyEmailOtpRequest = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+/** POST /wizard/sessions/:id/email/otp/verify — verifica el código que llegó al correo. */
+class VerifyEmailOtpRequest {
+}
+exports.VerifyEmailOtpRequest = VerifyEmailOtpRequest;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.Length)(4, 8),
+    __metadata("design:type", String)
+], VerifyEmailOtpRequest.prototype, "code", void 0);

package/bin/retailWizard/enums/EmailStateEnum.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Correo de la sesión del wizard: EXISTING = ya verificado en contacts; CAPTURED = lo tecleó el
+ * vendedor y se verificó con OTP; PENDING = falta capturarlo o verificarlo.
+ */
+export declare enum EmailStateEnum {
+    EXISTING = "EXISTING",
+    CAPTURED = "CAPTURED",
+    PENDING = "PENDING"
+}

package/bin/retailWizard/enums/EmailStateEnum.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailStateEnum = void 0;
+/**
+ * Correo de la sesión del wizard: EXISTING = ya verificado en contacts; CAPTURED = lo tecleó el
+ * vendedor y se verificó con OTP; PENDING = falta capturarlo o verificarlo.
+ */
+var EmailStateEnum;
+(function (EmailStateEnum) {
+    EmailStateEnum["EXISTING"] = "EXISTING";
+    EmailStateEnum["CAPTURED"] = "CAPTURED";
+    EmailStateEnum["PENDING"] = "PENDING";
+})(EmailStateEnum || (exports.EmailStateEnum = EmailStateEnum = {}));

package/bin/retailWizard/index.d.ts

@@ -26,6 +26,7 @@ export * from './enums/BlockedCategoryEnum';
 export * from './enums/WizardLineStatusEnum';
 export * from './enums/LinePaymentTypeEnum';
 export * from './enums/WizardLineRoleEnum';
+export * from './enums/EmailStateEnum';
 export * from './dtos/WizardConsents';
 export * from './dtos/WizardPayment';
 export * from './dtos/WizardProduct';
@@ -90,6 +91,8 @@ export * from './dtos/requests/SignatureSignRequest';
 export * from './dtos/requests/RegisterDeviceRequest';
 export * from './dtos/requests/CompleteSaleRequest';
 export * from './dtos/requests/SuggestIdentifiersQuery';
+export * from './dtos/requests/SendEmailOtpRequest';
+export * from './dtos/requests/VerifyEmailOtpRequest';
 export * from './dtos/responses/KycPrepareResponse';
 export * from './dtos/responses/ProofOfAddressPrepareResponse';
 export * from './dtos/responses/SessionFinanciersResponse';

package/bin/retailWizard/index.js

@@ -45,6 +45,7 @@ __exportStar(require("./enums/BlockedCategoryEnum"), exports);
 __exportStar(require("./enums/WizardLineStatusEnum"), exports);
 __exportStar(require("./enums/LinePaymentTypeEnum"), exports);
 __exportStar(require("./enums/WizardLineRoleEnum"), exports);
+__exportStar(require("./enums/EmailStateEnum"), exports);
 // DTOs anidados
 __exportStar(require("./dtos/WizardConsents"), exports);
 __exportStar(require("./dtos/WizardPayment"), exports);
@@ -115,6 +116,8 @@ __exportStar(require("./dtos/requests/SignatureSignRequest"), exports);
 __exportStar(require("./dtos/requests/RegisterDeviceRequest"), exports);
 __exportStar(require("./dtos/requests/CompleteSaleRequest"), exports);
 __exportStar(require("./dtos/requests/SuggestIdentifiersQuery"), exports);
+__exportStar(require("./dtos/requests/SendEmailOtpRequest"), exports);
+__exportStar(require("./dtos/requests/VerifyEmailOtpRequest"), exports);
 // Response DTOs (output tipado por endpoint)
 __exportStar(require("./dtos/responses/KycPrepareResponse"), exports);
 __exportStar(require("./dtos/responses/ProofOfAddressPrepareResponse"), exports);

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/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;
+}