@fiado/type-kit 3.515.0 → 3.517.0

package/_test_/unit/group/groupOwnerFields.test.ts

@@ -0,0 +1,32 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { GroupCreateRequest, GroupResponse, GroupStatus } from '../../../src/group';
+
+const base = { id: 'TAXMA', name: 'Taxma', status: GroupStatus.ACTIVE };
+
+describe('GroupCreateRequest.ownerDirectoryId', () => {
+    it('es opcional (la carga masiva por CSV no lo manda)', async () => {
+        expect(await validate(plainToInstance(GroupCreateRequest, base))).toEqual([]);
+    });
+    it('acepta un uuid v4', async () => {
+        const dto = plainToInstance(GroupCreateRequest, { ...base, ownerDirectoryId: 'b298ec6b-00b6-487b-b096-f4ac6ac8c91d' });
+        expect(await validate(dto)).toEqual([]);
+    });
+    it('rechaza lo que no es uuid v4', async () => {
+        const errors = await validate(plainToInstance(GroupCreateRequest, { ...base, ownerDirectoryId: 'no-es-uuid' }));
+        expect(errors[0].property).toBe('ownerDirectoryId');
+        expect(errors[0].constraints?.isUuid).toBeDefined();
+    });
+});
+
+describe('GroupResponse.owner', () => {
+    it('admite owner o null', () => {
+        const withOwner: Partial<GroupResponse> = {
+            owner: { agentId: 'AG-1', directoryId: 'DIR-1', name: null, email: null, status: 'ACTIVE' },
+        };
+        const withoutOwner: Partial<GroupResponse> = { owner: null };
+        expect(withOwner.owner?.agentId).toBe('AG-1');
+        expect(withoutOwner.owner).toBeNull();
+    });
+});

package/_test_/unit/referral-business/groupOwnersByGroupIdsDtos.test.ts

@@ -0,0 +1,46 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import {
+    GroupOwnersByGroupIdsRequest,
+    GROUP_OWNERS_BY_GROUP_IDS_MAX_BATCH,
+} from '../../../src/referral-business';
+import type { GroupOwnerItem, GroupOwnersByGroupIdsResponse } from '../../../src/referral-business';
+
+describe('GroupOwnersByGroupIdsRequest', () => {
+    it('el tope del lote es 100', () => {
+        expect(GROUP_OWNERS_BY_GROUP_IDS_MAX_BATCH).toBe(100);
+    });
+    it('acepta una lista de groupIds', async () => {
+        const dto = plainToInstance(GroupOwnersByGroupIdsRequest, { groupIds: ['FIADO', 'TAXMA'] });
+        expect(await validate(dto)).toEqual([]);
+    });
+    it('acepta la lista vacía', async () => {
+        const dto = plainToInstance(GroupOwnersByGroupIdsRequest, { groupIds: [] });
+        expect(await validate(dto)).toEqual([]);
+    });
+    it('rechaza 101 ids con arrayMaxSize', async () => {
+        const ids = Array.from({ length: 101 }, (_, i) => `G${i}`);
+        const errors = await validate(plainToInstance(GroupOwnersByGroupIdsRequest, { groupIds: ids }));
+        expect(errors[0].property).toBe('groupIds');
+        expect(errors[0].constraints?.arrayMaxSize).toBeDefined();
+    });
+    it('rechaza si groupIds no es arreglo', async () => {
+        const errors = await validate(plainToInstance(GroupOwnersByGroupIdsRequest, { groupIds: 'FIADO' }));
+        expect(errors[0].constraints?.isArray).toBeDefined();
+    });
+    it('rechaza elementos que no son string', async () => {
+        const errors = await validate(plainToInstance(GroupOwnersByGroupIdsRequest, { groupIds: [1] }));
+        expect(errors[0].constraints?.isString).toBeDefined();
+    });
+});
+
+describe('GroupOwnersByGroupIdsResponse', () => {
+    it('es un mapa groupId → GroupOwnerItem', () => {
+        const owner: GroupOwnerItem = {
+            agentId: 'AG-1', directoryId: 'DIR-1', name: 'MARIA DAVALOS', email: 'm@taxma.com', status: 'ACTIVE',
+        };
+        const res: GroupOwnersByGroupIdsResponse = { TAXMA: owner };
+        expect(res.TAXMA.directoryId).toBe('DIR-1');
+    });
+});

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

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

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

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

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

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

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

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

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

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

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

@@ -75,9 +75,9 @@ describe('enums de rewardsEligibility (valores que viajan por HTTP)', () => {
     );
     expect(Object.values(RunModeEnum).sort()).toEqual(['LIVE', 'SIMULATION']);
     expect(Object.values(TriggerTypeEnum).sort()).toEqual(['CRON', 'EVENT', 'MANUAL']);
-    expect(Object.values(RewardsEligibilityErrorCodeEnum).sort()).toEqual(
-      ['EVENT_TYPE_NOT_FOUND', 'INPUT_INVALID', 'RUN_NOT_FOUND'],
-    );
+    const codes = Object.values(RewardsEligibilityErrorCodeEnum);
+    expect(codes).toEqual(expect.arrayContaining(['EVENT_TYPE_NOT_FOUND', 'INPUT_INVALID', 'RUN_NOT_FOUND']));
+    expect(codes).toHaveLength(30);
   });
 });
 

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

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

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

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

package/bin/group/dtos/GroupCreateRequest.d.ts

@@ -5,6 +5,7 @@ export declare class GroupCreateRequest {
     description: string;
     leaderEmail?: string | null;
     leaderDirectoryId?: string | null;
+    ownerDirectoryId?: string;
     status: GroupStatus;
     codeToRefer?: Array<string>;
     uniqueMainDirectory?: string;

package/bin/group/dtos/GroupCreateRequest.js

@@ -44,6 +44,11 @@ __decorate([
     (0, class_transformer_1.Transform)(({ value }) => value ?? null),
     __metadata("design:type", String)
 ], GroupCreateRequest.prototype, "leaderDirectoryId", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsUUID)('4'),
+    __metadata("design:type", String)
+], GroupCreateRequest.prototype, "ownerDirectoryId", void 0);
 __decorate([
     (0, class_validator_1.IsEnum)(GroupStatus_1.GroupStatus),
     __metadata("design:type", String)

package/bin/group/dtos/GroupResponse.d.ts

@@ -1,4 +1,5 @@
 import { GroupStatus } from "../enums/GroupStatus";
+import type { GroupOwnerItem } from "../../referral-business/dtos/GroupOwnersByGroupIdsResponse";
 export declare class GroupResponse {
     id: string;
     name: string;
@@ -15,4 +16,5 @@ export declare class GroupResponse {
     imageUrl?: string | null;
     imageUrlSigned?: string | null;
     parentGroupId: string;
+    owner?: GroupOwnerItem | null;
 }

package/bin/referral-business/dtos/GroupOwnersByGroupIdsRequest.d.ts

@@ -0,0 +1,4 @@
+export declare const GROUP_OWNERS_BY_GROUP_IDS_MAX_BATCH = 100;
+export declare class GroupOwnersByGroupIdsRequest {
+    groupIds: string[];
+}

package/bin/referral-business/dtos/GroupOwnersByGroupIdsRequest.js

@@ -0,0 +1,25 @@
+"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.GroupOwnersByGroupIdsRequest = exports.GROUP_OWNERS_BY_GROUP_IDS_MAX_BATCH = void 0;
+const class_validator_1 = require("class-validator");
+// Tope de groupIds por request del endpoint batch de owners de grupo.
+exports.GROUP_OWNERS_BY_GROUP_IDS_MAX_BATCH = 100;
+// Body de POST /private/agents/owners/by-group-ids; la lista vacía es válida y responde {}.
+class GroupOwnersByGroupIdsRequest {
+}
+exports.GroupOwnersByGroupIdsRequest = GroupOwnersByGroupIdsRequest;
+__decorate([
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayMaxSize)(exports.GROUP_OWNERS_BY_GROUP_IDS_MAX_BATCH),
+    (0, class_validator_1.IsString)({ each: true }),
+    __metadata("design:type", Array)
+], GroupOwnersByGroupIdsRequest.prototype, "groupIds", void 0);

package/bin/referral-business/dtos/GroupOwnersByGroupIdsResponse.d.ts

@@ -0,0 +1,8 @@
+export interface GroupOwnerItem {
+    agentId: string;
+    directoryId: string;
+    name: string | null;
+    email: string | null;
+    status: string;
+}
+export type GroupOwnersByGroupIdsResponse = Record<string, GroupOwnerItem>;

package/bin/referral-business/dtos/GroupOwnersByGroupIdsResponse.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/bin/referral-business/index.d.ts

@@ -1,3 +1,5 @@
 export * from './enums/AgentRoleEnum';
 export * from './dtos/AgentsByDirectoryIdsRequest';
 export * from './dtos/AgentsByDirectoryIdsResponse';
+export * from './dtos/GroupOwnersByGroupIdsRequest';
+export * from './dtos/GroupOwnersByGroupIdsResponse';

package/bin/referral-business/index.js

@@ -19,3 +19,5 @@ __exportStar(require("./enums/AgentRoleEnum"), exports);
 //dtos
 __exportStar(require("./dtos/AgentsByDirectoryIdsRequest"), exports);
 __exportStar(require("./dtos/AgentsByDirectoryIdsResponse"), exports);
+__exportStar(require("./dtos/GroupOwnersByGroupIdsRequest"), exports);
+__exportStar(require("./dtos/GroupOwnersByGroupIdsResponse"), exports);

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

@@ -0,0 +1,12 @@
+/** Id de campaña, evaluación (minúsculas, dígitos y guion; 2 a 64; sin `#` ni `:` porque entran en llaves compuestas y en la idempotencyKey). */
+export declare const ELIGIBILITY_ID_PATTERN: RegExp;
+/** `eventKey` de un tipo de evento: MAYÚSCULAS con guion bajo (ej. `PHONE_SALES_CODE_REDEEMED`). */
+export declare const EVENT_KEY_PATTERN: RegExp;
+/** Fecha de vigencia de una campaña (UTC, inclusiva). */
+export declare const DATE_PATTERN: RegExp;
+/** Id de solicitud que genera el backoffice al abrir el formulario de una corrida manual (llave de idempotencia). */
+export declare const REQUEST_ID_PATTERN: RegExp;
+/** Cupos por campaña que caben junto a las reservas de una transacción (100 − 90 − registro del lote). */
+export declare const MAX_QUOTAS_PER_CAMPAIGN = 9;
+/** Tope de `limit` de los listados paginados. */
+export declare const LIST_PAGE_MAX = 100;

package/bin/rewardsEligibility/constants/BackofficeLimits.js

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

package/bin/rewardsEligibility/dtos/CampaignAlerts.js

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

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

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

package/bin/rewardsEligibility/dtos/CampaignQuota.js

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

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

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

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

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

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

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

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

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

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

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