igniteui-webcomponents-layouts 5.3.0 → 5.4.0

package/esm5/lib/igc-tool-action-field-selector-aggregation-module.js

@@ -0,0 +1,19 @@
+/*
+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 { IgcToolActionFieldSelectorAggregation } from './igc-tool-action-field-selector-aggregation';
+import { ToolActionFieldSelectorAggregation } from './ToolActionFieldSelectorAggregation';
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+var IgcToolActionFieldSelectorAggregationModule = /** @class */ /*@__PURE__*/ (function () {
+    function IgcToolActionFieldSelectorAggregationModule() {
+    }
+    IgcToolActionFieldSelectorAggregationModule.register = function () {
+        TypeRegistrar.registerCons("IgcToolActionFieldSelectorAggregation", IgcToolActionFieldSelectorAggregation);
+        TypeRegistrar.register("ToolActionFieldSelectorAggregation", ToolActionFieldSelectorAggregation.$type);
+    };
+    return IgcToolActionFieldSelectorAggregationModule;
+}());
+export { IgcToolActionFieldSelectorAggregationModule };

package/esm5/lib/igc-tool-action-field-selector-aggregation.js

@@ -0,0 +1,76 @@
+import { DataSourceSummaryOperand_$type } from "igniteui-webcomponents-core";
+import { ToolActionFieldSelectorAggregation as ToolActionFieldSelectorAggregation_internal } from "./ToolActionFieldSelectorAggregation";
+import { ensureEnum } from "igniteui-webcomponents-core";
+var IgcToolActionFieldSelectorAggregation = /** @class */ /*@__PURE__*/ (function () {
+    function IgcToolActionFieldSelectorAggregation() {
+        this._implementation = this.createImplementation();
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+        if (this._initializeAdapters) {
+            this._initializeAdapters();
+        }
+    }
+    IgcToolActionFieldSelectorAggregation.prototype.createImplementation = function () {
+        return new ToolActionFieldSelectorAggregation_internal();
+    };
+    Object.defineProperty(IgcToolActionFieldSelectorAggregation.prototype, "i", {
+        /**
+         * @hidden
+         */
+        get: function () {
+            return this._implementation;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IgcToolActionFieldSelectorAggregation.prototype.onImplementationCreated = function () {
+    };
+    IgcToolActionFieldSelectorAggregation.prototype._provideImplementation = function (i) {
+        this._implementation = i;
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+        if (this._initializeAdapters) {
+            this._initializeAdapters();
+        }
+    };
+    Object.defineProperty(IgcToolActionFieldSelectorAggregation.prototype, "label", {
+        get: function () {
+            return this.i.label;
+        },
+        set: function (v) {
+            this.i.label = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorAggregation.prototype, "name", {
+        get: function () {
+            return this.i.name;
+        },
+        set: function (v) {
+            this.i.name = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorAggregation.prototype, "operand", {
+        get: function () {
+            return this.i.operand;
+        },
+        set: function (v) {
+            this.i.operand = ensureEnum(DataSourceSummaryOperand_$type, v);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IgcToolActionFieldSelectorAggregation.prototype.findByName = function (name) {
+        if (this.findEphemera) {
+            if (name && name.indexOf("@@e:") == 0) {
+                return this.findEphemera(name);
+            }
+        }
+        return null;
+    };
+    return IgcToolActionFieldSelectorAggregation;
+}());
+export { IgcToolActionFieldSelectorAggregation };

package/esm5/lib/igc-tool-action-field-selector-aggregations-collection.js

@@ -0,0 +1,58 @@
+import { __extends } from "tslib";
+import { IgCollection } from "igniteui-webcomponents-core";
+import { markType } from "igniteui-webcomponents-core";
+import { SyncableObservableCollection$2 } from "igniteui-webcomponents-core";
+import { ToolActionFieldSelectorAggregation as ToolActionFieldSelectorAggregation_internal } from './ToolActionFieldSelectorAggregation';
+import { IgcToolActionFieldSelectorAggregation as IgcToolActionFieldSelectorAggregation } from './igc-tool-action-field-selector-aggregation';
+var IgcToolActionFieldSelectorAggregationsCollection = /** @class */ /*@__PURE__*/ (function (_super) {
+    __extends(IgcToolActionFieldSelectorAggregationsCollection, _super);
+    function IgcToolActionFieldSelectorAggregationsCollection(list) {
+        var _this = _super.call(this) || this;
+        if (!IgcToolActionFieldSelectorAggregation.$type) {
+            IgcToolActionFieldSelectorAggregation.$type = markType(IgcToolActionFieldSelectorAggregation, "IgcToolActionFieldSelectorAggregation");
+        }
+        if (list) {
+            for (var i = 0; i < list.length; i++) {
+                _this.add(list[i]);
+            }
+        }
+        return _this;
+    }
+    IgcToolActionFieldSelectorAggregationsCollection.prototype._createInnerColl = function () {
+        if (!IgcToolActionFieldSelectorAggregation.$type) {
+            IgcToolActionFieldSelectorAggregation.$type = markType(IgcToolActionFieldSelectorAggregation, "IgcToolActionFieldSelectorAggregation");
+        }
+        var coll = new SyncableObservableCollection$2(IgcToolActionFieldSelectorAggregation.$type, ToolActionFieldSelectorAggregation_internal.$type, 0);
+        coll.compare = function (ext, int) {
+            var comp = ext;
+            if (comp._implementation) {
+                comp = comp._implementation;
+            }
+            if (comp.equals) {
+                return comp.equals(int);
+            }
+            return comp === int;
+        };
+        coll.createTo = function (ext) {
+            return ext._implementation;
+        };
+        coll.createFrom = function (int) {
+            var ext = int.externalObject;
+            if (!ext) {
+                ext = new IgcToolActionFieldSelectorAggregation();
+                if (ext) {
+                    if (!int.$type && ext._implementation.setNativeElement) {
+                        ext._implementation.setNativeElement(int);
+                    }
+                    else {
+                        ext._implementation = int;
+                    }
+                }
+            }
+            return ext;
+        };
+        return coll;
+    };
+    return IgcToolActionFieldSelectorAggregationsCollection;
+}(IgCollection));
+export { IgcToolActionFieldSelectorAggregationsCollection };

package/esm5/lib/igc-tool-action-field-selector-component.js

@@ -0,0 +1,331 @@
+import { __extends } from "tslib";
+import { ToolActionFieldSelectorType_$type } from "./ToolActionFieldSelectorType";
+import { IgcToolActionFieldSelectorAggregationsCollection } from "./igc-tool-action-field-selector-aggregations-collection";
+import { IgcToolActionFieldSelectorSelectedAggregationsCollection } from "./igc-tool-action-field-selector-selected-aggregations-collection";
+import { IgcToolActionComponent } from "./igc-tool-action-component";
+import { ToolActionFieldSelector } from "./ToolActionFieldSelector";
+import { getAllPropertyNames, toSpinal, ensureEnum, enumToString, ensureBool } from "igniteui-webcomponents-core";
+import { RegisterElementHelper } from "igniteui-webcomponents-core";
+import { ToolActionFieldSelectorAggregationsCollection as ToolActionFieldSelectorAggregationsCollection_internal } from "./ToolActionFieldSelectorAggregationsCollection";
+import { ToolActionFieldSelectorAggregation } from "./ToolActionFieldSelectorAggregation";
+import { SyncableObservableCollection$1 } from "igniteui-webcomponents-core";
+import { ToolActionFieldSelectorSelectedAggregationsCollection as ToolActionFieldSelectorSelectedAggregationsCollection_internal } from "./ToolActionFieldSelectorSelectedAggregationsCollection";
+import { ToolActionFieldSelectorSelectedAggregation } from "./ToolActionFieldSelectorSelectedAggregation";
+var IgcToolActionFieldSelectorComponent = /** @class */ /*@__PURE__*/ (function (_super) {
+    __extends(IgcToolActionFieldSelectorComponent, _super);
+    function IgcToolActionFieldSelectorComponent() {
+        var _this = _super.call(this) || this;
+        _this._aggregations = null;
+        _this._selectedAggregations = null;
+        return _this;
+    }
+    IgcToolActionFieldSelectorComponent.prototype.createImplementation = function () {
+        return new ToolActionFieldSelector();
+    };
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "i", {
+        /**
+                                     * @hidden
+                                     */
+        get: function () {
+            return this._implementation;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IgcToolActionFieldSelectorComponent.prototype.connectedCallback = function () {
+        if (_super.prototype["connectedCallback"]) {
+            _super.prototype["connectedCallback"].call(this);
+        }
+        if (this.i.connectedCallback) {
+            this.i.connectedCallback();
+        }
+        if (this.updateContentChildren) {
+            this.updateContentChildren();
+        }
+        else if (this._updateAdapters) {
+            this._updateAdapters();
+        }
+        if (!this._attached) {
+            this._attached = true;
+            this._flushQueuedAttributes();
+        }
+    };
+    IgcToolActionFieldSelectorComponent.prototype.disconnectedCallback = function () {
+        if (_super.prototype["disconnectedCallback"]) {
+            _super.prototype["disconnectedCallback"].call(this);
+        }
+        if (this.i.disconnectedCallback) {
+            this.i.disconnectedCallback();
+        }
+        if (this._attached) {
+            this._attached = false;
+        }
+    };
+    Object.defineProperty(IgcToolActionFieldSelectorComponent, "observedAttributes", {
+        get: function () {
+            if (IgcToolActionFieldSelectorComponent._observedAttributesIgcToolActionFieldSelectorComponent == null) {
+                var names = getAllPropertyNames(IgcToolActionFieldSelectorComponent);
+                for (var i = 0; i < names.length; i++) {
+                    names[i] = toSpinal(names[i]);
+                }
+                IgcToolActionFieldSelectorComponent._observedAttributesIgcToolActionFieldSelectorComponent = names;
+            }
+            return IgcToolActionFieldSelectorComponent._observedAttributesIgcToolActionFieldSelectorComponent;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IgcToolActionFieldSelectorComponent.register = function () {
+        if (!IgcToolActionFieldSelectorComponent._isElementRegistered) {
+            IgcToolActionFieldSelectorComponent._isElementRegistered = true;
+            RegisterElementHelper.registerElement(IgcToolActionFieldSelectorComponent.htmlTagName, IgcToolActionFieldSelectorComponent);
+        }
+    };
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "dataSource", {
+        /**
+         * Gets or sets if the tool action is checked.
+        */
+        get: function () {
+            return this.i.ht;
+        },
+        set: function (v) {
+            this.i.ht = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "legendTarget", {
+        get: function () {
+            return this.i.ip;
+        },
+        set: function (v) {
+            this.i.ip = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "fieldType", {
+        /**
+         * Gets or sets if the tool action is checked.
+        */
+        get: function () {
+            return this.i.hx;
+        },
+        set: function (v) {
+            this.i.hx = ensureEnum(ToolActionFieldSelectorType_$type, v);
+            this._a("fieldType", enumToString(ToolActionFieldSelectorType_$type, this.i.hx));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "singleSelection", {
+        /**
+         * Gets or sets if the list only takes one selection at a time.
+        */
+        get: function () {
+            return this.i.h7;
+        },
+        set: function (v) {
+            this.i.h7 = ensureBool(v);
+            this._a("singleSelection", this.i.h7);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "aggregations", {
+        /**
+         * Gets or sets a list of aggregations to use, if null a default list is used instead.
+         * If list provided has custom aggregations the data source is never updated.
+        */
+        get: function () {
+            if (this._aggregations === null) {
+                var coll = new IgcToolActionFieldSelectorAggregationsCollection();
+                var innerColl = this.i.hu;
+                if (!innerColl) {
+                    innerColl = new ToolActionFieldSelectorAggregationsCollection_internal();
+                }
+                this._aggregations = coll._fromInner(innerColl);
+                this.i.hu = innerColl;
+            }
+            return this._aggregations;
+        },
+        set: function (v) {
+            if (this._aggregations !== null) {
+                this._aggregations._setSyncTarget(null);
+                this._aggregations = null;
+            }
+            var coll = new IgcToolActionFieldSelectorAggregationsCollection();
+            this._aggregations = coll._fromOuter(v);
+            var syncColl = new SyncableObservableCollection$1(ToolActionFieldSelectorAggregation.$type);
+            var innerColl = this.i.hu;
+            if (!innerColl) {
+                innerColl = new ToolActionFieldSelectorAggregationsCollection_internal();
+            }
+            syncColl._inner = innerColl;
+            syncColl.clear();
+            this._aggregations._setSyncTarget(syncColl);
+            this.i.hu = innerColl;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "updateDataSource", {
+        /**
+         * Gets or sets if the data source has to be updated when changes are made.
+        */
+        get: function () {
+            return this.i.h8;
+        },
+        set: function (v) {
+            this.i.h8 = ensureBool(v);
+            this._a("updateDataSource", this.i.h8);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "selectedAggregations", {
+        /**
+         * Used to set default values when using custom aggregations, will be overriden otherwise
+        */
+        get: function () {
+            if (this._selectedAggregations === null) {
+                var coll = new IgcToolActionFieldSelectorSelectedAggregationsCollection();
+                var innerColl = this.i.hw;
+                if (!innerColl) {
+                    innerColl = new ToolActionFieldSelectorSelectedAggregationsCollection_internal();
+                }
+                this._selectedAggregations = coll._fromInner(innerColl);
+                this.i.hw = innerColl;
+            }
+            return this._selectedAggregations;
+        },
+        set: function (v) {
+            if (this._selectedAggregations !== null) {
+                this._selectedAggregations._setSyncTarget(null);
+                this._selectedAggregations = null;
+            }
+            var coll = new IgcToolActionFieldSelectorSelectedAggregationsCollection();
+            this._selectedAggregations = coll._fromOuter(v);
+            var syncColl = new SyncableObservableCollection$1(ToolActionFieldSelectorSelectedAggregation.$type);
+            var innerColl = this.i.hw;
+            if (!innerColl) {
+                innerColl = new ToolActionFieldSelectorSelectedAggregationsCollection_internal();
+            }
+            syncColl._inner = innerColl;
+            syncColl.clear();
+            this._selectedAggregations._setSyncTarget(syncColl);
+            this.i.hw = innerColl;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "paddingLeft", {
+        get: function () {
+            return this.i.ii;
+        },
+        set: function (v) {
+            this.i.ii = +v;
+            this._a("paddingLeft", this.i.ii);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "actualPaddingLeft", {
+        get: function () {
+            return this.i.id;
+        },
+        set: function (v) {
+            this.i.id = +v;
+            this._a("actualPaddingLeft", this.i.id);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "paddingRight", {
+        get: function () {
+            return this.i.ij;
+        },
+        set: function (v) {
+            this.i.ij = +v;
+            this._a("paddingRight", this.i.ij);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "actualPaddingRight", {
+        get: function () {
+            return this.i.ie;
+        },
+        set: function (v) {
+            this.i.ie = +v;
+            this._a("actualPaddingRight", this.i.ie);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "paddingBottom", {
+        get: function () {
+            return this.i.ih;
+        },
+        set: function (v) {
+            this.i.ih = +v;
+            this._a("paddingBottom", this.i.ih);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "actualPaddingBottom", {
+        get: function () {
+            return this.i.ic;
+        },
+        set: function (v) {
+            this.i.ic = +v;
+            this._a("actualPaddingBottom", this.i.ic);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "paddingTop", {
+        get: function () {
+            return this.i.ik;
+        },
+        set: function (v) {
+            this.i.ik = +v;
+            this._a("paddingTop", this.i.ik);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorComponent.prototype, "actualPaddingTop", {
+        get: function () {
+            return this.i.ig;
+        },
+        set: function (v) {
+            this.i.ig = +v;
+            this._a("actualPaddingTop", this.i.ig);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IgcToolActionFieldSelectorComponent.prototype.findByName = function (name) {
+        var baseResult = _super.prototype.findByName.call(this, name);
+        if (baseResult) {
+            return baseResult;
+        }
+        if (this.dataSource && this.dataSource.name && this.dataSource.name == name) {
+            return this.dataSource;
+        }
+        if (this.aggregations != null && this.aggregations.findByName && this.aggregations.findByName(name)) {
+            return this.aggregations.findByName(name);
+        }
+        if (this.selectedAggregations != null && this.selectedAggregations.findByName && this.selectedAggregations.findByName(name)) {
+            return this.selectedAggregations.findByName(name);
+        }
+        return null;
+    };
+    IgcToolActionFieldSelectorComponent._observedAttributesIgcToolActionFieldSelectorComponent = null;
+    IgcToolActionFieldSelectorComponent.htmlTagName = "igc-tool-action-field-selector";
+    IgcToolActionFieldSelectorComponent._isElementRegistered = false;
+    return IgcToolActionFieldSelectorComponent;
+}(IgcToolActionComponent));
+export { IgcToolActionFieldSelectorComponent };

package/esm5/lib/igc-tool-action-field-selector-module.js

@@ -0,0 +1,20 @@
+/*
+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 { IgcToolActionFieldSelectorComponent } from './igc-tool-action-field-selector-component';
+import { ToolActionFieldSelector } from './ToolActionFieldSelector';
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+var IgcToolActionFieldSelectorModule = /** @class */ /*@__PURE__*/ (function () {
+    function IgcToolActionFieldSelectorModule() {
+    }
+    IgcToolActionFieldSelectorModule.register = function () {
+        IgcToolActionFieldSelectorComponent.register();
+        TypeRegistrar.registerCons("IgcToolActionFieldSelectorComponent", IgcToolActionFieldSelectorComponent);
+        TypeRegistrar.register("ToolActionFieldSelector", ToolActionFieldSelector.$type);
+    };
+    return IgcToolActionFieldSelectorModule;
+}());
+export { IgcToolActionFieldSelectorModule };

package/esm5/lib/igc-tool-action-field-selector-selected-aggregation-module.js

@@ -0,0 +1,19 @@
+/*
+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 { IgcToolActionFieldSelectorSelectedAggregation } from './igc-tool-action-field-selector-selected-aggregation';
+import { ToolActionFieldSelectorSelectedAggregation } from './ToolActionFieldSelectorSelectedAggregation';
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+var IgcToolActionFieldSelectorSelectedAggregationModule = /** @class */ /*@__PURE__*/ (function () {
+    function IgcToolActionFieldSelectorSelectedAggregationModule() {
+    }
+    IgcToolActionFieldSelectorSelectedAggregationModule.register = function () {
+        TypeRegistrar.registerCons("IgcToolActionFieldSelectorSelectedAggregation", IgcToolActionFieldSelectorSelectedAggregation);
+        TypeRegistrar.register("ToolActionFieldSelectorSelectedAggregation", ToolActionFieldSelectorSelectedAggregation.$type);
+    };
+    return IgcToolActionFieldSelectorSelectedAggregationModule;
+}());
+export { IgcToolActionFieldSelectorSelectedAggregationModule };

package/esm5/lib/igc-tool-action-field-selector-selected-aggregation.js

@@ -0,0 +1,76 @@
+import { DataSourceSummaryOperand_$type } from "igniteui-webcomponents-core";
+import { ToolActionFieldSelectorSelectedAggregation as ToolActionFieldSelectorSelectedAggregation_internal } from "./ToolActionFieldSelectorSelectedAggregation";
+import { ensureEnum } from "igniteui-webcomponents-core";
+var IgcToolActionFieldSelectorSelectedAggregation = /** @class */ /*@__PURE__*/ (function () {
+    function IgcToolActionFieldSelectorSelectedAggregation() {
+        this._implementation = this.createImplementation();
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+        if (this._initializeAdapters) {
+            this._initializeAdapters();
+        }
+    }
+    IgcToolActionFieldSelectorSelectedAggregation.prototype.createImplementation = function () {
+        return new ToolActionFieldSelectorSelectedAggregation_internal();
+    };
+    Object.defineProperty(IgcToolActionFieldSelectorSelectedAggregation.prototype, "i", {
+        /**
+         * @hidden
+         */
+        get: function () {
+            return this._implementation;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IgcToolActionFieldSelectorSelectedAggregation.prototype.onImplementationCreated = function () {
+    };
+    IgcToolActionFieldSelectorSelectedAggregation.prototype._provideImplementation = function (i) {
+        this._implementation = i;
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+        if (this._initializeAdapters) {
+            this._initializeAdapters();
+        }
+    };
+    Object.defineProperty(IgcToolActionFieldSelectorSelectedAggregation.prototype, "field", {
+        get: function () {
+            return this.i.field;
+        },
+        set: function (v) {
+            this.i.field = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorSelectedAggregation.prototype, "aggregationOperand", {
+        get: function () {
+            return this.i.aggregationOperand;
+        },
+        set: function (v) {
+            this.i.aggregationOperand = ensureEnum(DataSourceSummaryOperand_$type, v);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionFieldSelectorSelectedAggregation.prototype, "aggregationName", {
+        get: function () {
+            return this.i.aggregationName;
+        },
+        set: function (v) {
+            this.i.aggregationName = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IgcToolActionFieldSelectorSelectedAggregation.prototype.findByName = function (name) {
+        if (this.findEphemera) {
+            if (name && name.indexOf("@@e:") == 0) {
+                return this.findEphemera(name);
+            }
+        }
+        return null;
+    };
+    return IgcToolActionFieldSelectorSelectedAggregation;
+}());
+export { IgcToolActionFieldSelectorSelectedAggregation };

package/esm5/lib/igc-tool-action-field-selector-selected-aggregations-collection.js

@@ -0,0 +1,58 @@
+import { __extends } from "tslib";
+import { IgCollection } from "igniteui-webcomponents-core";
+import { markType } from "igniteui-webcomponents-core";
+import { SyncableObservableCollection$2 } from "igniteui-webcomponents-core";
+import { ToolActionFieldSelectorSelectedAggregation as ToolActionFieldSelectorSelectedAggregation_internal } from './ToolActionFieldSelectorSelectedAggregation';
+import { IgcToolActionFieldSelectorSelectedAggregation as IgcToolActionFieldSelectorSelectedAggregation } from './igc-tool-action-field-selector-selected-aggregation';
+var IgcToolActionFieldSelectorSelectedAggregationsCollection = /** @class */ /*@__PURE__*/ (function (_super) {
+    __extends(IgcToolActionFieldSelectorSelectedAggregationsCollection, _super);
+    function IgcToolActionFieldSelectorSelectedAggregationsCollection(list) {
+        var _this = _super.call(this) || this;
+        if (!IgcToolActionFieldSelectorSelectedAggregation.$type) {
+            IgcToolActionFieldSelectorSelectedAggregation.$type = markType(IgcToolActionFieldSelectorSelectedAggregation, "IgcToolActionFieldSelectorSelectedAggregation");
+        }
+        if (list) {
+            for (var i = 0; i < list.length; i++) {
+                _this.add(list[i]);
+            }
+        }
+        return _this;
+    }
+    IgcToolActionFieldSelectorSelectedAggregationsCollection.prototype._createInnerColl = function () {
+        if (!IgcToolActionFieldSelectorSelectedAggregation.$type) {
+            IgcToolActionFieldSelectorSelectedAggregation.$type = markType(IgcToolActionFieldSelectorSelectedAggregation, "IgcToolActionFieldSelectorSelectedAggregation");
+        }
+        var coll = new SyncableObservableCollection$2(IgcToolActionFieldSelectorSelectedAggregation.$type, ToolActionFieldSelectorSelectedAggregation_internal.$type, 0);
+        coll.compare = function (ext, int) {
+            var comp = ext;
+            if (comp._implementation) {
+                comp = comp._implementation;
+            }
+            if (comp.equals) {
+                return comp.equals(int);
+            }
+            return comp === int;
+        };
+        coll.createTo = function (ext) {
+            return ext._implementation;
+        };
+        coll.createFrom = function (int) {
+            var ext = int.externalObject;
+            if (!ext) {
+                ext = new IgcToolActionFieldSelectorSelectedAggregation();
+                if (ext) {
+                    if (!int.$type && ext._implementation.setNativeElement) {
+                        ext._implementation.setNativeElement(int);
+                    }
+                    else {
+                        ext._implementation = int;
+                    }
+                }
+            }
+            return ext;
+        };
+        return coll;
+    };
+    return IgcToolActionFieldSelectorSelectedAggregationsCollection;
+}(IgCollection));
+export { IgcToolActionFieldSelectorSelectedAggregationsCollection };