igniteui-angular-core 20.0.1 → 20.0.2-beta.1

package/esm2015/lib/ItemToolTipLayerDescriptionMetadata.js

@@ -29,6 +29,9 @@ export let ItemToolTipLayerDescriptionMetadata = /*@__PURE__*/ (() => {
             a.item("TargetSeriesRef", "(w:TargetSeries,wf:TargetSeries)DataRef::object");
             a.item("UseInterpolation", "Boolean");
             a.item("SkipUnknownValues", "Boolean");
+            a.item("ToolTipBackground", "Brush");
+            a.item("ToolTipBorderBrush", "Brush");
+            a.item("ToolTipBorderThickness", "Number:double");
         }
         static d(a) {
             ItemToolTipLayerDescriptionMetadata.b(a);

package/esm2015/lib/LayoutPrimaryKeyValueDescriptionMetadata.js

@@ -25,7 +25,7 @@ export let LayoutPrimaryKeyValueDescriptionMetadata = /*@__PURE__*/ (() => {
         static c(a) {
             a.item("__marshalByValue", "Boolean");
             a.item("Key", "Array:string");
-            a.item("Value", "Collection:object:Array:Object");
+            a.item("Value", "(w:Value/ObjectArrayTransform,xam:Value/ObjectArrayTransform,wf:Value/ObjectArrayTransform)Collection:object:Array:Object");
         }
         static d(a) {
             LayoutPrimaryKeyValueDescriptionMetadata.b(a);

package/esm2015/lib/ListPanelPrimaryKeyValueDescriptionMetadata.js

@@ -25,7 +25,7 @@ export let ListPanelPrimaryKeyValueDescriptionMetadata = /*@__PURE__*/ (() => {
         static c(a) {
             a.item("__marshalByValue", "Boolean");
             a.item("Key", "Array:string");
-            a.item("Value", "Collection:object:Array:Object");
+            a.item("Value", "(w:Value/ObjectArrayTransform,xam:Value/ObjectArrayTransform,wf:Value/ObjectArrayTransform)Collection:object:Array:Object");
         }
         static d(a) {
             ListPanelPrimaryKeyValueDescriptionMetadata.b(a);

package/esm2015/lib/LiteralFilterExpressionDescription.js

@@ -13,24 +13,48 @@ export let LiteralFilterExpressionDescription = /*@__PURE__*/ (() => {
     class LiteralFilterExpressionDescription extends FilterExpressionDescription {
         constructor() {
             super();
-            this.n = null;
-            this.l = false;
+            this.ah = 0;
+            this.ab = false;
+            this.ac = false;
+            this.aj = null;
+            this.ad = false;
         }
         get_type() {
             return "LiteralFilterExpression";
         }
+        get precedence() {
+            return this.ah;
+        }
+        set precedence(a) {
+            this.ah = a;
+            this.g("Precedence");
+        }
+        get isLiteral() {
+            return this.ab;
+        }
+        set isLiteral(a) {
+            this.ab = a;
+            this.g("IsLiteral");
+        }
+        get isNull() {
+            return this.ac;
+        }
+        set isNull(a) {
+            this.ac = a;
+            this.g("IsNull");
+        }
         get literalValue() {
-            return this.n;
+            return this.aj;
         }
         set literalValue(a) {
-            this.n = a;
+            this.aj = a;
             this.g("LiteralValue");
         }
         get leaveUnquoted() {
-            return this.l;
+            return this.ad;
         }
         set leaveUnquoted(a) {
-            this.l = a;
+            this.ad = a;
             this.g("LeaveUnquoted");
         }
     }

package/esm2015/lib/LiteralFilterExpressionDescriptionMetadata.js

@@ -25,6 +25,9 @@ export let LiteralFilterExpressionDescriptionMetadata = /*@__PURE__*/ (() => {
         }
         static c(a) {
             FilterExpressionDescriptionMetadata.c(a);
+            a.item("Precedence", "Number:int");
+            a.item("IsLiteral", "Boolean");
+            a.item("IsNull", "Boolean");
             a.item("LiteralValue", "Unknown");
             a.item("LeaveUnquoted", "Boolean");
         }

package/esm2015/lib/NumericAngleAxisDescription.js

@@ -13,24 +13,24 @@ export let NumericAngleAxisDescription = /*@__PURE__*/ (() => {
     class NumericAngleAxisDescription extends NumericAxisBaseDescription {
         constructor() {
             super();
-            this.ff = 0;
-            this.fh = null;
+            this.hb = 0;
+            this.hd = null;
         }
         get_type() {
             return "NumericAngleAxis";
         }
         get startAngleOffset() {
-            return this.ff;
+            return this.hb;
         }
         set startAngleOffset(a) {
-            this.ff = a;
+            this.hb = a;
             this.g("StartAngleOffset");
         }
         get labelMode() {
-            return this.fh;
+            return this.hd;
         }
         set labelMode(a) {
-            this.fh = a;
+            this.hd = a;
             this.g("LabelMode");
         }
     }

package/esm2015/lib/NumericAxisBaseDescription.js

@@ -13,232 +13,280 @@ export let NumericAxisBaseDescription = /*@__PURE__*/ (() => {
     class NumericAxisBaseDescription extends AxisDescription {
         constructor() {
             super();
-            this.e6 = null;
-            this.eh = 0;
-            this.eb = 0;
-            this.ee = 0;
-            this.eg = 0;
-            this.ea = 0;
-            this.ed = 0;
-            this.ef = 0;
-            this.d9 = 0;
-            this.ev = 0;
-            this.ex = 0;
-            this.d2 = false;
-            this.ei = 0;
-            this.ec = 0;
-            this.ej = 0;
-            this.d1 = false;
-            this.dy = false;
-            this.dz = false;
-            this.ew = 0;
-            this.e7 = null;
-            this.e1 = null;
-            this.dv = null;
-            this.d0 = false;
-            this.dx = false;
-            this.e4 = null;
-            this.e3 = null;
-            this.e2 = null;
-            this.e5 = null;
+            this.g2 = null;
+            this.f7 = 0;
+            this.fx = 0;
+            this.f0 = 0;
+            this.f6 = 0;
+            this.fw = 0;
+            this.fz = 0;
+            this.f5 = 0;
+            this.fv = 0;
+            this.gp = 0;
+            this.gs = 0;
+            this.fn = false;
+            this.f8 = 0;
+            this.fy = 0;
+            this.f9 = 0;
+            this.fm = false;
+            this.fi = false;
+            this.fk = false;
+            this.gr = 0;
+            this.f1 = 0;
+            this.f4 = 0;
+            this.f3 = 0;
+            this.f2 = 0;
+            this.fj = false;
+            this.gq = 0;
+            this.g3 = null;
+            this.gx = null;
+            this.ff = null;
+            this.fl = false;
+            this.fh = false;
+            this.g0 = null;
+            this.gz = null;
+            this.gy = null;
+            this.g1 = null;
         }
         get_type() {
             return "NumericAxisBase";
         }
         get autoRangeBufferMode() {
-            return this.e6;
+            return this.g2;
         }
         set autoRangeBufferMode(a) {
-            this.e6 = a;
+            this.g2 = a;
             this.g("AutoRangeBufferMode");
         }
         get minimumValue() {
-            return this.eh;
+            return this.f7;
         }
         set minimumValue(a) {
-            this.eh = a;
+            this.f7 = a;
             this.g("MinimumValue");
         }
         get actualMinimumValue() {
-            return this.eb;
+            return this.fx;
         }
         set actualMinimumValue(a) {
-            this.eb = a;
+            this.fx = a;
             this.g("ActualMinimumValue");
         }
         get actualVisibleMinimumValue() {
-            return this.ee;
+            return this.f0;
         }
         set actualVisibleMinimumValue(a) {
-            this.ee = a;
+            this.f0 = a;
             this.g("ActualVisibleMinimumValue");
         }
         get maximumValue() {
-            return this.eg;
+            return this.f6;
         }
         set maximumValue(a) {
-            this.eg = a;
+            this.f6 = a;
             this.g("MaximumValue");
         }
         get actualMaximumValue() {
-            return this.ea;
+            return this.fw;
         }
         set actualMaximumValue(a) {
-            this.ea = a;
+            this.fw = a;
             this.g("ActualMaximumValue");
         }
         get actualVisibleMaximumValue() {
-            return this.ed;
+            return this.fz;
         }
         set actualVisibleMaximumValue(a) {
-            this.ed = a;
+            this.fz = a;
             this.g("ActualVisibleMaximumValue");
         }
         get interval() {
-            return this.ef;
+            return this.f5;
         }
         set interval(a) {
-            this.ef = a;
+            this.f5 = a;
             this.g("Interval");
         }
         get actualInterval() {
-            return this.d9;
+            return this.fv;
         }
         set actualInterval(a) {
-            this.d9 = a;
+            this.fv = a;
             this.g("ActualInterval");
         }
         get actualMaxPrecision() {
-            return this.ev;
+            return this.gp;
         }
         set actualMaxPrecision(a) {
-            this.ev = a;
+            this.gp = a;
             this.g("ActualMaxPrecision");
         }
         get maxPrecision() {
-            return this.ex;
+            return this.gs;
         }
         set maxPrecision(a) {
-            this.ex = a;
+            this.gs = a;
             this.g("MaxPrecision");
         }
         get shouldApplyMaxPrecisionWhenZoomed() {
-            return this.d2;
+            return this.fn;
         }
         set shouldApplyMaxPrecisionWhenZoomed(a) {
-            this.d2 = a;
+            this.fn = a;
             this.g("ShouldApplyMaxPrecisionWhenZoomed");
         }
         get minorInterval() {
-            return this.ei;
+            return this.f8;
         }
         set minorInterval(a) {
-            this.ei = a;
+            this.f8 = a;
             this.g("MinorInterval");
         }
         get actualMinorInterval() {
-            return this.ec;
+            return this.fy;
         }
         set actualMinorInterval(a) {
-            this.ec = a;
+            this.fy = a;
             this.g("ActualMinorInterval");
         }
         get referenceValue() {
-            return this.ej;
+            return this.f9;
         }
         set referenceValue(a) {
-            this.ej = a;
+            this.f9 = a;
             this.g("ReferenceValue");
         }
         get isLogarithmic() {
-            return this.d1;
+            return this.fm;
         }
         set isLogarithmic(a) {
-            this.d1 = a;
+            this.fm = a;
             this.g("IsLogarithmic");
         }
         get actualIsLogarithmic() {
-            return this.dy;
+            return this.fi;
         }
         set actualIsLogarithmic(a) {
-            this.dy = a;
+            this.fi = a;
             this.g("ActualIsLogarithmic");
         }
         get favorLabellingScaleEnd() {
-            return this.dz;
+            return this.fk;
         }
         set favorLabellingScaleEnd(a) {
-            this.dz = a;
+            this.fk = a;
             this.g("FavorLabellingScaleEnd");
         }
         get logarithmBase() {
-            return this.ew;
+            return this.gr;
         }
         set logarithmBase(a) {
-            this.ew = a;
+            this.gr = a;
             this.g("LogarithmBase");
         }
+        get companionAxisInterval() {
+            return this.f1;
+        }
+        set companionAxisInterval(a) {
+            this.f1 = a;
+            this.g("CompanionAxisInterval");
+        }
+        get companionAxisMinorInterval() {
+            return this.f4;
+        }
+        set companionAxisMinorInterval(a) {
+            this.f4 = a;
+            this.g("CompanionAxisMinorInterval");
+        }
+        get companionAxisMinimumValue() {
+            return this.f3;
+        }
+        set companionAxisMinimumValue(a) {
+            this.f3 = a;
+            this.g("CompanionAxisMinimumValue");
+        }
+        get companionAxisMaximumValue() {
+            return this.f2;
+        }
+        set companionAxisMaximumValue(a) {
+            this.f2 = a;
+            this.g("CompanionAxisMaximumValue");
+        }
+        get companionAxisIsLogarithmic() {
+            return this.fj;
+        }
+        set companionAxisIsLogarithmic(a) {
+            this.fj = a;
+            this.g("CompanionAxisIsLogarithmic");
+        }
+        get companionAxisLogarithmBase() {
+            return this.gq;
+        }
+        set companionAxisLogarithmBase(a) {
+            this.gq = a;
+            this.g("CompanionAxisLogarithmBase");
+        }
         get formatAbbreviatedLabelRef() {
-            return this.e7;
+            return this.g3;
         }
         set formatAbbreviatedLabelRef(a) {
-            this.e7 = a;
+            this.g3 = a;
             this.g("FormatAbbreviatedLabelRef");
         }
         get abbreviatedLabelFormat() {
-            return this.e1;
+            return this.gx;
         }
         set abbreviatedLabelFormat(a) {
-            this.e1 = a;
+            this.gx = a;
             this.g("AbbreviatedLabelFormat");
         }
         get abbreviatedLabelFormatSpecifiers() {
-            return this.dv;
+            return this.ff;
         }
         set abbreviatedLabelFormatSpecifiers(a) {
-            this.dv = a;
+            this.ff = a;
             this.g("AbbreviatedLabelFormatSpecifiers");
         }
         get isFormattingAbbreviatedLargeNumber() {
-            return this.d0;
+            return this.fl;
         }
         set isFormattingAbbreviatedLargeNumber(a) {
-            this.d0 = a;
+            this.fl = a;
             this.g("IsFormattingAbbreviatedLargeNumber");
         }
         get abbreviateLargeNumbers() {
-            return this.dx;
+            return this.fh;
         }
         set abbreviateLargeNumbers(a) {
-            this.dx = a;
+            this.fh = a;
             this.g("AbbreviateLargeNumbers");
         }
         get actualMinimumValueChangeRef() {
-            return this.e4;
+            return this.g0;
         }
         set actualMinimumValueChangeRef(a) {
-            this.e4 = a;
+            this.g0 = a;
             this.g("ActualMinimumValueChangeRef");
         }
         get actualMaximumValueChangeRef() {
-            return this.e3;
+            return this.gz;
         }
         set actualMaximumValueChangeRef(a) {
-            this.e3 = a;
+            this.gz = a;
             this.g("ActualMaximumValueChangeRef");
         }
         get actualIntervalChangeRef() {
-            return this.e2;
+            return this.gy;
         }
         set actualIntervalChangeRef(a) {
-            this.e2 = a;
+            this.gy = a;
             this.g("ActualIntervalChangeRef");
         }
         get actualMinorIntervalChangeRef() {
-            return this.e5;
+            return this.g1;
         }
         set actualMinorIntervalChangeRef(a) {
-            this.e5 = a;
+            this.g1 = a;
             this.g("ActualMinorIntervalChangeRef");
         }
     }

package/esm2015/lib/NumericAxisBaseDescriptionMetadata.js

@@ -44,6 +44,12 @@ export let NumericAxisBaseDescriptionMetadata = /*@__PURE__*/ (() => {
             a.item("ActualIsLogarithmic", "Boolean");
             a.item("FavorLabellingScaleEnd", "Boolean");
             a.item("LogarithmBase", "Number:int");
+            a.item("CompanionAxisInterval", "Number:double");
+            a.item("CompanionAxisMinorInterval", "Number:double");
+            a.item("CompanionAxisMinimumValue", "Number:double");
+            a.item("CompanionAxisMaximumValue", "Number:double");
+            a.item("CompanionAxisIsLogarithmic", "Boolean");
+            a.item("CompanionAxisLogarithmBase", "Number:int");
             a.item("FormatAbbreviatedLabelRef", "(w:FormatAbbreviatedLabel,wf:FormatAbbreviatedLabel)MethodRef");
             a.item("AbbreviatedLabelFormat", "String");
             a.item("AbbreviatedLabelFormatSpecifiers", "Collection:FormatSpecifier:FormatSpecifierCollection:FormatSpecifier");

package/esm2015/lib/NumericCellInfoDescription.js

@@ -13,112 +13,112 @@ export let NumericCellInfoDescription = /*@__PURE__*/ (() => {
     class NumericCellInfoDescription extends CellInfoDescription {
         constructor() {
             super();
-            this.fu = 0;
-            this.fq = false;
-            this.f4 = null;
-            this.fn = null;
-            this.f3 = null;
-            this.f5 = null;
-            this.f7 = null;
-            this.f6 = null;
-            this.f8 = null;
-            this.fw = 0;
-            this.fx = 0;
-            this.fy = 0;
-            this.fr = false;
+            this.go = 0;
+            this.gk = false;
+            this.gy = null;
+            this.gh = null;
+            this.gx = null;
+            this.gz = null;
+            this.g1 = null;
+            this.g0 = null;
+            this.g2 = null;
+            this.gq = 0;
+            this.gr = 0;
+            this.gs = 0;
+            this.gl = false;
         }
         get_type() {
             return "NumericCellInfo";
         }
         get numericValue() {
-            return this.fu;
+            return this.go;
         }
         set numericValue(a) {
-            this.fu = a;
+            this.go = a;
             this.g("NumericValue");
         }
         get hasDecimalValue() {
-            return this.fq;
+            return this.gk;
         }
         set hasDecimalValue(a) {
-            this.fq = a;
+            this.gk = a;
             this.g("HasDecimalValue");
         }
         get formatStringOverride() {
-            return this.f4;
+            return this.gy;
         }
         set formatStringOverride(a) {
-            this.f4 = a;
+            this.gy = a;
             this.g("FormatStringOverride");
         }
         get formatSpecifiers() {
-            return this.fn;
+            return this.gh;
         }
         set formatSpecifiers(a) {
-            this.fn = a;
+            this.gh = a;
             this.g("FormatSpecifiers");
         }
         get formatOverrideRef() {
-            return this.f3;
+            return this.gx;
         }
         set formatOverrideRef(a) {
-            this.f3 = a;
+            this.gx = a;
             this.g("FormatOverrideRef");
         }
         get negativePrefix() {
-            return this.f5;
+            return this.gz;
         }
         set negativePrefix(a) {
-            this.f5 = a;
+            this.gz = a;
             this.g("NegativePrefix");
         }
         get positivePrefix() {
-            return this.f7;
+            return this.g1;
         }
         set positivePrefix(a) {
-            this.f7 = a;
+            this.g1 = a;
             this.g("PositivePrefix");
         }
         get negativeSuffix() {
-            return this.f6;
+            return this.g0;
         }
         set negativeSuffix(a) {
-            this.f6 = a;
+            this.g0 = a;
             this.g("NegativeSuffix");
         }
         get positiveSuffix() {
-            return this.f8;
+            return this.g2;
         }
         set positiveSuffix(a) {
-            this.f8 = a;
+            this.g2 = a;
             this.g("PositiveSuffix");
         }
         get maxFractionDigits() {
-            return this.fw;
+            return this.gq;
         }
         set maxFractionDigits(a) {
-            this.fw = a;
+            this.gq = a;
             this.g("MaxFractionDigits");
         }
         get minFractionDigits() {
-            return this.fx;
+            return this.gr;
         }
         set minFractionDigits(a) {
-            this.fx = a;
+            this.gr = a;
             this.g("MinFractionDigits");
         }
         get minIntegerDigits() {
-            return this.fy;
+            return this.gs;
         }
         set minIntegerDigits(a) {
-            this.fy = a;
+            this.gs = a;
             this.g("MinIntegerDigits");
         }
         get showGroupingSeparator() {
-            return this.fr;
+            return this.gl;
         }
         set showGroupingSeparator(a) {
-            this.fr = a;
+            this.gl = a;
             this.g("ShowGroupingSeparator");
         }
     }

package/esm2015/lib/NumericCellInfoDescriptionMetadata.js

@@ -28,7 +28,7 @@ export let NumericCellInfoDescriptionMetadata = /*@__PURE__*/ (() => {
             a.item("NumericValue", "Number:double");
             a.item("HasDecimalValue", "Boolean");
             a.item("FormatStringOverride", "String");
-            a.item("FormatSpecifiers", "Collection:FormatSpecifier:FormatSpecifierCollection:FormatSpecifier");
+            a.item("FormatSpecifiers", "(w:FormatSpecifiers/ObjectArrayTransform,xam:FormatSpecifiers/ObjectArrayTransform,wf:FormatSpecifiers/ObjectArrayTransform)Collection:FormatSpecifier:FormatSpecifierCollection:FormatSpecifier");
             a.item("FormatSpecifiers@mustSetInCode", "WebComponents;Blazor;React;WPF;Angular");
             a.item("FormatOverrideRef", "(w:FormatOverride,wf:FormatOverride)DataRef");
             a.item("NegativePrefix", "String");