@fiado/type-kit 3.613.0 → 3.615.0

package/_test_/unit/loanCredit/dtos/originateLoanCreditRequest.test.ts

@@ -62,4 +62,13 @@ describe('OriginateLoanCreditRequest', () => {
         const bad = await validateWhitelisted({ ...BASE, productCategory: 'CAR', productTier: 'ULTRA' });
         expect(bad.errors.map((error) => error.property).sort()).toEqual(['productCategory', 'productTier']);
     });
+
+    it('acepta la cadena opcional y rechaza la cadena vacía', async () => {
+        const ok = await validateWhitelisted({ ...BASE, retailerId: 'RT-1' });
+        expect(ok.errors).toEqual([]);
+        expect(ok.dto.retailerId).toBe('RT-1');
+
+        const bad = await validateWhitelisted({ ...BASE, retailerId: '' });
+        expect(bad.errors.map((error) => error.property)).toEqual(['retailerId']);
+    });
 });

package/_test_/unit/loanCredit/segmentFactsDtos.test.ts

@@ -0,0 +1,80 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import {
+    SegmentFactsBatchRequest,
+    SegmentFactsBatchResponse,
+    SegmentFactsPageRequest,
+    SegmentFactsPageResponse,
+} from '../../../src/loanCredit/index';
+import { CreditPlanLevelEnum, CustomerSegmentFacts } from '../../../src/loanOfferings/index';
+
+type Ctor<T> = new () => T;
+
+const errorProperties = async <T extends object>(cls: Ctor<T>, raw: Record<string, unknown>): Promise<string[]> =>
+    (await validate(plainToInstance(cls, raw, { excludeExtraneousValues: true }))).map((error) => error.property);
+
+describe('SegmentFactsBatchRequest', () => {
+    it('acepta de 1 a 100 ids', async () => {
+        expect(await errorProperties(SegmentFactsBatchRequest, { retailCustomerIds: ['RC-1'] })).toEqual([]);
+        const hundred = Array.from({ length: 100 }, (_, i) => `RC-${i}`);
+        expect(await errorProperties(SegmentFactsBatchRequest, { retailCustomerIds: hundred })).toEqual([]);
+    });
+
+    it('rechaza el lote vacío, el de más de 100 y los ids que no son texto', async () => {
+        expect(await errorProperties(SegmentFactsBatchRequest, { retailCustomerIds: [] })).toEqual(['retailCustomerIds']);
+        const tooMany = Array.from({ length: 101 }, (_, i) => `RC-${i}`);
+        expect(await errorProperties(SegmentFactsBatchRequest, { retailCustomerIds: tooMany })).toEqual(['retailCustomerIds']);
+        expect(await errorProperties(SegmentFactsBatchRequest, { retailCustomerIds: [1] })).toEqual(['retailCustomerIds']);
+        expect(await errorProperties(SegmentFactsBatchRequest, {})).toEqual(['retailCustomerIds']);
+    });
+
+    it('rechaza ids vacíos', async () => {
+        expect(await errorProperties(SegmentFactsBatchRequest, { retailCustomerIds: ['RC-1', ''] })).toEqual(['retailCustomerIds']);
+    });
+});
+
+describe('SegmentFactsPageRequest', () => {
+    it('la primera página va sin cursor ni límite', async () => {
+        expect(await errorProperties(SegmentFactsPageRequest, {})).toEqual([]);
+    });
+
+    it('acepta cursor y un límite entre 1 y 100', async () => {
+        expect(await errorProperties(SegmentFactsPageRequest, { cursor: 'abc', limit: 100 })).toEqual([]);
+        expect(await errorProperties(SegmentFactsPageRequest, { limit: 0 })).toEqual(['limit']);
+        expect(await errorProperties(SegmentFactsPageRequest, { limit: 101 })).toEqual(['limit']);
+        expect(await errorProperties(SegmentFactsPageRequest, { limit: 2.5 })).toEqual(['limit']);
+        expect(await errorProperties(SegmentFactsPageRequest, { limit: '50' })).toEqual(['limit']);
+    });
+});
+
+describe('Responses de segment-facts', () => {
+    it('los datos del acreditado sirven directo como datos del cliente para segmentar', () => {
+        const batch: SegmentFactsBatchResponse = {
+            items: [
+                {
+                    retailCustomerId: 'RC-1',
+                    borrowerId: null,
+                    facts: {
+                        totalCredits: 0,
+                        activeCredits: 0,
+                        completedCredits: 0,
+                        lifetimeWriteOffs: 0,
+                        currentArrearsDays: 0,
+                        delinquencyDaysLast6M: 0,
+                        lifetimeRestructures: 0,
+                    },
+                },
+            ],
+        };
+        const page: SegmentFactsPageResponse = {
+            items: [{ ...batch.items[0], borrowerId: 'BRW-1', facts: { ...batch.items[0].facts, sciLevel: CreditPlanLevelEnum.GOLD } }],
+            nextCursor: null,
+        };
+        const facts: CustomerSegmentFacts = page.items[0].facts;
+
+        expect(facts.sciLevel).toBe(CreditPlanLevelEnum.GOLD);
+        expect(batch.items[0].facts.sciLevel).toBeUndefined();
+        expect(page.nextCursor).toBeNull();
+    });
+});

package/_test_/unit/loanOfferings/promotionRetailerScope.test.ts

@@ -0,0 +1,79 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import {
+    CreatePromotionRequest,
+    ListPromotedSkusRequest,
+    ListSkuPromotionsRequest,
+    PROMOTION_RETAILER_IDS_MAX_ITEMS,
+    SimulateCreditPlanRequest,
+    UpdatePromotionRequest,
+} from '../../../src/loanOfferings/index';
+import type { PromotionResponse } from '../../../src/loanOfferings/index';
+
+type DtoClass = new () => object;
+
+const errorsOf = async (dtoClass: DtoClass, body: object): Promise<string[]> =>
+    (await validate(plainToInstance(dtoClass, body, { excludeExtraneousValues: true }) as object)).map((e) => e.property);
+
+const createBase = {
+    name: 'Tasa preferente cadena',
+    description: 'Baja la tasa en una cadena',
+    effect: { downPaymentDeltaPct: 0.05 },
+    segmentId: 'SEG_SILVER',
+    targetLevels: ['SILVER'],
+};
+
+describe('alcance por cadena en promociones de crédito', () => {
+    it('Create acepta cadenas, null y lista vacía como «todas»', async () => {
+        const dto = plainToInstance(CreatePromotionRequest, { ...createBase, retailerIds: ['RT-1', 'RT-2'] }, { excludeExtraneousValues: true });
+        expect(await validate(dto)).toHaveLength(0);
+        expect(dto.retailerIds).toEqual(['RT-1', 'RT-2']);
+        expect(await errorsOf(CreatePromotionRequest, { ...createBase, retailerIds: null })).toEqual([]);
+        expect(await errorsOf(CreatePromotionRequest, { ...createBase, retailerIds: [] })).toEqual([]);
+    });
+
+    it.each([CreatePromotionRequest, UpdatePromotionRequest])('%p rechaza cadenas mal formadas', async (dtoClass) => {
+        const body = dtoClass === CreatePromotionRequest ? createBase : {};
+        const tooMany = Array.from({ length: PROMOTION_RETAILER_IDS_MAX_ITEMS + 1 }, (_v, i) => `RT-${i}`);
+        expect(await errorsOf(dtoClass, { ...body, retailerIds: 'RT-1' })).toContain('retailerIds');
+        expect(await errorsOf(dtoClass, { ...body, retailerIds: [7] })).toContain('retailerIds');
+        expect(await errorsOf(dtoClass, { ...body, retailerIds: [''] })).toContain('retailerIds');
+        expect(await errorsOf(dtoClass, { ...body, retailerIds: tooMany })).toContain('retailerIds');
+        expect(await errorsOf(dtoClass, { ...body, retailerIds: tooMany.slice(1) })).toEqual([]);
+    });
+
+    it('Update acepta el parche solo con cadenas', async () => {
+        expect(PROMOTION_RETAILER_IDS_MAX_ITEMS).toBe(50);
+        expect(await errorsOf(UpdatePromotionRequest, { retailerIds: ['RT-1'] })).toEqual([]);
+        expect(await errorsOf(UpdatePromotionRequest, { retailerIds: null })).toEqual([]);
+    });
+
+    it('la respuesta expone las cadenas con null como «todas»', () => {
+        const scope: Pick<PromotionResponse, 'retailerIds'> = { retailerIds: null };
+        expect(scope.retailerIds).toBeNull();
+    });
+
+    it('el simulador recibe la cadena opcional como string', async () => {
+        const base = { productPriceCents: 500000, downPaymentPct: 0.2, termWeeks: 26 };
+        const dto = plainToInstance(SimulateCreditPlanRequest, { ...base, retailerId: 'RT-1' }, { excludeExtraneousValues: true });
+        expect(await validate(dto)).toHaveLength(0);
+        expect(dto.retailerId).toBe('RT-1');
+        expect(await errorsOf(SimulateCreditPlanRequest, { ...base, retailerId: 7 })).toContain('retailerId');
+        expect(await errorsOf(SimulateCreditPlanRequest, { ...base, retailerId: '' })).toContain('retailerId');
+    });
+});
+
+describe.each([ListPromotedSkusRequest, ListSkuPromotionsRequest])('%p con cadena', (dtoClass) => {
+    const valid = { storeId: 'st-1', items: [{ sku: 'SKU-1' }] };
+
+    it('acepta la cadena opcional junto a la tienda', async () => {
+        expect(await errorsOf(dtoClass, valid)).toEqual([]);
+        expect(await errorsOf(dtoClass, { ...valid, retailerId: 'RT-1' })).toEqual([]);
+    });
+
+    it('rechaza la cadena vacía o no string', async () => {
+        expect(await errorsOf(dtoClass, { ...valid, retailerId: '' })).toContain('retailerId');
+        expect(await errorsOf(dtoClass, { ...valid, retailerId: 7 })).toContain('retailerId');
+    });
+});

package/_test_/unit/loanOfferings/segmentCatalog.test.ts

@@ -5,7 +5,6 @@ import {
   ListSegmentCatalogQuery,
   SegmentCatalogItem,
   SegmentCatalogResponse,
-  SegmentFilterIdEnum,
   SegmentStatusEnum,
 } from '../../../src/loanOfferings/index';
 
@@ -45,10 +44,13 @@ describe('SegmentCatalogResponse', () => {
       segmentId: 'seg-1',
       name: 'Nuevos',
       status: SegmentStatusEnum.ACTIVE,
-      filterIds: Object.values(SegmentFilterIdEnum).slice(0, 1),
+      cohortIds: ['COH-LEVEL-GOLD'],
+      dependsOnFacts: true,
+      filterIds: ['COH-LEVEL-GOLD'],
       isDefault: false,
     };
     const response: SegmentCatalogResponse = { segments: [item] };
     expect(response.segments[0].segmentId).toBe('seg-1');
+    expect(response.segments[0].filterIds).toEqual(response.segments[0].cohortIds);
   });
 });

package/_test_/unit/loanOfferings/segmentCohorts.test.ts

@@ -0,0 +1,333 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate, ValidationError } from 'class-validator';
+import {
+  ChangeCohortStatusRequest,
+  CohortConditionOutcomeEnum,
+  CohortFactKeyEnum,
+  CohortOperatorEnum,
+  CohortResponse,
+  CohortStatusEnum,
+  CreateCohortRequest,
+  CreateSegmentRequest,
+  CreditPlanLevelEnum,
+  CustomerSegmentFacts,
+  ListCohortsQuery,
+  ResolveCustomerSegmentsRequest,
+  ResolveSegmentMembersRequest,
+  SegmentMembersResponse,
+  SegmentMembershipReasonEnum,
+  SegmentResponse,
+  SegmentationRecountRunsResponse,
+  SegmentationRecountStatusEnum,
+  SegmentationRecountTriggerEnum,
+  SegmentColorSlotEnum,
+  SegmentStatusEnum,
+  TestCohortRequest,
+  TestCohortResponse,
+  TestCustomerSegmentsRequest,
+  TestCustomerSegmentsResponse,
+  UpdateCohortRequest,
+  UpdateSegmentRequest,
+} from '../../../src/loanOfferings/index';
+
+type Ctor<T> = new () => T;
+
+const toDto = <T extends object>(cls: Ctor<T>, raw: Record<string, unknown>): T =>
+  plainToInstance(cls, raw, { excludeExtraneousValues: true });
+
+const errorProperties = async <T extends object>(cls: Ctor<T>, raw: Record<string, unknown>): Promise<string[]> =>
+  (await validate(toDto(cls, raw))).map((error) => error.property).sort();
+
+const nestedErrors = (errors: ValidationError[]): string[] =>
+  errors.flatMap((error) => [error.property, ...nestedErrors(error.children ?? [])]);
+
+const GOLD = { field: CohortFactKeyEnum.SCI_LEVEL, op: CohortOperatorEnum.EQUALS, value: 'GOLD' };
+const COMPLETED_GTE_3 = { field: CohortFactKeyEnum.COMPLETED_CREDITS, op: CohortOperatorEnum.GTE, value: 3 };
+
+describe('Enums de cohorts', () => {
+  it('las llaves del catálogo coinciden con los campos de CustomerSegmentFacts', () => {
+    expect(Object.values(CohortFactKeyEnum).sort()).toEqual(
+      [
+        'activeCredits',
+        'completedCredits',
+        'currentArrearsDays',
+        'delinquencyDaysLast6M',
+        'hasPcfAccount',
+        'isEmployee',
+        'lifetimeRestructures',
+        'lifetimeWriteOffs',
+        'sciLevel',
+        'totalCredits',
+      ].sort(),
+    );
+  });
+
+  it('declara los operadores del contrato', () => {
+    expect(Object.values(CohortOperatorEnum)).toEqual(['EQUALS', 'NOT_EQUALS', 'GT', 'GTE', 'LT', 'LTE', 'IN', 'NOT_IN']);
+  });
+});
+
+describe('CustomerSegmentFacts y ResolveCustomerSegmentsRequest', () => {
+  const FULL_FACTS = {
+    sciLevel: CreditPlanLevelEnum.GOLD,
+    totalCredits: 4,
+    activeCredits: 1,
+    completedCredits: 3,
+    lifetimeWriteOffs: 0,
+    currentArrearsDays: 0,
+    delinquencyDaysLast6M: 0,
+    lifetimeRestructures: 0,
+    isEmployee: false,
+    hasPcfAccount: true,
+  };
+
+  it('acepta todos los datos opcionales vacíos', async () => {
+    expect(await errorProperties(CustomerSegmentFacts, {})).toEqual([]);
+  });
+
+  it('acepta el juego completo de datos', async () => {
+    expect(await errorProperties(CustomerSegmentFacts, FULL_FACTS)).toEqual([]);
+  });
+
+  it('rechaza conteos negativos, con decimales o como texto', async () => {
+    expect(await errorProperties(CustomerSegmentFacts, { totalCredits: -1 })).toEqual(['totalCredits']);
+    expect(await errorProperties(CustomerSegmentFacts, { activeCredits: 1.5 })).toEqual(['activeCredits']);
+    expect(await errorProperties(CustomerSegmentFacts, { currentArrearsDays: '3' })).toEqual(['currentArrearsDays']);
+  });
+
+  it('rechaza un nivel fuera del enum y un booleano como texto', async () => {
+    expect(await errorProperties(CustomerSegmentFacts, { sciLevel: 'PLATINUM' })).toEqual(['sciLevel']);
+    expect(await errorProperties(CustomerSegmentFacts, { hasPcfAccount: 'true' })).toEqual(['hasPcfAccount']);
+  });
+
+  it('el resolve sigue aceptando solo el retailCustomerId', async () => {
+    expect(await errorProperties(ResolveCustomerSegmentsRequest, { retailCustomerId: 'RC-1' })).toEqual([]);
+  });
+
+  it('el resolve hereda y conserva los datos del cliente', async () => {
+    const dto = toDto(ResolveCustomerSegmentsRequest, { retailCustomerId: 'RC-1', ...FULL_FACTS, extra: 'x' });
+    expect(await validate(dto)).toHaveLength(0);
+    expect(dto).toEqual({ retailCustomerId: 'RC-1', ...FULL_FACTS });
+    expect(await errorProperties(ResolveCustomerSegmentsRequest, { retailCustomerId: 'RC-1', totalCredits: -1 })).toEqual([
+      'totalCredits',
+    ]);
+  });
+
+  it('el resolve exige retailCustomerId', async () => {
+    expect(await errorProperties(ResolveCustomerSegmentsRequest, {})).toEqual(['retailCustomerId']);
+  });
+});
+
+describe('CreateCohortRequest', () => {
+  it('acepta un cohort con condiciones de número y de selección', async () => {
+    expect(await errorProperties(CreateCohortRequest, { name: 'VIP', conditions: [GOLD, COMPLETED_GTE_3] })).toEqual([]);
+  });
+
+  it('acepta IN con lista de valores', async () => {
+    const condition = { field: CohortFactKeyEnum.SCI_LEVEL, op: CohortOperatorEnum.IN, values: ['GOLD', 'SILVER'] };
+    expect(await errorProperties(CreateCohortRequest, { name: 'Oro o Plata', conditions: [condition] })).toEqual([]);
+  });
+
+  it('exige entre 1 y 10 condiciones', async () => {
+    expect(await errorProperties(CreateCohortRequest, { name: 'Vacío', conditions: [] })).toEqual(['conditions']);
+    expect(
+      await errorProperties(CreateCohortRequest, { name: 'Largo', conditions: Array.from({ length: 11 }, () => GOLD) }),
+    ).toEqual(['conditions']);
+    expect(await errorProperties(CreateCohortRequest, { name: 'Sin condiciones' })).toEqual(['conditions']);
+  });
+
+  it('valida cada condición: campo y operador del catálogo, lista de hasta 10 textos', async () => {
+    const dto = toDto(CreateCohortRequest, {
+      name: 'Malo',
+      conditions: [
+        { field: 'age', op: CohortOperatorEnum.GT, value: 18 },
+        { field: CohortFactKeyEnum.SCI_LEVEL, op: 'CONTAINS', value: 'G' },
+        { field: CohortFactKeyEnum.SCI_LEVEL, op: CohortOperatorEnum.IN, values: Array.from({ length: 11 }, () => 'GOLD') },
+        { field: CohortFactKeyEnum.SCI_LEVEL, op: CohortOperatorEnum.IN, values: [1] },
+      ],
+    });
+    const errors = nestedErrors(await validate(dto));
+    expect(errors.filter((property) => ['field', 'op', 'values'].includes(property)).sort()).toEqual([
+      'field',
+      'op',
+      'values',
+      'values',
+    ]);
+  });
+
+  it('rechaza opciones vacías en la lista de valores', async () => {
+    const condition = { field: CohortFactKeyEnum.SCI_LEVEL, op: CohortOperatorEnum.IN, values: ['GOLD', ''] };
+    const errors = nestedErrors(await validate(toDto(CreateCohortRequest, { name: 'Vacía', conditions: [condition] })));
+    expect(errors).toContain('values');
+  });
+
+  it('limita el nombre a 120 y la descripción a 500', async () => {
+    expect(
+      await errorProperties(CreateCohortRequest, {
+        name: 'n'.repeat(121),
+        description: 'd'.repeat(501),
+        conditions: [GOLD],
+      }),
+    ).toEqual(['description', 'name']);
+  });
+});
+
+describe('UpdateCohortRequest', () => {
+  it('es parcial: acepta un body vacío', async () => {
+    expect(await errorProperties(UpdateCohortRequest, {})).toEqual([]);
+  });
+
+  it('si trae condiciones, aplica las mismas reglas que el alta', async () => {
+    expect(await errorProperties(UpdateCohortRequest, { conditions: [] })).toEqual(['conditions']);
+    expect(await errorProperties(UpdateCohortRequest, { conditions: [COMPLETED_GTE_3], reason: 'Ajuste' })).toEqual([]);
+  });
+
+  it('limita el motivo a 280', async () => {
+    expect(await errorProperties(UpdateCohortRequest, { reason: 'r'.repeat(281) })).toEqual(['reason']);
+  });
+});
+
+describe('ChangeCohortStatusRequest, TestCohortRequest y ListCohortsQuery', () => {
+  it('cambia el estado con un valor del enum', async () => {
+    expect(await errorProperties(ChangeCohortStatusRequest, { status: CohortStatusEnum.ARCHIVED })).toEqual([]);
+    expect(await errorProperties(ChangeCohortStatusRequest, { status: 'DELETED' })).toEqual(['status']);
+  });
+
+  it('prueba exige cliente y condiciones', async () => {
+    expect(await errorProperties(TestCohortRequest, { retailCustomerId: 'RC-1', conditions: [GOLD] })).toEqual([]);
+    expect(await errorProperties(TestCohortRequest, {})).toEqual(['conditions', 'retailCustomerId']);
+  });
+
+  it('la lista filtra por estado opcional', async () => {
+    expect(await errorProperties(ListCohortsQuery, {})).toEqual([]);
+    expect(await errorProperties(ListCohortsQuery, { status: CohortStatusEnum.ACTIVE })).toEqual([]);
+    expect(await errorProperties(ListCohortsQuery, { status: 'DRAFT' })).toEqual(['status']);
+  });
+});
+
+describe('Segmento con cohorts', () => {
+  it('el alta acepta cohortIds y descarta los filterIds viejos', async () => {
+    const dto = toDto(CreateSegmentRequest, {
+      name: 'VIP',
+      colorSlot: SegmentColorSlotEnum.SLATE,
+      cohortIds: ['COH-LEVEL-GOLD'],
+      filterIds: ['levelGold'],
+    });
+    expect(await validate(dto)).toHaveLength(0);
+    expect(dto.cohortIds).toEqual(['COH-LEVEL-GOLD']);
+    expect('filterIds' in dto).toBe(false);
+  });
+
+  it('limita los cohorts a 20 y exige textos', async () => {
+    const many = Array.from({ length: 21 }, (_, i) => `COH-${i}`);
+    expect(await errorProperties(CreateSegmentRequest, { name: 'X', cohortIds: many })).toEqual(['cohortIds']);
+    expect(await errorProperties(UpdateSegmentRequest, { cohortIds: many })).toEqual(['cohortIds']);
+    expect(await errorProperties(UpdateSegmentRequest, { cohortIds: [1] })).toEqual(['cohortIds']);
+    expect(await errorProperties(UpdateSegmentRequest, { cohortIds: [] })).toEqual([]);
+  });
+
+  it('rechaza ids de cohort vacíos', async () => {
+    expect(await errorProperties(CreateSegmentRequest, { name: 'X', cohortIds: ['COH-A', ''] })).toEqual(['cohortIds']);
+    expect(await errorProperties(UpdateSegmentRequest, { cohortIds: ['COH-A', ''] })).toEqual(['cohortIds']);
+  });
+
+  it('members en lote exige entre 1 y 100 clientes y valida cada uno', async () => {
+    expect(await errorProperties(ResolveSegmentMembersRequest, { customers: [{ retailCustomerId: 'RC-1' }] })).toEqual([]);
+    expect(await errorProperties(ResolveSegmentMembersRequest, { customers: [] })).toEqual(['customers']);
+    expect(
+      await errorProperties(ResolveSegmentMembersRequest, {
+        customers: Array.from({ length: 101 }, (_, i) => ({ retailCustomerId: `RC-${i}` })),
+      }),
+    ).toEqual(['customers']);
+
+    const dto = toDto(ResolveSegmentMembersRequest, { customers: [{ retailCustomerId: 'RC-1', completedCredits: -2 }] });
+    expect(dto.customers[0]).toBeInstanceOf(ResolveCustomerSegmentsRequest);
+    expect(nestedErrors(await validate(dto))).toContain('completedCredits');
+  });
+
+  it('probar segmentos exige el cliente', async () => {
+    expect(await errorProperties(TestCustomerSegmentsRequest, { retailCustomerId: 'RC-1' })).toEqual([]);
+    expect(await errorProperties(TestCustomerSegmentsRequest, {})).toEqual(['retailCustomerId']);
+  });
+});
+
+describe('Responses de cohorts y segmentos', () => {
+  it('tipan las formas del contrato', () => {
+    const cohort: CohortResponse = {
+      cohortId: 'COH-LEVEL-GOLD',
+      name: 'Nivel Oro',
+      description: null,
+      conditions: [{ field: CohortFactKeyEnum.SCI_LEVEL, op: CohortOperatorEnum.EQUALS, value: 'GOLD', values: null }],
+      status: CohortStatusEnum.ACTIVE,
+      version: 1,
+      memberCount: null,
+      pctTotal: null,
+      countedAt: null,
+      countPending: true,
+      usedBySegments: [{ segmentId: 'SEG-VIP', name: 'VIP' }],
+      createdAt: '2026-10-29T00:00:00.000Z',
+      updatedAt: '2026-10-29T00:00:00.000Z',
+      createdBy: 'system',
+      updatedBy: 'system',
+    };
+    const segment: SegmentResponse = {
+      segmentId: 'SEG-VIP',
+      name: 'VIP',
+      description: null,
+      colorSlot: SegmentColorSlotEnum.SLATE,
+      cohortIds: [cohort.cohortId],
+      memberIds: [],
+      isDefault: false,
+      status: SegmentStatusEnum.ACTIVE,
+      version: 1,
+      clientCount: 10,
+      pctTotal: 40,
+      countedAt: '2026-10-29T09:00:00.000Z',
+      countPending: false,
+      createdAt: '2026-10-29T00:00:00.000Z',
+      updatedAt: '2026-10-29T00:00:00.000Z',
+      createdBy: 'system',
+      updatedBy: 'system',
+    };
+    const test: TestCohortResponse = {
+      retailCustomerId: 'RC-1',
+      matched: false,
+      facts: { completedCredits: 2 },
+      conditions: [{ ...COMPLETED_GTE_3, values: null, actual: 2, outcome: CohortConditionOutcomeEnum.NO_MATCH }],
+    };
+    const trace: TestCustomerSegmentsResponse = {
+      retailCustomerId: 'RC-1',
+      facts: {},
+      segments: [
+        { segmentId: 'SEG-VIP', name: 'VIP', matched: true, reason: SegmentMembershipReasonEnum.COHORT, matchedCohortIds: ['COH-LEVEL-GOLD'] },
+      ],
+      defaultApplies: false,
+      evaluatorAvailable: true,
+    };
+    const members: SegmentMembersResponse = {
+      items: [{ retailCustomerId: 'RC-1', segments: [{ segmentId: 'SEG-VIP', name: 'VIP', isDefault: false }] }],
+    };
+    const runs: SegmentationRecountRunsResponse = {
+      runs: [
+        {
+          runId: 'RUN-1',
+          trigger: SegmentationRecountTriggerEnum.NIGHTLY,
+          status: SegmentationRecountStatusEnum.RUNNING,
+          actor: 'system',
+          startedAt: '2026-10-29T09:00:00.000Z',
+          finishedAt: null,
+          evaluated: null,
+          durationMs: null,
+          error: null,
+        },
+      ],
+    };
+
+    expect(segment.cohortIds).toEqual([cohort.cohortId]);
+    expect(test.conditions[0].outcome).toBe('NO_MATCH');
+    expect(trace.segments[0].reason).toBe('COHORT');
+    expect(members.items[0].segments).toHaveLength(1);
+    expect(runs.runs[0].status).toBe('RUNNING');
+  });
+});

package/bin/loanCredit/dtos/requests/OriginateLoanCreditRequest.d.ts

@@ -46,4 +46,6 @@ export declare class OriginateLoanCreditRequest {
     productCategory?: ProductCategoryEnum;
     /** Gama del equipo: resuelve promociones acotadas por gama. */
     productTier?: ProductTierEnum;
+    /** Cadena de la tienda que vende; sin ella no se resuelven las promociones acotadas por cadena. */
+    retailerId?: string;
 }

package/bin/loanCredit/dtos/requests/OriginateLoanCreditRequest.js

@@ -122,3 +122,10 @@ __decorate([
     (0, class_validator_1.IsEnum)(ProductTierEnum_1.ProductTierEnum),
     __metadata("design:type", String)
 ], OriginateLoanCreditRequest.prototype, "productTier", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], OriginateLoanCreditRequest.prototype, "retailerId", void 0);

package/bin/loanCredit/dtos/requests/SegmentFactsBatchRequest.d.ts

@@ -0,0 +1,4 @@
+/** Body de `POST /private/borrowers/segment-facts`: datos para segmentar de hasta 100 clientes retail. */
+export declare class SegmentFactsBatchRequest {
+    retailCustomerIds: string[];
+}

package/bin/loanCredit/dtos/requests/SegmentFactsBatchRequest.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.SegmentFactsBatchRequest = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+/** Body de `POST /private/borrowers/segment-facts`: datos para segmentar de hasta 100 clientes retail. */
+class SegmentFactsBatchRequest {
+}
+exports.SegmentFactsBatchRequest = SegmentFactsBatchRequest;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayMinSize)(1),
+    (0, class_validator_1.ArrayMaxSize)(100),
+    (0, class_validator_1.IsString)({ each: true }),
+    (0, class_validator_1.IsNotEmpty)({ each: true }),
+    __metadata("design:type", Array)
+], SegmentFactsBatchRequest.prototype, "retailCustomerIds", void 0);

package/bin/loanCredit/dtos/requests/SegmentFactsPageRequest.d.ts

@@ -0,0 +1,7 @@
+/** Body de `POST /private/borrowers/segment-facts/page`: una página de la cartera de acreditados. */
+export declare class SegmentFactsPageRequest {
+    /** Cursor opaco de la página anterior. Ausente en la primera página. */
+    cursor?: string;
+    /** Acreditados por página. Ausente = 100. */
+    limit?: number;
+}

package/bin/loanCredit/dtos/requests/SegmentFactsPageRequest.js

@@ -0,0 +1,32 @@
+"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.SegmentFactsPageRequest = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+/** Body de `POST /private/borrowers/segment-facts/page`: una página de la cartera de acreditados. */
+class SegmentFactsPageRequest {
+}
+exports.SegmentFactsPageRequest = SegmentFactsPageRequest;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], SegmentFactsPageRequest.prototype, "cursor", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.Max)(100),
+    __metadata("design:type", Number)
+], SegmentFactsPageRequest.prototype, "limit", void 0);

package/bin/loanCredit/dtos/responses/BorrowerSegmentFacts.d.ts

@@ -0,0 +1,22 @@
+import { CreditPlanLevelEnum } from '../../../loanOfferings/enums/CreditPlanLevelEnum';
+/**
+ * Datos del acreditado para evaluar cohorts, ya normalizados: sin acreditado, conteos y días en
+ * `0`; `sciLevel` ausente si no hay evaluación o el nivel es `ALL` / `NOT_ELIGIBLE`.
+ */
+export interface BorrowerSegmentFacts {
+    sciLevel?: CreditPlanLevelEnum;
+    totalCredits: number;
+    activeCredits: number;
+    completedCredits: number;
+    lifetimeWriteOffs: number;
+    currentArrearsDays: number;
+    /** Sin cuotas en la ventana de 180 días cuenta como `0`. */
+    delinquencyDaysLast6M: number;
+    lifetimeRestructures: number;
+}
+/** Un cliente retail y sus datos para segmentar. `borrowerId` en `null` = no tiene acreditado. */
+export interface BorrowerSegmentFactsItem {
+    retailCustomerId: string;
+    borrowerId: string | null;
+    facts: BorrowerSegmentFacts;
+}

package/bin/loanCredit/dtos/responses/BorrowerSegmentFacts.js

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

package/bin/loanCredit/dtos/responses/SegmentFactsBatchResponse.d.ts

@@ -0,0 +1,5 @@
+import { BorrowerSegmentFactsItem } from './BorrowerSegmentFacts';
+/** Respuesta de `POST /private/borrowers/segment-facts`: un ítem por id pedido, en el mismo orden. */
+export interface SegmentFactsBatchResponse {
+    items: BorrowerSegmentFactsItem[];
+}

package/bin/loanCredit/dtos/responses/SegmentFactsBatchResponse.js

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