igniteui-angular-core 17.1.0 → 17.2.0-beta.0

package/esm2015/lib/DomainChartDescriptionMetadata.js

@@ -10,6 +10,7 @@ import { ChartSeriesEventArgsDescriptionMetadata } from "./ChartSeriesEventArgsD
 import { DomainChartSeriesPointerEventArgsDescriptionMetadata } from "./DomainChartSeriesPointerEventArgsDescriptionMetadata";
 import { CalloutStyleUpdatingEventArgsDescriptionMetadata } from "./CalloutStyleUpdatingEventArgsDescriptionMetadata";
 import { CalloutRenderStyleUpdatingEventArgsDescriptionMetadata } from "./CalloutRenderStyleUpdatingEventArgsDescriptionMetadata";
+import { FilterStringErrorsParsingEventArgsDescriptionMetadata } from "./FilterStringErrorsParsingEventArgsDescriptionMetadata";
 /**
  * @hidden
  */
@@ -28,6 +29,7 @@ export let DomainChartDescriptionMetadata = /*@__PURE__*/ (() => {
             DomainChartSeriesPointerEventArgsDescriptionMetadata.d(a);
             CalloutStyleUpdatingEventArgsDescriptionMetadata.d(a);
             CalloutRenderStyleUpdatingEventArgsDescriptionMetadata.d(a);
+            FilterStringErrorsParsingEventArgsDescriptionMetadata.d(a);
         }
         static c(a) {
             a.item("PixelScalingRatio", "Number:double");
@@ -189,14 +191,19 @@ export let DomainChartDescriptionMetadata = /*@__PURE__*/ (() => {
             a.item("GroupSortDescriptions", "Collection:ChartSortDescription:ChartSortDescriptionCollection:ChartSortDescription");
             a.item("GroupDescriptions", "Collection:ChartSortDescription:ChartSortDescriptionCollection:ChartSortDescription");
             a.item("FilterExpressions", "Collection:FilterExpression:FilterExpressionCollection:FilterExpression");
+            a.item("HighlightFilterExpressions", "Collection:FilterExpression:FilterExpressionCollection:FilterExpression");
             a.item("SummaryDescriptions", "Collection:ChartSummaryDescription:ChartSummaryDescriptionCollection:ChartSummaryDescription");
             a.item("InitialSortDescriptions", "Collection:ChartSortDescription:ChartSortDescriptionCollection:ChartSortDescription");
             a.item("InitialGroupSortDescriptions", "Collection:ChartSortDescription:ChartSortDescriptionCollection:ChartSortDescription");
             a.item("InitialGroupDescriptions", "Collection:ChartSortDescription:ChartSortDescriptionCollection:ChartSortDescription");
+            a.item("InitialFilterExpressions", "Collection:FilterExpression:FilterExpressionCollection:FilterExpression");
+            a.item("InitialHighlightFilterExpressions", "Collection:FilterExpression:FilterExpressionCollection:FilterExpression");
             a.item("InitialSummaryDescriptions", "Collection:ChartSummaryDescription:ChartSummaryDescriptionCollection:ChartSummaryDescription");
             a.item("InitialSorts", "String");
             a.item("GroupSorts", "String");
             a.item("InitialGroups", "String");
+            a.item("InitialFilter", "String");
+            a.item("InitialHighlightFilter", "String");
             a.item("InitialSummaries", "String");
             a.item("DataSourceRef", "(w:ItemsSource,xam:ItemsSource,wf:DataSource)DataRef::object");
             a.item("DataSource", "(w:ItemsSource,xam:ItemsSource)ExportedType:BaseDataSource:BaseDataSource");
@@ -211,6 +218,8 @@ export let DomainChartDescriptionMetadata = /*@__PURE__*/ (() => {
             a.item("IsVerticalZoomEnabled", "Boolean");
             a.item("ShouldDisplayMockData", "Boolean");
             a.item("ShouldUseSkeletonStyleForMockData", "Boolean");
+            a.item("HighlightedValuesDisplayMode", "ExportedType:string:SeriesHighlightedValuesDisplayMode");
+            a.item("HighlightedValuesDisplayMode@names", "Auto;Hidden;Overlay");
             a.item("IsSeriesHighlightingEnabled", "Boolean");
             a.item("WindowRect", "Rect");
             a.item("ChartTitle", "(w:Title,xam:Title,wf:Title)String");
@@ -342,6 +351,7 @@ export let DomainChartDescriptionMetadata = /*@__PURE__*/ (() => {
             a.item("SeriesPointerUpRef", "EventRef::seriesPointerUp");
             a.item("CalloutStyleUpdatingRef", "EventRef::calloutStyleUpdating");
             a.item("CalloutRenderStyleUpdatingRef", "EventRef::calloutRenderStyleUpdating");
+            a.item("FilterStringErrorsParsingRef", "EventRef::filterStringErrorsParsing");
         }
         static d(a) {
             DomainChartDescriptionMetadata.b(a);

package/esm2015/lib/FastStochasticOscillatorIndicatorDescription.js

@@ -13,16 +13,16 @@ export let FastStochasticOscillatorIndicatorDescription = /*@__PURE__*/ (() => {
     class FastStochasticOscillatorIndicatorDescription extends StrategyBasedIndicatorDescription {
         constructor() {
             super();
-            this.el = 0;
+            this.fn = 0;
         }
         get_type() {
             return "FastStochasticOscillatorIndicator";
         }
         get period() {
-            return this.el;
+            return this.fn;
         }
         set period(a) {
-            this.el = a;
+            this.fn = a;
             this.g("Period");
         }
     }

package/esm2015/lib/FilterExpressionConversionVisitor.js

@@ -0,0 +1,230 @@
+/*
+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 { FilterSyntaxVisitor } from "./FilterSyntaxVisitor";
+import { List$1 } from "./List$1";
+import { Stack$1 } from "./Stack$1";
+import { IFilterExpression_$type } from "./IFilterExpression";
+import { StringBuilder } from "./StringBuilder";
+import { OperationFilterExpression } from "./OperationFilterExpression";
+import { FilterSyntaxTokenType_$type } from "./FilterSyntaxTokenType";
+import { String_$type, EnumUtil, typeCast, enumGetBox, markType } from "./type";
+import { FilterSyntaxIdentifierExpressionSyntax } from "./FilterSyntaxIdentifierExpressionSyntax";
+import { PropertyReferenceFilterExpression } from "./PropertyReferenceFilterExpression";
+import { FilterExpressionFunctionType } from "./FilterExpressionFunctionType";
+import { FunctionFilterExpression } from "./FunctionFilterExpression";
+import { LiteralFilterExpression } from "./LiteralFilterExpression";
+/**
+ * @hidden
+ */
+export let FilterExpressionConversionVisitor = /*@__PURE__*/ (() => {
+    class FilterExpressionConversionVisitor extends FilterSyntaxVisitor {
+        constructor() {
+            super();
+            this.q = null;
+            this.n = null;
+            this.r = new Stack$1(IFilterExpression_$type);
+            this.s = new StringBuilder(0);
+            this.q = new List$1(String_$type, 0);
+        }
+        o() {
+            return this.r.e();
+        }
+        get p() {
+            return this.q.count > 0;
+        }
+        get k() {
+            return this.q.toArray();
+        }
+        c(a) {
+            this.b(a.b);
+            let b = this.r.e();
+            this.b(a.c);
+            let c = this.r.e();
+            let d = new OperationFilterExpression(null, 1, null);
+            d.operator = this.m(a.d);
+            d.left = b;
+            d.right = c;
+            this.r.h(d);
+        }
+        t(a) {
+            this.q.add(a);
+        }
+        m(a) {
+            switch (a) {
+                case 54: return 1;
+                case 55: return 2;
+                case 56: return 5;
+                case 57: return 6;
+                case 58: return 3;
+                case 59: return 4;
+                case 61: return 10;
+                case 62: return 11;
+                case 63: return 12;
+                case 64: return 13;
+                case 65: return 14;
+                case 66: return 9;
+                case 52: return 7;
+                case 53: return 8;
+            }
+            this.t("unexpected operator: " + EnumUtil.getName(FilterSyntaxTokenType_$type, a));
+            return 0;
+        }
+        d(a) {
+            let b = new PropertyReferenceFilterExpression(null);
+            b.propertyReference = a.c.toString();
+            this.r.h(b);
+        }
+        e(a) {
+            this.b(a.b);
+            let b = this.r.e();
+            if (a.c != null) {
+                this.b(a.c);
+                let c = this.r.e();
+                b.propertyReference += "." + c.propertyReference;
+            }
+            this.r.h(b);
+        }
+        f(a) {
+            let b = this.l(a.c);
+            let c = new FunctionFilterExpression(b, ...[]);
+            c.functionType = b;
+            if (a.b != null) {
+                let d = true;
+                let g = a.b;
+                for (let f = 0; f < g.length; f++) {
+                    let e = g[f];
+                    this.b(e);
+                    let h = this.r.e();
+                    c.functionArguments.add(h);
+                }
+            }
+            this.r.h(c);
+        }
+        l(a) {
+            if (typeCast(FilterSyntaxIdentifierExpressionSyntax.$, a) !== null) {
+                let b = a;
+                switch (b.b) {
+                    case 20:
+                        this.t("unsupported function: " + enumGetBox(FilterSyntaxTokenType_$type, b.b));
+                        return 7;
+                    case 21: return 2;
+                    case 22: return 1;
+                    case 23: return 5;
+                    case 24: return FilterExpressionFunctionType.Length;
+                    case 25: return 4;
+                    case 26: return 6;
+                    case 27: return 0;
+                    case 28: return 7;
+                    case 29: return 8;
+                    case 30: return 9;
+                    case 31: return 10;
+                    case 32: return 16;
+                    case 33: return 14;
+                    case 34: return 11;
+                    case 35:
+                        this.t("unsupported function: " + enumGetBox(FilterSyntaxTokenType_$type, b.b));
+                        return 7;
+                    case 36: return 12;
+                    case 37:
+                        this.t("unsupported function: " + enumGetBox(FilterSyntaxTokenType_$type, b.b));
+                        return 7;
+                    case 38: return 13;
+                    case 39:
+                        this.t("unsupported function: " + enumGetBox(FilterSyntaxTokenType_$type, b.b));
+                        return 7;
+                    case 40: return 15;
+                    case 41:
+                        this.t("unsupported function: " + enumGetBox(FilterSyntaxTokenType_$type, b.b));
+                        return 7;
+                    case 42: return 20;
+                    case 43: return 21;
+                    case 44: return 17;
+                    case 45: return 18;
+                    case 46: return 19;
+                    case 47:
+                        this.t("unsupported function: " + enumGetBox(FilterSyntaxTokenType_$type, b.b));
+                        return 7;
+                    case 48:
+                        this.t("unsupported function: " + enumGetBox(FilterSyntaxTokenType_$type, b.b));
+                        return 7;
+                    case 49:
+                        this.t("unsupported function: " + enumGetBox(FilterSyntaxTokenType_$type, b.b));
+                        return 7;
+                    case 50:
+                        this.t("unsupported function: " + enumGetBox(FilterSyntaxTokenType_$type, b.b));
+                        return 7;
+                    case 51: return 22;
+                    case 68: return 24;
+                }
+            }
+            this.t("unsupported function type");
+            return 7;
+        }
+        g(a) {
+            this.r.h(((() => {
+                let $ret = new LiteralFilterExpression(null, false);
+                $ret.literalValue = null;
+                return $ret;
+            })()));
+        }
+        h(a) {
+            let b = ((() => {
+                let $ret = new OperationFilterExpression(null, 1, null);
+                $ret.operator = 15;
+                return $ret;
+            })());
+            this.b(a.b);
+            let c = this.r.e();
+            b.left = c;
+            this.r.h(b);
+        }
+        i(a) {
+            switch (a.b) {
+                case 4:
+                case 3:
+                case 5:
+                    this.r.h(((() => {
+                        let $ret = new LiteralFilterExpression(null, false);
+                        $ret.literalValue = a.c;
+                        return $ret;
+                    })()));
+                    break;
+                case 0:
+                    this.r.h(((() => {
+                        let $ret = new LiteralFilterExpression(null, false);
+                        $ret.literalValue = a.c;
+                        return $ret;
+                    })()));
+                    break;
+                case 1:
+                    this.r.h(((() => {
+                        let $ret = new LiteralFilterExpression(null, false);
+                        $ret.literalValue = a.c;
+                        return $ret;
+                    })()));
+                    break;
+                case 2:
+                    this.r.h(((() => {
+                        let $ret = new LiteralFilterExpression(null, false);
+                        $ret.literalValue = a.c;
+                        return $ret;
+                    })()));
+                    break;
+            }
+        }
+        j(a) {
+            this.b(a.b);
+            let b = this.r.e();
+            let c = new OperationFilterExpression(null, 1, null);
+            c.operator = this.m(a.c);
+            c.left = b;
+            this.r.h(c);
+        }
+    }
+    FilterExpressionConversionVisitor.$t = markType(FilterExpressionConversionVisitor, 'FilterExpressionConversionVisitor', FilterSyntaxVisitor.$);
+    return FilterExpressionConversionVisitor;
+})();

package/esm2015/lib/FilterExpressionParsingHelper.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, markType } from "./type";
+import { FilterExpressionParsingResult } from "./FilterExpressionParsingResult";
+import { FilterSyntaxParser } from "./FilterSyntaxParser";
+import { FilterExpressionConversionVisitor } from "./FilterExpressionConversionVisitor";
+import { stringJoin } from "./string";
+/**
+ * @hidden
+ */
+export let FilterExpressionParsingHelper = /*@__PURE__*/ (() => {
+    class FilterExpressionParsingHelper extends Base {
+        static getFilterExpression(a) {
+            let b = new FilterExpressionParsingResult();
+            let c = new FilterSyntaxParser();
+            let d = c.d(a);
+            if (d.b) {
+                b.b = d.e;
+                return b;
+            }
+            let e = new FilterExpressionConversionVisitor();
+            e.b(d.a);
+            if (e.k != null && (e.k.length > 0)) {
+                b.b = stringJoin("\r\n", ...e.k);
+                return b;
+            }
+            b.a = e.o();
+            return b;
+        }
+    }
+    FilterExpressionParsingHelper.$t = markType(FilterExpressionParsingHelper, 'FilterExpressionParsingHelper');
+    return FilterExpressionParsingHelper;
+})();

package/esm2015/lib/FilterExpressionParsingResult.js

@@ -0,0 +1,21 @@
+/*
+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, markType } from "./type";
+/**
+ * @hidden
+ */
+export let FilterExpressionParsingResult = /*@__PURE__*/ (() => {
+    class FilterExpressionParsingResult extends Base {
+        constructor() {
+            super(...arguments);
+            this.a = null;
+            this.b = null;
+        }
+    }
+    FilterExpressionParsingResult.$t = markType(FilterExpressionParsingResult, 'FilterExpressionParsingResult');
+    return FilterExpressionParsingResult;
+})();

package/esm2015/lib/FilterFactory_combined.js

@@ -897,17 +897,17 @@ export let OperationFilterExpression = /*@__PURE__*/ (() => {
                 case 13:
                 case 14:
                 case 12:
-                case 11: return this.b2(a, b, c);
+                case 11: return this.b3(a, b, c);
                 case 0:
                 case 1:
                 case 3:
                 case 4:
                 case 5:
                 case 6:
-                case 2: return this.b3(a, b, c);
+                case 2: return this.b4(a, b, c);
                 case 7:
                 case 9:
-                case 8: return this.b4(a, b, c);
+                case 8: return this.b5(a, b, c);
                 case 15: if (this.left != null) {
                     return this.left.evaluate(a, b, c);
                 }
@@ -920,7 +920,7 @@ export let OperationFilterExpression = /*@__PURE__*/ (() => {
             }
             throw new NotImplementedException(0);
         }
-        b3(a, b, c) {
+        b4(a, b, c) {
             let d = null;
             let e = null;
             let f = -1;
@@ -944,6 +944,12 @@ export let OperationFilterExpression = /*@__PURE__*/ (() => {
             if (typeof d === 'number' && isNaN_(d) || typeof e === 'number' && isNaN_(e) || typeof d === 'number' && isNaN_(d) || typeof e === 'number' && isNaN_(e)) {
                 return false;
             }
+            if (typeof d === 'number' && !(typeof e === 'number')) {
+                e = OperationFilterExpression.b2(e);
+            }
+            if (typeof e === 'number' && !(typeof d === 'number')) {
+                d = OperationFilterExpression.b2(d);
+            }
             if (typeCast(Date_$type, d) !== null && typeCast(Date_$type, e) !== null) {
                 switch (this.operator) {
                     case 1: return d.getTime() == e.getTime();
@@ -1039,7 +1045,16 @@ export let OperationFilterExpression = /*@__PURE__*/ (() => {
             }
             throw new InvalidOperationException(0);
         }
-        b4(a, b, c) {
+        static b2(a) {
+            if (typeCast(Date_$type, a) !== null) {
+                return a.getTime();
+            }
+            if (a == null) {
+                return 0;
+            }
+            return a;
+        }
+        b5(a, b, c) {
             let d = null;
             let e = null;
             if (this.left != null) {
@@ -1069,7 +1084,7 @@ export let OperationFilterExpression = /*@__PURE__*/ (() => {
             }
             return false;
         }
-        b2(a, b, c) {
+        b3(a, b, c) {
             let d = null;
             let e = null;
             if (this.left != null) {
@@ -1248,11 +1263,17 @@ export let FunctionFilterExpression = /*@__PURE__*/ (() => {
                     if (d == null) {
                         d = 0;
                     }
+                    if (!(typeof d === 'number')) {
+                        d = OperationFilterExpression.b2(d);
+                    }
                     return Math.ceil(d);
                 case 18:
                     if (d == null) {
                         d = 0;
                     }
+                    if (!(typeof d === 'number')) {
+                        d = OperationFilterExpression.b2(d);
+                    }
                     return Math.floor(d);
                 case 17:
                     if (d == null) {
@@ -1261,6 +1282,9 @@ export let FunctionFilterExpression = /*@__PURE__*/ (() => {
                     if (typeof d === 'number') {
                         return Math.round(d);
                     }
+                    if (!(typeof d === 'number')) {
+                        d = OperationFilterExpression.b2(d);
+                    }
                     return Math.round(d);
                 case 11:
                     if (d == null) {

package/esm2015/lib/FilterStringErrorsParsingEventArgsDescription.js

@@ -0,0 +1,42 @@
+/*
+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 FilterStringErrorsParsingEventArgsDescription = /*@__PURE__*/ (() => {
+    class FilterStringErrorsParsingEventArgsDescription extends Description {
+        constructor() {
+            super();
+            this.i = null;
+            this.h = null;
+        }
+        get_type() {
+            return "FilterStringErrorsParsingEventArgs";
+        }
+        get type() {
+            return this.get_type();
+        }
+        get propertyName() {
+            return this.i;
+        }
+        set propertyName(a) {
+            this.i = a;
+            this.g("PropertyName");
+        }
+        get errors() {
+            return this.h;
+        }
+        set errors(a) {
+            this.h = a;
+            this.g("Errors");
+        }
+    }
+    FilterStringErrorsParsingEventArgsDescription.$t = markType(FilterStringErrorsParsingEventArgsDescription, 'FilterStringErrorsParsingEventArgsDescription', Description.$);
+    return FilterStringErrorsParsingEventArgsDescription;
+})();

package/esm2015/lib/FilterStringErrorsParsingEventArgsDescriptionMetadata.js

@@ -0,0 +1,38 @@
+/*
+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 { FilterStringErrorsParsingEventArgsDescription } from "./FilterStringErrorsParsingEventArgsDescription";
+/**
+ * @hidden
+ */
+export let FilterStringErrorsParsingEventArgsDescriptionMetadata = /*@__PURE__*/ (() => {
+    class FilterStringErrorsParsingEventArgsDescriptionMetadata extends Base {
+        static b(a) {
+            if (FilterStringErrorsParsingEventArgsDescriptionMetadata.a == null) {
+                FilterStringErrorsParsingEventArgsDescriptionMetadata.a = new Dictionary$2(String_$type, String_$type, 0);
+                FilterStringErrorsParsingEventArgsDescriptionMetadata.c(FilterStringErrorsParsingEventArgsDescriptionMetadata.a);
+            }
+            if (a.k(FilterStringErrorsParsingEventArgsDescriptionMetadata.a)) {
+                return;
+            }
+            a.ab(FilterStringErrorsParsingEventArgsDescriptionMetadata.a);
+        }
+        static c(a) {
+            a.item("PropertyName", "String");
+            a.item("Errors", "String");
+        }
+        static d(a) {
+            FilterStringErrorsParsingEventArgsDescriptionMetadata.b(a);
+            a.ad("FilterStringErrorsParsingEventArgs", () => new FilterStringErrorsParsingEventArgsDescription());
+            a.ac("FilterStringErrorsParsingEventArgs", FilterStringErrorsParsingEventArgsDescriptionMetadata.a);
+        }
+    }
+    FilterStringErrorsParsingEventArgsDescriptionMetadata.$t = markType(FilterStringErrorsParsingEventArgsDescriptionMetadata, 'FilterStringErrorsParsingEventArgsDescriptionMetadata');
+    FilterStringErrorsParsingEventArgsDescriptionMetadata.a = null;
+    return FilterStringErrorsParsingEventArgsDescriptionMetadata;
+})();

package/esm2015/lib/FilterSyntaxBinaryOperatorExpressionSyntax.js

@@ -0,0 +1,7 @@
+/*
+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.
+*/
+export { FilterSyntaxBinaryOperatorExpressionSyntax } from "./FilterSyntaxExpressionSyntax_combined";

package/esm2015/lib/FilterSyntaxExpressionSyntax.js

@@ -0,0 +1,7 @@
+/*
+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.
+*/
+export { FilterSyntaxExpressionSyntax } from "./FilterSyntaxExpressionSyntax_combined";