igniteui-angular-core 14.1.2 → 14.2.0

package/esm2015/lib/WebFilteringEventArgsDetailDescriptionMetadata.js

@@ -0,0 +1,44 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Base, String_$type, markType } from "./type";
+import { Dictionary$2 } from "./Dictionary$2";
+import { WebFilteringExpressionsTreeDescriptionMetadata } from "./WebFilteringExpressionsTreeDescriptionMetadata";
+import { WebCancelableEventArgsDetailDescriptionMetadata } from "./WebCancelableEventArgsDetailDescriptionMetadata";
+import { WebFilteringEventArgsDetailDescription } from "./WebFilteringEventArgsDetailDescription";
+/**
+ * @hidden
+ */
+export let WebFilteringEventArgsDetailDescriptionMetadata = /*@__PURE__*/ (() => {
+    class WebFilteringEventArgsDetailDescriptionMetadata extends Base {
+        static b(a) {
+            if (WebFilteringEventArgsDetailDescriptionMetadata.a == null) {
+                WebFilteringEventArgsDetailDescriptionMetadata.a = new Dictionary$2(String_$type, String_$type, 0);
+                WebFilteringEventArgsDetailDescriptionMetadata.c(WebFilteringEventArgsDetailDescriptionMetadata.a);
+            }
+            if (a.j(WebFilteringEventArgsDetailDescriptionMetadata.a)) {
+                return;
+            }
+            a.y(WebFilteringEventArgsDetailDescriptionMetadata.a);
+            WebFilteringExpressionsTreeDescriptionMetadata.d(a);
+        }
+        static c(a) {
+            WebCancelableEventArgsDetailDescriptionMetadata.c(a);
+            a.item("__qualifiedNameTS", "String:FilteringEventArgsDetail");
+            a.item("__packageNameWC", "String:grids");
+            a.item("__isPlainObject", "Boolean");
+            a.item("FilteringExpressions", "ExportedType:WebFilteringExpressionsTree");
+        }
+        static d(a) {
+            WebFilteringEventArgsDetailDescriptionMetadata.b(a);
+            a.aa("WebFilteringEventArgsDetail", () => new WebFilteringEventArgsDetailDescription());
+            a.z("WebFilteringEventArgsDetail", WebFilteringEventArgsDetailDescriptionMetadata.a);
+        }
+    }
+    WebFilteringEventArgsDetailDescriptionMetadata.$t = markType(WebFilteringEventArgsDetailDescriptionMetadata, 'WebFilteringEventArgsDetailDescriptionMetadata');
+    WebFilteringEventArgsDetailDescriptionMetadata.a = null;
+    return WebFilteringEventArgsDetailDescriptionMetadata;
+})();

package/esm2015/lib/WebFilteringExpressionsTreeDescription.js

@@ -0,0 +1,60 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Description } from "./Description";
+import { markType } from "./type";
+/**
+ * @hidden
+ */
+export let WebFilteringExpressionsTreeDescription = /*@__PURE__*/ (() => {
+    class WebFilteringExpressionsTreeDescription extends Description {
+        constructor() {
+            super();
+            this.f = null;
+            this.k = null;
+            this.j = null;
+            this.l = null;
+        }
+        get_type() {
+            return "WebFilteringExpressionsTree";
+        }
+        get type() {
+            return this.get_type();
+        }
+        get filteringOperands() {
+            return this.f;
+        }
+        set filteringOperands(a) {
+            this.f = a;
+            this.e("FilteringOperands");
+        }
+        get operator() {
+            return this.k;
+        }
+        set operator(a) {
+            this.k = a;
+            this.e("Operator");
+        }
+        get fieldName() {
+            return this.j;
+        }
+        set fieldName(a) {
+            this.j = a;
+            this.e("FieldName");
+        }
+        get treeType() {
+            return this.l;
+        }
+        set treeType(a) {
+            this.l = a;
+            this.e("TreeType");
+        }
+    }
+    WebFilteringExpressionsTreeDescription.$t = markType(WebFilteringExpressionsTreeDescription, 'WebFilteringExpressionsTreeDescription', Description.$);
+    WebFilteringExpressionsTreeDescription.__marshalByValue = true;
+    WebFilteringExpressionsTreeDescription.__marshalByValueAlias = "FilteringExpressionsTree";
+    return WebFilteringExpressionsTreeDescription;
+})();

package/esm2015/lib/WebFilteringExpressionsTreeDescriptionMetadata.js

@@ -0,0 +1,46 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Base, String_$type, markType } from "./type";
+import { Dictionary$2 } from "./Dictionary$2";
+import { WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata } from "./WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata";
+import { WebFilteringExpressionsTreeDescription } from "./WebFilteringExpressionsTreeDescription";
+/**
+ * @hidden
+ */
+export let WebFilteringExpressionsTreeDescriptionMetadata = /*@__PURE__*/ (() => {
+    class WebFilteringExpressionsTreeDescriptionMetadata extends Base {
+        static b(a) {
+            if (WebFilteringExpressionsTreeDescriptionMetadata.a == null) {
+                WebFilteringExpressionsTreeDescriptionMetadata.a = new Dictionary$2(String_$type, String_$type, 0);
+                WebFilteringExpressionsTreeDescriptionMetadata.c(WebFilteringExpressionsTreeDescriptionMetadata.a);
+            }
+            if (a.j(WebFilteringExpressionsTreeDescriptionMetadata.a)) {
+                return;
+            }
+            a.y(WebFilteringExpressionsTreeDescriptionMetadata.a);
+            WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata.d(a);
+        }
+        static c(a) {
+            a.item("__qualifiedNameTS", "String:FilteringExpressionsTree");
+            a.item("__packageNameWC", "String:grids");
+            a.item("FilteringOperands", "ExportedType:WebFilteringExpressionsTreeOrFilteringExpression");
+            a.item("Operator", "ExportedType:string:FilteringLogic");
+            a.item("Operator@names", "And;Or");
+            a.item("FieldName", "String");
+            a.item("TreeType", "(wc:Type)ExportedType:string:FilteringExpressionsTreeType");
+            a.item("TreeType@names", "Regular;Advanced");
+        }
+        static d(a) {
+            WebFilteringExpressionsTreeDescriptionMetadata.b(a);
+            a.aa("WebFilteringExpressionsTree", () => new WebFilteringExpressionsTreeDescription());
+            a.z("WebFilteringExpressionsTree", WebFilteringExpressionsTreeDescriptionMetadata.a);
+        }
+    }
+    WebFilteringExpressionsTreeDescriptionMetadata.$t = markType(WebFilteringExpressionsTreeDescriptionMetadata, 'WebFilteringExpressionsTreeDescriptionMetadata');
+    WebFilteringExpressionsTreeDescriptionMetadata.a = null;
+    return WebFilteringExpressionsTreeDescriptionMetadata;
+})();

package/esm2015/lib/WebFilteringExpressionsTreeDetailDescription.js

@@ -0,0 +1,60 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Description } from "./Description";
+import { markType } from "./type";
+/**
+ * @hidden
+ */
+export let WebFilteringExpressionsTreeDetailDescription = /*@__PURE__*/ (() => {
+    class WebFilteringExpressionsTreeDetailDescription extends Description {
+        constructor() {
+            super();
+            this.f = null;
+            this.k = null;
+            this.j = null;
+            this.l = null;
+        }
+        get_type() {
+            return "WebFilteringExpressionsTreeDetail";
+        }
+        get type() {
+            return this.get_type();
+        }
+        get filteringOperands() {
+            return this.f;
+        }
+        set filteringOperands(a) {
+            this.f = a;
+            this.e("FilteringOperands");
+        }
+        get operator() {
+            return this.k;
+        }
+        set operator(a) {
+            this.k = a;
+            this.e("Operator");
+        }
+        get fieldName() {
+            return this.j;
+        }
+        set fieldName(a) {
+            this.j = a;
+            this.e("FieldName");
+        }
+        get treeType() {
+            return this.l;
+        }
+        set treeType(a) {
+            this.l = a;
+            this.e("TreeType");
+        }
+    }
+    WebFilteringExpressionsTreeDetailDescription.$t = markType(WebFilteringExpressionsTreeDetailDescription, 'WebFilteringExpressionsTreeDetailDescription', Description.$);
+    WebFilteringExpressionsTreeDetailDescription.__marshalByValue = true;
+    WebFilteringExpressionsTreeDetailDescription.__marshalByValueAlias = "FilteringExpressionsTreeDetail";
+    return WebFilteringExpressionsTreeDetailDescription;
+})();

package/esm2015/lib/WebFilteringExpressionsTreeDetailDescriptionMetadata.js

@@ -0,0 +1,46 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Base, String_$type, markType } from "./type";
+import { Dictionary$2 } from "./Dictionary$2";
+import { WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata } from "./WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata";
+import { WebFilteringExpressionsTreeDetailDescription } from "./WebFilteringExpressionsTreeDetailDescription";
+/**
+ * @hidden
+ */
+export let WebFilteringExpressionsTreeDetailDescriptionMetadata = /*@__PURE__*/ (() => {
+    class WebFilteringExpressionsTreeDetailDescriptionMetadata extends Base {
+        static b(a) {
+            if (WebFilteringExpressionsTreeDetailDescriptionMetadata.a == null) {
+                WebFilteringExpressionsTreeDetailDescriptionMetadata.a = new Dictionary$2(String_$type, String_$type, 0);
+                WebFilteringExpressionsTreeDetailDescriptionMetadata.c(WebFilteringExpressionsTreeDetailDescriptionMetadata.a);
+            }
+            if (a.j(WebFilteringExpressionsTreeDetailDescriptionMetadata.a)) {
+                return;
+            }
+            a.y(WebFilteringExpressionsTreeDetailDescriptionMetadata.a);
+            WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata.d(a);
+        }
+        static c(a) {
+            a.item("__qualifiedNameTS", "String:FilteringExpressionsTreeDetail");
+            a.item("__packageNameWC", "String:grids");
+            a.item("FilteringOperands", "ExportedType:WebFilteringExpressionsTreeOrFilteringExpression");
+            a.item("Operator", "ExportedType:string:FilteringLogic");
+            a.item("Operator@names", "And;Or");
+            a.item("FieldName", "String");
+            a.item("TreeType", "(wc:Type)ExportedType:string:FilteringExpressionsTreeType");
+            a.item("TreeType@names", "Regular;Advanced");
+        }
+        static d(a) {
+            WebFilteringExpressionsTreeDetailDescriptionMetadata.b(a);
+            a.aa("WebFilteringExpressionsTreeDetail", () => new WebFilteringExpressionsTreeDetailDescription());
+            a.z("WebFilteringExpressionsTreeDetail", WebFilteringExpressionsTreeDetailDescriptionMetadata.a);
+        }
+    }
+    WebFilteringExpressionsTreeDetailDescriptionMetadata.$t = markType(WebFilteringExpressionsTreeDetailDescriptionMetadata, 'WebFilteringExpressionsTreeDetailDescriptionMetadata');
+    WebFilteringExpressionsTreeDetailDescriptionMetadata.a = null;
+    return WebFilteringExpressionsTreeDetailDescriptionMetadata;
+})();

package/esm2015/lib/WebFilteringExpressionsTreeEventArgsDescription.js

@@ -0,0 +1,36 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Description } from "./Description";
+import { markType } from "./type";
+/**
+ * @hidden
+ */
+export let WebFilteringExpressionsTreeEventArgsDescription = /*@__PURE__*/ (() => {
+    class WebFilteringExpressionsTreeEventArgsDescription extends Description {
+        constructor() {
+            super();
+            this.f = null;
+        }
+        get_type() {
+            return "WebFilteringExpressionsTreeEventArgs";
+        }
+        get type() {
+            return this.get_type();
+        }
+        get detail() {
+            return this.f;
+        }
+        set detail(a) {
+            this.f = a;
+            this.e("Detail");
+        }
+    }
+    WebFilteringExpressionsTreeEventArgsDescription.$t = markType(WebFilteringExpressionsTreeEventArgsDescription, 'WebFilteringExpressionsTreeEventArgsDescription', Description.$);
+    WebFilteringExpressionsTreeEventArgsDescription.__marshalByValue = true;
+    WebFilteringExpressionsTreeEventArgsDescription.__marshalByValueAlias = "FilteringExpressionsTreeEventArgs";
+    return WebFilteringExpressionsTreeEventArgsDescription;
+})();

package/esm2015/lib/WebFilteringExpressionsTreeEventArgsDescriptionMetadata.js

@@ -0,0 +1,40 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Base, String_$type, markType } from "./type";
+import { Dictionary$2 } from "./Dictionary$2";
+import { WebFilteringExpressionsTreeDetailDescriptionMetadata } from "./WebFilteringExpressionsTreeDetailDescriptionMetadata";
+import { WebFilteringExpressionsTreeEventArgsDescription } from "./WebFilteringExpressionsTreeEventArgsDescription";
+/**
+ * @hidden
+ */
+export let WebFilteringExpressionsTreeEventArgsDescriptionMetadata = /*@__PURE__*/ (() => {
+    class WebFilteringExpressionsTreeEventArgsDescriptionMetadata extends Base {
+        static b(a) {
+            if (WebFilteringExpressionsTreeEventArgsDescriptionMetadata.a == null) {
+                WebFilteringExpressionsTreeEventArgsDescriptionMetadata.a = new Dictionary$2(String_$type, String_$type, 0);
+                WebFilteringExpressionsTreeEventArgsDescriptionMetadata.c(WebFilteringExpressionsTreeEventArgsDescriptionMetadata.a);
+            }
+            if (a.j(WebFilteringExpressionsTreeEventArgsDescriptionMetadata.a)) {
+                return;
+            }
+            a.y(WebFilteringExpressionsTreeEventArgsDescriptionMetadata.a);
+            WebFilteringExpressionsTreeDetailDescriptionMetadata.d(a);
+        }
+        static c(a) {
+            a.item("__qualifiedNameTS", "String:FilteringExpressionsTreeEventArgs");
+            a.item("Detail", "ExportedType:WebFilteringExpressionsTreeDetail");
+        }
+        static d(a) {
+            WebFilteringExpressionsTreeEventArgsDescriptionMetadata.b(a);
+            a.aa("WebFilteringExpressionsTreeEventArgs", () => new WebFilteringExpressionsTreeEventArgsDescription());
+            a.z("WebFilteringExpressionsTreeEventArgs", WebFilteringExpressionsTreeEventArgsDescriptionMetadata.a);
+        }
+    }
+    WebFilteringExpressionsTreeEventArgsDescriptionMetadata.$t = markType(WebFilteringExpressionsTreeEventArgsDescriptionMetadata, 'WebFilteringExpressionsTreeEventArgsDescriptionMetadata');
+    WebFilteringExpressionsTreeEventArgsDescriptionMetadata.a = null;
+    return WebFilteringExpressionsTreeEventArgsDescriptionMetadata;
+})();

package/esm2015/lib/WebFilteringExpressionsTreeOrFilteringExpressionDescription.js

@@ -0,0 +1,26 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Description } from "./Description";
+import { markType } from "./type";
+/**
+ * @hidden
+ */
+export let WebFilteringExpressionsTreeOrFilteringExpressionDescription = /*@__PURE__*/ (() => {
+    class WebFilteringExpressionsTreeOrFilteringExpressionDescription extends Description {
+        constructor() {
+            super();
+        }
+        get_type() {
+            return "WebFilteringExpressionsTreeOrFilteringExpression";
+        }
+        get type() {
+            return this.get_type();
+        }
+    }
+    WebFilteringExpressionsTreeOrFilteringExpressionDescription.$t = markType(WebFilteringExpressionsTreeOrFilteringExpressionDescription, 'WebFilteringExpressionsTreeOrFilteringExpressionDescription', Description.$);
+    return WebFilteringExpressionsTreeOrFilteringExpressionDescription;
+})();

package/esm2015/lib/WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata.js

@@ -0,0 +1,37 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Base, String_$type, markType } from "./type";
+import { Dictionary$2 } from "./Dictionary$2";
+import { WebFilteringExpressionsTreeOrFilteringExpressionDescription } from "./WebFilteringExpressionsTreeOrFilteringExpressionDescription";
+/**
+ * @hidden
+ */
+export let WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata = /*@__PURE__*/ (() => {
+    class WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata extends Base {
+        static b(a) {
+            if (WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata.a == null) {
+                WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata.a = new Dictionary$2(String_$type, String_$type, 0);
+                WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata.c(WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata.a);
+            }
+            if (a.j(WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata.a)) {
+                return;
+            }
+            a.y(WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata.a);
+        }
+        static c(a) {
+            a.item("__qualifiedNameTS", "String:FilteringExpressionsTreeOrFilteringExpression");
+        }
+        static d(a) {
+            WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata.b(a);
+            a.aa("WebFilteringExpressionsTreeOrFilteringExpression", () => new WebFilteringExpressionsTreeOrFilteringExpressionDescription());
+            a.z("WebFilteringExpressionsTreeOrFilteringExpression", WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata.a);
+        }
+    }
+    WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata.$t = markType(WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata, 'WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata');
+    WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata.a = null;
+    return WebFilteringExpressionsTreeOrFilteringExpressionDescriptionMetadata;
+})();

package/esm2015/lib/WebFilteringExpressionsTreeOrFilteringOperationDescription.js

@@ -0,0 +1,26 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Description } from "./Description";
+import { markType } from "./type";
+/**
+ * @hidden
+ */
+export let WebFilteringExpressionsTreeOrFilteringOperationDescription = /*@__PURE__*/ (() => {
+    class WebFilteringExpressionsTreeOrFilteringOperationDescription extends Description {
+        constructor() {
+            super();
+        }
+        get_type() {
+            return "WebFilteringExpressionsTreeOrFilteringOperation";
+        }
+        get type() {
+            return this.get_type();
+        }
+    }
+    WebFilteringExpressionsTreeOrFilteringOperationDescription.$t = markType(WebFilteringExpressionsTreeOrFilteringOperationDescription, 'WebFilteringExpressionsTreeOrFilteringOperationDescription', Description.$);
+    return WebFilteringExpressionsTreeOrFilteringOperationDescription;
+})();

package/esm2015/lib/WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata.js

@@ -0,0 +1,37 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Base, String_$type, markType } from "./type";
+import { Dictionary$2 } from "./Dictionary$2";
+import { WebFilteringExpressionsTreeOrFilteringOperationDescription } from "./WebFilteringExpressionsTreeOrFilteringOperationDescription";
+/**
+ * @hidden
+ */
+export let WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata = /*@__PURE__*/ (() => {
+    class WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata extends Base {
+        static b(a) {
+            if (WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata.a == null) {
+                WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata.a = new Dictionary$2(String_$type, String_$type, 0);
+                WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata.c(WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata.a);
+            }
+            if (a.j(WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata.a)) {
+                return;
+            }
+            a.y(WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata.a);
+        }
+        static c(a) {
+            a.item("__qualifiedNameTS", "String:FilteringExpressionsTreeOrFilteringOperation");
+        }
+        static d(a) {
+            WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata.b(a);
+            a.aa("WebFilteringExpressionsTreeOrFilteringOperation", () => new WebFilteringExpressionsTreeOrFilteringOperationDescription());
+            a.z("WebFilteringExpressionsTreeOrFilteringOperation", WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata.a);
+        }
+    }
+    WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata.$t = markType(WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata, 'WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata');
+    WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata.a = null;
+    return WebFilteringExpressionsTreeOrFilteringOperationDescriptionMetadata;
+})();

package/esm2015/lib/{WebValueChangedEventArgsDescription.js → WebFilteringOperandDescription.js}

@@ -9,26 +9,26 @@ import { markType } from "./type";
 /**
  * @hidden
  */
-export let WebValueChangedEventArgsDescription = /*@__PURE__*/ (() => {
-    class WebValueChangedEventArgsDescription extends Description {
+export let WebFilteringOperandDescription = /*@__PURE__*/ (() => {
+    class WebFilteringOperandDescription extends Description {
         constructor() {
             super();
             this.f = null;
         }
         get_type() {
-            return "WebValueChangedEventArgs";
+            return "WebFilteringOperand";
         }
         get type() {
             return this.get_type();
         }
-        get details() {
+        get operations() {
             return this.f;
         }
-        set details(a) {
+        set operations(a) {
             this.f = a;
-            this.e("Details");
+            this.e("Operations");
         }
     }
-    WebValueChangedEventArgsDescription.$t = markType(WebValueChangedEventArgsDescription, 'WebValueChangedEventArgsDescription', Description.$);
-    return WebValueChangedEventArgsDescription;
+    WebFilteringOperandDescription.$t = markType(WebFilteringOperandDescription, 'WebFilteringOperandDescription', Description.$);
+    return WebFilteringOperandDescription;
 })();

package/esm2015/lib/WebFilteringOperandDescriptionMetadata.js

@@ -0,0 +1,41 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Base, String_$type, markType } from "./type";
+import { Dictionary$2 } from "./Dictionary$2";
+import { WebFilteringOperationDescriptionMetadata } from "./WebFilteringOperationDescriptionMetadata";
+import { WebFilteringOperandDescription } from "./WebFilteringOperandDescription";
+/**
+ * @hidden
+ */
+export let WebFilteringOperandDescriptionMetadata = /*@__PURE__*/ (() => {
+    class WebFilteringOperandDescriptionMetadata extends Base {
+        static b(a) {
+            if (WebFilteringOperandDescriptionMetadata.a == null) {
+                WebFilteringOperandDescriptionMetadata.a = new Dictionary$2(String_$type, String_$type, 0);
+                WebFilteringOperandDescriptionMetadata.c(WebFilteringOperandDescriptionMetadata.a);
+            }
+            if (a.j(WebFilteringOperandDescriptionMetadata.a)) {
+                return;
+            }
+            a.y(WebFilteringOperandDescriptionMetadata.a);
+            WebFilteringOperationDescriptionMetadata.d(a);
+        }
+        static c(a) {
+            a.item("__qualifiedNameTS", "String:FilteringOperand");
+            a.item("__packageNameWC", "String:grids");
+            a.item("Operations", "Array:WebFilteringOperationDescription:FilteringOperation");
+        }
+        static d(a) {
+            WebFilteringOperandDescriptionMetadata.b(a);
+            a.aa("WebFilteringOperand", () => new WebFilteringOperandDescription());
+            a.z("WebFilteringOperand", WebFilteringOperandDescriptionMetadata.a);
+        }
+    }
+    WebFilteringOperandDescriptionMetadata.$t = markType(WebFilteringOperandDescriptionMetadata, 'WebFilteringOperandDescriptionMetadata');
+    WebFilteringOperandDescriptionMetadata.a = null;
+    return WebFilteringOperandDescriptionMetadata;
+})();

package/esm2015/lib/WebFilteringOperationDescription.js

@@ -0,0 +1,60 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Description } from "./Description";
+import { markType } from "./type";
+/**
+ * @hidden
+ */
+export let WebFilteringOperationDescription = /*@__PURE__*/ (() => {
+    class WebFilteringOperationDescription extends Description {
+        constructor() {
+            super();
+            this.m = null;
+            this.h = false;
+            this.l = null;
+            this.g = false;
+        }
+        get_type() {
+            return "WebFilteringOperation";
+        }
+        get type() {
+            return this.get_type();
+        }
+        get name() {
+            return this.m;
+        }
+        set name(a) {
+            this.m = a;
+            this.e("Name");
+        }
+        get isUnary() {
+            return this.h;
+        }
+        set isUnary(a) {
+            this.h = a;
+            this.e("IsUnary");
+        }
+        get iconName() {
+            return this.l;
+        }
+        set iconName(a) {
+            this.l = a;
+            this.e("IconName");
+        }
+        get hidden() {
+            return this.g;
+        }
+        set hidden(a) {
+            this.g = a;
+            this.e("Hidden");
+        }
+    }
+    WebFilteringOperationDescription.$t = markType(WebFilteringOperationDescription, 'WebFilteringOperationDescription', Description.$);
+    WebFilteringOperationDescription.__marshalByValue = true;
+    WebFilteringOperationDescription.__marshalByValueAlias = "FilteringOperation";
+    return WebFilteringOperationDescription;
+})();

package/esm2015/lib/WebFilteringOperationDescriptionMetadata.js

@@ -0,0 +1,43 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Base, String_$type, markType } from "./type";
+import { Dictionary$2 } from "./Dictionary$2";
+import { WebFilteringOperationDescription } from "./WebFilteringOperationDescription";
+/**
+ * @hidden
+ */
+export let WebFilteringOperationDescriptionMetadata = /*@__PURE__*/ (() => {
+    class WebFilteringOperationDescriptionMetadata extends Base {
+        static b(a) {
+            if (WebFilteringOperationDescriptionMetadata.a == null) {
+                WebFilteringOperationDescriptionMetadata.a = new Dictionary$2(String_$type, String_$type, 0);
+                WebFilteringOperationDescriptionMetadata.c(WebFilteringOperationDescriptionMetadata.a);
+            }
+            if (a.j(WebFilteringOperationDescriptionMetadata.a)) {
+                return;
+            }
+            a.y(WebFilteringOperationDescriptionMetadata.a);
+        }
+        static c(a) {
+            a.item("__qualifiedNameTS", "String:FilteringOperation");
+            a.item("__packageNameWC", "String:grids");
+            a.item("__isPlainObject", "Boolean");
+            a.item("Name", "String");
+            a.item("IsUnary", "Boolean");
+            a.item("IconName", "String");
+            a.item("Hidden", "Boolean");
+        }
+        static d(a) {
+            WebFilteringOperationDescriptionMetadata.b(a);
+            a.aa("WebFilteringOperation", () => new WebFilteringOperationDescription());
+            a.z("WebFilteringOperation", WebFilteringOperationDescriptionMetadata.a);
+        }
+    }
+    WebFilteringOperationDescriptionMetadata.$t = markType(WebFilteringOperationDescriptionMetadata, 'WebFilteringOperationDescriptionMetadata');
+    WebFilteringOperationDescriptionMetadata.a = null;
+    return WebFilteringOperationDescriptionMetadata;
+})();