igniteui-webcomponents-layouts 1.4.0 → 3.2.0

package/esm5/lib/igc-property-editor-property-description-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 { PropertyEditorPropertyDescription as PropertyEditorPropertyDescription_internal } from './PropertyEditorPropertyDescription';
+import { IgcPropertyEditorPropertyDescriptionComponent as IgcPropertyEditorPropertyDescriptionComponent } from './igc-property-editor-property-description-component';
+var IgcPropertyEditorPropertyDescriptionCollection = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(IgcPropertyEditorPropertyDescriptionCollection, _super);
+    function IgcPropertyEditorPropertyDescriptionCollection(list) {
+        var _this = _super.call(this) || this;
+        if (!IgcPropertyEditorPropertyDescriptionComponent.$type) {
+            IgcPropertyEditorPropertyDescriptionComponent.$type = markType(IgcPropertyEditorPropertyDescriptionComponent, "IgcPropertyEditorPropertyDescriptionComponent");
+        }
+        if (list) {
+            for (var i = 0; i < list.length; i++) {
+                _this.add(list[i]);
+            }
+        }
+        return _this;
+    }
+    IgcPropertyEditorPropertyDescriptionCollection.prototype._createInnerColl = function () {
+        if (!IgcPropertyEditorPropertyDescriptionComponent.$type) {
+            IgcPropertyEditorPropertyDescriptionComponent.$type = markType(IgcPropertyEditorPropertyDescriptionComponent, "IgcPropertyEditorPropertyDescriptionComponent");
+        }
+        var coll = new SyncableObservableCollection$2(IgcPropertyEditorPropertyDescriptionComponent.$type, PropertyEditorPropertyDescription_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 IgcPropertyEditorPropertyDescriptionComponent();
+                if (ext) {
+                    ext._implementation = int;
+                }
+            }
+            return ext;
+        };
+        return coll;
+    };
+    return IgcPropertyEditorPropertyDescriptionCollection;
+}(IgCollection));
+export { IgcPropertyEditorPropertyDescriptionCollection };

package/esm5/lib/igc-property-editor-property-description-component.js

@@ -0,0 +1,500 @@
+import * as tslib_1 from "tslib";
+import { IgcHTMLElement } from "igniteui-webcomponents-core";
+import { delegateCombine, delegateRemove } from "igniteui-webcomponents-core";
+import { PropertyEditorValueType_$type } from "./PropertyEditorValueType";
+import { IgcPropertyEditorDescriptionObject } from "./igc-property-editor-description-object";
+import { IgcPropertyEditorDescriptionObjectCollection } from "./igc-property-editor-description-object-collection";
+import { IgcPropertyEditorPropertyDescriptionButtonClickEventArgs } from "./igc-property-editor-property-description-button-click-event-args";
+import { IgcPropertyEditorPropertyDescriptionChangedEventArgs } from "./igc-property-editor-property-description-changed-event-args";
+import { IgcPropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs } from "./igc-property-editor-property-description-target-property-updating-event-args";
+import { PropertyEditorPropertyDescription } from "./PropertyEditorPropertyDescription";
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+import { NamePatcher, getAllPropertyNames, fromSpinal, toSpinal, ensureEnum, enumToString, ensureBool, initializePropertiesFromCss } from "igniteui-webcomponents-core";
+import { RegisterElementHelper } from "igniteui-webcomponents-core";
+import { PropertyEditorDescriptionObjectCollection as PropertyEditorDescriptionObjectCollection_internal } from "./PropertyEditorDescriptionObjectCollection";
+import { PropertyEditorDescriptionObject } from "./PropertyEditorDescriptionObject";
+import { SyncableObservableCollection$1 } from "igniteui-webcomponents-core";
+var IgcPropertyEditorPropertyDescriptionComponent = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(IgcPropertyEditorPropertyDescriptionComponent, _super);
+    function IgcPropertyEditorPropertyDescriptionComponent() {
+        var _this = _super.call(this) || this;
+        _this._settingAttributes = false;
+        _this._attached = false;
+        _this._queuedSetAttributes = [];
+        _this._updatingFromAttribute = false;
+        _this._complexValues = null;
+        _this.__p = null;
+        _this._hasUserValues = new Set();
+        _this._stylingContainer = null;
+        _this._stylingParent = null;
+        _this._inStyling = false;
+        _this._buttonClicked = null;
+        _this._buttonClicked_wrapped = null;
+        _this._changed = null;
+        _this._changed_wrapped = null;
+        _this._targetPropertyUpdating = null;
+        _this._targetPropertyUpdating_wrapped = null;
+        if (_this._styling) {
+            NamePatcher.ensureStylablePatched(Object.getPrototypeOf(_this));
+        }
+        _this._implementation = _this.createImplementation();
+        _this._implementation.externalObject = _this;
+        _this.onImplementationCreated();
+        return _this;
+    }
+    IgcPropertyEditorPropertyDescriptionComponent.prototype.createImplementation = function () {
+        return new PropertyEditorPropertyDescription();
+    };
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "i", {
+        /**
+         * @hidden
+         */
+        get: function () {
+            return this._implementation;
+        } /**
+                                     * @hidden
+                                     */,
+        enumerable: true,
+        configurable: true
+    });
+    IgcPropertyEditorPropertyDescriptionComponent._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);
+    };
+    IgcPropertyEditorPropertyDescriptionComponent.prototype.onImplementationCreated = function () {
+    };
+    IgcPropertyEditorPropertyDescriptionComponent.prototype._enqueueSetAttribute = function (attrName, attrValue) {
+        this._queuedSetAttributes.push({ attrName: attrName, attrValue: attrValue });
+    };
+    IgcPropertyEditorPropertyDescriptionComponent.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;
+    };
+    IgcPropertyEditorPropertyDescriptionComponent.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;
+    };
+    IgcPropertyEditorPropertyDescriptionComponent.prototype.connectedCallback = function () {
+        if (_super.prototype["connectedCallback"]) {
+            _super.prototype["connectedCallback"].call(this);
+        }
+        if (!this._attached) {
+            this._attached = true;
+            this._flushQueuedAttributes();
+        }
+    };
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent, "observedAttributes", {
+        get: function () {
+            if (IgcPropertyEditorPropertyDescriptionComponent._observedAttributesIgcPropertyEditorPropertyDescriptionComponent == null) {
+                var names = getAllPropertyNames(IgcPropertyEditorPropertyDescriptionComponent);
+                for (var i = 0; i < names.length; i++) {
+                    names[i] = toSpinal(names[i]);
+                }
+                IgcPropertyEditorPropertyDescriptionComponent._observedAttributesIgcPropertyEditorPropertyDescriptionComponent = names;
+            }
+            return IgcPropertyEditorPropertyDescriptionComponent._observedAttributesIgcPropertyEditorPropertyDescriptionComponent;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    IgcPropertyEditorPropertyDescriptionComponent.prototype.attributeChangedCallback = function (name, oldValue, newValue) {
+        if (this._settingAttributes) {
+            return;
+        }
+        var setName = fromSpinal(name);
+        this._updatingFromAttribute = true;
+        this[setName] = newValue;
+        this._updatingFromAttribute = false;
+    };
+    IgcPropertyEditorPropertyDescriptionComponent.register = function () {
+        if (!IgcPropertyEditorPropertyDescriptionComponent._isElementRegistered) {
+            IgcPropertyEditorPropertyDescriptionComponent._isElementRegistered = true;
+            RegisterElementHelper.registerElement(IgcPropertyEditorPropertyDescriptionComponent.htmlTagName, IgcPropertyEditorPropertyDescriptionComponent);
+        }
+    };
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "propertyPath", {
+        get: function () {
+            return this.i.al;
+        },
+        set: function (v) {
+            this.i.al = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "label", {
+        get: function () {
+            return this.i.aj;
+        },
+        set: function (v) {
+            this.i.aj = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "valueType", {
+        get: function () {
+            return this.i.n;
+        },
+        set: function (v) {
+            this.i.n = ensureEnum(PropertyEditorValueType_$type, v);
+            this._a("valueType", enumToString(PropertyEditorValueType_$type, this.i.n));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "propertyDescriptionType", {
+        get: function () {
+            return this.i.ak;
+        },
+        set: function (v) {
+            this.i.ak = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "shouldOverrideDefaultEditor", {
+        get: function () {
+            return this.i.q;
+        },
+        set: function (v) {
+            this.i.q = ensureBool(v);
+            this._a("shouldOverrideDefaultEditor", this.i.q);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "elementDescriptionType", {
+        get: function () {
+            return this.i.ai;
+        },
+        set: function (v) {
+            this.i.ai = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "dropDownNames", {
+        get: function () {
+            return this.i.c;
+        },
+        set: function (v) {
+            if (v && !Array.isArray(v) && typeof (v) == "string") {
+                var re = /\s*(?:,|\s|$)\s*/gm;
+                v = v.split(re);
+            }
+            this.i.c = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "dropDownValues", {
+        get: function () {
+            return this.i.d;
+        },
+        set: function (v) {
+            if (v && !Array.isArray(v) && typeof (v) == "string") {
+                var re = /\s*(?:,|\s|$)\s*/gm;
+                v = v.split(re);
+            }
+            this.i.d = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "primitiveValue", {
+        get: function () {
+            return this.i.ad;
+        },
+        set: function (v) {
+            this.i.ad = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "min", {
+        get: function () {
+            return this.i.z;
+        },
+        set: function (v) {
+            this.i.z = +v;
+            this._a("min", this.i.z);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "editorWidth", {
+        get: function () {
+            return this.i.w;
+        },
+        set: function (v) {
+            this.i.w = +v;
+            this._a("editorWidth", this.i.w);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "labelWidth", {
+        get: function () {
+            return this.i.x;
+        },
+        set: function (v) {
+            this.i.x = +v;
+            this._a("labelWidth", this.i.x);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "max", {
+        get: function () {
+            return this.i.y;
+        },
+        set: function (v) {
+            this.i.y = +v;
+            this._a("max", this.i.y);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "step", {
+        get: function () {
+            return this.i.aa;
+        },
+        set: function (v) {
+            this.i.aa = +v;
+            this._a("step", this.i.aa);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "complexValue", {
+        get: function () {
+            if (this.i.g == null) {
+                return null;
+            }
+            if (!this.i.g.externalObject) {
+                var e = new IgcPropertyEditorDescriptionObject();
+                e._implementation = this.i.g;
+                this.i.g.externalObject = e;
+            }
+            return this.i.g.externalObject;
+        },
+        set: function (v) {
+            v == null ? this.i.g = null : this.i.g = v.i;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "complexValues", {
+        get: function () {
+            if (this._complexValues === null) {
+                var coll = new IgcPropertyEditorDescriptionObjectCollection();
+                var innerColl = this.i.i;
+                if (!innerColl) {
+                    innerColl = new PropertyEditorDescriptionObjectCollection_internal();
+                }
+                this._complexValues = coll._fromInner(innerColl);
+                this.i.i = innerColl;
+            }
+            return this._complexValues;
+        },
+        set: function (v) {
+            if (this._complexValues !== null) {
+                this._complexValues._setSyncTarget(null);
+                this._complexValues = null;
+            }
+            var coll = new IgcPropertyEditorDescriptionObjectCollection();
+            this._complexValues = coll._fromOuter(v);
+            var syncColl = new SyncableObservableCollection$1(PropertyEditorDescriptionObject.$type);
+            var innerColl = this.i.i;
+            if (!innerColl) {
+                innerColl = new PropertyEditorDescriptionObjectCollection_internal();
+            }
+            syncColl._inner = innerColl;
+            syncColl.clear();
+            this._complexValues._setSyncTarget(syncColl);
+            this.i.i = innerColl;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    IgcPropertyEditorPropertyDescriptionComponent.prototype.findByName = function (name) {
+        if (this.complexValue && this.complexValue.name && this.complexValue.name == name) {
+            return this.complexValue;
+        }
+        if (this.complexValues != null && this.complexValues.findByName && this.complexValues.findByName(name)) {
+            return this.complexValues.findByName(name);
+        }
+        return null;
+    };
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "hasUserValues", {
+        get: function () {
+            return this._hasUserValues;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    IgcPropertyEditorPropertyDescriptionComponent.prototype.__m = function (propertyName) {
+        if (!this._inStyling) {
+            this._hasUserValues.add(propertyName);
+        }
+    };
+    IgcPropertyEditorPropertyDescriptionComponent.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("PropertyEditorPropertyDescriptionComponent");
+        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;
+    };
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "buttonClicked", {
+        get: function () {
+            return this._buttonClicked;
+        },
+        set: function (ev) {
+            var _this = this;
+            if (this._buttonClicked_wrapped !== null) {
+                this.i.buttonClicked = delegateRemove(this.i.buttonClicked, this._buttonClicked_wrapped);
+                this._buttonClicked_wrapped = null;
+                this._buttonClicked = null;
+            }
+            this._buttonClicked = ev;
+            this._buttonClicked_wrapped = function (o, e) {
+                var outerArgs = new IgcPropertyEditorPropertyDescriptionButtonClickEventArgs();
+                outerArgs._provideImplementation(e);
+                if (_this.beforeButtonClicked) {
+                    _this.beforeButtonClicked(_this, outerArgs);
+                }
+                if (_this._buttonClicked) {
+                    _this._buttonClicked(_this, outerArgs);
+                }
+            };
+            this.i.buttonClicked = delegateCombine(this.i.buttonClicked, this._buttonClicked_wrapped);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "changed", {
+        get: function () {
+            return this._changed;
+        },
+        set: function (ev) {
+            var _this = this;
+            if (this._changed_wrapped !== null) {
+                this.i.changed = delegateRemove(this.i.changed, this._changed_wrapped);
+                this._changed_wrapped = null;
+                this._changed = null;
+            }
+            this._changed = ev;
+            this._changed_wrapped = function (o, e) {
+                var outerArgs = new IgcPropertyEditorPropertyDescriptionChangedEventArgs();
+                outerArgs._provideImplementation(e);
+                if (_this.beforeChanged) {
+                    _this.beforeChanged(_this, outerArgs);
+                }
+                if (_this._changed) {
+                    _this._changed(_this, outerArgs);
+                }
+            };
+            this.i.changed = delegateCombine(this.i.changed, this._changed_wrapped);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionComponent.prototype, "targetPropertyUpdating", {
+        get: function () {
+            return this._targetPropertyUpdating;
+        },
+        set: function (ev) {
+            var _this = this;
+            if (this._targetPropertyUpdating_wrapped !== null) {
+                this.i.targetPropertyUpdating = delegateRemove(this.i.targetPropertyUpdating, this._targetPropertyUpdating_wrapped);
+                this._targetPropertyUpdating_wrapped = null;
+                this._targetPropertyUpdating = null;
+            }
+            this._targetPropertyUpdating = ev;
+            this._targetPropertyUpdating_wrapped = function (o, e) {
+                var outerArgs = new IgcPropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs();
+                outerArgs._provideImplementation(e);
+                if (_this.beforeTargetPropertyUpdating) {
+                    _this.beforeTargetPropertyUpdating(_this, outerArgs);
+                }
+                if (_this._targetPropertyUpdating) {
+                    _this._targetPropertyUpdating(_this, outerArgs);
+                }
+            };
+            this.i.targetPropertyUpdating = delegateCombine(this.i.targetPropertyUpdating, this._targetPropertyUpdating_wrapped);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    IgcPropertyEditorPropertyDescriptionComponent._observedAttributesIgcPropertyEditorPropertyDescriptionComponent = null;
+    IgcPropertyEditorPropertyDescriptionComponent.htmlTagName = "igc-property-editor-property-description";
+    IgcPropertyEditorPropertyDescriptionComponent._isElementRegistered = false;
+    return IgcPropertyEditorPropertyDescriptionComponent;
+}(IgcHTMLElement));
+export { IgcPropertyEditorPropertyDescriptionComponent };

package/esm5/lib/igc-property-editor-property-description-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 { IgcPropertyEditorPropertyDescriptionComponent } from './igc-property-editor-property-description-component';
+import { PropertyEditorPropertyDescription } from './PropertyEditorPropertyDescription';
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+var IgcPropertyEditorPropertyDescriptionModule = /** @class */ /*@__PURE__*/ (function () {
+    function IgcPropertyEditorPropertyDescriptionModule() {
+    }
+    IgcPropertyEditorPropertyDescriptionModule.register = function () {
+        IgcPropertyEditorPropertyDescriptionComponent.register();
+        TypeRegistrar.registerCons("IgcPropertyEditorPropertyDescriptionComponent", IgcPropertyEditorPropertyDescriptionComponent);
+        TypeRegistrar.register("PropertyEditorPropertyDescription", PropertyEditorPropertyDescription.$type);
+    };
+    return IgcPropertyEditorPropertyDescriptionModule;
+}());
+export { IgcPropertyEditorPropertyDescriptionModule };

package/esm5/lib/igc-property-editor-property-description-target-property-updating-event-args.js

@@ -0,0 +1,60 @@
+import { PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs as PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs_internal } from "./PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs";
+var IgcPropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs = /** @class */ /*@__PURE__*/ (function () {
+    function IgcPropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs() {
+        this._implementation = this.createImplementation();
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+    }
+    IgcPropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs.prototype.createImplementation = function () {
+        return new PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs_internal();
+    };
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs.prototype, "i", {
+        /**
+         * @hidden
+         */
+        get: function () {
+            return this._implementation;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    IgcPropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs.prototype.onImplementationCreated = function () {
+    };
+    IgcPropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs.prototype._provideImplementation = function (i) {
+        this._implementation = i;
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+    };
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs.prototype, "target", {
+        get: function () {
+            return this.i.target;
+        },
+        set: function (v) {
+            this.i.target = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs.prototype, "value", {
+        get: function () {
+            return this.i.value;
+        },
+        set: function (v) {
+            this.i.value = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IgcPropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs.prototype, "propertyPath", {
+        get: function () {
+            return this.i.propertyPath;
+        },
+        set: function (v) {
+            this.i.propertyPath = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return IgcPropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs;
+}());
+export { IgcPropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs };