igniteui-webcomponents-layouts 3.2.3 → 3.5.0

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

@@ -0,0 +1,409 @@
+import * as tslib_1 from "tslib";
+import { IgcHTMLElement } from "igniteui-webcomponents-core";
+import { delegateCombine, delegateRemove } from "igniteui-webcomponents-core";
+import { IgcToolCommandEventArgs } from "./igc-tool-command-event-args";
+import { IgcToolActionPerformedEventArgs } from "./igc-tool-action-performed-event-args";
+import { ToolAction } from "./ToolAction";
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+import { NamePatcher, getAllPropertyNames, fromSpinal, toSpinal, initializePropertiesFromCss } from "igniteui-webcomponents-core";
+import { RegisterElementHelper } from "igniteui-webcomponents-core";
+/**
+ * Represents base class for all tool actions in toolbar
+*/
+var IgcToolActionComponent = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(IgcToolActionComponent, _super);
+    function IgcToolActionComponent() {
+        var _this = _super.call(this) || this;
+        _this._settingAttributes = false;
+        _this._attached = false;
+        _this._queuedSetAttributes = [];
+        _this._updatingFromAttribute = false;
+        _this.__p = null;
+        _this._hasUserValues = new Set();
+        _this._stylingContainer = null;
+        _this._stylingParent = null;
+        _this._inStyling = false;
+        _this._onCommand = null;
+        _this._onCommand_wrapped = null;
+        _this._performed = null;
+        _this._performed_wrapped = null;
+        if (_this._styling) {
+            NamePatcher.ensureStylablePatched(Object.getPrototypeOf(_this));
+        }
+        _this._implementation = _this.createImplementation();
+        _this._implementation.externalObject = _this;
+        _this.onImplementationCreated();
+        return _this;
+    }
+    IgcToolActionComponent.prototype.createImplementation = function () {
+        return new ToolAction();
+    };
+    Object.defineProperty(IgcToolActionComponent.prototype, "i", {
+        /**
+         * @hidden
+         */
+        get: function () {
+            return this._implementation;
+        } /**
+                                     * @hidden
+                                     */,
+        enumerable: true,
+        configurable: true
+    });
+    IgcToolActionComponent._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);
+    };
+    IgcToolActionComponent.prototype.onImplementationCreated = function () {
+    };
+    IgcToolActionComponent.prototype._enqueueSetAttribute = function (attrName, attrValue) {
+        this._queuedSetAttributes.push({ attrName: attrName, attrValue: attrValue });
+    };
+    IgcToolActionComponent.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;
+    };
+    IgcToolActionComponent.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;
+    };
+    IgcToolActionComponent.prototype.connectedCallback = function () {
+        if (_super.prototype["connectedCallback"]) {
+            _super.prototype["connectedCallback"].call(this);
+        }
+        if (this.i.connectedCallback) {
+            this.i.connectedCallback();
+        }
+        if (!this._attached) {
+            this._attached = true;
+            this._flushQueuedAttributes();
+        }
+    };
+    IgcToolActionComponent.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(IgcToolActionComponent, "observedAttributes", {
+        get: function () {
+            if (IgcToolActionComponent._observedAttributesIgcToolActionComponent == null) {
+                var names = getAllPropertyNames(IgcToolActionComponent);
+                for (var i = 0; i < names.length; i++) {
+                    names[i] = toSpinal(names[i]);
+                }
+                IgcToolActionComponent._observedAttributesIgcToolActionComponent = names;
+            }
+            return IgcToolActionComponent._observedAttributesIgcToolActionComponent;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    IgcToolActionComponent.prototype.attributeChangedCallback = function (name, oldValue, newValue) {
+        if (this._settingAttributes) {
+            return;
+        }
+        var setName = fromSpinal(name);
+        this._updatingFromAttribute = true;
+        this[setName] = newValue;
+        this._updatingFromAttribute = false;
+    };
+    IgcToolActionComponent.register = function () {
+        if (!IgcToolActionComponent._isElementRegistered) {
+            IgcToolActionComponent._isElementRegistered = true;
+            RegisterElementHelper.registerElement(IgcToolActionComponent.htmlTagName, IgcToolActionComponent);
+        }
+    };
+    Object.defineProperty(IgcToolActionComponent.prototype, "id", {
+        get: function () {
+            return this.i.ao;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionComponent.prototype, "parentId", {
+        get: function () {
+            return this.i.ax;
+        },
+        set: function (v) {
+            this.i.ax = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionComponent.prototype, "commandId", {
+        get: function () {
+            return this.i.ai;
+        },
+        set: function (v) {
+            this.i.ai = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionComponent.prototype, "commandArgument", {
+        get: function () {
+            return this.i.af;
+        },
+        set: function (v) {
+            this.i.af = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionComponent.prototype, "commandArgumentValue", {
+        get: function () {
+            return this.i.v;
+        },
+        set: function (v) {
+            this.i.v = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionComponent.prototype, "paddingLeft", {
+        get: function () {
+            return this.i.r;
+        },
+        set: function (v) {
+            this.i.r = +v;
+            this._a("paddingLeft", this.i.r);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionComponent.prototype, "paddingRight", {
+        get: function () {
+            return this.i.s;
+        },
+        set: function (v) {
+            this.i.s = +v;
+            this._a("paddingRight", this.i.s);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionComponent.prototype, "paddingBottom", {
+        get: function () {
+            return this.i.q;
+        },
+        set: function (v) {
+            this.i.q = +v;
+            this._a("paddingBottom", this.i.q);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionComponent.prototype, "paddingTop", {
+        get: function () {
+            return this.i.t;
+        },
+        set: function (v) {
+            this.i.t = +v;
+            this._a("paddingTop", this.i.t);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionComponent.prototype, "name", {
+        get: function () {
+            return this.i.ar;
+        },
+        set: function (v) {
+            this.i.ar = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionComponent.prototype, "label", {
+        get: function () {
+            return this.i.ap;
+        },
+        set: function (v) {
+            this.i.ap = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionComponent.prototype, "iconName", {
+        get: function () {
+            return this.i.am;
+        },
+        set: function (v) {
+            this.i.am = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionComponent.prototype, "iconCollectionName", {
+        get: function () {
+            return this.i.ak;
+        },
+        set: function (v) {
+            this.i.ak = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    IgcToolActionComponent.prototype.findByName = function (name) {
+        if (this.findEphemera) {
+            if (name && name.indexOf("@@e:") == 0) {
+                return this.findEphemera(name);
+            }
+        }
+        return null;
+    };
+    Object.defineProperty(IgcToolActionComponent.prototype, "hasUserValues", {
+        get: function () {
+            return this._hasUserValues;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    IgcToolActionComponent.prototype.__m = function (propertyName) {
+        if (!this._inStyling) {
+            this._hasUserValues.add(propertyName);
+        }
+    };
+    IgcToolActionComponent.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("ToolActionComponent");
+        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;
+    };
+    IgcToolActionComponent.prototype.fromInfo = function (info) {
+        this.i.a6(info);
+    };
+    Object.defineProperty(IgcToolActionComponent.prototype, "onCommand", {
+        get: function () {
+            return this._onCommand;
+        },
+        set: function (ev) {
+            var _this = this;
+            if (this._onCommand_wrapped !== null) {
+                this.i.onCommand = delegateRemove(this.i.onCommand, this._onCommand_wrapped);
+                this._onCommand_wrapped = null;
+                this._onCommand = null;
+            }
+            this._onCommand = ev;
+            this._onCommand_wrapped = function (o, e) {
+                var outerArgs = new IgcToolCommandEventArgs();
+                outerArgs._provideImplementation(e);
+                if (_this.beforeOnCommand) {
+                    _this.beforeOnCommand(_this, outerArgs);
+                }
+                if (_this._onCommand) {
+                    _this._onCommand(_this, outerArgs);
+                }
+            };
+            this.i.onCommand = delegateCombine(this.i.onCommand, this._onCommand_wrapped);
+            ;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionComponent.prototype, "performed", {
+        get: function () {
+            return this._performed;
+        },
+        set: function (ev) {
+            var _this = this;
+            if (this._performed_wrapped !== null) {
+                this.i.performed = delegateRemove(this.i.performed, this._performed_wrapped);
+                this._performed_wrapped = null;
+                this._performed = null;
+            }
+            this._performed = ev;
+            this._performed_wrapped = function (o, e) {
+                var outerArgs = new IgcToolActionPerformedEventArgs();
+                outerArgs._provideImplementation(e);
+                if (_this.beforePerformed) {
+                    _this.beforePerformed(_this, outerArgs);
+                }
+                if (_this._performed) {
+                    _this._performed(_this, outerArgs);
+                }
+            };
+            this.i.performed = delegateCombine(this.i.performed, this._performed_wrapped);
+            ;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    IgcToolActionComponent._observedAttributesIgcToolActionComponent = null;
+    IgcToolActionComponent.htmlTagName = "igc-tool-action";
+    IgcToolActionComponent._isElementRegistered = false;
+    return IgcToolActionComponent;
+}(IgcHTMLElement));
+export { IgcToolActionComponent };

package/esm5/lib/igc-tool-action-event-detail-collection.js

@@ -0,0 +1,53 @@
+import * as tslib_1 from "tslib";
+import { IgCollection } from "igniteui-webcomponents-core";
+import { markType } from "igniteui-webcomponents-core";
+import { SyncableObservableCollection$2 } from "igniteui-webcomponents-core";
+import { ToolActionEventDetail as ToolActionEventDetail_internal } from './ToolActionEventDetail';
+import { IgcToolActionEventDetail as IgcToolActionEventDetail } from './igc-tool-action-event-detail';
+var IgcToolActionEventDetailCollection = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(IgcToolActionEventDetailCollection, _super);
+    function IgcToolActionEventDetailCollection(list) {
+        var _this = _super.call(this) || this;
+        if (!IgcToolActionEventDetail.$type) {
+            IgcToolActionEventDetail.$type = markType(IgcToolActionEventDetail, "IgcToolActionEventDetail");
+        }
+        if (list) {
+            for (var i = 0; i < list.length; i++) {
+                _this.add(list[i]);
+            }
+        }
+        return _this;
+    }
+    IgcToolActionEventDetailCollection.prototype._createInnerColl = function () {
+        if (!IgcToolActionEventDetail.$type) {
+            IgcToolActionEventDetail.$type = markType(IgcToolActionEventDetail, "IgcToolActionEventDetail");
+        }
+        var coll = new SyncableObservableCollection$2(IgcToolActionEventDetail.$type, ToolActionEventDetail_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 IgcToolActionEventDetail();
+                if (ext) {
+                    ext._implementation = int;
+                }
+            }
+            return ext;
+        };
+        return coll;
+    };
+    return IgcToolActionEventDetailCollection;
+}(IgCollection));
+export { IgcToolActionEventDetailCollection };

package/esm5/lib/igc-tool-action-event-detail.js

@@ -0,0 +1,125 @@
+import { IgcToolActionComponent } from "./igc-tool-action-component";
+import { ToolActionType_$type } from "igniteui-webcomponents-core";
+import { ToolActionEventDetail as ToolActionEventDetail_internal } from "./ToolActionEventDetail";
+import { ensureEnum, ensureBool } from "igniteui-webcomponents-core";
+var IgcToolActionEventDetail = /** @class */ /*@__PURE__*/ (function () {
+    function IgcToolActionEventDetail() {
+        this._implementation = this.createImplementation();
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+    }
+    IgcToolActionEventDetail.prototype.createImplementation = function () {
+        return new ToolActionEventDetail_internal();
+    };
+    Object.defineProperty(IgcToolActionEventDetail.prototype, "i", {
+        /**
+         * @hidden
+         */
+        get: function () {
+            return this._implementation;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    IgcToolActionEventDetail.prototype.onImplementationCreated = function () {
+    };
+    IgcToolActionEventDetail.prototype._provideImplementation = function (i) {
+        this._implementation = i;
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+    };
+    Object.defineProperty(IgcToolActionEventDetail.prototype, "action", {
+        get: function () {
+            var r = this.i.a;
+            if (r == null) {
+                return null;
+            }
+            if (!r.externalObject) {
+                var e = IgcToolActionComponent._createFromInternal(r);
+                if (e) {
+                    e._implementation = r;
+                }
+                r.externalObject = e;
+            }
+            return r.externalObject;
+        },
+        set: function (v) {
+            v == null ? this.i.a = null : this.i.a = v.i;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionEventDetail.prototype, "actionType", {
+        get: function () {
+            return this.i.b;
+        },
+        set: function (v) {
+            this.i.b = ensureEnum(ToolActionType_$type, v);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionEventDetail.prototype, "isModified", {
+        get: function () {
+            return this.i.d;
+        },
+        set: function (v) {
+            this.i.d = ensureBool(v);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionEventDetail.prototype, "boolValue", {
+        get: function () {
+            return this.i.c;
+        },
+        set: function (v) {
+            this.i.c = ensureBool(v);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionEventDetail.prototype, "numberValue", {
+        get: function () {
+            return this.i.f;
+        },
+        set: function (v) {
+            this.i.f = +v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionEventDetail.prototype, "dateTimeValue", {
+        get: function () {
+            return this.i.e;
+        },
+        set: function (v) {
+            this.i.e = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcToolActionEventDetail.prototype, "untypedValue", {
+        get: function () {
+            return this.i.g;
+        },
+        set: function (v) {
+            this.i.g = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    IgcToolActionEventDetail.prototype.findByName = function (name) {
+        if (this.findEphemera) {
+            if (name && name.indexOf("@@e:") == 0) {
+                return this.findEphemera(name);
+            }
+        }
+        if (this.action && this.action.name && this.action.name == name) {
+            return this.action;
+        }
+        return null;
+    };
+    return IgcToolActionEventDetail;
+}());
+export { IgcToolActionEventDetail };

package/esm5/lib/igc-tool-action-group-header-component.js

@@ -0,0 +1,72 @@
+import * as tslib_1 from "tslib";
+import { IgcToolActionComponent } from "./igc-tool-action-component";
+import { ToolActionGroupHeader } from "./ToolActionGroupHeader";
+import { getAllPropertyNames, toSpinal } from "igniteui-webcomponents-core";
+import { RegisterElementHelper } from "igniteui-webcomponents-core";
+var IgcToolActionGroupHeaderComponent = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(IgcToolActionGroupHeaderComponent, _super);
+    function IgcToolActionGroupHeaderComponent() {
+        return _super.call(this) || this;
+    }
+    IgcToolActionGroupHeaderComponent.prototype.createImplementation = function () {
+        return new ToolActionGroupHeader();
+    };
+    Object.defineProperty(IgcToolActionGroupHeaderComponent.prototype, "i", {
+        /**
+                                     * @hidden
+                                     */
+        get: function () {
+            return this._implementation;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    IgcToolActionGroupHeaderComponent.prototype.connectedCallback = function () {
+        if (_super.prototype["connectedCallback"]) {
+            _super.prototype["connectedCallback"].call(this);
+        }
+        if (this.i.connectedCallback) {
+            this.i.connectedCallback();
+        }
+        if (!this._attached) {
+            this._attached = true;
+            this._flushQueuedAttributes();
+        }
+    };
+    IgcToolActionGroupHeaderComponent.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(IgcToolActionGroupHeaderComponent, "observedAttributes", {
+        get: function () {
+            if (IgcToolActionGroupHeaderComponent._observedAttributesIgcToolActionGroupHeaderComponent == null) {
+                var names = getAllPropertyNames(IgcToolActionGroupHeaderComponent);
+                for (var i = 0; i < names.length; i++) {
+                    names[i] = toSpinal(names[i]);
+                }
+                IgcToolActionGroupHeaderComponent._observedAttributesIgcToolActionGroupHeaderComponent = names;
+            }
+            return IgcToolActionGroupHeaderComponent._observedAttributesIgcToolActionGroupHeaderComponent;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    IgcToolActionGroupHeaderComponent.register = function () {
+        if (!IgcToolActionGroupHeaderComponent._isElementRegistered) {
+            IgcToolActionGroupHeaderComponent._isElementRegistered = true;
+            RegisterElementHelper.registerElement(IgcToolActionGroupHeaderComponent.htmlTagName, IgcToolActionGroupHeaderComponent);
+        }
+    };
+    IgcToolActionGroupHeaderComponent._observedAttributesIgcToolActionGroupHeaderComponent = null;
+    IgcToolActionGroupHeaderComponent.htmlTagName = "igc-tool-action-group-header";
+    IgcToolActionGroupHeaderComponent._isElementRegistered = false;
+    return IgcToolActionGroupHeaderComponent;
+}(IgcToolActionComponent));
+export { IgcToolActionGroupHeaderComponent };

package/esm5/lib/igc-tool-action-group-header-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 { IgcToolActionGroupHeaderComponent } from './igc-tool-action-group-header-component';
+import { ToolActionGroupHeader } from './ToolActionGroupHeader';
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+var IgcToolActionGroupHeaderModule = /** @class */ /*@__PURE__*/ (function () {
+    function IgcToolActionGroupHeaderModule() {
+    }
+    IgcToolActionGroupHeaderModule.register = function () {
+        IgcToolActionGroupHeaderComponent.register();
+        TypeRegistrar.registerCons("IgcToolActionGroupHeaderComponent", IgcToolActionGroupHeaderComponent);
+        TypeRegistrar.register("ToolActionGroupHeader", ToolActionGroupHeader.$type);
+    };
+    return IgcToolActionGroupHeaderModule;
+}());
+export { IgcToolActionGroupHeaderModule };