@fiado/type-kit 3.595.0 → 3.597.0

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

@@ -19,10 +19,43 @@ export declare class RulesTraceConditionResponse {
         message: string;
     };
 }
+/** Un relacionado evaluado dentro de un bloque de relación, con su traza propia. */
+export declare class RulesTraceRelatedResponse {
+    directoryId: string;
+    outcome: RulesOutcomeEnum;
+    trace: RulesTraceResponse;
+}
+/**
+ * Un bloque de relación evaluado (ej. «referidos»). Discriminante: `kind: 'RELATION'`.
+ * No lleva `origin`/`asOf`; los relacionados pueden llevarlos en su `trace` anidado.
+ */
+export declare class RulesTraceRelationResponse {
+    kind: 'RELATION';
+    relation: string;
+    quantifier?: {
+        kind: 'ANY' | 'ALL' | 'COUNT';
+        op?: 'GT' | 'GTE' | 'EQ' | 'LT' | 'LTE';
+        value?: number;
+    };
+    exposeAs?: string;
+    outcome: RulesOutcomeEnum;
+    matched: number;
+    errored: number;
+    total: number;
+    related: RulesTraceRelatedResponse[];
+    /**
+     * Solo si `outcome` es `ERROR`. `code` ∈ `RELATION_NOT_RESOLVED`, `RELATED_UNDECIDABLE`,
+     * `RELATION_CARDINALITY_VIOLATION`, `MAX_DEPTH_EXCEEDED` o el código del resolver (`MAX_RELATED_EXCEEDED`, `RESOLVER_FAILED`…).
+     */
+    error?: {
+        code: string;
+        message: string;
+    };
+}
 export declare class RulesTraceGroupResponse {
     match: 'ALL' | 'ANY';
     outcome: RulesOutcomeEnum;
-    conditions: RulesTraceConditionResponse[];
+    conditions: (RulesTraceConditionResponse | RulesTraceRelationResponse)[];
 }
 /** Traza completa de una evaluación: por qué cumplió o no. */
 export declare class RulesTraceResponse {

package/bin/rules/dtos/RulesTraceResponse.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RulesTraceResponse = exports.RulesTraceGroupResponse = exports.RulesTraceConditionResponse = void 0;
+exports.RulesTraceResponse = exports.RulesTraceGroupResponse = exports.RulesTraceRelationResponse = exports.RulesTraceRelatedResponse = exports.RulesTraceConditionResponse = void 0;
 /**
  * Una condición evaluada: qué se esperaba y qué se encontró.
  * Sin `origin`/`asOf`: el central no sabe de dónde salió el dato; el consumidor (rewards) los agrega.
@@ -8,6 +8,17 @@ exports.RulesTraceResponse = exports.RulesTraceGroupResponse = exports.RulesTrac
 class RulesTraceConditionResponse {
 }
 exports.RulesTraceConditionResponse = RulesTraceConditionResponse;
+/** Un relacionado evaluado dentro de un bloque de relación, con su traza propia. */
+class RulesTraceRelatedResponse {
+}
+exports.RulesTraceRelatedResponse = RulesTraceRelatedResponse;
+/**
+ * Un bloque de relación evaluado (ej. «referidos»). Discriminante: `kind: 'RELATION'`.
+ * No lleva `origin`/`asOf`; los relacionados pueden llevarlos en su `trace` anidado.
+ */
+class RulesTraceRelationResponse {
+}
+exports.RulesTraceRelationResponse = RulesTraceRelationResponse;
 class RulesTraceGroupResponse {
 }
 exports.RulesTraceGroupResponse = RulesTraceGroupResponse;

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

@@ -1,6 +1,28 @@
+import { RulesNodeErrorCodeEnum } from '../enums/RulesNodeErrorCodeEnum';
+import { RulesValueTypeEnum } from '../enums/RulesValueTypeEnum';
+/** Error de validación de un nodo del árbol de la regla (bloque de relación o condición). */
+export declare class RulesNodeValidationErrorResponse {
+    /** Ruta del nodo dentro de la regla (para pintar el error en el editor). */
+    path: string;
+    code: RulesNodeErrorCodeEnum;
+    message: string;
+}
+/** Campo devuelto que expone un bloque de relación con `exposeAs`. */
+export declare class RulesExposedFieldResponse {
+    /** `relación:exposeAs` (ver `relationReturnFieldId`); cumple `RETURN_FIELD_ID_PATTERN`. */
+    id: string;
+    relation: string;
+    exposeAs: string;
+    /** Siempre `NUMBER` (conteo de relacionados). */
+    valueType: RulesValueTypeEnum;
+}
 /** Resultado de `POST /validate`. */
 export declare class ValidateRulesResponse {
     valid: boolean;
     /** Mensajes de `validateRule`, tal cual (vacío si `valid`). */
     errors: string[];
+    /** Errores por nodo de relación (vacío si no hay). */
+    nodeErrors: RulesNodeValidationErrorResponse[];
+    /** Campos que la regla puede devolver vía `exposeAs` (vacío si no hay). */
+    exposedFields: RulesExposedFieldResponse[];
 }

package/bin/rules/dtos/ValidateRulesResponse.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidateRulesResponse = void 0;
+exports.ValidateRulesResponse = exports.RulesExposedFieldResponse = exports.RulesNodeValidationErrorResponse = void 0;
+/** Error de validación de un nodo del árbol de la regla (bloque de relación o condición). */
+class RulesNodeValidationErrorResponse {
+}
+exports.RulesNodeValidationErrorResponse = RulesNodeValidationErrorResponse;
+/** Campo devuelto que expone un bloque de relación con `exposeAs`. */
+class RulesExposedFieldResponse {
+}
+exports.RulesExposedFieldResponse = RulesExposedFieldResponse;
 /** Resultado de `POST /validate`. */
 class ValidateRulesResponse {
 }

package/bin/rules/dtos/population/SegmentGroup.d.ts

@@ -1,7 +1,8 @@
 import { SegmentMatchEnum } from '../../enums/SegmentMatchEnum';
 import { SegmentAggregateCondition } from './SegmentAggregateCondition';
 import { SegmentColumnCondition } from './SegmentColumnCondition';
-export type SegmentCondition = SegmentColumnCondition | SegmentAggregateCondition;
+import { SegmentRelationCondition } from './SegmentRelationCondition';
+export type SegmentCondition = SegmentColumnCondition | SegmentAggregateCondition | SegmentRelationCondition;
 export declare class SegmentGroup {
     match: SegmentMatchEnum;
     /** `kind` decide la clase; un `kind` desconocido NO se instancia y la validacion lo rechaza (el objeto queda sin `@Equals` valido). */

package/bin/rules/dtos/population/SegmentGroup.js

@@ -16,6 +16,7 @@ const SegmentConditionKindEnum_1 = require("../../enums/SegmentConditionKindEnum
 const SegmentMatchEnum_1 = require("../../enums/SegmentMatchEnum");
 const SegmentAggregateCondition_1 = require("./SegmentAggregateCondition");
 const SegmentColumnCondition_1 = require("./SegmentColumnCondition");
+const SegmentRelationCondition_1 = require("./SegmentRelationCondition");
 class SegmentGroup {
 }
 exports.SegmentGroup = SegmentGroup;
@@ -37,6 +38,7 @@ __decorate([
             subTypes: [
                 { value: SegmentColumnCondition_1.SegmentColumnCondition, name: SegmentConditionKindEnum_1.SegmentConditionKindEnum.COLUMN },
                 { value: SegmentAggregateCondition_1.SegmentAggregateCondition, name: SegmentConditionKindEnum_1.SegmentConditionKindEnum.AGGREGATE },
+                { value: SegmentRelationCondition_1.SegmentRelationCondition, name: SegmentConditionKindEnum_1.SegmentConditionKindEnum.RELATION },
             ],
         },
     }),

package/bin/rules/dtos/population/SegmentRelationCondition.d.ts

@@ -0,0 +1,18 @@
+import { SegmentConditionKindEnum } from '../../enums/SegmentConditionKindEnum';
+import { SegmentOperatorEnum } from '../../enums/SegmentOperatorEnum';
+import { SegmentRelationQuantifierKindEnum } from '../../enums/SegmentRelationQuantifierKindEnum';
+import { SegmentColumnCondition } from './SegmentColumnCondition';
+/** Cuantificador de una relacion 1:N. COUNT exige `op` y `value`; ANY/ALL no los llevan. */
+export declare class SegmentRelationQuantifier {
+    kind: SegmentRelationQuantifierKindEnum;
+    op?: SegmentOperatorEnum;
+    value?: number;
+}
+/** (c) Condicion sobre los relacionados de la persona (referidor / referidos). `filters` se aplica a cada relacionado. */
+export declare class SegmentRelationCondition {
+    kind: SegmentConditionKindEnum.RELATION;
+    relation: string;
+    /** MANY: obligatorio; ONE: ausente (lo valida el compilador, no el DTO). */
+    quantifier?: SegmentRelationQuantifier;
+    filters: SegmentColumnCondition[];
+}

package/bin/rules/dtos/population/SegmentRelationCondition.js

@@ -0,0 +1,69 @@
+"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.SegmentRelationCondition = exports.SegmentRelationQuantifier = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const RulesRelationLimits_1 = require("../../constants/RulesRelationLimits");
+const SegmentConditionKindEnum_1 = require("../../enums/SegmentConditionKindEnum");
+const SegmentOperatorEnum_1 = require("../../enums/SegmentOperatorEnum");
+const SegmentRelationQuantifierKindEnum_1 = require("../../enums/SegmentRelationQuantifierKindEnum");
+const SegmentColumnCondition_1 = require("./SegmentColumnCondition");
+/** Cuantificador de una relacion 1:N. COUNT exige `op` y `value`; ANY/ALL no los llevan. */
+class SegmentRelationQuantifier {
+}
+exports.SegmentRelationQuantifier = SegmentRelationQuantifier;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEnum)(SegmentRelationQuantifierKindEnum_1.SegmentRelationQuantifierKindEnum),
+    __metadata("design:type", String)
+], SegmentRelationQuantifier.prototype, "kind", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.ValidateIf)((q) => q.kind === SegmentRelationQuantifierKindEnum_1.SegmentRelationQuantifierKindEnum.COUNT || q.op !== undefined),
+    (0, class_validator_1.IsEnum)(SegmentOperatorEnum_1.SegmentOperatorEnum),
+    __metadata("design:type", String)
+], SegmentRelationQuantifier.prototype, "op", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.ValidateIf)((q) => q.kind === SegmentRelationQuantifierKindEnum_1.SegmentRelationQuantifierKindEnum.COUNT || q.value !== undefined),
+    (0, class_validator_1.IsNumber)(),
+    __metadata("design:type", Number)
+], SegmentRelationQuantifier.prototype, "value", void 0);
+/** (c) Condicion sobre los relacionados de la persona (referidor / referidos). `filters` se aplica a cada relacionado. */
+class SegmentRelationCondition {
+}
+exports.SegmentRelationCondition = SegmentRelationCondition;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Equals)(SegmentConditionKindEnum_1.SegmentConditionKindEnum.RELATION),
+    __metadata("design:type", String)
+], SegmentRelationCondition.prototype, "kind", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.Matches)(RulesRelationLimits_1.RULES_RELATION_NAME_PATTERN),
+    __metadata("design:type", String)
+], SegmentRelationCondition.prototype, "relation", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.ValidateNested)(),
+    (0, class_transformer_1.Type)(() => SegmentRelationQuantifier),
+    __metadata("design:type", SegmentRelationQuantifier)
+], SegmentRelationCondition.prototype, "quantifier", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayMaxSize)(10),
+    (0, class_validator_1.ValidateNested)({ each: true }),
+    (0, class_transformer_1.Type)(() => SegmentColumnCondition_1.SegmentColumnCondition),
+    __metadata("design:type", Array)
+], SegmentRelationCondition.prototype, "filters", void 0);

package/bin/rules/enums/RulesNodeErrorCodeEnum.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Códigos de error de validación de nodos de relación en `POST /validate`.
+ * Mismos strings que `RelationIssueCode` de `@fiado/rules-engine`.
+ */
+export declare enum RulesNodeErrorCodeEnum {
+    UNKNOWN_RELATION = "UNKNOWN_RELATION",
+    INVALID_RELATION_NODE = "INVALID_RELATION_NODE",
+    QUANTIFIER_REQUIRED = "QUANTIFIER_REQUIRED",
+    QUANTIFIER_NOT_ALLOWED = "QUANTIFIER_NOT_ALLOWED",
+    INVALID_QUANTIFIER = "INVALID_QUANTIFIER",
+    SUBJECT_IN_RELATION = "SUBJECT_IN_RELATION",
+    EXPOSE_AS_NOT_ALLOWED = "EXPOSE_AS_NOT_ALLOWED",
+    INVALID_EXPOSE_AS = "INVALID_EXPOSE_AS",
+    DUPLICATE_EXPOSE_AS = "DUPLICATE_EXPOSE_AS",
+    MAX_DEPTH_EXCEEDED = "MAX_DEPTH_EXCEEDED",
+    MAX_BLOCKS_EXCEEDED = "MAX_BLOCKS_EXCEEDED",
+    /** LIVE rechaza una sub-regla 1:N con fuentes que no consultan por lote. */
+    RELATION_SOURCE_NOT_BATCH_CAPABLE = "RELATION_SOURCE_NOT_BATCH_CAPABLE",
+    /** Runtime: un sujeto excede `maxRelated`. */
+    MAX_RELATED_EXCEEDED = "MAX_RELATED_EXCEEDED"
+}

package/bin/rules/enums/RulesNodeErrorCodeEnum.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RulesNodeErrorCodeEnum = void 0;
+/**
+ * Códigos de error de validación de nodos de relación en `POST /validate`.
+ * Mismos strings que `RelationIssueCode` de `@fiado/rules-engine`.
+ */
+var RulesNodeErrorCodeEnum;
+(function (RulesNodeErrorCodeEnum) {
+    RulesNodeErrorCodeEnum["UNKNOWN_RELATION"] = "UNKNOWN_RELATION";
+    RulesNodeErrorCodeEnum["INVALID_RELATION_NODE"] = "INVALID_RELATION_NODE";
+    RulesNodeErrorCodeEnum["QUANTIFIER_REQUIRED"] = "QUANTIFIER_REQUIRED";
+    RulesNodeErrorCodeEnum["QUANTIFIER_NOT_ALLOWED"] = "QUANTIFIER_NOT_ALLOWED";
+    RulesNodeErrorCodeEnum["INVALID_QUANTIFIER"] = "INVALID_QUANTIFIER";
+    RulesNodeErrorCodeEnum["SUBJECT_IN_RELATION"] = "SUBJECT_IN_RELATION";
+    RulesNodeErrorCodeEnum["EXPOSE_AS_NOT_ALLOWED"] = "EXPOSE_AS_NOT_ALLOWED";
+    RulesNodeErrorCodeEnum["INVALID_EXPOSE_AS"] = "INVALID_EXPOSE_AS";
+    RulesNodeErrorCodeEnum["DUPLICATE_EXPOSE_AS"] = "DUPLICATE_EXPOSE_AS";
+    RulesNodeErrorCodeEnum["MAX_DEPTH_EXCEEDED"] = "MAX_DEPTH_EXCEEDED";
+    RulesNodeErrorCodeEnum["MAX_BLOCKS_EXCEEDED"] = "MAX_BLOCKS_EXCEEDED";
+    /** LIVE rechaza una sub-regla 1:N con fuentes que no consultan por lote. */
+    RulesNodeErrorCodeEnum["RELATION_SOURCE_NOT_BATCH_CAPABLE"] = "RELATION_SOURCE_NOT_BATCH_CAPABLE";
+    /** Runtime: un sujeto excede `maxRelated`. */
+    RulesNodeErrorCodeEnum["MAX_RELATED_EXCEEDED"] = "MAX_RELATED_EXCEEDED";
+})(RulesNodeErrorCodeEnum || (exports.RulesNodeErrorCodeEnum = RulesNodeErrorCodeEnum = {}));

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

@@ -0,0 +1,5 @@
+/** Cardinalidad de una relación del catálogo de reglas: un relacionado (1:1) o varios (1:N). */
+export declare enum RulesRelationCardinalityEnum {
+    ONE = "ONE",
+    MANY = "MANY"
+}

package/bin/rules/enums/RulesRelationCardinalityEnum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RulesRelationCardinalityEnum = void 0;
+/** Cardinalidad de una relación del catálogo de reglas: un relacionado (1:1) o varios (1:N). */
+var RulesRelationCardinalityEnum;
+(function (RulesRelationCardinalityEnum) {
+    RulesRelationCardinalityEnum["ONE"] = "ONE";
+    RulesRelationCardinalityEnum["MANY"] = "MANY";
+})(RulesRelationCardinalityEnum || (exports.RulesRelationCardinalityEnum = RulesRelationCardinalityEnum = {}));

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

@@ -0,0 +1,5 @@
+/** A qué apunta una relación: otra persona (`PERSON`) o registros propios con campos (`RECORD`, ej. créditos). */
+export declare enum RulesRelationTargetEnum {
+    PERSON = "PERSON",
+    RECORD = "RECORD"
+}

package/bin/rules/enums/RulesRelationTargetEnum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RulesRelationTargetEnum = void 0;
+/** A qué apunta una relación: otra persona (`PERSON`) o registros propios con campos (`RECORD`, ej. créditos). */
+var RulesRelationTargetEnum;
+(function (RulesRelationTargetEnum) {
+    RulesRelationTargetEnum["PERSON"] = "PERSON";
+    RulesRelationTargetEnum["RECORD"] = "RECORD";
+})(RulesRelationTargetEnum || (exports.RulesRelationTargetEnum = RulesRelationTargetEnum = {}));

package/bin/rules/enums/SegmentConditionKindEnum.d.ts

@@ -1,4 +1,5 @@
 export declare enum SegmentConditionKindEnum {
     COLUMN = "COLUMN",
-    AGGREGATE = "AGGREGATE"
+    AGGREGATE = "AGGREGATE",
+    RELATION = "RELATION"
 }

package/bin/rules/enums/SegmentConditionKindEnum.js

@@ -5,4 +5,5 @@ var SegmentConditionKindEnum;
 (function (SegmentConditionKindEnum) {
     SegmentConditionKindEnum["COLUMN"] = "COLUMN";
     SegmentConditionKindEnum["AGGREGATE"] = "AGGREGATE";
+    SegmentConditionKindEnum["RELATION"] = "RELATION";
 })(SegmentConditionKindEnum || (exports.SegmentConditionKindEnum = SegmentConditionKindEnum = {}));

package/bin/rules/enums/SegmentRelationQuantifierKindEnum.d.ts

@@ -0,0 +1,5 @@
+export declare enum SegmentRelationQuantifierKindEnum {
+    ANY = "ANY",
+    ALL = "ALL",
+    COUNT = "COUNT"
+}

package/bin/rules/enums/SegmentRelationQuantifierKindEnum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentRelationQuantifierKindEnum = void 0;
+var SegmentRelationQuantifierKindEnum;
+(function (SegmentRelationQuantifierKindEnum) {
+    SegmentRelationQuantifierKindEnum["ANY"] = "ANY";
+    SegmentRelationQuantifierKindEnum["ALL"] = "ALL";
+    SegmentRelationQuantifierKindEnum["COUNT"] = "COUNT";
+})(SegmentRelationQuantifierKindEnum || (exports.SegmentRelationQuantifierKindEnum = SegmentRelationQuantifierKindEnum = {}));

package/bin/rules/index.d.ts

@@ -3,7 +3,11 @@ export * from './enums/RulesGenerationStatusEnum';
 export * from './enums/RulesChatRoleEnum';
 export * from './enums/RulesValueTypeEnum';
 export * from './enums/RulesErrorCodeEnum';
+export * from './enums/RulesRelationCardinalityEnum';
+export * from './enums/RulesRelationTargetEnum';
+export * from './enums/RulesNodeErrorCodeEnum';
 export * from './constants/RulesLimits';
+export * from './constants/RulesRelationLimits';
 export * from './dtos/RulesCatalogResponse';
 export * from './dtos/ValidateRulesRequest';
 export * from './dtos/ValidateRulesResponse';
@@ -16,6 +20,7 @@ export * from './dtos/EvaluateRulesResponse';
 export * from './enums/SegmentMatchEnum';
 export * from './enums/SegmentOutputEnum';
 export * from './enums/SegmentConditionKindEnum';
+export * from './enums/SegmentRelationQuantifierKindEnum';
 export * from './enums/SegmentAggregateFnEnum';
 export * from './enums/SegmentOperatorEnum';
 export * from './enums/SegmentParamTypeEnum';
@@ -24,6 +29,7 @@ export * from './constants/SegmentLimits';
 export * from './dtos/population/SegmentWindow';
 export * from './dtos/population/SegmentColumnCondition';
 export * from './dtos/population/SegmentAggregateCondition';
+export * from './dtos/population/SegmentRelationCondition';
 export * from './dtos/population/SegmentGroup';
 export * from './dtos/population/PopulationSegmentDefinition';
 export * from './dtos/population/SegmentParam';

package/bin/rules/index.js

@@ -20,8 +20,12 @@ __exportStar(require("./enums/RulesGenerationStatusEnum"), exports);
 __exportStar(require("./enums/RulesChatRoleEnum"), exports);
 __exportStar(require("./enums/RulesValueTypeEnum"), exports);
 __exportStar(require("./enums/RulesErrorCodeEnum"), exports);
+__exportStar(require("./enums/RulesRelationCardinalityEnum"), exports);
+__exportStar(require("./enums/RulesRelationTargetEnum"), exports);
+__exportStar(require("./enums/RulesNodeErrorCodeEnum"), exports);
 //Constants
 __exportStar(require("./constants/RulesLimits"), exports);
+__exportStar(require("./constants/RulesRelationLimits"), exports);
 //DTOs
 __exportStar(require("./dtos/RulesCatalogResponse"), exports);
 __exportStar(require("./dtos/ValidateRulesRequest"), exports);
@@ -36,6 +40,7 @@ __exportStar(require("./dtos/EvaluateRulesResponse"), exports);
 __exportStar(require("./enums/SegmentMatchEnum"), exports);
 __exportStar(require("./enums/SegmentOutputEnum"), exports);
 __exportStar(require("./enums/SegmentConditionKindEnum"), exports);
+__exportStar(require("./enums/SegmentRelationQuantifierKindEnum"), exports);
 __exportStar(require("./enums/SegmentAggregateFnEnum"), exports);
 __exportStar(require("./enums/SegmentOperatorEnum"), exports);
 __exportStar(require("./enums/SegmentParamTypeEnum"), exports);
@@ -44,6 +49,7 @@ __exportStar(require("./constants/SegmentLimits"), exports);
 __exportStar(require("./dtos/population/SegmentWindow"), exports);
 __exportStar(require("./dtos/population/SegmentColumnCondition"), exports);
 __exportStar(require("./dtos/population/SegmentAggregateCondition"), exports);
+__exportStar(require("./dtos/population/SegmentRelationCondition"), exports);
 __exportStar(require("./dtos/population/SegmentGroup"), exports);
 __exportStar(require("./dtos/population/PopulationSegmentDefinition"), exports);
 __exportStar(require("./dtos/population/SegmentParam"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiado/type-kit",
-  "version": "3.595.0",
+  "version": "3.597.0",
   "description": "",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",

package/src/retailPromotions/constants/retailPromotionsErrorHttpStatus.ts

@@ -31,7 +31,6 @@ export const RETAIL_PROMOTIONS_ERROR_HTTP_STATUS: Readonly<Record<C, 400 | 403 |
     [C.SALE_PROMOTION_HOLD_CONFLICT]: 409,
     [C.INVALID_NEXT_TOKEN]: 400,
     [C.CATALOG_SKU_NOT_FOUND]: 404,
-    [C.SPLIT_FINANCING_DISABLED]: 409,
     [C.PROMOTION_NOT_STACKABLE]: 422,
     [C.PROMOTION_PAYMENT_NOT_ELIGIBLE]: 422,
     [C.SYSTEM_PROMOTION_TRANSITION_NOT_ALLOWED]: 422,

package/src/retailPromotions/enums/RetailPromotionsErrorCodeEnum.ts

@@ -43,8 +43,6 @@ export 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/src/rewardsEligibility/dtos/backoffice/ResultTraceResponse.ts

@@ -20,10 +20,32 @@ export class TraceConditionResponse {
     error?: { code: string; message: string };
 }
 
+/** Un relacionado evaluado dentro de un bloque de relación, con su traza propia. */
+export class TraceRelatedResponse {
+    directoryId: string;
+    outcome: EvaluationOutcomeEnum;
+    trace: ResultTraceResponse;
+}
+
+/** Un bloque de relación evaluado (ej. «referidos»). Discriminante: `kind: 'RELATION'`. Sin `origin`/`asOf`. */
+export 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 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). */

package/src/rewardsEligibility/dtos/backoffice/RuleCatalogResponse.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`). */
@@ -25,8 +27,23 @@ export class RuleCatalogSourceResponse {
     fields: RuleCatalogFieldResponse[];
 }
 
+/** Una relación que las reglas pueden recorrer (espejo de `RulesCatalogRelationResponse`). */
+export 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 class RuleCatalogResponse {
     sources: RuleCatalogSourceResponse[];
     /** Etiqueta legible de cada operador (`GTE` → «≥»). */
     operators: Record<string, string>;
+    /** Relaciones disponibles (vacío si no hay). */
+    relations: RuleCatalogRelationResponse[];
 }

package/src/rewardsEligibility/enums/RulesRelationCardinalityEnum.ts

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

package/src/rewardsEligibility/enums/RulesRelationTargetEnum.ts

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

package/src/rewardsEligibility/index.ts

@@ -41,6 +41,8 @@ export * from './dtos/EvaluationTrigger';
 //Backoffice (fase 3): enums, constantes y DTOs
 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/src/rules/constants/RulesRelationLimits.ts

@@ -0,0 +1,18 @@
+/** Nombre de relación del catálogo (`referidos`, `referidor`). */
+export const RULES_RELATION_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+/** Nombre con el que un bloque de relación expone su conteo como campo devuelto. */
+export const RULES_EXPOSE_AS_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
+/** Profundidad máxima de anidación de bloques de relación. */
+export const RULES_MAX_RELATION_DEPTH = 2;
+/** Máximo de bloques de relación por regla (todos los niveles). */
+export const RULES_MAX_RELATION_BLOCKS = 5;
+/** Máximo de días del operador `WITHIN_LAST_DAYS`. */
+export 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 function relationReturnFieldId(relation: string, exposeAs: string): string {
+    return `${relation}:${exposeAs}`;
+}

package/src/rules/dtos/RulesCatalogResponse.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. */
@@ -28,8 +30,23 @@ export class RulesCatalogItemResponse {
     fields: RulesCatalogFieldResponse[];
 }
 
+/** Una relación que las reglas pueden recorrer (ej. `referidos`): bloque `RELATION` con sub-regla. */
+export 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 class RulesCatalogResponse {
     items: RulesCatalogItemResponse[];
     /** Etiqueta legible de cada operador (`GTE` → «≥»). */
     operators: Record<string, string>;
+    /** Relaciones disponibles (vacío si no hay). */
+    relations: RulesCatalogRelationResponse[];
 }

package/src/rules/dtos/RulesTraceResponse.ts

@@ -18,10 +18,38 @@ export class RulesTraceConditionResponse {
     error?: { code: string; message: string };
 }
 
+/** Un relacionado evaluado dentro de un bloque de relación, con su traza propia. */
+export class RulesTraceRelatedResponse {
+    directoryId: string;
+    outcome: RulesOutcomeEnum;
+    trace: RulesTraceResponse;
+}
+
+/**
+ * Un bloque de relación evaluado (ej. «referidos»). Discriminante: `kind: 'RELATION'`.
+ * No lleva `origin`/`asOf`; los relacionados pueden llevarlos en su `trace` anidado.
+ */
+export class RulesTraceRelationResponse {
+    kind: 'RELATION';
+    relation: string;
+    quantifier?: { kind: 'ANY' | 'ALL' | 'COUNT'; op?: 'GT' | 'GTE' | 'EQ' | 'LT' | 'LTE'; value?: number };
+    exposeAs?: string;
+    outcome: RulesOutcomeEnum;
+    matched: number;
+    errored: number;
+    total: number;
+    related: RulesTraceRelatedResponse[];
+    /**
+     * Solo si `outcome` es `ERROR`. `code` ∈ `RELATION_NOT_RESOLVED`, `RELATED_UNDECIDABLE`,
+     * `RELATION_CARDINALITY_VIOLATION`, `MAX_DEPTH_EXCEEDED` o el código del resolver (`MAX_RELATED_EXCEEDED`, `RESOLVER_FAILED`…).
+     */
+    error?: { code: string; message: string };
+}
+
 export class RulesTraceGroupResponse {
     match: 'ALL' | 'ANY';
     outcome: RulesOutcomeEnum;
-    conditions: RulesTraceConditionResponse[];
+    conditions: (RulesTraceConditionResponse | RulesTraceRelationResponse)[];
 }
 
 /** Traza completa de una evaluación: por qué cumplió o no. */