@fiado/type-kit 3.595.0 → 3.597.0

package/_test_/unit/retailPromotions/constants.test.ts

@@ -43,8 +43,7 @@ describe('catálogo de errores', () => {
     expect(RETAIL_PROMOTIONS_ERROR_HTTP_STATUS.CODE_NOT_FOUND).toBe(404);
     expect(RETAIL_PROMOTIONS_ERROR_HTTP_STATUS.DISCOUNT_AFTER_QUOTE).toBe(409);
     expect(RETAIL_PROMOTIONS_ERROR_HTTP_STATUS.CODE_NOT_OWNED).toBe(422);
-    expect(Object.keys(RetailPromotionsErrorCodeEnum)).toHaveLength(36);
-    expect(RETAIL_PROMOTIONS_ERROR_HTTP_STATUS.SPLIT_FINANCING_DISABLED).toBe(409);
+    expect(Object.keys(RetailPromotionsErrorCodeEnum)).toHaveLength(35);
   });
 
   it('la forma de pago que la promo no acepta es 422', () => {

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

@@ -11,6 +11,7 @@ describe('DTOs de catálogos (forma)', () => {
                 fields: [{ field: 'accountAgeDays', label: 'Antigüedad', valueType: RuleValueTypeEnum.NUMBER, operators: ['GT', 'LTE'] }],
             }],
             operators: { GT: '>', LTE: '≤' },
+            relations: [],
         };
         expect(catalog.sources[0]?.fields[0]?.valueType).toBe('NUMBER');
     });

package/_test_/unit/rules/relationContract.test.ts

@@ -0,0 +1,84 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import {
+    RETURN_FIELD_ID_PATTERN,
+    RULES_EXPOSE_AS_PATTERN,
+    RULES_MAX_RELATION_BLOCKS,
+    RULES_MAX_RELATION_DEPTH,
+    RULES_MAX_WITHIN_LAST_DAYS,
+    RULES_RELATION_NAME_PATTERN,
+    RulesCatalogResponse,
+    RulesRelationCardinalityEnum,
+    RulesRelationTargetEnum,
+    relationReturnFieldId,
+} from '../../../src/rules';
+import {
+    RuleCatalogResponse,
+    RulesRelationCardinalityEnum as EligibilityCardinality,
+    RulesRelationTargetEnum as EligibilityTarget,
+} from '../../../src/rewardsEligibility';
+
+describe('contrato de relaciones (rules)', () => {
+    it('relationReturnFieldId concatena relación:exposeAs y cumple RETURN_FIELD_ID_PATTERN', () => {
+        const id = relationReturnFieldId('referidos', 'referidos_mx_count');
+        expect(id).toBe('referidos:referidos_mx_count');
+        expect(RETURN_FIELD_ID_PATTERN.test(id)).toBe(true);
+    });
+
+    it('RULES_RELATION_NAME_PATTERN acepta minúsculas con guiones y rechaza el resto', () => {
+        expect(RULES_RELATION_NAME_PATTERN.test('referidos')).toBe(true);
+        expect(RULES_RELATION_NAME_PATTERN.test('mi-relacion2')).toBe(true);
+        expect(RULES_RELATION_NAME_PATTERN.test('Referidos')).toBe(false);
+        expect(RULES_RELATION_NAME_PATTERN.test('mx count')).toBe(false);
+    });
+
+    it('RULES_EXPOSE_AS_PATTERN acepta letras/dígitos/guion bajo y rechaza espacios', () => {
+        expect(RULES_EXPOSE_AS_PATTERN.test('referidos_mx_count')).toBe(true);
+        expect(RULES_EXPOSE_AS_PATTERN.test('Referidos')).toBe(true);
+        expect(RULES_EXPOSE_AS_PATTERN.test('mx count')).toBe(false);
+        expect(RULES_EXPOSE_AS_PATTERN.test('1abc')).toBe(false);
+    });
+
+    it('topes fijados por el plan', () => {
+        expect(RULES_MAX_RELATION_DEPTH).toBe(2);
+        expect(RULES_MAX_RELATION_BLOCKS).toBe(5);
+        expect(RULES_MAX_WITHIN_LAST_DAYS).toBe(365);
+    });
+
+    it('valores de los enums', () => {
+        expect(RulesRelationCardinalityEnum).toEqual({ ONE: 'ONE', MANY: 'MANY' });
+        expect(RulesRelationTargetEnum).toEqual({ PERSON: 'PERSON', RECORD: 'RECORD' });
+    });
+
+    it('plainToInstance conserva relations del catálogo de rules', () => {
+        const parsed = plainToInstance(RulesCatalogResponse, {
+            items: [],
+            operators: { WITHIN_LAST_DAYS: 'en los últimos N días' },
+            relations: [
+                { name: 'referidos', label: 'Referidos', description: 'd', cardinality: 'MANY', target: 'PERSON', maxRelated: 500 },
+                { name: 'creditos', label: 'Créditos', description: 'd', cardinality: 'MANY', target: 'RECORD', fields: [] },
+            ],
+        });
+        expect(parsed.relations).toHaveLength(2);
+        expect(parsed.relations[0].cardinality).toBe(RulesRelationCardinalityEnum.MANY);
+        expect(parsed.relations[0].maxRelated).toBe(500);
+        expect(parsed.relations[1].target).toBe(RulesRelationTargetEnum.RECORD);
+    });
+});
+
+describe('contrato de relaciones (rewardsEligibility)', () => {
+    it('reutiliza los enums de rules', () => {
+        expect(EligibilityCardinality).toBe(RulesRelationCardinalityEnum);
+        expect(EligibilityTarget).toBe(RulesRelationTargetEnum);
+    });
+
+    it('plainToInstance conserva relations del catálogo de eligibility', () => {
+        const parsed = plainToInstance(RuleCatalogResponse, {
+            sources: [],
+            operators: {},
+            relations: [{ name: 'referidor', label: 'Referidor', description: 'd', cardinality: 'ONE', target: 'PERSON' }],
+        });
+        expect(parsed.relations[0].cardinality).toBe(EligibilityCardinality.ONE);
+        expect(parsed.relations[0].maxRelated).toBeUndefined();
+    });
+});

package/_test_/unit/rules/segmentRelation.test.ts

@@ -0,0 +1,62 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import * as Rules from '../../../src/rules';
+
+const filter = { kind: 'COLUMN', table: 'directory', column: 'status', op: 'EQUALS', value: 'ACTIVE' };
+const relation = (over: object = {}): object => ({
+    kind: 'RELATION', relation: 'referidos',
+    quantifier: { kind: 'COUNT', op: 'GTE', value: 1 },
+    filters: [filter], ...over,
+});
+const group = (conditions: object[]): object => ({ match: 'ALL', conditions });
+
+const errorsOf = async (plain: object): Promise<number> =>
+    (await validate(plainToInstance(Rules.SegmentGroup, plain, { excludeExtraneousValues: true }))).length;
+
+describe('SegmentRelationCondition', () => {
+    it('enum RELATION y quantifier kinds', () => {
+        expect(Rules.SegmentConditionKindEnum.RELATION).toBe('RELATION');
+        expect(Object.values(Rules.SegmentRelationQuantifierKindEnum)).toEqual(['ANY', 'ALL', 'COUNT']);
+    });
+
+    it('instancia SegmentRelationCondition por discriminador', () => {
+        const g = plainToInstance(Rules.SegmentGroup, group([relation()]), { excludeExtraneousValues: true });
+        expect(g.conditions[0]).toBeInstanceOf(Rules.SegmentRelationCondition);
+        expect((g.conditions[0] as Rules.SegmentRelationCondition).quantifier).toBeInstanceOf(Rules.SegmentRelationQuantifier);
+    });
+
+    it('COUNT con filtros -> valido', async () => {
+        expect(await errorsOf(group([relation()]))).toBe(0);
+    });
+
+    it('ANY / ALL sin op ni value -> valido; ONE sin quantifier -> valido', async () => {
+        expect(await errorsOf(group([relation({ quantifier: { kind: 'ANY' } })]))).toBe(0);
+        expect(await errorsOf(group([relation({ quantifier: { kind: 'ALL' } })]))).toBe(0);
+        expect(await errorsOf(group([relation({ relation: 'referidor', quantifier: undefined })]))).toBe(0);
+    });
+
+    it('COUNT sin op o sin value -> error', async () => {
+        expect(await errorsOf(group([relation({ quantifier: { kind: 'COUNT', value: 1 } })]))).toBeGreaterThan(0);
+        expect(await errorsOf(group([relation({ quantifier: { kind: 'COUNT', op: 'GTE' } })]))).toBeGreaterThan(0);
+    });
+
+    it('relation con mayusculas o espacios -> error', async () => {
+        expect(await errorsOf(group([relation({ relation: 'Referidos' })]))).toBeGreaterThan(0);
+        expect(await errorsOf(group([relation({ relation: 'ref idos' })]))).toBeGreaterThan(0);
+    });
+
+    it('quantifier kind desconocido -> error', async () => {
+        expect(await errorsOf(group([relation({ quantifier: { kind: 'SOME' } })]))).toBeGreaterThan(0);
+    });
+
+    it('mas de 10 filters -> error; filters ausente -> error', async () => {
+        expect(await errorsOf(group([relation({ filters: Array(11).fill(filter) })]))).toBeGreaterThan(0);
+        expect(await errorsOf(group([relation({ filters: undefined })]))).toBeGreaterThan(0);
+    });
+
+    it('kind desconocido sigue rechazado; COLUMN y AGGREGATE siguen', async () => {
+        expect(await errorsOf(group([{ kind: 'OTHER' }]))).toBeGreaterThan(0);
+        expect(await errorsOf(group([filter]))).toBe(0);
+    });
+});

package/_test_/unit/rules/traceNested.test.ts

@@ -0,0 +1,115 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import {
+    RulesOutcomeEnum,
+    RulesTraceConditionResponse,
+    RulesTraceGroupResponse,
+    RulesTraceRelatedResponse,
+    RulesTraceRelationResponse,
+    RulesTraceResponse,
+} from '../../../src/rules';
+import {
+    EvaluationOutcomeEnum,
+    TraceConditionResponse,
+    TraceGroupResponse,
+    TraceRelatedResponse,
+    TraceRelationResponse,
+} from '../../../src/rewardsEligibility';
+
+const condition: RulesTraceConditionResponse = {
+    source: 'directory',
+    field: 'country',
+    op: 'EQ',
+    expected: 'MX',
+    actual: 'MX',
+    outcome: RulesOutcomeEnum.MATCH,
+};
+
+const relatedTrace: RulesTraceResponse = {
+    match: 'ALL',
+    outcome: RulesOutcomeEnum.MATCH,
+    groups: [{ match: 'ALL', outcome: RulesOutcomeEnum.MATCH, conditions: [condition] }],
+};
+
+const relatedOne: RulesTraceRelatedResponse = {
+    directoryId: 'dir-1',
+    outcome: RulesOutcomeEnum.MATCH,
+    trace: relatedTrace,
+};
+
+const block: RulesTraceRelationResponse = {
+    kind: 'RELATION',
+    relation: 'referidos',
+    quantifier: { kind: 'COUNT', op: 'GTE', value: 1 },
+    exposeAs: 'referidos_mx_count',
+    outcome: RulesOutcomeEnum.MATCH,
+    matched: 1,
+    errored: 0,
+    total: 1,
+    related: [relatedOne],
+};
+
+describe('trazas anidadas (rules)', () => {
+    it('serializa y deserializa un bloque de relación con relacionado sin pérdida', () => {
+        const group: RulesTraceGroupResponse = {
+            match: 'ALL',
+            outcome: RulesOutcomeEnum.MATCH,
+            conditions: [condition, block],
+        };
+        const roundTrip: RulesTraceGroupResponse = JSON.parse(JSON.stringify(group));
+        expect(roundTrip).toStrictEqual(group);
+    });
+
+    it('el discriminante kind distingue bloque de condición plana', () => {
+        const group: RulesTraceGroupResponse = {
+            match: 'ANY',
+            outcome: RulesOutcomeEnum.MATCH,
+            conditions: [condition, block],
+        };
+        const blocks = group.conditions.filter((n): n is RulesTraceRelationResponse => 'kind' in n && n.kind === 'RELATION');
+        expect(blocks).toHaveLength(1);
+        expect(blocks[0].related[0].trace.groups[0].conditions[0]).toStrictEqual(condition);
+    });
+
+    it('una traza plana de 0.4.1 compila y se conserva igual', () => {
+        const flat: RulesTraceGroupResponse = { match: 'ALL', outcome: RulesOutcomeEnum.MATCH, conditions: [condition] };
+        expect(plainToInstance(RulesTraceGroupResponse, flat)).toEqual(flat);
+    });
+
+    it('un bloque en ERROR lleva error y sin related', () => {
+        const errored: RulesTraceRelationResponse = {
+            kind: 'RELATION',
+            relation: 'referidos',
+            outcome: RulesOutcomeEnum.ERROR,
+            matched: 0,
+            errored: 0,
+            total: 0,
+            related: [],
+            error: { code: 'RELATION_NOT_RESOLVED', message: 'sin resolver' },
+        };
+        expect(JSON.parse(JSON.stringify(errored))).toStrictEqual(errored);
+    });
+});
+
+describe('trazas anidadas (eligibility)', () => {
+    const cond: TraceConditionResponse = {
+        source: 'directory', field: 'country', op: 'EQ', expected: 'MX', actual: 'MX',
+        outcome: EvaluationOutcomeEnum.MATCH,
+    };
+    const related: TraceRelatedResponse = {
+        directoryId: 'dir-1',
+        outcome: EvaluationOutcomeEnum.MATCH,
+        trace: { match: 'ALL', outcome: EvaluationOutcomeEnum.MATCH, groups: [{ match: 'ALL', outcome: EvaluationOutcomeEnum.MATCH, conditions: [cond] }] },
+    };
+    const eBlock: TraceRelationResponse = {
+        kind: 'RELATION', relation: 'referidor',
+        outcome: EvaluationOutcomeEnum.MATCH, matched: 1, errored: 0, total: 1, related: [related],
+    };
+
+    it('serializa un grupo con condición plana y bloque', () => {
+        const group: TraceGroupResponse = { match: 'ALL', outcome: EvaluationOutcomeEnum.MATCH, conditions: [cond, eBlock] };
+        expect(JSON.parse(JSON.stringify(group))).toStrictEqual(JSON.parse(JSON.stringify(group)));
+        const back: TraceGroupResponse = JSON.parse(JSON.stringify(group));
+        expect(back.conditions[1]).toStrictEqual(JSON.parse(JSON.stringify(eBlock)));
+    });
+});

package/_test_/unit/rules/validateNodes.test.ts

@@ -0,0 +1,68 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import {
+    RETURN_FIELD_ID_PATTERN,
+    RulesExposedFieldResponse,
+    RulesNodeErrorCodeEnum,
+    RulesValueTypeEnum,
+    ValidateRulesResponse,
+    relationReturnFieldId,
+} from '../../../src/rules';
+
+const ENGINE_NODE_ERROR_CODES: string[] = [
+    'UNKNOWN_RELATION',
+    'INVALID_RELATION_NODE',
+    'QUANTIFIER_REQUIRED',
+    'QUANTIFIER_NOT_ALLOWED',
+    'INVALID_QUANTIFIER',
+    'SUBJECT_IN_RELATION',
+    'EXPOSE_AS_NOT_ALLOWED',
+    'INVALID_EXPOSE_AS',
+    'DUPLICATE_EXPOSE_AS',
+    'MAX_DEPTH_EXCEEDED',
+    'MAX_BLOCKS_EXCEEDED',
+];
+
+describe('validación de nodos de relación (rules)', () => {
+    it('RulesNodeErrorCodeEnum contiene los 11 códigos del engine, string a string', () => {
+        const values: string[] = Object.values(RulesNodeErrorCodeEnum);
+        ENGINE_NODE_ERROR_CODES.forEach(code => expect(values).toContain(code));
+    });
+
+    it('agrega los códigos del Plan B y cada clave coincide con su valor', () => {
+        expect(RulesNodeErrorCodeEnum.RELATION_SOURCE_NOT_BATCH_CAPABLE).toBe('RELATION_SOURCE_NOT_BATCH_CAPABLE');
+        expect(RulesNodeErrorCodeEnum.MAX_RELATED_EXCEEDED).toBe('MAX_RELATED_EXCEEDED');
+        expect(Object.values(RulesNodeErrorCodeEnum)).toHaveLength(ENGINE_NODE_ERROR_CODES.length + 2);
+        Object.entries(RulesNodeErrorCodeEnum).forEach(([key, value]) => expect(value).toBe(key));
+    });
+
+    it('un ValidateRulesResponse plano serializa con nodeErrors y exposedFields vacíos', () => {
+        const plain = { valid: true, errors: [], nodeErrors: [], exposedFields: [] };
+        const response = plainToInstance(ValidateRulesResponse, plain);
+        expect(JSON.parse(JSON.stringify(response))).toStrictEqual(plain);
+        expect(response.nodeErrors).toStrictEqual([]);
+        expect(response.exposedFields).toStrictEqual([]);
+    });
+
+    it('conserva nodeErrors con path/code/message al deserializar', () => {
+        const response = plainToInstance(ValidateRulesResponse, {
+            valid: false,
+            errors: ['x'],
+            nodeErrors: [{ path: 'groups[0].conditions[1]', code: 'UNKNOWN_RELATION', message: 'no existe' }],
+            exposedFields: [],
+        });
+        expect(response.nodeErrors[0].code).toBe(RulesNodeErrorCodeEnum.UNKNOWN_RELATION);
+        expect(response.nodeErrors[0].path).toBe('groups[0].conditions[1]');
+    });
+
+    it('exposedFields[].id cumple RETURN_FIELD_ID_PATTERN', () => {
+        const field: RulesExposedFieldResponse = {
+            id: relationReturnFieldId('referidos', 'referidos_mx_count'),
+            relation: 'referidos',
+            exposeAs: 'referidos_mx_count',
+            valueType: RulesValueTypeEnum.NUMBER,
+        };
+        expect(RETURN_FIELD_ID_PATTERN.test(field.id)).toBe(true);
+        expect(field.id).toBe('referidos:referidos_mx_count');
+    });
+});

package/bin/retailPromotions/constants/retailPromotionsErrorHttpStatus.js

@@ -33,7 +33,6 @@ exports.RETAIL_PROMOTIONS_ERROR_HTTP_STATUS = {
     [RetailPromotionsErrorCodeEnum_1.RetailPromotionsErrorCodeEnum.SALE_PROMOTION_HOLD_CONFLICT]: 409,
     [RetailPromotionsErrorCodeEnum_1.RetailPromotionsErrorCodeEnum.INVALID_NEXT_TOKEN]: 400,
     [RetailPromotionsErrorCodeEnum_1.RetailPromotionsErrorCodeEnum.CATALOG_SKU_NOT_FOUND]: 404,
-    [RetailPromotionsErrorCodeEnum_1.RetailPromotionsErrorCodeEnum.SPLIT_FINANCING_DISABLED]: 409,
     [RetailPromotionsErrorCodeEnum_1.RetailPromotionsErrorCodeEnum.PROMOTION_NOT_STACKABLE]: 422,
     [RetailPromotionsErrorCodeEnum_1.RetailPromotionsErrorCodeEnum.PROMOTION_PAYMENT_NOT_ELIGIBLE]: 422,
     [RetailPromotionsErrorCodeEnum_1.RetailPromotionsErrorCodeEnum.SYSTEM_PROMOTION_TRANSITION_NOT_ALLOWED]: 422,

package/bin/retailPromotions/enums/RetailPromotionsErrorCodeEnum.d.ts

@@ -43,8 +43,6 @@ export declare enum RetailPromotionsErrorCodeEnum {
     INVALID_NEXT_TOKEN = "INVALID_NEXT_TOKEN",
     /** El SKU no existe en el catálogo. */
     CATALOG_SKU_NOT_FOUND = "CATALOG_SKU_NOT_FOUND",
-    /** Con el reparto apagado no se aplican palancas de precio ni código; los regalos sí. */
-    SPLIT_FINANCING_DISABLED = "SPLIT_FINANCING_DISABLED",
     /** La promo no acumulable choca con otra en la misma línea. */
     PROMOTION_NOT_STACKABLE = "PROMOTION_NOT_STACKABLE",
     /** La promo no acepta la forma de pago o el medio de cobro de la venta. */

package/bin/retailPromotions/enums/RetailPromotionsErrorCodeEnum.js

@@ -47,8 +47,6 @@ var RetailPromotionsErrorCodeEnum;
     RetailPromotionsErrorCodeEnum["INVALID_NEXT_TOKEN"] = "INVALID_NEXT_TOKEN";
     /** El SKU no existe en el catálogo. */
     RetailPromotionsErrorCodeEnum["CATALOG_SKU_NOT_FOUND"] = "CATALOG_SKU_NOT_FOUND";
-    /** Con el reparto apagado no se aplican palancas de precio ni código; los regalos sí. */
-    RetailPromotionsErrorCodeEnum["SPLIT_FINANCING_DISABLED"] = "SPLIT_FINANCING_DISABLED";
     /** La promo no acumulable choca con otra en la misma línea. */
     RetailPromotionsErrorCodeEnum["PROMOTION_NOT_STACKABLE"] = "PROMOTION_NOT_STACKABLE";
     /** La promo no acepta la forma de pago o el medio de cobro de la venta. */

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

@@ -21,10 +21,37 @@ export declare class TraceConditionResponse {
         message: string;
     };
 }
+/** Un relacionado evaluado dentro de un bloque de relación, con su traza propia. */
+export declare class TraceRelatedResponse {
+    directoryId: string;
+    outcome: EvaluationOutcomeEnum;
+    trace: ResultTraceResponse;
+}
+/** Un bloque de relación evaluado (ej. «referidos»). Discriminante: `kind: 'RELATION'`. Sin `origin`/`asOf`. */
+export declare class TraceRelationResponse {
+    kind: 'RELATION';
+    relation: string;
+    quantifier?: {
+        kind: 'ANY' | 'ALL' | 'COUNT';
+        op?: 'GT' | 'GTE' | 'EQ' | 'LT' | 'LTE';
+        value?: number;
+    };
+    exposeAs?: string;
+    outcome: EvaluationOutcomeEnum;
+    matched: number;
+    errored: number;
+    total: number;
+    related: TraceRelatedResponse[];
+    /** Solo si `outcome` es `ERROR` (`RELATION_NOT_RESOLVED`, `RELATED_UNDECIDABLE`, `MAX_RELATED_EXCEEDED`…). */
+    error?: {
+        code: string;
+        message: string;
+    };
+}
 export declare class TraceGroupResponse {
     match: 'ALL' | 'ANY';
     outcome: EvaluationOutcomeEnum;
-    conditions: TraceConditionResponse[];
+    conditions: (TraceConditionResponse | TraceRelationResponse)[];
 }
 /** Traza completa de una evaluación: por qué cumplió o no (criterio de éxito 4). */
 export declare class ResultTraceResponse {

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

@@ -1,10 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResultTraceResponse = exports.TraceGroupResponse = exports.TraceConditionResponse = void 0;
+exports.ResultTraceResponse = exports.TraceGroupResponse = exports.TraceRelationResponse = exports.TraceRelatedResponse = exports.TraceConditionResponse = void 0;
 /** Una condición evaluada: qué se esperaba, qué se encontró y de dónde salió el dato (spec 5.4). */
 class TraceConditionResponse {
 }
 exports.TraceConditionResponse = TraceConditionResponse;
+/** Un relacionado evaluado dentro de un bloque de relación, con su traza propia. */
+class TraceRelatedResponse {
+}
+exports.TraceRelatedResponse = TraceRelatedResponse;
+/** Un bloque de relación evaluado (ej. «referidos»). Discriminante: `kind: 'RELATION'`. Sin `origin`/`asOf`. */
+class TraceRelationResponse {
+}
+exports.TraceRelationResponse = TraceRelationResponse;
 class TraceGroupResponse {
 }
 exports.TraceGroupResponse = TraceGroupResponse;

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

@@ -1,4 +1,6 @@
 import { InputField } from '../../../dynamicForm/dtos/InputField';
+import { RulesRelationCardinalityEnum } from '../../../rules/enums/RulesRelationCardinalityEnum';
+import { RulesRelationTargetEnum } from '../../../rules/enums/RulesRelationTargetEnum';
 import { RuleValueTypeEnum } from '../../enums/RuleValueTypeEnum';
 /** Un campo que una fuente resuelve para las reglas (`GET /rule-catalog`). */
 export declare class RuleCatalogFieldResponse {
@@ -26,8 +28,22 @@ export declare class RuleCatalogSourceResponse {
     description: string;
     fields: RuleCatalogFieldResponse[];
 }
+/** Una relación que las reglas pueden recorrer (espejo de `RulesCatalogRelationResponse`). */
+export declare class RuleCatalogRelationResponse {
+    name: string;
+    label: string;
+    description: string;
+    cardinality: RulesRelationCardinalityEnum;
+    target: RulesRelationTargetEnum;
+    /** Solo LIVE: tope de relacionados por sujeto; excederlo da ERROR, nunca trunca. */
+    maxRelated?: number;
+    /** Solo target RECORD: campos propios del registro. */
+    fields?: RuleCatalogFieldResponse[];
+}
 export declare class RuleCatalogResponse {
     sources: RuleCatalogSourceResponse[];
     /** Etiqueta legible de cada operador (`GTE` → «≥»). */
     operators: Record<string, string>;
+    /** Relaciones disponibles (vacío si no hay). */
+    relations: RuleCatalogRelationResponse[];
 }

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuleCatalogResponse = exports.RuleCatalogSourceResponse = exports.RuleCatalogFieldResponse = void 0;
+exports.RuleCatalogResponse = exports.RuleCatalogRelationResponse = exports.RuleCatalogSourceResponse = exports.RuleCatalogFieldResponse = void 0;
 /** Un campo que una fuente resuelve para las reglas (`GET /rule-catalog`). */
 class RuleCatalogFieldResponse {
 }
@@ -8,6 +8,10 @@ exports.RuleCatalogFieldResponse = RuleCatalogFieldResponse;
 class RuleCatalogSourceResponse {
 }
 exports.RuleCatalogSourceResponse = RuleCatalogSourceResponse;
+/** Una relación que las reglas pueden recorrer (espejo de `RulesCatalogRelationResponse`). */
+class RuleCatalogRelationResponse {
+}
+exports.RuleCatalogRelationResponse = RuleCatalogRelationResponse;
 class RuleCatalogResponse {
 }
 exports.RuleCatalogResponse = RuleCatalogResponse;

package/bin/rewardsEligibility/enums/RulesRelationCardinalityEnum.d.ts

@@ -0,0 +1 @@
+export * from '../../rules/enums/RulesRelationCardinalityEnum';

package/bin/rewardsEligibility/enums/RulesRelationCardinalityEnum.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../rules/enums/RulesRelationCardinalityEnum"), exports);

package/bin/rewardsEligibility/enums/RulesRelationTargetEnum.d.ts

@@ -0,0 +1 @@
+export * from '../../rules/enums/RulesRelationTargetEnum';

package/bin/rewardsEligibility/enums/RulesRelationTargetEnum.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../rules/enums/RulesRelationTargetEnum"), exports);

package/bin/rewardsEligibility/index.d.ts

@@ -30,6 +30,8 @@ export * from './dtos/EvaluationReward';
 export * from './dtos/EvaluationTrigger';
 export * from './enums/MetricsDimensionEnum';
 export * from './enums/RuleValueTypeEnum';
+export * from './enums/RulesRelationCardinalityEnum';
+export * from './enums/RulesRelationTargetEnum';
 export * from './enums/RulesChatRoleEnum';
 export * from './constants/BackofficeLimits';
 export * from './constants/BatchLimits';

package/bin/rewardsEligibility/index.js

@@ -52,6 +52,8 @@ __exportStar(require("./dtos/EvaluationTrigger"), exports);
 //Backoffice (fase 3): enums, constantes y DTOs
 __exportStar(require("./enums/MetricsDimensionEnum"), exports);
 __exportStar(require("./enums/RuleValueTypeEnum"), exports);
+__exportStar(require("./enums/RulesRelationCardinalityEnum"), exports);
+__exportStar(require("./enums/RulesRelationTargetEnum"), exports);
 __exportStar(require("./enums/RulesChatRoleEnum"), exports);
 __exportStar(require("./constants/BackofficeLimits"), exports);
 __exportStar(require("./constants/BatchLimits"), exports);

package/bin/rules/constants/RulesRelationLimits.d.ts

@@ -0,0 +1,15 @@
+/** Nombre de relación del catálogo (`referidos`, `referidor`). */
+export declare const RULES_RELATION_NAME_PATTERN: RegExp;
+/** Nombre con el que un bloque de relación expone su conteo como campo devuelto. */
+export declare const RULES_EXPOSE_AS_PATTERN: RegExp;
+/** Profundidad máxima de anidación de bloques de relación. */
+export declare const RULES_MAX_RELATION_DEPTH = 2;
+/** Máximo de bloques de relación por regla (todos los niveles). */
+export declare const RULES_MAX_RELATION_BLOCKS = 5;
+/** Máximo de días del operador `WITHIN_LAST_DAYS`. */
+export declare const RULES_MAX_WITHIN_LAST_DAYS = 365;
+/**
+ * Id del campo devuelto que expone un bloque de relación: `relación:exposeAs`
+ * (ej. `referidos:referidos_mx_count`). Cumple `RETURN_FIELD_ID_PATTERN`.
+ */
+export declare function relationReturnFieldId(relation: string, exposeAs: string): string;

package/bin/rules/constants/RulesRelationLimits.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULES_MAX_WITHIN_LAST_DAYS = exports.RULES_MAX_RELATION_BLOCKS = exports.RULES_MAX_RELATION_DEPTH = exports.RULES_EXPOSE_AS_PATTERN = exports.RULES_RELATION_NAME_PATTERN = void 0;
+exports.relationReturnFieldId = relationReturnFieldId;
+/** Nombre de relación del catálogo (`referidos`, `referidor`). */
+exports.RULES_RELATION_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+/** Nombre con el que un bloque de relación expone su conteo como campo devuelto. */
+exports.RULES_EXPOSE_AS_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
+/** Profundidad máxima de anidación de bloques de relación. */
+exports.RULES_MAX_RELATION_DEPTH = 2;
+/** Máximo de bloques de relación por regla (todos los niveles). */
+exports.RULES_MAX_RELATION_BLOCKS = 5;
+/** Máximo de días del operador `WITHIN_LAST_DAYS`. */
+exports.RULES_MAX_WITHIN_LAST_DAYS = 365;
+/**
+ * Id del campo devuelto que expone un bloque de relación: `relación:exposeAs`
+ * (ej. `referidos:referidos_mx_count`). Cumple `RETURN_FIELD_ID_PATTERN`.
+ */
+function relationReturnFieldId(relation, exposeAs) {
+    return `${relation}:${exposeAs}`;
+}

package/bin/rules/dtos/RulesCatalogResponse.d.ts

@@ -1,4 +1,6 @@
 import { InputField } from '../../dynamicForm/dtos/InputField';
+import { RulesRelationCardinalityEnum } from '../enums/RulesRelationCardinalityEnum';
+import { RulesRelationTargetEnum } from '../enums/RulesRelationTargetEnum';
 import { RulesValueTypeEnum } from '../enums/RulesValueTypeEnum';
 /** Un campo que un ítem del catálogo resuelve para las reglas. */
 export declare class RulesCatalogFieldResponse {
@@ -29,8 +31,22 @@ export declare class RulesCatalogItemResponse {
     description: string;
     fields: RulesCatalogFieldResponse[];
 }
+/** Una relación que las reglas pueden recorrer (ej. `referidos`): bloque `RELATION` con sub-regla. */
+export declare class RulesCatalogRelationResponse {
+    name: string;
+    label: string;
+    description: string;
+    cardinality: RulesRelationCardinalityEnum;
+    target: RulesRelationTargetEnum;
+    /** Solo LIVE: tope de relacionados por sujeto; excederlo da ERROR, nunca trunca. */
+    maxRelated?: number;
+    /** Solo target RECORD: campos propios del registro. */
+    fields?: RulesCatalogFieldResponse[];
+}
 export declare class RulesCatalogResponse {
     items: RulesCatalogItemResponse[];
     /** Etiqueta legible de cada operador (`GTE` → «≥»). */
     operators: Record<string, string>;
+    /** Relaciones disponibles (vacío si no hay). */
+    relations: RulesCatalogRelationResponse[];
 }

package/bin/rules/dtos/RulesCatalogResponse.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RulesCatalogResponse = exports.RulesCatalogItemResponse = exports.RulesCatalogFieldResponse = void 0;
+exports.RulesCatalogResponse = exports.RulesCatalogRelationResponse = exports.RulesCatalogItemResponse = exports.RulesCatalogFieldResponse = void 0;
 /** Un campo que un ítem del catálogo resuelve para las reglas. */
 class RulesCatalogFieldResponse {
 }
@@ -9,6 +9,10 @@ exports.RulesCatalogFieldResponse = RulesCatalogFieldResponse;
 class RulesCatalogItemResponse {
 }
 exports.RulesCatalogItemResponse = RulesCatalogItemResponse;
+/** Una relación que las reglas pueden recorrer (ej. `referidos`): bloque `RELATION` con sub-regla. */
+class RulesCatalogRelationResponse {
+}
+exports.RulesCatalogRelationResponse = RulesCatalogRelationResponse;
 class RulesCatalogResponse {
 }
 exports.RulesCatalogResponse = RulesCatalogResponse;