igniteui-webcomponents-dashboards 5.1.1-beta.0

package/esm5/lib/igc-dashboard-tile-component.js

@@ -0,0 +1,1401 @@
+import { __extends, __values } from "tslib";
+import { DashboardTile } from "./DashboardTile";
+import { ensureEnum, brushToString, stringToBrush, ensureBool, initializePropertiesFromCss, NamePatcher, toSpinal, fromBrushCollection, toBrushCollection, brushCollectionToString, enumToString, getAllPropertyNames, fromSpinal } from "igniteui-webcomponents-core";
+import { WebComponentRenderer, PortalManager } from "igniteui-webcomponents-core";
+import { delegateCombine, delegateRemove } from "igniteui-webcomponents-core";
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+import { RegisterElementHelper } from "igniteui-webcomponents-core";
+import { ControlDisplayDensity_$type } from "igniteui-webcomponents-core";
+import { BaseControlTheme_$type } from "igniteui-webcomponents-core";
+import { IgcHTMLElement } from "igniteui-webcomponents-core";
+import { IgcDashboardTileFilterStringErrorsParsingEventArgs } from "./igc-dashboard-tile-filter-string-errors-parsing-event-args";
+import { DashboardTileVisualizationType_$type } from "./DashboardTileVisualizationType";
+import { CrosshairsDisplayMode_$type } from "igniteui-webcomponents-charts";
+import { IgcValueModeCollection } from "igniteui-webcomponents-charts";
+import { SyncableObservableCollection$1 } from "igniteui-webcomponents-core";
+import { ValueLayerValueMode_$type } from "igniteui-webcomponents-charts";
+import { ValueModeCollection as ValueModeCollection_internal } from "igniteui-webcomponents-charts";
+import { IgcChartSelectedItemCollection } from "igniteui-webcomponents-charts";
+import { ChartSelectedItemCollection as ChartSelectedItemCollection_internal } from "igniteui-webcomponents-charts";
+import { ChartSelection } from "igniteui-webcomponents-charts";
+import { SeriesHighlightedValuesDisplayMode_$type } from "igniteui-webcomponents-core";
+import { TrendLineType_$type } from "igniteui-webcomponents-core";
+import { IgcDashboardTileSummaryDescriptionCollection } from "./igc-dashboard-tile-summary-description-collection";
+import { IgcFilterExpressionCollection } from "igniteui-webcomponents-core";
+import { IgcDashboardTileSortDescriptionCollection } from "./igc-dashboard-tile-sort-description-collection";
+import { NotifyCollectionChangedAction } from "igniteui-webcomponents-core";
+import { IgcDashboardTileCustomizationCollection } from "./igc-dashboard-tile-customization-collection";
+import { IgcDashboardTileChangingContentEventArgs } from "./igc-dashboard-tile-changing-content-event-args";
+var IgcDashboardTileComponent = /** @class */ /*@__PURE__*/ (function (_super) {
+    __extends(IgcDashboardTileComponent, _super);
+    function IgcDashboardTileComponent() {
+        var _this = _super.call(this) || this;
+        _this._disconnected = false;
+        _this._settingAttributes = false;
+        _this._attached = false;
+        _this._queuedSetAttributes = [];
+        _this._updatingFromAttribute = false;
+        _this._customizations = null;
+        _this._selectedSeriesItems = null;
+        _this._valueLines = null;
+        _this.__p = null;
+        _this._hasUserValues = new Set();
+        _this._stylingContainer = null;
+        _this._stylingParent = null;
+        _this._inStyling = false;
+        _this._changingContent = null;
+        _this._changingContent_wrapped = null;
+        _this._filterStringErrorsParsing = null;
+        _this._filterStringErrorsParsing_wrapped = null;
+        if (_this._styling) {
+            NamePatcher.ensureStylablePatched(Object.getPrototypeOf(_this));
+        }
+        _this._portalManager = new PortalManager("DashboardTileContent");
+        _this._renderer = new WebComponentRenderer(_this, document, true, {}, _this._portalManager);
+        _this._container = _this._renderer.createElement("div");
+        _this._renderer.updateRoot(_this._container);
+        _this._implementation = _this.createImplementation();
+        _this._implementation.externalObject = _this;
+        _this._container.setStyleProperty("width", "100%");
+        _this._container.setStyleProperty("height", "100%");
+        var root;
+        root = _this._container;
+        if (_this._container.getNativeElement() != null) {
+            root = _this._container.getNativeElement();
+        }
+        _this._wrapper = _this._renderer;
+        var DashboardTile = _this.i;
+        _this._DashboardTile = DashboardTile;
+        DashboardTile.provideContainer(_this._renderer);
+        _this._onChildrenChanged();
+        //Checkbox.notifySizeChanged();
+        var mut = new MutationObserver(function (list) {
+            var e_1, _b;
+            try {
+                for (var list_1 = __values(list), list_1_1 = list_1.next(); !list_1_1.done; list_1_1 = list_1.next()) {
+                    var mutation = list_1_1.value;
+                    if (mutation.type == 'childList') {
+                        _this._onChildrenChanged();
+                    }
+                }
+            }
+            catch (e_1_1) {
+                e_1 = { error: e_1_1 };
+            }
+            finally {
+                try {
+                    if (list_1_1 && !list_1_1.done && (_b = list_1.return))
+                        _b.call(list_1);
+                }
+                finally {
+                    if (e_1)
+                        throw e_1.error;
+                }
+            }
+        });
+        mut.observe(_this, {
+            childList: true
+        });
+        return _this;
+        //this._renderer.addSizeWatcher(() => {
+        //    this._checkbox.notifySizeChanged();
+        //});
+    }
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "height", {
+        get: function () {
+            return this._height;
+        },
+        set: function (value) {
+            this._height = value;
+            this.style.height = value;
+            this.notifyContainerResized();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "width", {
+        get: function () {
+            return this._width;
+        },
+        set: function (value) {
+            this._width = value;
+            this.style.width = value;
+            this.notifyContainerResized();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IgcDashboardTileComponent.prototype.notifyContainerResized = function () {
+        this.i.notifyContainerResized();
+    };
+    IgcDashboardTileComponent.prototype._onChildrenChanged = function () {
+        var children = [];
+        for (var i = 0; i < this.childNodes.length; i++) {
+            var child = this.childNodes[i];
+            if (child !== this._container.getNativeElement()) {
+                children.push(child);
+            }
+        }
+        this._portalManager.onChildrenChanged(children);
+    };
+    // supports angular themes or custom properties set in CSS
+    IgcDashboardTileComponent.prototype.updateStyle = function () {
+        this._styling(this, this);
+    };
+    IgcDashboardTileComponent.prototype.destroy = function () {
+        this._DashboardTile.destroy();
+        this._wrapper.destroy();
+    };
+    IgcDashboardTileComponent.prototype.createImplementation = function () {
+        return new DashboardTile();
+    };
+    IgcDashboardTileComponent.prototype.disconnectedCallback = function () {
+        this._disconnected = true;
+        if (this.i) {
+            this.i.onDetachedFromUI();
+        }
+    };
+    IgcDashboardTileComponent.prototype.connectedCallback = function () {
+        if (this._disconnected) {
+            this._disconnected = false;
+            if (this.i) {
+                this.i.onAttachedToUI();
+            }
+            return;
+        }
+        this.classList.add("ig-dashboard-tile");
+        this.classList.add("igc-dashboard-tile");
+        this.appendChild(this._container.getNativeElement());
+        this._attached = true;
+        this.style.display = "block";
+        //this.style.height = this._height;
+        //this.style.width = this._width;
+        this._flushQueuedAttributes();
+        // supports themes or custom properties set in CSS 
+        this._styling(this, this);
+        this.afterContentInit();
+    };
+    IgcDashboardTileComponent.prototype.afterContentInit = function () {
+        //this.i.notifySizeChanged();
+    };
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "i", {
+        /**
+         * @hidden
+         */
+        get: function () {
+            return this._implementation;
+        } /**
+                                     * @hidden
+                                     */,
+        enumerable: false,
+        configurable: true
+    });
+    IgcDashboardTileComponent._createFromInternal = function (internal) {
+        if (!internal) {
+            return null;
+        }
+        if (!internal.$type) {
+            return null;
+        }
+        var name = internal.$type.name;
+        var externalName = "Igc" + name + "Component";
+        if (!TypeRegistrar.isRegistered(externalName)) {
+            return null;
+        }
+        return TypeRegistrar.create(externalName);
+    };
+    IgcDashboardTileComponent.prototype._enqueueSetAttribute = function (attrName, attrValue) {
+        this._queuedSetAttributes.push({ attrName: attrName, attrValue: attrValue });
+    };
+    IgcDashboardTileComponent.prototype._flushQueuedAttributes = function () {
+        this._settingAttributes = true;
+        for (var i = 0; i < this._queuedSetAttributes.length; i++) {
+            this.setAttribute(this._queuedSetAttributes[i].attrName, this._queuedSetAttributes[i].attrValue);
+        }
+        this._settingAttributes = false;
+        this._queuedSetAttributes.length = 0;
+    };
+    IgcDashboardTileComponent.prototype._a = function (attrName, attrValue) {
+        if (this._updatingFromAttribute) {
+            return;
+        }
+        if (attrValue) {
+            attrValue = attrValue.toString();
+        }
+        this._settingAttributes = true;
+        attrName = toSpinal(attrName);
+        if (this._attached) {
+            this.setAttribute(attrName, attrValue);
+        }
+        else {
+            this._enqueueSetAttribute(attrName, attrValue);
+        }
+        this._settingAttributes = false;
+    };
+    Object.defineProperty(IgcDashboardTileComponent, "observedAttributes", {
+        get: function () {
+            if (IgcDashboardTileComponent._observedAttributesIgcDashboardTileComponent == null) {
+                var names = getAllPropertyNames(IgcDashboardTileComponent);
+                for (var i = 0; i < names.length; i++) {
+                    names[i] = toSpinal(names[i]);
+                }
+                IgcDashboardTileComponent._observedAttributesIgcDashboardTileComponent = names;
+            }
+            return IgcDashboardTileComponent._observedAttributesIgcDashboardTileComponent;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IgcDashboardTileComponent.prototype.attributeChangedCallback = function (name, oldValue, newValue) {
+        if (this._settingAttributes) {
+            return;
+        }
+        var setName = fromSpinal(name);
+        this._updatingFromAttribute = true;
+        this[setName] = newValue;
+        this._updatingFromAttribute = false;
+    };
+    IgcDashboardTileComponent.register = function () {
+        if (!IgcDashboardTileComponent._isElementRegistered) {
+            IgcDashboardTileComponent._isElementRegistered = true;
+            RegisterElementHelper.registerElement(IgcDashboardTileComponent.htmlTagName, IgcDashboardTileComponent);
+        }
+    };
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "actualCustomizations", {
+        get: function () {
+            if (!this._actualCustomizations) {
+                this._actualCustomizations = [];
+            }
+            return this._actualCustomizations;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "contentCustomizations", {
+        get: function () {
+            if (!this._contentCustomizations) {
+                this._contentCustomizations = [];
+            }
+            return this._contentCustomizations;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "customizations", {
+        /**
+         * Gets a collection where you can add customization that will be applied to the generated visualizations.
+        */
+        get: function () {
+            var _this = this;
+            if (this._customizations === null) {
+                var coll = new IgcDashboardTileCustomizationCollection();
+                var inner = coll._innerColl;
+                this._customizations = coll;
+                inner.addListener(function (sender, e) {
+                    switch (e.action) {
+                        case NotifyCollectionChangedAction.Add:
+                            _this._customizationsAdapter.insertManualItem(e.newStartingIndex, e.newItems.item(0));
+                            break;
+                        case NotifyCollectionChangedAction.Remove:
+                            _this._customizationsAdapter.removeManualItemAt(e.oldStartingIndex);
+                            break;
+                        case NotifyCollectionChangedAction.Replace:
+                            _this._customizationsAdapter.removeManualItemAt(e.oldStartingIndex);
+                            _this._customizationsAdapter.insertManualItem(e.newStartingIndex, e.newItems.item(0));
+                            break;
+                        case NotifyCollectionChangedAction.Reset:
+                            _this._customizationsAdapter.clearManualItems();
+                            break;
+                    }
+                });
+                ;
+            }
+            return this._customizations;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "tileTitle", {
+        /**
+         * Gets or sets text to display above the plot area.
+        */
+        get: function () {
+            return this.i.ge;
+        },
+        set: function (v) {
+            this.i.ge = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "initialSortDescriptions", {
+        /**
+         * Gets the initial sorts that are applied to the chart.
+        */
+        get: function () {
+            var r = this.i.aw;
+            if (r == null) {
+                return null;
+            }
+            if (!r.externalObject) {
+                var e = new IgcDashboardTileSortDescriptionCollection();
+                if (r.$type) {
+                    e._implementation = r;
+                }
+                else {
+                    if (e.i.setNativeElement) {
+                        e.i.setNativeElement(r);
+                    }
+                }
+                r.externalObject = e;
+            }
+            return r.externalObject;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "initialGroupSortDescriptions", {
+        /**
+         * Gets the initial sorts that are applied to the chart after groupings and summaries are applied.
+        */
+        get: function () {
+            var r = this.i.av;
+            if (r == null) {
+                return null;
+            }
+            if (!r.externalObject) {
+                var e = new IgcDashboardTileSortDescriptionCollection();
+                if (r.$type) {
+                    e._implementation = r;
+                }
+                else {
+                    if (e.i.setNativeElement) {
+                        e.i.setNativeElement(r);
+                    }
+                }
+                r.externalObject = e;
+            }
+            return r.externalObject;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "initialGroupDescriptions", {
+        /**
+         * Gets the initial groupings that are applied to the chart.
+        */
+        get: function () {
+            var r = this.i.au;
+            if (r == null) {
+                return null;
+            }
+            if (!r.externalObject) {
+                var e = new IgcDashboardTileSortDescriptionCollection();
+                if (r.$type) {
+                    e._implementation = r;
+                }
+                else {
+                    if (e.i.setNativeElement) {
+                        e.i.setNativeElement(r);
+                    }
+                }
+                r.externalObject = e;
+            }
+            return r.externalObject;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "initialFilterExpressions", {
+        /**
+         * Gets the initial filters that are applied to the chart.
+        */
+        get: function () {
+            var r = this.i.bj;
+            if (r == null) {
+                return null;
+            }
+            if (!r.externalObject) {
+                var e = new IgcFilterExpressionCollection();
+                if (r.$type) {
+                    e._implementation = r;
+                }
+                else {
+                    if (e.i.setNativeElement) {
+                        e.i.setNativeElement(r);
+                    }
+                }
+                r.externalObject = e;
+            }
+            return r.externalObject;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "initialHighlightFilterExpressions", {
+        /**
+         * Gets the initial highlight filters that are applied to the chart.
+        */
+        get: function () {
+            var r = this.i.bk;
+            if (r == null) {
+                return null;
+            }
+            if (!r.externalObject) {
+                var e = new IgcFilterExpressionCollection();
+                if (r.$type) {
+                    e._implementation = r;
+                }
+                else {
+                    if (e.i.setNativeElement) {
+                        e.i.setNativeElement(r);
+                    }
+                }
+                r.externalObject = e;
+            }
+            return r.externalObject;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "initialSummaryDescriptions", {
+        /**
+         * Gets the initial summaries that are applied to the chart.
+        */
+        get: function () {
+            var r = this.i.a0;
+            if (r == null) {
+                return null;
+            }
+            if (!r.externalObject) {
+                var e = new IgcDashboardTileSummaryDescriptionCollection();
+                if (r.$type) {
+                    e._implementation = r;
+                }
+                else {
+                    if (e.i.setNativeElement) {
+                        e.i.setNativeElement(r);
+                    }
+                }
+                r.externalObject = e;
+            }
+            return r.externalObject;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "initialSorts", {
+        /**
+         * Gets or sets the sorts to apply to the chart. This property will become ignored if sorts are changed outside of this property.
+        */
+        get: function () {
+            return this.i.f2;
+        },
+        set: function (v) {
+            this.i.f2 = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "groupSorts", {
+        /**
+         * Gets or sets the sorts to apply after grouping has been applied.
+        */
+        get: function () {
+            return this.i.fr;
+        },
+        set: function (v) {
+            this.i.fr = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "initialGroups", {
+        /**
+         * Gets or sets the groupings to apply to the chart. This property will become ignored if sorts are changed outside of this property.
+        */
+        get: function () {
+            return this.i.fy;
+        },
+        set: function (v) {
+            this.i.fy = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "initialFilter", {
+        /**
+         * Gets or sets the filter to apply to the chart. This property will become ignored if the filter is changed outside of this property.
+        */
+        get: function () {
+            return this.i.fw;
+        },
+        set: function (v) {
+            this.i.fw = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "initialHighlightFilter", {
+        /**
+         * Gets or sets the filter to apply to the chart. This property will become ignored if the filter is changed outside of this property.
+        */
+        get: function () {
+            return this.i.f0;
+        },
+        set: function (v) {
+            this.i.f0 = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "initialSummaries", {
+        /**
+         * Gets or sets the summaries to apply to the chart. This property will become ignored if sorts are changed outside of this property.
+        */
+        get: function () {
+            return this.i.f4;
+        },
+        set: function (v) {
+            this.i.f4 = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "sortDescriptions", {
+        /**
+         * Gets the current sort that is applied to the grid. Collection can be updated to modify the sort for the grid. Once sort descriptions are in this collection, the grid will no longer listen for changes on their properties.
+        */
+        get: function () {
+            var r = this.i.ax;
+            if (r == null) {
+                return null;
+            }
+            if (!r.externalObject) {
+                var e = new IgcDashboardTileSortDescriptionCollection();
+                if (r.$type) {
+                    e._implementation = r;
+                }
+                else {
+                    if (e.i.setNativeElement) {
+                        e.i.setNativeElement(r);
+                    }
+                }
+                r.externalObject = e;
+            }
+            return r.externalObject;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "groupSortDescriptions", {
+        get: function () {
+            var r = this.i.at;
+            if (r == null) {
+                return null;
+            }
+            if (!r.externalObject) {
+                var e = new IgcDashboardTileSortDescriptionCollection();
+                if (r.$type) {
+                    e._implementation = r;
+                }
+                else {
+                    if (e.i.setNativeElement) {
+                        e.i.setNativeElement(r);
+                    }
+                }
+                r.externalObject = e;
+            }
+            return r.externalObject;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "groupDescriptions", {
+        /**
+         * Gets the current grouping that is applied to the grid. Collection can be updated to modify the grouping for the grid. Once grouping descriptions are in this collection, the grid will no longer listen for changes on their properties.
+        */
+        get: function () {
+            var r = this.i.as;
+            if (r == null) {
+                return null;
+            }
+            if (!r.externalObject) {
+                var e = new IgcDashboardTileSortDescriptionCollection();
+                if (r.$type) {
+                    e._implementation = r;
+                }
+                else {
+                    if (e.i.setNativeElement) {
+                        e.i.setNativeElement(r);
+                    }
+                }
+                r.externalObject = e;
+            }
+            return r.externalObject;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "filterExpressions", {
+        /**
+         * Gets the current filter that is applied to the chart. Collection can be updated to modify the filter for the chart. Once filter expressions are in this collection, the chart will no longer listen for changes on their properties.
+        */
+        get: function () {
+            var r = this.i.bh;
+            if (r == null) {
+                return null;
+            }
+            if (!r.externalObject) {
+                var e = new IgcFilterExpressionCollection();
+                if (r.$type) {
+                    e._implementation = r;
+                }
+                else {
+                    if (e.i.setNativeElement) {
+                        e.i.setNativeElement(r);
+                    }
+                }
+                r.externalObject = e;
+            }
+            return r.externalObject;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "highlightFilterExpressions", {
+        /**
+         * Gets the current highlight filter that is applied to the chart. Collection can be updated to modify the highlight filter for the chart. Once filter expressions are in this collection, the chart will no longer listen for changes on their properties.
+        */
+        get: function () {
+            var r = this.i.bi;
+            if (r == null) {
+                return null;
+            }
+            if (!r.externalObject) {
+                var e = new IgcFilterExpressionCollection();
+                if (r.$type) {
+                    e._implementation = r;
+                }
+                else {
+                    if (e.i.setNativeElement) {
+                        e.i.setNativeElement(r);
+                    }
+                }
+                r.externalObject = e;
+            }
+            return r.externalObject;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "summaryDescriptions", {
+        /**
+         * Gets the current summaries that are applied to the grid.
+        */
+        get: function () {
+            var r = this.i.a1;
+            if (r == null) {
+                return null;
+            }
+            if (!r.externalObject) {
+                var e = new IgcDashboardTileSummaryDescriptionCollection();
+                if (r.$type) {
+                    e._implementation = r;
+                }
+                else {
+                    if (e.i.setNativeElement) {
+                        e.i.setNativeElement(r);
+                    }
+                }
+                r.externalObject = e;
+            }
+            return r.externalObject;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "dataSource", {
+        /**
+         * Gets or sets a collection of data items used to generate the dashboard tile.
+         * The ItemsSource of this dashboard tile can be a list of objects containing one or more numeric properties.
+         * Additionally, if the objects in the list implement an enumerable interface,
+         * the dashboard tile will attempt to delve into the sub-collections when reading through the data source.
+         * Data binding can be further configured by attributing the data item classes
+         * with the data intent feature.
+        */
+        get: function () {
+            return this.i.itemsSource;
+        },
+        set: function (v) {
+            this.i.itemsSource = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "highlightedDataSource", {
+        /**
+         * Gets or sets a collection of data items used to generate the dashboard tile.
+         * The HighlightedItemsSource of this dashboard tile can be a list of objects containing one or more numeric properties.
+         * Additionally, if the objects in the list implement an enumerable interface,
+         * the dashboard tile will attempt to delve into the sub-collections when reading through the data source.
+         * Data binding can be further configured by attributing the data item classes
+         * with the data intent feature.
+        */
+        get: function () {
+            return this.i.highlightedItemsSource;
+        },
+        set: function (v) {
+            this.i.highlightedItemsSource = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "shouldDisplayMockData", {
+        /**
+         * Gets or sets whether the dashboard tile should display mock data when the data source has not been provided, if supported for this type of chart.
+        */
+        get: function () {
+            return this.i.de;
+        },
+        set: function (v) {
+            this.i.de = ensureBool(v);
+            this._a("shouldDisplayMockData", this.i.de);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "shouldAvoidAxisAnnotationCollisions", {
+        /**
+         * Gets or sets whether annotations for the final value of each series is displayed on the axis.
+        */
+        get: function () {
+            return this.i.shouldAvoidAxisAnnotationCollisions;
+        },
+        set: function (v) {
+            this.i.shouldAvoidAxisAnnotationCollisions = ensureBool(v);
+            this._a("shouldAvoidAxisAnnotationCollisions", this.i.shouldAvoidAxisAnnotationCollisions);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "trendLineType", {
+        /**
+         * Gets or sets the formula used for calculating trend lines in this chart.
+         * This property applies only to these chart types: point, line, spline, and bubble
+        */
+        get: function () {
+            return this.i.trendLineType;
+        },
+        set: function (v) {
+            this.i.trendLineType = ensureEnum(TrendLineType_$type, v);
+            this._a("trendLineType", enumToString(TrendLineType_$type, this.i.trendLineType));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "shouldUseSkeletonStyleForMockData", {
+        /**
+         * Gets or sets whether the dashboard tile should use a faded skeleton style for mock data.
+        */
+        get: function () {
+            return this.i.df;
+        },
+        set: function (v) {
+            this.i.df = ensureBool(v);
+            this._a("shouldUseSkeletonStyleForMockData", this.i.df);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "highlightedValuesDisplayMode", {
+        /**
+         * Gets or sets whether and how to display highlighted values for the series. Note, this is distinct from the highlighting feature that indicates what is closest or under the mouse.
+         * This property applies to Category Chart and Financial Chart controls.
+        */
+        get: function () {
+            return this.i.af;
+        },
+        set: function (v) {
+            this.i.af = ensureEnum(SeriesHighlightedValuesDisplayMode_$type, v);
+            this._a("highlightedValuesDisplayMode", enumToString(SeriesHighlightedValuesDisplayMode_$type, this.i.af));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "includedProperties", {
+        /**
+         * Gets or sets a set of property paths that should be included for consideration by the category chart, leaving the remainder excluded. If null, all properties will be considered.
+        */
+        get: function () {
+            return this.i.includedProperties;
+        },
+        set: function (v) {
+            if (v && !Array.isArray(v) && typeof (v) == "string") {
+                var re = /\s*(?:,|\s|$)\s*/gm;
+                v = v.split(re);
+            }
+            this.i.includedProperties = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "validVisualizationTypes", {
+        /**
+         * Gets the current set of valid visualization types for the data.
+        */
+        get: function () {
+            return this.i.m;
+        },
+        set: function (v) {
+            if (v && !Array.isArray(v) && typeof (v) == "string") {
+                var re = /\s*(?:,|\s|$)\s*/gm;
+                v = v.split(re);
+            }
+            this.i.m = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "excludedProperties", {
+        /**
+         * Gets or sets a set of property paths that should be excluded from consideration by the category chart.
+        */
+        get: function () {
+            return this.i.excludedProperties;
+        },
+        set: function (v) {
+            if (v && !Array.isArray(v) && typeof (v) == "string") {
+                var re = /\s*(?:,|\s|$)\s*/gm;
+                v = v.split(re);
+            }
+            this.i.excludedProperties = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "brushes", {
+        /**
+         * Gets or sets the palette of brushes to use for coloring the dashboard tile.
+         * The value provided should be an array of CSS color strings or JavaScript objects defining gradients. Optionally the first element can be a string reading "RGB" or "HSV" to specify the interpolation mode of the collection
+        */
+        get: function () {
+            return fromBrushCollection(this.i.v);
+        },
+        set: function (v) {
+            this.i.v = toBrushCollection(v);
+            this._a("brushes", brushCollectionToString(this.i.v));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "outlines", {
+        /**
+         * Gets or sets the palette of brushes to use for outlines on the dashboard tile.
+         * The value provided should be an array of CSS color strings or JavaScript objects defining gradients. Optionally the first element can be a string reading "RGB" or "HSV" to specify the interpolation mode of the collection
+        */
+        get: function () {
+            return fromBrushCollection(this.i.w);
+        },
+        set: function (v) {
+            this.i.w = toBrushCollection(v);
+            this._a("outlines", brushCollectionToString(this.i.w));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "selectedSeriesItems", {
+        /**
+         * Gets the currently selected data items.  Adding or removing data items from this collection will
+         * select or deselect the visuals associated with those items.
+        */
+        get: function () {
+            if (this._selectedSeriesItems === null) {
+                var coll = new IgcChartSelectedItemCollection();
+                var innerColl = this.i.selectedSeriesItems;
+                if (!innerColl) {
+                    innerColl = new ChartSelectedItemCollection_internal();
+                }
+                this._selectedSeriesItems = coll._fromInner(innerColl);
+                this.i.selectedSeriesItems = innerColl;
+            }
+            return this._selectedSeriesItems;
+        },
+        set: function (v) {
+            if (this._selectedSeriesItems !== null) {
+                this._selectedSeriesItems._setSyncTarget(null);
+                this._selectedSeriesItems = null;
+            }
+            var coll = new IgcChartSelectedItemCollection();
+            this._selectedSeriesItems = coll._fromOuter(v);
+            var syncColl = new SyncableObservableCollection$1(ChartSelection.$type);
+            var innerColl = this.i.selectedSeriesItems;
+            if (!innerColl) {
+                innerColl = new ChartSelectedItemCollection_internal();
+            }
+            syncColl._inner = innerColl;
+            syncColl.clear();
+            this._selectedSeriesItems._setSyncTarget(syncColl);
+            this.i.selectedSeriesItems = innerColl;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "actualBrushes", {
+        /**
+         * Gets the actual palette of brushes to use for coloring the chart series.
+        */
+        get: function () {
+            return fromBrushCollection(this.i.t);
+        },
+        set: function (v) {
+            this.i.t = toBrushCollection(v);
+            this._a("actualBrushes", brushCollectionToString(this.i.t));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "actualOutlines", {
+        /**
+         * Gets the actual palette of brushes to use for outlines on the chart series.
+        */
+        get: function () {
+            return fromBrushCollection(this.i.u);
+        },
+        set: function (v) {
+            this.i.u = toBrushCollection(v);
+            this._a("actualOutlines", brushCollectionToString(this.i.u));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "categoryAxisMajorStroke", {
+        /**
+         * Gets the brush to use for the Category axis major strokes, if applicable.
+        */
+        get: function () {
+            return brushToString(this.i.h9);
+        },
+        set: function (v) {
+            this.i.h9 = stringToBrush(v);
+            this._a("categoryAxisMajorStroke", brushToString(this.i.h9));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "valueLines", {
+        /**
+         * Gets or sets what value lines to use in the chart.
+        */
+        get: function () {
+            if (this._valueLines === null) {
+                var coll = new IgcValueModeCollection();
+                var innerColl = this.i.valueLines;
+                if (!innerColl) {
+                    innerColl = new ValueModeCollection_internal();
+                }
+                this._valueLines = coll._fromInner(innerColl);
+                this.i.valueLines = innerColl;
+            }
+            return this._valueLines;
+        },
+        set: function (v) {
+            if (this._valueLines !== null) {
+                this._valueLines._setSyncTarget(null);
+                this._valueLines = null;
+            }
+            var coll = new IgcValueModeCollection();
+            this._valueLines = coll._fromOuter(v);
+            var syncColl = new SyncableObservableCollection$1(ValueLayerValueMode_$type);
+            var innerColl = this.i.valueLines;
+            if (!innerColl) {
+                innerColl = new ValueModeCollection_internal();
+            }
+            syncColl._inner = innerColl;
+            syncColl.clear();
+            this._valueLines._setSyncTarget(syncColl);
+            this.i.valueLines = innerColl;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "valueLinesBrushes", {
+        /**
+         * Gets or sets the palette of brushes to use for coloring the value lines present in the ValueLines property.
+         * The value provided should be an array of CSS color strings or JavaScript objects defining gradients. Optionally the first element can be a string reading "RGB" or "HSV" to specify the interpolation mode of the collection
+        */
+        get: function () {
+            return fromBrushCollection(this.i.valueLinesBrushes);
+        },
+        set: function (v) {
+            this.i.valueLinesBrushes = toBrushCollection(v);
+            this._a("valueLinesBrushes", brushCollectionToString(this.i.valueLinesBrushes));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "autoCalloutsVisible", {
+        /**
+         * Gets or sets if the auto value callouts should be displayed.
+        */
+        get: function () {
+            return this.i.autoCalloutsVisible;
+        },
+        set: function (v) {
+            this.i.autoCalloutsVisible = ensureBool(v);
+            this._a("autoCalloutsVisible", this.i.autoCalloutsVisible);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "crosshairsAnnotationEnabled", {
+        /**
+         * Gets or sets whether annotations are shown along the axis for crosshair values
+        */
+        get: function () {
+            return this.i.crosshairsAnnotationEnabled;
+        },
+        set: function (v) {
+            this.i.crosshairsAnnotationEnabled = ensureBool(v);
+            this._a("crosshairsAnnotationEnabled", this.i.crosshairsAnnotationEnabled);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "finalValueAnnotationsVisible", {
+        /**
+         * Gets or sets whether annotations for the final value of each series is displayed on the axis.
+        */
+        get: function () {
+            return this.i.finalValueAnnotationsVisible;
+        },
+        set: function (v) {
+            this.i.finalValueAnnotationsVisible = ensureBool(v);
+            this._a("finalValueAnnotationsVisible", this.i.finalValueAnnotationsVisible);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "crosshairsDisplayMode", {
+        /**
+         * Gets or sets the crosshairs to be displayed.
+        */
+        get: function () {
+            return this.i.crosshairsDisplayMode;
+        },
+        set: function (v) {
+            this.i.crosshairsDisplayMode = ensureEnum(CrosshairsDisplayMode_$type, v);
+            this._a("crosshairsDisplayMode", enumToString(CrosshairsDisplayMode_$type, this.i.crosshairsDisplayMode));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "visualizationType", {
+        /**
+         * Gets or sets the crosshairs to be displayed.
+        */
+        get: function () {
+            return this.i.a6;
+        },
+        set: function (v) {
+            this.i.a6 = ensureEnum(DashboardTileVisualizationType_$type, v);
+            this._a("visualizationType", enumToString(DashboardTileVisualizationType_$type, this.i.a6));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "validVisualizationTypePriorityThreshold", {
+        /**
+         * Gets or sets the crosshairs to be displayed.
+        */
+        get: function () {
+            return this.i.d7;
+        },
+        set: function (v) {
+            this.i.d7 = +v;
+            this._a("validVisualizationTypePriorityThreshold", this.i.d7);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "baseTheme", {
+        /**
+         * Gets or sets the base built in theme to use for the checkbox.
+        */
+        get: function () {
+            return this.i.bt;
+        },
+        set: function (v) {
+            this.i.bt = ensureEnum(BaseControlTheme_$type, v);
+            this._a("baseTheme", enumToString(BaseControlTheme_$type, this.i.bt));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "density", {
+        /**
+         * Gets or sets the display density to use for the toolbar.
+        */
+        get: function () {
+            return this.i.bv;
+        },
+        set: function (v) {
+            this.i.bv = ensureEnum(ControlDisplayDensity_$type, v);
+            this._a("density", enumToString(ControlDisplayDensity_$type, this.i.bv));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "backgroundColor", {
+        /**
+         * Gets or sets the color to use for the background of the component.
+        */
+        get: function () {
+            return brushToString(this.i.h8);
+        },
+        set: function (v) {
+            this.i.h8 = stringToBrush(v);
+            this._a("backgroundColor", brushToString(this.i.h8));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "isVisTypeStacked", {
+        get: function () {
+            return this.i.c9;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "isVisTypeRadial", {
+        get: function () {
+            return this.i.c8;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IgcDashboardTileComponent.prototype.findByName = function (name) {
+        if (this.findEphemera) {
+            if (name && name.indexOf("@@e:") == 0) {
+                return this.findEphemera(name);
+            }
+        }
+        if (this.customizations != null && this.customizations.findByName && this.customizations.findByName(name)) {
+            return this.customizations.findByName(name);
+        }
+        if (this.initialSortDescriptions != null && this.initialSortDescriptions.findByName && this.initialSortDescriptions.findByName(name)) {
+            return this.initialSortDescriptions.findByName(name);
+        }
+        if (this.initialGroupSortDescriptions != null && this.initialGroupSortDescriptions.findByName && this.initialGroupSortDescriptions.findByName(name)) {
+            return this.initialGroupSortDescriptions.findByName(name);
+        }
+        if (this.initialGroupDescriptions != null && this.initialGroupDescriptions.findByName && this.initialGroupDescriptions.findByName(name)) {
+            return this.initialGroupDescriptions.findByName(name);
+        }
+        if (this.initialFilterExpressions != null && this.initialFilterExpressions.findByName && this.initialFilterExpressions.findByName(name)) {
+            return this.initialFilterExpressions.findByName(name);
+        }
+        if (this.initialHighlightFilterExpressions != null && this.initialHighlightFilterExpressions.findByName && this.initialHighlightFilterExpressions.findByName(name)) {
+            return this.initialHighlightFilterExpressions.findByName(name);
+        }
+        if (this.initialSummaryDescriptions != null && this.initialSummaryDescriptions.findByName && this.initialSummaryDescriptions.findByName(name)) {
+            return this.initialSummaryDescriptions.findByName(name);
+        }
+        if (this.sortDescriptions != null && this.sortDescriptions.findByName && this.sortDescriptions.findByName(name)) {
+            return this.sortDescriptions.findByName(name);
+        }
+        if (this.groupSortDescriptions != null && this.groupSortDescriptions.findByName && this.groupSortDescriptions.findByName(name)) {
+            return this.groupSortDescriptions.findByName(name);
+        }
+        if (this.groupDescriptions != null && this.groupDescriptions.findByName && this.groupDescriptions.findByName(name)) {
+            return this.groupDescriptions.findByName(name);
+        }
+        if (this.filterExpressions != null && this.filterExpressions.findByName && this.filterExpressions.findByName(name)) {
+            return this.filterExpressions.findByName(name);
+        }
+        if (this.highlightFilterExpressions != null && this.highlightFilterExpressions.findByName && this.highlightFilterExpressions.findByName(name)) {
+            return this.highlightFilterExpressions.findByName(name);
+        }
+        if (this.summaryDescriptions != null && this.summaryDescriptions.findByName && this.summaryDescriptions.findByName(name)) {
+            return this.summaryDescriptions.findByName(name);
+        }
+        if (this.selectedSeriesItems != null && this.selectedSeriesItems.findByName && this.selectedSeriesItems.findByName(name)) {
+            return this.selectedSeriesItems.findByName(name);
+        }
+        if (this.valueLines != null && this.valueLines.findByName && this.valueLines.findByName(name)) {
+            return this.valueLines.findByName(name);
+        }
+        return null;
+    };
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "hasUserValues", {
+        get: function () {
+            return this._hasUserValues;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IgcDashboardTileComponent.prototype.__m = function (propertyName) {
+        if (!this._inStyling) {
+            this._hasUserValues.add(propertyName);
+        }
+    };
+    IgcDashboardTileComponent.prototype._styling = function (container, component, parent) {
+        if (this._inStyling) {
+            return;
+        }
+        this._inStyling = true;
+        this._stylingContainer = container;
+        this._stylingParent = component;
+        var genericPrefix = "";
+        var typeName = this.i.$type.name;
+        if (typeName.indexOf("Xam") === 0) {
+            typeName = typeName.substring(3);
+        }
+        genericPrefix = toSpinal("DashboardTileComponent");
+        var additionalPrefixes = [];
+        var prefix = toSpinal(typeName);
+        additionalPrefixes.push(prefix + "-");
+        var b = this.i.$type.baseType;
+        while (b && b.name != "Object" &&
+            b.name != "Base" &&
+            b.name != "Control" &&
+            b.Name != "DependencyObject" &&
+            b.Name != "FrameworkElement") {
+            typeName = b.name;
+            if (typeName.indexOf("Xam") === 0) {
+                typeName = typeName.substring(3);
+            }
+            var basePrefix = toSpinal(typeName);
+            additionalPrefixes.push(basePrefix + "-");
+            b = b.baseType;
+        }
+        if (parent) {
+            var parentTypeName = parent.i.$type.name;
+            if (parentTypeName.indexOf("Xam") === 0) {
+                parentTypeName = parentTypeName.substring(3);
+            }
+            var parentPrefix = toSpinal(parentTypeName);
+            additionalPrefixes.push(parentPrefix + "-" + genericPrefix + "-");
+            additionalPrefixes.push(parentPrefix + "-" + prefix + "-");
+        }
+        initializePropertiesFromCss(container, this, genericPrefix + "-", this.hasUserValues, false, additionalPrefixes);
+        if (this._otherStyling) {
+            this._otherStyling(container, component, parent);
+        }
+        this._inStyling = false;
+    };
+    IgcDashboardTileComponent.prototype.updateSettingsValue = function (key, value) {
+        this.i.h2(key, value);
+    };
+    IgcDashboardTileComponent.prototype.getSettingsValue = function (key) {
+        var iv = this.i.er(key);
+        return (iv);
+    };
+    IgcDashboardTileComponent.prototype.hasModifiedSettings = function () {
+        var iv = this.i.ct();
+        return (iv);
+    };
+    IgcDashboardTileComponent.prototype.clearSettings = function () {
+        this.i.gr();
+    };
+    IgcDashboardTileComponent.prototype.removeSettingsValue = function (key) {
+        this.i.hr(key);
+    };
+    IgcDashboardTileComponent.prototype.zoomIn = function (percentage) {
+        this.i.zoomIn(percentage);
+    };
+    /**
+     * Performs zoom out action on the chart by specified percentage of current window rect
+    
+    */
+    IgcDashboardTileComponent.prototype.zoomOut = function (percentage) {
+        this.i.zoomOut(percentage);
+    };
+    /**
+     * Resets the zoom level to default.
+    
+    */
+    IgcDashboardTileComponent.prototype.resetZoom = function () {
+        this.i.resetZoom();
+    };
+    IgcDashboardTileComponent.prototype.onUIReady = function () {
+        this.i.hk();
+    };
+    IgcDashboardTileComponent.prototype.getDesiredToolbarActions = function () {
+        var iv = this.i.getDesiredToolbarActions();
+        return (iv);
+    };
+    IgcDashboardTileComponent.prototype.addCommandAvailabilityListener = function (listener) {
+        this.i.addCommandAvailabilityListener(listener);
+    };
+    IgcDashboardTileComponent.prototype.removeCommandAvailabilityListener = function (listener) {
+        this.i.removeCommandAvailabilityListener(listener);
+    };
+    IgcDashboardTileComponent.prototype.addCommandStateChangedListener = function (listener) {
+        this.i.addCommandStateChangedListener(listener);
+    };
+    IgcDashboardTileComponent.prototype.removeCommandStateChangedListener = function (listener) {
+        this.i.removeCommandStateChangedListener(listener);
+    };
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "changingContent", {
+        get: function () {
+            return this._changingContent;
+        },
+        set: function (ev) {
+            var _this = this;
+            if (this._changingContent_wrapped !== null) {
+                this.i.changingContent = delegateRemove(this.i.changingContent, this._changingContent_wrapped);
+                this._changingContent_wrapped = null;
+                this._changingContent = null;
+            }
+            this._changingContent = ev;
+            this._changingContent_wrapped = function (o, e) {
+                var outerArgs = new IgcDashboardTileChangingContentEventArgs();
+                outerArgs._provideImplementation(e);
+                if (_this.beforeChangingContent) {
+                    _this.beforeChangingContent(_this, outerArgs);
+                }
+                if (_this._changingContent) {
+                    _this._changingContent(_this, outerArgs);
+                }
+            };
+            this.i.changingContent = delegateCombine(this.i.changingContent, this._changingContent_wrapped);
+            ;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcDashboardTileComponent.prototype, "filterStringErrorsParsing", {
+        get: function () {
+            return this._filterStringErrorsParsing;
+        },
+        set: function (ev) {
+            var _this = this;
+            if (this._filterStringErrorsParsing_wrapped !== null) {
+                this.i.filterStringErrorsParsing = delegateRemove(this.i.filterStringErrorsParsing, this._filterStringErrorsParsing_wrapped);
+                this._filterStringErrorsParsing_wrapped = null;
+                this._filterStringErrorsParsing = null;
+            }
+            this._filterStringErrorsParsing = ev;
+            this._filterStringErrorsParsing_wrapped = function (o, e) {
+                var outerArgs = new IgcDashboardTileFilterStringErrorsParsingEventArgs();
+                outerArgs._provideImplementation(e);
+                if (_this.beforeFilterStringErrorsParsing) {
+                    _this.beforeFilterStringErrorsParsing(_this, outerArgs);
+                }
+                if (_this._filterStringErrorsParsing) {
+                    _this._filterStringErrorsParsing(_this, outerArgs);
+                }
+            };
+            this.i.filterStringErrorsParsing = delegateCombine(this.i.filterStringErrorsParsing, this._filterStringErrorsParsing_wrapped);
+            ;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IgcDashboardTileComponent._observedAttributesIgcDashboardTileComponent = null;
+    IgcDashboardTileComponent.htmlTagName = "igc-dashboard-tile";
+    IgcDashboardTileComponent._isElementRegistered = false;
+    return IgcDashboardTileComponent;
+}(IgcHTMLElement));
+export { IgcDashboardTileComponent };