@fiado/type-kit 3.596.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/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/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/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/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

@@ -20,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';
@@ -28,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

@@ -40,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);
@@ -48,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.596.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/rules/dtos/population/SegmentGroup.ts

@@ -4,8 +4,9 @@ import { SegmentConditionKindEnum } from '../../enums/SegmentConditionKindEnum';
 import { SegmentMatchEnum } from '../../enums/SegmentMatchEnum';
 import { SegmentAggregateCondition } from './SegmentAggregateCondition';
 import { SegmentColumnCondition } from './SegmentColumnCondition';
+import { SegmentRelationCondition } from './SegmentRelationCondition';
 
-export type SegmentCondition = SegmentColumnCondition | SegmentAggregateCondition;
+export type SegmentCondition = SegmentColumnCondition | SegmentAggregateCondition | SegmentRelationCondition;
 
 export class SegmentGroup {
     @Expose() @IsEnum(SegmentMatchEnum) match: SegmentMatchEnum;
@@ -20,6 +21,7 @@ export class SegmentGroup {
             subTypes: [
                 { value: SegmentColumnCondition, name: SegmentConditionKindEnum.COLUMN },
                 { value: SegmentAggregateCondition, name: SegmentConditionKindEnum.AGGREGATE },
+                { value: SegmentRelationCondition, name: SegmentConditionKindEnum.RELATION },
             ],
         },
     })

package/src/rules/dtos/population/SegmentRelationCondition.ts

@@ -0,0 +1,25 @@
+import { Expose, Type } from 'class-transformer';
+import { ArrayMaxSize, Equals, IsArray, IsEnum, IsNumber, IsOptional, Matches, ValidateIf, ValidateNested } from 'class-validator';
+import { RULES_RELATION_NAME_PATTERN } from '../../constants/RulesRelationLimits';
+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 class SegmentRelationQuantifier {
+    @Expose() @IsEnum(SegmentRelationQuantifierKindEnum) kind: SegmentRelationQuantifierKindEnum;
+    @Expose() @ValidateIf((q: SegmentRelationQuantifier) => q.kind === SegmentRelationQuantifierKindEnum.COUNT || q.op !== undefined)
+    @IsEnum(SegmentOperatorEnum) op?: SegmentOperatorEnum;
+    @Expose() @ValidateIf((q: SegmentRelationQuantifier) => q.kind === SegmentRelationQuantifierKindEnum.COUNT || q.value !== undefined)
+    @IsNumber() value?: number;
+}
+
+/** (c) Condicion sobre los relacionados de la persona (referidor / referidos). `filters` se aplica a cada relacionado. */
+export class SegmentRelationCondition {
+    @Expose() @Equals(SegmentConditionKindEnum.RELATION) kind: SegmentConditionKindEnum.RELATION;
+    @Expose() @Matches(RULES_RELATION_NAME_PATTERN) relation: string;
+    /** MANY: obligatorio; ONE: ausente (lo valida el compilador, no el DTO). */
+    @Expose() @IsOptional() @ValidateNested() @Type(() => SegmentRelationQuantifier) quantifier?: SegmentRelationQuantifier;
+    @Expose() @IsArray() @ArrayMaxSize(10) @ValidateNested({ each: true }) @Type(() => SegmentColumnCondition) filters: SegmentColumnCondition[];
+}

package/src/rules/enums/SegmentConditionKindEnum.ts

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

package/src/rules/enums/SegmentRelationQuantifierKindEnum.ts

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

package/src/rules/index.ts

@@ -27,6 +27,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';
@@ -35,6 +36,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';