@frontegg/entitlements-javascript-commons 1.1.5 → 1.2.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { FeatureFlagEvaluationResult, FeatureFlag, evaluateFeatureFlag } from './feature-flags';
 export { PlanEvaluationResult, Plan, evaluatePlan } from './plans';
-export { TreatmentEnum, Rule } from './rules';
+export { TreatmentEnum, Rule, ConditionGroup, isConditionGroup } from './rules';
 export { Condition } from './conditions';
 export { OperationEnum, ConditionValue } from './operations/types';
 export { evaluateIsEntitledToFeature, evaluateIsEntitledToPermissions, prepareAttributes, checkPermission, createPermissionCheckRegex, Permissions, JwtAttributes, CustomAttributes, FronteggAttributes, NotEntitledJustification, UserEntitlementsContext, EntitlementResult, Attributes, } from './user-entitlements';

package/dist/index.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotEntitledJustification = exports.createPermissionCheckRegex = exports.checkPermission = exports.prepareAttributes = exports.evaluateIsEntitledToPermissions = exports.evaluateIsEntitledToFeature = exports.OperationEnum = exports.TreatmentEnum = exports.evaluatePlan = exports.evaluateFeatureFlag = void 0;
+exports.NotEntitledJustification = exports.createPermissionCheckRegex = exports.checkPermission = exports.prepareAttributes = exports.evaluateIsEntitledToPermissions = exports.evaluateIsEntitledToFeature = exports.OperationEnum = exports.isConditionGroup = exports.TreatmentEnum = exports.evaluatePlan = exports.evaluateFeatureFlag = void 0;
 var feature_flags_1 = require("./feature-flags");
 Object.defineProperty(exports, "evaluateFeatureFlag", { enumerable: true, get: function () { return feature_flags_1.evaluateFeatureFlag; } });
 var plans_1 = require("./plans");
 Object.defineProperty(exports, "evaluatePlan", { enumerable: true, get: function () { return plans_1.evaluatePlan; } });
 var rules_1 = require("./rules");
 Object.defineProperty(exports, "TreatmentEnum", { enumerable: true, get: function () { return rules_1.TreatmentEnum; } });
+Object.defineProperty(exports, "isConditionGroup", { enumerable: true, get: function () { return rules_1.isConditionGroup; } });
 var types_1 = require("./operations/types");
 Object.defineProperty(exports, "OperationEnum", { enumerable: true, get: function () { return types_1.OperationEnum; } });
 var user_entitlements_1 = require("./user-entitlements");

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,iDAAgG;AAA7C,oHAAA,mBAAmB,OAAA;AACtE,iCAAmE;AAA9B,qGAAA,YAAY,OAAA;AACjD,iCAA8C;AAArC,sGAAA,aAAa,OAAA;AAEtB,4CAAmE;AAA1D,sGAAA,aAAa,OAAA;AACtB,yDAc6B;AAb3B,gIAAA,2BAA2B,OAAA;AAC3B,oIAAA,+BAA+B,OAAA;AAC/B,sHAAA,iBAAiB,OAAA;AACjB,oHAAA,eAAe,OAAA;AACf,+HAAA,0BAA0B,OAAA;AAK1B,6HAAA,wBAAwB,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,iDAAgG;AAA7C,oHAAA,mBAAmB,OAAA;AACtE,iCAAmE;AAA9B,qGAAA,YAAY,OAAA;AACjD,iCAAgF;AAAvE,sGAAA,aAAa,OAAA;AAAwB,yGAAA,gBAAgB,OAAA;AAE9D,4CAAmE;AAA1D,sGAAA,aAAa,OAAA;AACtB,yDAc6B;AAb3B,gIAAA,2BAA2B,OAAA;AAC3B,oIAAA,+BAA+B,OAAA;AAC/B,sHAAA,iBAAiB,OAAA;AACjB,oHAAA,eAAe,OAAA;AACf,+HAAA,0BAA0B,OAAA;AAK1B,6HAAA,wBAAwB,OAAA"}

package/dist/rules/rule.evaluator.js

@@ -3,12 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRuleEvaluator = void 0;
 const types_1 = require("./types");
 const conditions_1 = require("../conditions");
+function evaluateGroup(group, attributes) {
+    const evaluateItem = (item) => {
+        if ((0, types_1.isConditionGroup)(item)) {
+            return evaluateGroup(item, attributes);
+        }
+        const evaluator = (0, conditions_1.createConditionEvaluator)({ condition: item });
+        return evaluator(attributes);
+    };
+    const arrayMethod = group.conditionLogic === types_1.ConditionLogicEnum.Or ? 'some' : 'every';
+    return group.conditions[arrayMethod](evaluateItem);
+}
 function createRuleEvaluator(payload) {
     return (attributes) => {
-        const isRuleTreatable = payload.rule.conditions.every((condition) => {
-            const evaluator = (0, conditions_1.createConditionEvaluator)({ condition });
-            return evaluator(attributes);
-        });
+        const isRuleTreatable = evaluateGroup(payload.rule, attributes);
         return isRuleTreatable ? types_1.RuleEvaluationResultEnum.Treatable : types_1.RuleEvaluationResultEnum.Insufficient;
     };
 }

package/dist/rules/rule.evaluator.js.map

@@ -1 +1 @@
-{"version":3,"file":"rule.evaluator.js","sourceRoot":"","sources":["../../src/rules/rule.evaluator.ts"],"names":[],"mappings":";;;AAAA,mCAA8F;AAC9F,8CAAyD;AAEzD,SAAgB,mBAAmB,CAAC,OAAmC;IACrE,OAAO,CAAC,UAAmC,EAA4B,EAAE;QACvE,MAAM,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,EAAE;YAClE,MAAM,SAAS,GAAG,IAAA,qCAAwB,EAAC,EAAE,SAAS,EAAE,CAAC,CAAC;YAE1D,OAAO,SAAS,CAAC,UAAU,CAAC,CAAC;QAC/B,CAAC,CAAC,CAAC;QAEH,OAAO,eAAe,CAAC,CAAC,CAAC,gCAAwB,CAAC,SAAS,CAAC,CAAC,CAAC,gCAAwB,CAAC,YAAY,CAAC;IACtG,CAAC,CAAC;AACJ,CAAC;AAVD,kDAUC"}
+{"version":3,"file":"rule.evaluator.js","sourceRoot":"","sources":["../../src/rules/rule.evaluator.ts"],"names":[],"mappings":";;;AAAA,mCAOiB;AACjB,8CAAoE;AAEpE,SAAS,aAAa,CAAC,KAAqB,EAAE,UAAmC;IAC/E,MAAM,YAAY,GAAG,CAAC,IAAgC,EAAW,EAAE;QACjE,IAAI,IAAA,wBAAgB,EAAC,IAAI,CAAC,EAAE;YAC1B,OAAO,aAAa,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;SACxC;QACD,MAAM,SAAS,GAAG,IAAA,qCAAwB,EAAC,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAChE,OAAO,SAAS,CAAC,UAAU,CAAC,CAAC;IAC/B,CAAC,CAAC;IAEF,MAAM,WAAW,GAAG,KAAK,CAAC,cAAc,KAAK,0BAAkB,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;IACtF,OAAO,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,YAAY,CAAC,CAAC;AACrD,CAAC;AAED,SAAgB,mBAAmB,CAAC,OAAmC;IACrE,OAAO,CAAC,UAAmC,EAA4B,EAAE;QACvE,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAChE,OAAO,eAAe,CAAC,CAAC,CAAC,gCAAwB,CAAC,SAAS,CAAC,CAAC,CAAC,gCAAwB,CAAC,YAAY,CAAC;IACtG,CAAC,CAAC;AACJ,CAAC;AALD,kDAKC"}

package/dist/rules/types.d.ts

@@ -1,11 +1,17 @@
 import { Condition } from '../conditions';
+export interface ConditionGroup {
+    conditionLogic: ConditionLogicEnum;
+    conditions: (Condition | ConditionGroup)[];
+}
+export declare function isConditionGroup(item: Condition | ConditionGroup): item is ConditionGroup;
 export interface Rule {
-    conditionLogic: ConditionLogicEnum.And;
-    conditions: Condition[];
+    conditionLogic: ConditionLogicEnum;
+    conditions: (Condition | ConditionGroup)[];
     treatment: TreatmentEnum;
 }
 export declare enum ConditionLogicEnum {
-    And = "and"
+    And = "and",
+    Or = "or"
 }
 export declare enum TreatmentEnum {
     True = "true",

package/dist/rules/types.js

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuleEvaluationResultEnum = exports.TreatmentEnum = exports.ConditionLogicEnum = void 0;
+exports.RuleEvaluationResultEnum = exports.TreatmentEnum = exports.ConditionLogicEnum = exports.isConditionGroup = void 0;
+function isConditionGroup(item) {
+    return 'conditionLogic' in item && !('op' in item);
+}
+exports.isConditionGroup = isConditionGroup;
 var ConditionLogicEnum;
 (function (ConditionLogicEnum) {
     ConditionLogicEnum["And"] = "and";
+    ConditionLogicEnum["Or"] = "or";
 })(ConditionLogicEnum = exports.ConditionLogicEnum || (exports.ConditionLogicEnum = {}));
 var TreatmentEnum;
 (function (TreatmentEnum) {

package/dist/rules/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/rules/types.ts"],"names":[],"mappings":";;;AAQA,IAAY,kBAEX;AAFD,WAAY,kBAAkB;IAC5B,iCAAW,CAAA;AACb,CAAC,EAFW,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAE7B;AAED,IAAY,aAGX;AAHD,WAAY,aAAa;IACvB,8BAAa,CAAA;IACb,gCAAe,CAAA;AACjB,CAAC,EAHW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAGxB;AAED,IAAY,wBAGX;AAHD,WAAY,wBAAwB;IAClC,mDAAuB,CAAA;IACvB,yDAA6B,CAAA;AAC/B,CAAC,EAHW,wBAAwB,GAAxB,gCAAwB,KAAxB,gCAAwB,QAGnC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/rules/types.ts"],"names":[],"mappings":";;;AAOA,SAAgB,gBAAgB,CAAC,IAAgC;IAC/D,OAAO,gBAAgB,IAAI,IAAI,IAAI,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC;AACrD,CAAC;AAFD,4CAEC;AAQD,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC5B,iCAAW,CAAA;IACX,+BAAS,CAAA;AACX,CAAC,EAHW,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAG7B;AAED,IAAY,aAGX;AAHD,WAAY,aAAa;IACvB,8BAAa,CAAA;IACb,gCAAe,CAAA;AACjB,CAAC,EAHW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAGxB;AAED,IAAY,wBAGX;AAHD,WAAY,wBAAwB;IAClC,mDAAuB,CAAA;IACvB,yDAA6B,CAAA;AAC/B,CAAC,EAHW,wBAAwB,GAAxB,gCAAwB,KAAxB,gCAAwB,QAGnC"}

package/docs/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [1.2.0](https://github.com/frontegg/entitlements-javascript-commons/compare/v-1.1.5...v-1.2.0) (2026-02-22)
+
+
+### Features
+
+* **or:** support or ([4ec8cc2](https://github.com/frontegg/entitlements-javascript-commons/commit/4ec8cc2e7669528c8418560c173e8dc9c237ff5b))
+
+# [1.2.0-alpha.1](https://github.com/frontegg/entitlements-javascript-commons/compare/v-1.1.5...v-1.2.0-alpha.1) (2026-02-19)
+
+
+### Features
+
+* **or:** support or ([4ec8cc2](https://github.com/frontegg/entitlements-javascript-commons/commit/4ec8cc2e7669528c8418560c173e8dc9c237ff5b))
+
 ## [1.1.5](https://github.com/frontegg/entitlements-javascript-commons/compare/v-1.1.4...v-1.1.5) (2026-02-15)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontegg/entitlements-javascript-commons",
-  "version": "1.1.5",
+  "version": "1.2.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -1,6 +1,6 @@
 export { FeatureFlagEvaluationResult, FeatureFlag, evaluateFeatureFlag } from './feature-flags';
 export { PlanEvaluationResult, Plan, evaluatePlan } from './plans';
-export { TreatmentEnum, Rule } from './rules';
+export { TreatmentEnum, Rule, ConditionGroup, isConditionGroup } from './rules';
 export { Condition } from './conditions';
 export { OperationEnum, ConditionValue } from './operations/types';
 export {

package/src/rules/rule.evaluator.ts

@@ -1,14 +1,29 @@
-import { CreateRuleEvaluatorPayload, RuleEvaluationResultEnum, RuleEvaluator } from './types';
-import { createConditionEvaluator } from '../conditions';
+import {
+  ConditionGroup,
+  ConditionLogicEnum,
+  CreateRuleEvaluatorPayload,
+  isConditionGroup,
+  RuleEvaluationResultEnum,
+  RuleEvaluator,
+} from './types';
+import { Condition, createConditionEvaluator } from '../conditions';
 
-export function createRuleEvaluator(payload: CreateRuleEvaluatorPayload): RuleEvaluator {
-  return (attributes: Record<string, unknown>): RuleEvaluationResultEnum => {
-    const isRuleTreatable = payload.rule.conditions.every((condition) => {
-      const evaluator = createConditionEvaluator({ condition });
+function evaluateGroup(group: ConditionGroup, attributes: Record<string, unknown>): boolean {
+  const evaluateItem = (item: Condition | ConditionGroup): boolean => {
+    if (isConditionGroup(item)) {
+      return evaluateGroup(item, attributes);
+    }
+    const evaluator = createConditionEvaluator({ condition: item });
+    return evaluator(attributes);
+  };
 
-      return evaluator(attributes);
-    });
+  const arrayMethod = group.conditionLogic === ConditionLogicEnum.Or ? 'some' : 'every';
+  return group.conditions[arrayMethod](evaluateItem);
+}
 
+export function createRuleEvaluator(payload: CreateRuleEvaluatorPayload): RuleEvaluator {
+  return (attributes: Record<string, unknown>): RuleEvaluationResultEnum => {
+    const isRuleTreatable = evaluateGroup(payload.rule, attributes);
     return isRuleTreatable ? RuleEvaluationResultEnum.Treatable : RuleEvaluationResultEnum.Insufficient;
   };
 }

package/src/rules/tests/rule.evaluator.spec.ts

@@ -1,4 +1,4 @@
-import { ConditionLogicEnum, Rule, RuleEvaluationResultEnum, TreatmentEnum } from '../types';
+import { ConditionGroup, ConditionLogicEnum, Rule, RuleEvaluationResultEnum, TreatmentEnum } from '../types';
 import { createRuleEvaluator } from '../rule.evaluator';
 import { OperationEnum } from '../../operations/types';
 
@@ -132,4 +132,257 @@ describe('RuleEvaluator', () => {
 
     expect(result).toEqual(RuleEvaluationResultEnum.Treatable);
   });
+
+  it('should return RuleEvaluationResultEnum.Treatable with "or" logic when at least one condition passes', () => {
+    const rule: Rule = {
+      treatment: TreatmentEnum.True,
+      conditions: [
+        {
+          attribute: 'attribute',
+          op: OperationEnum.StartsWith,
+          value: { list: ['no-match'] },
+          negate: false,
+        },
+        {
+          attribute: 'attribute',
+          op: OperationEnum.Contains,
+          value: { list: ['test'] },
+          negate: false,
+        },
+      ],
+      conditionLogic: ConditionLogicEnum.Or,
+    };
+
+    const ruleEvaluator = createRuleEvaluator({ rule });
+    const result = ruleEvaluator({ attribute: 'test' });
+
+    expect(result).toEqual(RuleEvaluationResultEnum.Treatable);
+  });
+
+  it('should return RuleEvaluationResultEnum.Insufficient with "or" logic when no conditions pass', () => {
+    const rule: Rule = {
+      treatment: TreatmentEnum.True,
+      conditions: [
+        {
+          attribute: 'attribute',
+          op: OperationEnum.StartsWith,
+          value: { list: ['no-match'] },
+          negate: false,
+        },
+        {
+          attribute: 'attribute',
+          op: OperationEnum.Contains,
+          value: { list: ['no-match'] },
+          negate: false,
+        },
+      ],
+      conditionLogic: ConditionLogicEnum.Or,
+    };
+
+    const ruleEvaluator = createRuleEvaluator({ rule });
+    const result = ruleEvaluator({ attribute: 'test' });
+
+    expect(result).toEqual(RuleEvaluationResultEnum.Insufficient);
+  });
+
+  it('should return RuleEvaluationResultEnum.Treatable with "or" logic when all conditions pass', () => {
+    const rule: Rule = {
+      treatment: TreatmentEnum.True,
+      conditions: [
+        {
+          attribute: 'attribute',
+          op: OperationEnum.InList,
+          value: { list: ['test'] },
+          negate: false,
+        },
+        {
+          attribute: 'attribute',
+          op: OperationEnum.Contains,
+          value: { list: ['test'] },
+          negate: false,
+        },
+      ],
+      conditionLogic: ConditionLogicEnum.Or,
+    };
+
+    const ruleEvaluator = createRuleEvaluator({ rule });
+    const result = ruleEvaluator({ attribute: 'test' });
+
+    expect(result).toEqual(RuleEvaluationResultEnum.Treatable);
+  });
+
+  describe('nested condition groups', () => {
+    it('should return Treatable for x | (y & z) when x passes but y & z do not', () => {
+      const rule: Rule = {
+        treatment: TreatmentEnum.True,
+        conditionLogic: ConditionLogicEnum.Or,
+        conditions: [
+          {
+            attribute: 'x',
+            op: OperationEnum.Equal,
+            value: { number: 1 },
+            negate: false,
+          },
+          {
+            conditionLogic: ConditionLogicEnum.And,
+            conditions: [
+              {
+                attribute: 'y',
+                op: OperationEnum.Equal,
+                value: { number: 1 },
+                negate: false,
+              },
+              {
+                attribute: 'z',
+                op: OperationEnum.Equal,
+                value: { number: 1 },
+                negate: false,
+              },
+            ],
+          } as ConditionGroup,
+        ],
+      };
+
+      const ruleEvaluator = createRuleEvaluator({ rule });
+      const result = ruleEvaluator({ x: 1, y: 0, z: 0 });
+
+      expect(result).toEqual(RuleEvaluationResultEnum.Treatable);
+    });
+
+    it('should return Insufficient for x | (y & z) when none pass', () => {
+      const rule: Rule = {
+        treatment: TreatmentEnum.True,
+        conditionLogic: ConditionLogicEnum.Or,
+        conditions: [
+          {
+            attribute: 'x',
+            op: OperationEnum.Equal,
+            value: { number: 1 },
+            negate: false,
+          },
+          {
+            conditionLogic: ConditionLogicEnum.And,
+            conditions: [
+              {
+                attribute: 'y',
+                op: OperationEnum.Equal,
+                value: { number: 1 },
+                negate: false,
+              },
+              {
+                attribute: 'z',
+                op: OperationEnum.Equal,
+                value: { number: 1 },
+                negate: false,
+              },
+            ],
+          } as ConditionGroup,
+        ],
+      };
+
+      const ruleEvaluator = createRuleEvaluator({ rule });
+      const result = ruleEvaluator({ x: 0, y: 0, z: 0 });
+
+      expect(result).toEqual(RuleEvaluationResultEnum.Insufficient);
+    });
+
+    it('should return Treatable for (a & b) | (c & d) when second group passes', () => {
+      const rule: Rule = {
+        treatment: TreatmentEnum.True,
+        conditionLogic: ConditionLogicEnum.Or,
+        conditions: [
+          {
+            conditionLogic: ConditionLogicEnum.And,
+            conditions: [
+              {
+                attribute: 'a',
+                op: OperationEnum.Equal,
+                value: { number: 1 },
+                negate: false,
+              },
+              {
+                attribute: 'b',
+                op: OperationEnum.Equal,
+                value: { number: 1 },
+                negate: false,
+              },
+            ],
+          } as ConditionGroup,
+          {
+            conditionLogic: ConditionLogicEnum.And,
+            conditions: [
+              {
+                attribute: 'c',
+                op: OperationEnum.Equal,
+                value: { number: 1 },
+                negate: false,
+              },
+              {
+                attribute: 'd',
+                op: OperationEnum.Equal,
+                value: { number: 1 },
+                negate: false,
+              },
+            ],
+          } as ConditionGroup,
+        ],
+      };
+
+      const ruleEvaluator = createRuleEvaluator({ rule });
+      const result = ruleEvaluator({ a: 0, b: 0, c: 1, d: 1 });
+
+      expect(result).toEqual(RuleEvaluationResultEnum.Treatable);
+    });
+
+    it('should handle deeply nested groups', () => {
+      const rule: Rule = {
+        treatment: TreatmentEnum.True,
+        conditionLogic: ConditionLogicEnum.And,
+        conditions: [
+          {
+            attribute: 'a',
+            op: OperationEnum.Equal,
+            value: { number: 1 },
+            negate: false,
+          },
+          {
+            conditionLogic: ConditionLogicEnum.Or,
+            conditions: [
+              {
+                attribute: 'b',
+                op: OperationEnum.Equal,
+                value: { number: 1 },
+                negate: false,
+              },
+              {
+                conditionLogic: ConditionLogicEnum.And,
+                conditions: [
+                  {
+                    attribute: 'c',
+                    op: OperationEnum.Equal,
+                    value: { number: 1 },
+                    negate: false,
+                  },
+                  {
+                    attribute: 'd',
+                    op: OperationEnum.Equal,
+                    value: { number: 1 },
+                    negate: false,
+                  },
+                ],
+              } as ConditionGroup,
+            ],
+          } as ConditionGroup,
+        ],
+      };
+
+      const ruleEvaluator = createRuleEvaluator({ rule });
+
+      // a=1 AND (b=0 OR (c=1 AND d=1)) -> 1 AND (0 OR 1) -> 1 AND 1 -> Treatable
+      expect(ruleEvaluator({ a: 1, b: 0, c: 1, d: 1 })).toEqual(RuleEvaluationResultEnum.Treatable);
+
+      // a=1 AND (b=0 OR (c=1 AND d=0)) -> 1 AND (0 OR 0) -> 1 AND 0 -> Insufficient
+      expect(ruleEvaluator({ a: 1, b: 0, c: 1, d: 0 })).toEqual(RuleEvaluationResultEnum.Insufficient);
+    });
+  });
 });

package/src/rules/types.ts

@@ -1,13 +1,23 @@
 import { Condition } from '../conditions';
 
+export interface ConditionGroup {
+  conditionLogic: ConditionLogicEnum;
+  conditions: (Condition | ConditionGroup)[];
+}
+
+export function isConditionGroup(item: Condition | ConditionGroup): item is ConditionGroup {
+  return 'conditionLogic' in item && !('op' in item);
+}
+
 export interface Rule {
-  conditionLogic: ConditionLogicEnum.And;
-  conditions: Condition[];
+  conditionLogic: ConditionLogicEnum;
+  conditions: (Condition | ConditionGroup)[];
   treatment: TreatmentEnum;
 }
 
 export enum ConditionLogicEnum {
   And = 'and',
+  Or = 'or',
 }
 
 export enum TreatmentEnum {