(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory(require("vue"));
	else if(typeof define === 'function' && define.amd)
		define(["vue"], factory);
	else if(typeof exports === 'object')
		exports["KendoGridVueWrapper"] = factory(require("vue"));
	else
		root["KendoGridVueWrapper"] = factory(root["Vue"]);
})(typeof self !== 'undefined' ? self : this, function(__WEBPACK_EXTERNAL_MODULE_0__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 4);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports) {

module.exports = __WEBPACK_EXTERNAL_MODULE_0__;

/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});

var _Columns = __webpack_require__(11);

var _Columns2 = _interopRequireDefault(_Columns);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var KendoGridColumn = {
    name: 'kendo-grid-column',
    render: function render() {
        return null;
    },

    mixins: [_Columns2.default]
};

exports.default = KendoGridColumn;

/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});

var _vue = __webpack_require__(0);

var Vue = _interopRequireWildcard(_vue);

var _KendoGridMixin = __webpack_require__(5);

var _KendoGridMixin2 = _interopRequireDefault(_KendoGridMixin);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

var allVue = Vue;
var gh = allVue.h;
var isV3 = allVue.version && allVue.version[0] === '3';
exports.default = {
    name: 'kendo-grid',
    mixins: [_KendoGridMixin2.default],
    setup: function setup() {
        var v3 = isV3;
        return {
            v3: v3
        };
    },
    render: function render(createElement) {
        var h = gh || createElement;
        var defaultSlot = this.v3 && this.$slots.default && typeof this.$slots.default === 'function' ? this.$slots.default() : this.$slots.default;
        return h('div', [this.$slots['kendo-datasource'], defaultSlot]);
    }
};

/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});

var _Toolbar = __webpack_require__(12);

var _Toolbar2 = _interopRequireDefault(_Toolbar);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var KendoGridToolbar = {
    name: 'kendo-grid-toolbar-item',
    render: function render() {
        return null;
    },

    mixins: [_Toolbar2.default]
};

exports.default = KendoGridToolbar;

/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.GridInstaller = exports.KendoGridInstaller = exports.GridColumn = exports.KendoGridColumn = exports.Grid = exports.KendoGrid = undefined;

var _KendoGrid = __webpack_require__(2);

var _KendoGrid2 = _interopRequireDefault(_KendoGrid);

var _KendoGridColumn = __webpack_require__(1);

var _KendoGridColumn2 = _interopRequireDefault(_KendoGridColumn);

var _kendoGridInstaller = __webpack_require__(26);

var _kendoGridInstaller2 = _interopRequireDefault(_kendoGridInstaller);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.KendoGrid = _KendoGrid2.default;
exports.Grid = _KendoGrid2.default;
exports.KendoGridColumn = _KendoGridColumn2.default;
exports.GridColumn = _KendoGridColumn2.default;
exports.KendoGridInstaller = _kendoGridInstaller2.default;
exports.GridInstaller = _kendoGridInstaller2.default;

/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});

var _kendoBaseComponentsVueWrapper = __webpack_require__(6);

var _KendoGridColumn = __webpack_require__(1);

var _KendoGridColumn2 = _interopRequireDefault(_KendoGridColumn);

var _KendoGridToolbar = __webpack_require__(3);

var _KendoGridToolbar2 = _interopRequireDefault(_KendoGridToolbar);

var _GridProps = __webpack_require__(13);

var _GridProps2 = _interopRequireDefault(_GridProps);

var _AllowCopy = __webpack_require__(14);

var _AllowCopy2 = _interopRequireDefault(_AllowCopy);

var _ColumnMenu = __webpack_require__(15);

var _ColumnMenu2 = _interopRequireDefault(_ColumnMenu);

var _Editable = __webpack_require__(16);

var _Editable2 = _interopRequireDefault(_Editable);

var _Excel = __webpack_require__(17);

var _Excel2 = _interopRequireDefault(_Excel);

var _Filterable = __webpack_require__(18);

var _Filterable2 = _interopRequireDefault(_Filterable);

var _Groupable = __webpack_require__(19);

var _Groupable2 = _interopRequireDefault(_Groupable);

var _Messages = __webpack_require__(20);

var _Messages2 = _interopRequireDefault(_Messages);

var _NoRecords = __webpack_require__(21);

var _NoRecords2 = _interopRequireDefault(_NoRecords);

var _Pageable = __webpack_require__(22);

var _Pageable2 = _interopRequireDefault(_Pageable);

var _Pdf = __webpack_require__(23);

var _Pdf2 = _interopRequireDefault(_Pdf);

var _Scrollable = __webpack_require__(24);

var _Scrollable2 = _interopRequireDefault(_Scrollable);

var _Sortable = __webpack_require__(25);

var _Sortable2 = _interopRequireDefault(_Sortable);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
    props: _GridProps2.default,
    emits: {
        'kendowidgetready': null
    },
    mixins: [_kendoBaseComponentsVueWrapper.KendoBaseComponent, _kendoBaseComponentsVueWrapper.KendoBaseDatasourceComponent, _AllowCopy2.default, _ColumnMenu2.default, _Editable2.default, _Excel2.default, _Filterable2.default, _Groupable2.default, _Messages2.default, _NoRecords2.default, _Pageable2.default, _Pdf2.default, _Scrollable2.default, _Sortable2.default],
    mounted: function mounted() {
        this._resolveChildren();
        kendo.jQuery(this.$el).kendoGrid(this.widgetOptions);

        if (this.v3) {
            this.ready();
            this.$emit('kendowidgetready', this.kendoWidget());
        } else {
            this.$emit('kendowidgetready', this.kendoWidget());
        }
    },

    methods: {
        kendoWidget: function kendoWidget() {
            return kendo.jQuery(this.$el).getKendoGrid();
        },
        _resolveChildren: function _resolveChildren() {
            this.resolveChildren('columns', _KendoGridColumn2.default.name);
            this.resolveChildren('toolbar', _KendoGridToolbar2.default.name);
        }
    }
};

/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.KendoSharedMethods = exports.KendoBaseInputComponent = exports.KendoBaseDatasourceComponent = exports.KendoBaseComponent = undefined;

var _kendoBaseComponent = __webpack_require__(7);

var _kendoBaseComponent2 = _interopRequireDefault(_kendoBaseComponent);

var _kendoBaseDatasourceComponent = __webpack_require__(8);

var _kendoBaseDatasourceComponent2 = _interopRequireDefault(_kendoBaseDatasourceComponent);

var _kendoBaseInputComponent = __webpack_require__(9);

var _kendoBaseInputComponent2 = _interopRequireDefault(_kendoBaseInputComponent);

var _kendoSharedMethods = __webpack_require__(10);

var _kendoSharedMethods2 = _interopRequireDefault(_kendoSharedMethods);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.KendoBaseComponent = _kendoBaseComponent2.default;
exports.KendoBaseDatasourceComponent = _kendoBaseDatasourceComponent2.default;
exports.KendoBaseInputComponent = _kendoBaseInputComponent2.default;
exports.KendoSharedMethods = _kendoSharedMethods2.default;

/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _vue = __webpack_require__(0);

var aVue = _interopRequireWildcard(_vue);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

var allVue = aVue;
var gh = allVue.h;
var isV3 = allVue.version && allVue.version[0] === '3';
var createApp = allVue.createApp;
exports.default = {
    name: 'baseComponent',
    props: {
        disabled: {
            type: Boolean,
            default: undefined
        },
        readonly: {
            type: Boolean,
            default: undefined
        }
    },
    render: function render(createElement) {
        var h = gh || createElement;
        return h('div');
    },
    created: function created() {
        this.createdMethod();
    },

    beforeDestroy: gh ? undefined : function () {
        this.destroyKendoWidget();
    },
    beforeUnmount: function beforeUnmount() {
        this.destroyKendoWidget();
    },
    setup: function setup() {
        var v3 = isV3;
        return {
            v3: v3
        };
    },

    beforeMount: function beforeMount() {
        if (this.v3) {
            this.createdMethod();
            var defaultSlot = this.v3 && this.$slots.default && typeof this.$slots.default === 'function' ? this.$slots.default() : this.$slots.default;
            var hasDataSource = !this.$props.dataSource;
            if (hasDataSource && defaultSlot) {
                var innerDatasource = defaultSlot.find(function (slot) {
                    return slot.type && slot.type.name && slot.type.name.indexOf('datasource') !== -1;
                });
                if (innerDatasource) {
                    var dataSourceOptions = this.parseOptions(innerDatasource, innerDatasource.type.mixins[0].mixins);
                    this.widgetOptions.dataSource = dataSourceOptions;
                }
            }
        }
    },
    updated: function updated() {
        if (this.modelValue) {
            this.changeValue(this.modelValue);
        }
    },
    mounted: function mounted() {
        if (this.$el.classList && this.$el.classList.length > 0) {
            this.nativeClasses = [].concat(_toConsumableArray(this.$el.classList));
        } else {
            this.nativeClasses = [];
        }
        var props = this.v3 ? this.$props : this.$options.propsData;
        for (var key in props) {
            var that = this;

            if (key.toLowerCase().indexOf('template') !== -1) {
                var isFunction = this.widgetOptions[key] instanceof Function;

                if (isFunction) {
                    this.widgetOptions[key] = this.transformTemplate(key);
                }
            }

            if (key === 'value') {
                that.$watch(key, function (newValue) {
                    that.changeValue(newValue);
                });
            } else if (key === 'disabled') {
                that.$watch(key, function (newValue) {
                    that.makeDisabled(newValue);
                });
            } else if (key === 'readonly') {
                that.$watch(key, function (newValue) {
                    that.makeReadonly(newValue);
                });
            } else {
                that.$watch(key, function (newValue, oldValue) {
                    // Vue always dispatches a change when inline complex objects are bound
                    // https://github.com/telerik/kendo-ui-core/issues/3952
                    if (JSON.stringify(oldValue) !== JSON.stringify(newValue)) {
                        that.updateWidget();
                    }
                });
            }
        }
    },

    watch: {
        $attrs: function $attrs() {
            this.toggleClasses();
        }
    },
    methods: {
        createdMethod: function createdMethod() {
            this.resolveWidgetOptions();
            this.$_nativeTemplates = [];
            if (!this.v3) {
                this.$on('kendowidgetready', this.ready);
            }
        },
        destroyKendoWidget: function destroyKendoWidget() {
            if (this.kendoWidget() && this.kendoWidget().destroy) {
                this.kendoWidget().destroy();
                if (this.$_nativeTemplates.length) {
                    for (var i = 0; i < this.$_nativeTemplates.length; i++) {
                        var currentTemplate = this.$_nativeTemplates[i];
                        if (currentTemplate.unmount) {
                            currentTemplate.unmount();
                        } else {
                            currentTemplate.$destroy();
                        }
                    }
                }
            }
        },
        toggleClasses: function toggleClasses() {
            var that = this;
            var $element = kendo.jQuery(that.$el);
            var $wrapper = that.kendoWidget().wrapper;

            if ($wrapper && $wrapper[0] !== $element[0]) {
                that.nativeClasses.forEach(function (item) {
                    $wrapper.removeClass(item);
                });

                // Add to wrapper only the custom classes without the default Kendo ones
                if (that.kendoClasses) {
                    that.nativeClasses = [].concat(_toConsumableArray(that.$el.classList)).filter(function (item) {
                        return that.kendoClasses.indexOf(item) < 0;
                    });
                } else {
                    that.nativeClasses = [].concat(_toConsumableArray(that.$el.classList));
                }

                that.nativeClasses.forEach(function (item) {
                    $wrapper.addClass(item);
                });
            }

            if (that.kendoClasses) {
                that.kendoClasses.forEach(function (item) {
                    $element.addClass(item);
                });
            }
        },
        updateWidget: function updateWidget() {
            var that = this;

            that.resolveWidgetOptions();

            if (that._resolveChildren) {
                that._resolveChildren();
            }

            var currentWidget = that.kendoWidget();

            if (currentWidget && currentWidget.setOptions) {
                currentWidget.setOptions(that.widgetOptions);
            }
        },

        transformTemplate: function transformTemplate(key, val) {
            var that = this;
            var object;
            var props = that.v3 ? that.$props : that.$options.propsData;
            var templateDefinition = val || props[key];
            try {
                object = templateDefinition.call(that, {});
            } catch (e) {
                return templateDefinition;
            }

            if (!object.template) {
                return templateDefinition;
            }

            return function () {
                object = templateDefinition.apply(this, arguments);
                var kendoguid;
                if (that.v3) {
                    var newTemplateArgs = typeof object.templateArgs === 'string' ? object.templateArgs : Object.assign({}, object.templateArgs);
                    var tempComponent = (0, createApp)(Object.assign({}, object.template, {
                        data: function data() {
                            return Object.assign({}, object.template.data ? object.template.data() : {}, {
                                templateArgs: newTemplateArgs
                            });
                        }
                    }));
                    kendoguid = 'kendo' + kendo.guid();

                    that.$nextTick(function () {
                        if (document.getElementById(kendoguid)) {
                            tempComponent.mount('#' + kendoguid);
                            that.$_nativeTemplates.push(tempComponent);
                        }
                    });
                } else {
                    var newVue = allVue.default.extend(object);
                    var vueObject = new newVue(object.template);
                    vueObject.$data.templateArgs = object.templateArgs;
                    kendoguid = 'kendo' + kendo.guid();
                    that.$nextTick(function () {
                        if (document.getElementById(kendoguid)) {
                            vueObject.$mount('#' + kendoguid);
                            that.$_nativeTemplates.push(vueObject);
                        }
                    });
                }

                return '<div id="' + kendoguid + '"></div>';
            };
        },
        resolveChildren: function resolveChildren(prop, name) {
            var defaultSlot = this.v3 && this.$slots.default && typeof this.$slots.default === 'function' ? this.$slots.default() : this.$slots.default;
            if (!this.widgetOptions[prop] && defaultSlot) {
                var items = [];
                var _iteratorNormalCompletion = true;
                var _didIteratorError = false;
                var _iteratorError = undefined;

                try {
                    for (var _iterator = defaultSlot[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                        var childSlot = _step.value;

                        if (childSlot.tag && childSlot.tag.indexOf(name) !== -1 || childSlot.type && childSlot.type.name && childSlot.type.name.toLowerCase().indexOf(name) !== -1) {
                            var childInstance = this.v3 ? childSlot : childSlot.componentInstance;
                            var itemOptions = this.parseOptions(childInstance);

                            if (itemOptions.dataSourceRef) {
                                this.setInnerDataSource('dataSourceRef', 'dataSource', itemOptions);
                            }

                            items.push(itemOptions);
                            this.handleWatcher(childInstance);
                        }
                    }
                } catch (err) {
                    _didIteratorError = true;
                    _iteratorError = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion && _iterator.return) {
                            _iterator.return();
                        }
                    } finally {
                        if (_didIteratorError) {
                            throw _iteratorError;
                        }
                    }
                }

                if (items.length) {
                    this.widgetOptions[prop] = items;
                }
            }
        },
        handleWatcher: function handleWatcher(childInstance) {
            var that = this;
            childInstance.stashedPropsData = JSON.stringify(that.v3 ? childInstance.$props : childInstance.$options.propsData);

            if (!that.v3 && !childInstance._isWatchAttached) {
                childInstance.$watch('$props', function () {
                    var props = that.v3 ? childInstance.$props : childInstance.$options.propsData;
                    var propsAsJson = JSON.stringify(props);
                    var needsUpdate = childInstance.stashedPropsData !== propsAsJson;

                    if (that.updateWidget && needsUpdate) {
                        that.updateWidget();
                    } else if (that._resolveInnerChildren) {
                        that._resolveInnerChildren();
                    }

                    childInstance.stashedPropsData = propsAsJson;
                }, { deep: true });

                childInstance._isWatchAttached = true;
            }
        },
        makeDisabled: function makeDisabled(toDisable) {
            if (this.kendoWidget().enable) {
                this.kendoWidget().enable(!toDisable);
            }
        },
        makeReadonly: function makeReadonly(value) {
            if (this.kendoWidget().readonly) {
                this.kendoWidget().readonly(value);
            }
        },
        changeValue: function changeValue(newValue) {
            if (this.kendoWidget().value) {
                this.kendoWidget().value(newValue);
            }
        },
        resolveWidgetOptions: function resolveWidgetOptions() {
            this.widgetOptions = this.parseOptions();
        },
        getListeners: function getListeners() {
            if (this.v3) {
                var listeners = {};
                for (var key in this.$attrs) {
                    if (key.startsWith('on')) {
                        listeners[key] = this.$attrs[key];
                    }
                }

                return listeners;
            } else {
                return this.$listeners;
            }
        },
        parseOptions: function parseOptions(component, defaultMixins) {
            var _this = this;

            var that = component || this;
            var options = {};
            var props = this.v3 ? component ? that.props : that.$props : that.$options.propsData;

            var _loop = function _loop(_key) {
                propOptions = _this.v3 ? component ? undefined : (that.$options.__props ? that.$options.__props[0][_key] : that.$options.props[_key]) || that.$options.__props[0][0][_key] : that.$options.props[_key];
                val = props[_key];

                if (_this.v3 && _key.indexOf('-') !== -1) {
                    _key = _this.camelize(_key);
                }

                compositeProps = propOptions ? propOptions.kComposite : undefined;


                if (that.v3 || _this.v3) {
                    var mixins = component ? defaultMixins || component.type.mixins : that.$options.mixins;
                    if (mixins) {
                        mixins.forEach(function (mixin) {
                            if (mixin.props && mixin.name !== 'baseComponent' && mixin.name !== 'baseDataSourceComponent' && mixin.props[_key] !== undefined && (that.$props ? that.$props[_key] !== undefined : true)) {
                                compositeProps = mixin.props[_key].kComposite;
                            }
                        });
                    }
                }

                if (!compositeProps) {
                    if (_key.toLowerCase().indexOf('template') !== -1 && val instanceof Function) {
                        options[_key] = _this.transformTemplate(_key, val);
                    } else {
                        if (val !== undefined) {
                            options[_key] = val;
                        }
                    }
                } else {
                    if (val !== undefined) {
                        _this.addCompositeProperty(options, compositeProps.split('.'), val);
                    }
                }
                key = _key;
            };

            for (var key in props) {
                var propOptions;
                var val;
                var compositeProps;

                _loop(key);
            }

            if (that.getListeners) {
                if (this.v3) {
                    Object.keys(that.$attrs).forEach(function (event) {
                        var listeners = that.getListeners();
                        var eventName = _this.v3 ? event : event.toLowerCase();
                        if (listeners && listeners[eventName]) {
                            var kendoIndex = event.lastIndexOf('kendo');
                            var kendoEvent;
                            if (kendoIndex !== -1) {
                                kendoEvent = event.replace('kendo', '').toLowerCase();
                            }

                            if (_this.v3 && event.indexOf('onKendo') !== -1) {
                                kendoEvent = event.replace('onKendo', '').toLowerCase();
                            }
                            var kendoEventProp = Object.keys(that.$props).find(function (e) {
                                return e.toLowerCase() === _this.removeOn(event);
                            });
                            options[kendoEvent || kendoEventProp || _this.removeOn(event)] = listeners[eventName];
                        }
                    });
                } else {
                    Object.keys(that.$props).forEach(function (event) {
                        var listeners = that.getListeners();
                        if (listeners && listeners[event.toLowerCase()]) {
                            var kendoIndex = event.lastIndexOf('kendo');
                            var kendoEvent;
                            if (kendoIndex !== -1) {
                                kendoEvent = event.replace('kendo', '').toLowerCase();
                            }

                            options[kendoEvent || event] = listeners[event.toLowerCase()];
                        }
                    });
                }
            }

            if (this.v3 && this.$props.modelValue) {
                options.value = this.$props.modelValue;
            }

            return options;
        },
        addCompositeProperty: function addCompositeProperty(obj, keys, val) {
            var lastKey = keys.pop();
            var lastObj = keys.reduce(function (obj, key) {
                obj[key] = _typeof(obj[key]) === 'object' ? obj[key] || {} : {};
                return obj[key];
            }, obj);

            if (lastKey.toLowerCase().indexOf('template') !== -1 && val instanceof Function) {
                lastObj[lastKey] = this.transformTemplate(lastKey, val);
            } else {
                lastObj[lastKey] = val;
            }
        },
        resolveInnerTags: function resolveInnerTags(tagName) {
            var items = [];
            var defaultSlot = this.v3 && this.$slots.default && typeof this.$slots.default === 'function' ? this.$slots.default() : this.$slots.default;
            var _iteratorNormalCompletion2 = true;
            var _didIteratorError2 = false;
            var _iteratorError2 = undefined;

            try {
                for (var _iterator2 = defaultSlot[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                    var childSlot = _step2.value;

                    if (childSlot.tag && childSlot.tag.indexOf(tagName) !== -1 || childSlot.type && childSlot.type.name && childSlot.type.name.toLowerCase().indexOf(tagName) !== -1) {
                        var childOptions = childSlot.componentOptions;
                        var childInstance = this.v3 ? childSlot : childSlot.componentInstance;
                        var item = this.v3 ? childInstance.$props || childInstance.props : childOptions.propsData;

                        if (this.v3) {
                            var itemKeys = Object.keys(item);
                            var _iteratorNormalCompletion3 = true;
                            var _didIteratorError3 = false;
                            var _iteratorError3 = undefined;

                            try {
                                for (var _iterator3 = itemKeys[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                                    var propKey = _step3.value;

                                    if (propKey.indexOf('-') !== -1) {
                                        item[this.camelize(propKey)] = item[propKey];
                                    }
                                }
                            } catch (err) {
                                _didIteratorError3 = true;
                                _iteratorError3 = err;
                            } finally {
                                try {
                                    if (!_iteratorNormalCompletion3 && _iterator3.return) {
                                        _iterator3.return();
                                    }
                                } finally {
                                    if (_didIteratorError3) {
                                        throw _iteratorError3;
                                    }
                                }
                            }
                        }

                        if (!item.items) {
                            item.items = childInstance.subitems;
                        }

                        items.push(item);
                        this.handleWatcher(childInstance);
                    }
                }
            } catch (err) {
                _didIteratorError2 = true;
                _iteratorError2 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
                        _iterator2.return();
                    }
                } finally {
                    if (_didIteratorError2) {
                        throw _iteratorError2;
                    }
                }
            }

            return items;
        },
        ready: function ready() {
            var that = this;

            if (this.$el.classList.length > 0) {
                that.kendoClasses = [].concat(_toConsumableArray(that.$el.classList)).filter(function (item) {
                    return that.nativeClasses.indexOf(item) < 0;
                });
            }
            var props = that.v3 ? that.$props : that.$options.propsData;
            if (props && props.disabled) {
                that.makeDisabled(true);
            }

            if (props && props.readonly) {
                that.makeReadonly(true);
            }
        },
        camelize: function camelize(str) {
            var arr = str.split('-');
            var capital = arr.map(function (item, index) {
                return index ? item.charAt(0).toUpperCase() + item.slice(1).toLowerCase() : item;
            });
            var capitalString = capital.join('');

            return capitalString;
        },
        removeOn: function removeOn(str) {

            if (str.indexOf('onKendo') !== -1) {
                return str.replace('onKendo', '').toLowerCase();
            }

            return str.replace('on', '').toLowerCase();
        }
    }
};

/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    name: 'baseDataSourceComponent',
    props: {
        dataSourceRef: {
            type: String,
            default: undefined
        }
    },
    render: function render(h) {
        return h('div');
    },

    methods: {
        findDataSource: function findDataSource() {
            var dataSource;
            if (this.$children) {
                var _iteratorNormalCompletion = true;
                var _didIteratorError = false;
                var _iteratorError = undefined;

                try {
                    for (var _iterator = this.$children[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                        var a = _step.value;

                        if (this.$children.length && a.kendoDataSource) {
                            dataSource = a.kendoDataSource;
                            break;
                        }
                    }
                } catch (err) {
                    _didIteratorError = true;
                    _iteratorError = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion && _iterator.return) {
                            _iterator.return();
                        }
                    } finally {
                        if (_didIteratorError) {
                            throw _iteratorError;
                        }
                    }
                }
            }
            return dataSource;
        },
        setInnerDataSource: function setInnerDataSource() {
            var dataSourceRefProp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'dataSourceRef';
            var rootProp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'dataSource';
            var subProp = arguments[2];

            var innerDataSource = this.findDataSource();

            if (innerDataSource) {
                if (!subProp) {
                    this.widgetOptions[rootProp] = innerDataSource;
                } else {
                    subProp[rootProp] = innerDataSource;
                }
            } else {
                var refString = subProp ? subProp[dataSourceRefProp] : this[dataSourceRefProp];
                var referredDataSource = this.getParentsRef(refString);

                if (referredDataSource) {
                    this.attachEvents(referredDataSource);
                    if (!subProp) {
                        this.widgetOptions[rootProp] = referredDataSource.kendoDataSource;
                    } else {
                        subProp[rootProp] = referredDataSource.kendoDataSource;
                    }
                }
            }
        },
        getParentsRef: function getParentsRef(anchor) {
            var parent = this.$parent;

            while (parent && !parent.$refs[anchor]) {
                parent = parent.$parent;
            }

            return parent ? parent.$refs[anchor] : undefined;
        },
        setDataSource: function setDataSource(newValue) {
            var newDataSourceRef = this.getParentsRef(newValue);
            var kendoWidget = this.kendoWidget();

            if (kendoWidget.setDataSource && newDataSourceRef) {
                kendoWidget.setDataSource(newDataSourceRef.kendoDataSource);
            } else if (kendoWidget.setDataSource) {
                kendoWidget.setDataSource(newValue);
            }
        },
        attachEvents: function attachEvents(referredDataSource) {
            if (referredDataSource.kendoDataSource) {
                referredDataSource.kendoDataSource.bind('change', function (ev) {
                    if (referredDataSource.getListeners()['change']) {
                        referredDataSource.$emit('change', ev);
                    }
                });

                referredDataSource.kendoDataSource.bind('error', function (ev) {
                    if (referredDataSource.getListeners()['error']) {
                        referredDataSource.$emit('error', ev);
                    }
                });

                referredDataSource.kendoDataSource.bind('push', function (ev) {
                    if (referredDataSource.getListeners()['push']) {
                        referredDataSource.$emit('push', ev);
                    }
                });

                referredDataSource.kendoDataSource.bind('requestEnd', function (ev) {
                    if (referredDataSource.getListeners()['requestend']) {
                        referredDataSource.$emit('requestend', ev);
                    }
                });

                referredDataSource.kendoDataSource.bind('requestStart', function (ev) {
                    if (referredDataSource.getListeners()['requeststart']) {
                        referredDataSource.$emit('requeststart', ev);
                    }
                });

                referredDataSource.kendoDataSource.bind('sync', function (ev) {
                    if (referredDataSource.getListeners()['sync']) {
                        referredDataSource.$emit('sync', ev);
                    }
                });
            }
        }
    },
    mounted: function mounted() {
        var that = this;

        that.$watch('dataSourceRef', function (newValue) {
            that.setDataSource(newValue);
        });
        that.$watch('dataSource', function (newValue) {
            that.setDataSource(newValue);
        });

        that.setInnerDataSource();
    }
};

/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});

var _vue = __webpack_require__(0);

var Vue = _interopRequireWildcard(_vue);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

var allVue = Vue; // @ts-ignore

var gh = allVue.h;
exports.default = {
    render: function render(createElement) {
        var h = gh || createElement;
        return h('input', {
            ref: 'valueInput',
            props: {
                value: this.value
            }
        });
    },

    model: {
        event: 'changemodel'
    }
};

/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    methods: {
        resolveInnerTags: function resolveInnerTags(tagName) {
            var items = [];
            var defaultSlot = this.v3 && this.$slots.default && typeof this.$slots.default === 'function' ? this.$slots.default() : this.$slots.default;
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = defaultSlot[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var childSlot = _step.value;

                    if (childSlot.tag && childSlot.tag.indexOf(tagName) !== -1 || childSlot.type && childSlot.type.name && childSlot.type.name.toLowerCase().indexOf(tagName) !== -1) {
                        var childOptions = childSlot.componentOptions;
                        var childInstance = this.v3 ? childSlot : childSlot.componentInstance;
                        var item = this.v3 ? childInstance.$props || childInstance.props : childOptions.propsData;

                        if (this.v3) {
                            var itemKeys = Object.keys(item);
                            var _iteratorNormalCompletion2 = true;
                            var _didIteratorError2 = false;
                            var _iteratorError2 = undefined;

                            try {
                                for (var _iterator2 = itemKeys[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                                    var propKey = _step2.value;

                                    if (propKey.indexOf('-') !== -1) {
                                        item[this.camelize(propKey)] = item[propKey];
                                    }
                                }
                            } catch (err) {
                                _didIteratorError2 = true;
                                _iteratorError2 = err;
                            } finally {
                                try {
                                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
                                        _iterator2.return();
                                    }
                                } finally {
                                    if (_didIteratorError2) {
                                        throw _iteratorError2;
                                    }
                                }
                            }
                        }

                        if (!item.items) {
                            item.items = childInstance.subitems;
                        }

                        items.push(item);
                        this.handleWatcher(childInstance);
                    }
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }

            return items;
        },
        handleWatcher: function handleWatcher(childInstance) {
            var that = this;

            if (!childInstance._isWatchAttached && childInstance.$watch) {
                childInstance.$watch('$props', function () {
                    if (that.updateWidget) {
                        that.updateWidget();
                    } else if (that._resolveInnerChildren) {
                        that._resolveInnerChildren();
                    }
                }, { deep: true });

                childInstance._isWatchAttached = true;
            }
        },
        camelize: function camelize(str) {
            var arr = str.split('-');
            var capital = arr.map(function (item, index) {
                return index ? item.charAt(0).toUpperCase() + item.slice(1).toLowerCase() : item;
            });
            var capitalString = capital.join('');

            return capitalString;
        }
    }
};

/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    props: {
        aggregates: Array,
        attributes: Object,
        columns: Array,
        command: String | Array,
        editable: Function,
        editor: Function,
        encoded: Boolean,
        field: String,
        filterable: Boolean | Object,
        filterableCellDataSource: {
            type: Object,
            default: undefined,
            kComposite: 'filterable.cell.dataSource'
        },
        filterableCellDataTextField: {
            type: String,
            default: undefined,
            kComposite: 'filterable.cell.dataTextField'
        },
        filterableCellDelay: {
            type: Number,
            default: undefined,
            kComposite: 'filterable.cell.delay'
        },
        filterableCellInputWidth: {
            type: Number,
            default: undefined,
            kComposite: 'filterable.cell.inputWidth'
        },
        filterableCellSuggestionOperator: {
            type: String,
            default: undefined,
            kComposite: 'filterable.cell.suggestionOperator'
        },
        filterableCellMinLength: {
            type: Number,
            default: undefined,
            kComposite: 'filterable.cell.minLength'
        },
        filterableCellEnabled: {
            type: Boolean,
            default: undefined,
            kComposite: 'filterable.cell.enabled'
        },
        filterableCellOperator: {
            type: String,
            default: undefined,
            kComposite: 'filterable.cell.operator'
        },
        filterableCellShowOperators: {
            type: Boolean,
            default: undefined,
            kComposite: 'filterable.cell.showOperators'
        },
        filterableCellTemplate: {
            type: Function,
            default: undefined,
            kComposite: 'filterable.cell.template'
        },
        filterableMulti: {
            type: Boolean,
            default: undefined,
            kComposite: 'filterable.multi'
        },
        filterableDataSource: {
            type: [Object, Array],
            default: undefined,
            kComposite: 'filterable.dataSource'
        },
        filterableCheckAll: {
            type: Boolean,
            default: undefined,
            kComposite: 'filterable.checkAll'
        },
        filterableItemTemplate: {
            type: Function,
            default: undefined,
            kComposite: 'filterable.itemTemplate'
        },
        filterableOperators: {
            type: Object,
            default: undefined,
            kComposite: 'filterable.operators'
        },
        filterableSearch: {
            type: Boolean,
            default: undefined,
            kComposite: 'filterable.search'
        },
        filterableIgnoreCase: {
            type: Boolean,
            default: undefined,
            kComposite: 'filterable.ignoreCase'
        },
        filterableUi: {
            type: [String, Function],
            default: undefined,
            kComposite: 'filterable.ui'
        },
        footerAttributes: {
            type: Object,
            default: undefined,
            kComposite: 'footerAttributes'
        },
        footerTemplate: {
            type: [String, Function],
            default: undefined,
            kComposite: 'footerTemplate'
        },
        format: String,
        groupable: Boolean | Object,
        groupableSortCompare: {
            type: Function,
            default: undefined,
            kComposite: 'groupable.sort.compare'
        },
        groupableSortDir: {
            type: String,
            default: undefined,
            kComposite: 'groupable.sort.dir'
        },
        groupHeaderTemplate: {
            type: [String, Function],
            default: undefined,
            kComposite: 'groupHeaderTemplate'
        },
        groupHeaderColumnTemplate: {
            type: [String, Function],
            default: undefined,
            kComposite: 'groupHeaderColumnTemplate'
        },
        groupFooterTemplate: {
            type: [String, Function],
            default: undefined,
            kComposite: 'groupFooterTemplate'
        },
        headerAttributes: {
            type: Object,
            default: undefined,
            kComposite: 'headerAttributes'
        },
        headerTemplate: {
            type: [String, Function],
            default: undefined,
            kComposite: 'headerTemplate'
        },
        hidden: {
            type: Boolean,
            default: undefined,
            kComposite: 'hidden'
        },
        locked: Boolean,
        lockable: Boolean,
        media: String,
        minResizableWidth: {
            type: Number,
            default: undefined,
            kComposite: 'minResizableWidth'
        },
        minScreenWidth: {
            type: Number,
            default: undefined,
            kComposite: 'minScreenWidth'
        },
        selectable: Boolean,
        sortable: Boolean,
        sortableCompare: {
            type: Function,
            default: undefined,
            kComposite: 'sortable.compare'
        },
        sortableInitialDirection: {
            type: String,
            default: undefined,
            kComposite: 'sortable.initialDirection'
        },
        template: String | Function,
        title: String,
        width: String | Number,
        values: Array,
        menu: Boolean
    }
};

/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    props: {
        iconClass: {
            type: String,
            default: undefined,
            kComposite: 'iconClass'
        },
        name: {
            type: String,
            default: undefined,
            kComposite: 'name'
        },
        template: {
            type: [String, Function],
            default: undefined,
            kComposite: 'template'
        },
        text: {
            type: String,
            default: undefined,
            kComposite: 'text'
        }
    }
};

/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    allowCopy: {
        type: [Boolean, Object],
        default: undefined
    },
    altRowTemplate: {
        type: [String, Function],
        default: undefined
    },
    autoBind: {
        type: Boolean,
        default: undefined
    },
    columnResizeHandleWidth: {
        type: Number,
        default: undefined
    },
    columns: {
        type: Array,
        default: undefined
    },
    columnMenu: {
        type: [Boolean, Object],
        default: undefined
    },
    dataSource: {
        type: [Object, Array],
        default: undefined
    },
    detailTemplate: {
        type: [String, Function],
        default: undefined
    },
    editable: {
        type: [Boolean, Object, String],
        default: undefined
    },
    excel: {
        type: Object,
        default: undefined
    },
    filterable: {
        type: [Boolean, Object],
        default: undefined
    },
    groupable: {
        type: [Boolean, Object],
        default: undefined
    },
    height: {
        type: [Number, String],
        default: undefined
    },
    messages: {
        type: Object,
        default: undefined
    },
    mobile: {
        type: [Boolean, String],
        default: undefined
    },
    navigatable: {
        type: Boolean,
        default: undefined
    },
    noRecords: {
        type: [Boolean, Object],
        default: undefined
    },
    pageable: {
        type: [Boolean, Object],
        default: undefined
    },
    pdf: {
        type: Object,
        default: undefined
    },
    persistSelection: {
        type: Boolean,
        default: undefined
    },
    reorderable: {
        type: Boolean,
        default: undefined
    },
    resizable: {
        type: Boolean,
        default: undefined
    },
    rowTemplate: {
        type: [String, Function],
        default: undefined
    },
    scrollable: {
        type: [Boolean, Object],
        default: undefined
    },
    selectable: {
        type: [Boolean, String],
        default: undefined
    },
    sortable: {
        type: [Boolean, Object],
        default: undefined
    },
    toolbar: {
        type: [String, Function, Array],
        default: undefined
    },

    // Events
    beforeEdit: {
        type: Function,
        default: undefined
    },
    cancel: {
        type: Function,
        default: undefined
    },
    cellClose: {
        type: Function,
        default: undefined
    },
    change: {
        type: Function,
        default: undefined
    },
    columnHide: {
        type: Function,
        default: undefined
    },
    columnMenuInit: {
        type: Function,
        default: undefined
    },
    columnMenuOpen: {
        type: Function,
        default: undefined
    },
    columnReorder: {
        type: Function,
        default: undefined
    },
    columnResize: {
        type: Function,
        default: undefined
    },
    columnShow: {
        type: Function,
        default: undefined
    },
    dataBinding: {
        type: Function,
        default: undefined
    },
    dataBound: {
        type: Function,
        default: undefined
    },
    detailCollapse: {
        type: Function,
        default: undefined
    },
    detailExpand: {
        type: Function,
        default: undefined
    },
    detailInit: {
        type: Function,
        default: undefined
    },
    edit: {
        type: Function,
        default: undefined
    },
    excelExport: {
        type: Function,
        default: undefined
    },
    filter: {
        type: Function,
        default: undefined
    },
    group: {
        type: Function,
        default: undefined
    },
    groupCollapse: {
        type: Function,
        default: undefined
    },
    groupExpand: {
        type: Function,
        default: undefined
    },
    page: {
        type: Function,
        default: undefined
    },
    pdfExport: {
        type: Function,
        default: undefined
    },
    filterMenuInit: {
        type: Function,
        default: undefined
    },
    filterMenuOpen: {
        type: Function,
        default: undefined
    },
    remove: {
        type: Function,
        default: undefined
    },
    save: {
        type: Function,
        default: undefined
    },
    saveChanges: {
        type: Function,
        default: undefined
    },
    sort: {
        type: Function,
        default: undefined
    },
    columnLock: {
        type: Function,
        default: undefined
    },
    columnUnlock: {
        type: Function,
        default: undefined
    },
    navigate: {
        type: Function,
        default: undefined
    },
    rowReorder: {
        type: Function,
        default: undefined
    }
};

/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    props: {
        allowCopyDelimeter: {
            type: String | Object,
            default: undefined,
            kComposite: 'allowCopy.delimeter'
        }
    }
};

/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    props: {
        columnMenuColumns: {
            type: Boolean,
            default: undefined,
            kComposite: 'columnMenu.columns'
        },
        columnMenuFilterable: {
            type: Boolean,
            default: undefined,
            kComposite: 'columnMenu.filterable'
        },
        columnMenuSortable: {
            type: Boolean,
            default: undefined,
            kComposite: 'columnMenu.sortable'
        },
        columnMenuMessagesColumns: {
            type: String,
            default: undefined,
            kComposite: 'columnMenu.messages.columns'
        },
        columnMenuMessagesFilter: {
            type: String,
            default: undefined,
            kComposite: 'columnMenu.messages.filter'
        },
        columnMenuMessagesSortAscending: {
            type: String,
            default: undefined,
            kComposite: 'columnMenu.messages.sortAscending'
        },
        columnMenuMessagesSortDescending: {
            type: String,
            default: undefined,
            kComposite: 'columnMenu.messages.sortDescending'
        },
        columnMenuMessagesSettings: {
            type: String,
            default: undefined,
            kComposite: 'columnMenu.messages.settings'
        },
        columnMenuMessagesDone: {
            type: String,
            default: undefined,
            kComposite: 'columnMenu.messages.done'
        },
        columnMenuMessagesLock: {
            type: String,
            default: undefined,
            kComposite: 'columnMenu.messages.lock'
        },
        columnMenuMessagesUnlock: {
            type: String,
            default: undefined,
            kComposite: 'columnMenu.messages.unlock'
        }
    }
};

/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    props: {
        editableConfirmation: {
            type: [Boolean, String, Function],
            default: undefined,
            kComposite: 'editable.confirmation'
        },
        editableCancelDelete: {
            type: String,
            default: undefined,
            kComposite: 'editable.cancelDelete'
        },
        editableConfirmDelete: {
            type: String,
            default: undefined,
            kComposite: 'editable.confirmDelete'
        },
        editableCreateAt: {
            type: String,
            default: undefined,
            kComposite: 'editable.createAt'
        },
        editableDestroy: {
            type: Boolean,
            default: undefined,
            kComposite: 'editable.destroy'
        },
        editableMode: {
            type: String,
            default: undefined,
            kComposite: 'editable.mode'
        },
        editableTemplate: {
            type: [String, Function],
            default: undefined,
            kComposite: 'editable.template'
        },
        editableUpdate: {
            type: Boolean,
            default: undefined,
            kComposite: 'editable.update'
        },
        editableWindow: {
            type: Object,
            default: undefined,
            kComposite: 'editable.window'
        }
    }
};

/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    props: {
        excelAllPages: {
            type: Boolean,
            default: undefined,
            kComposite: 'excel.allPages'
        },
        excelFileName: {
            type: String,
            default: undefined,
            kComposite: 'excel.fileName'
        },
        excelFilterable: {
            type: Boolean,
            default: undefined,
            kComposite: 'excel.filterable'
        },
        excelForceProxy: {
            type: Boolean,
            default: undefined,
            kComposite: 'excel.forceProxy'
        },
        excelProxyURL: {
            type: String,
            default: undefined,
            kComposite: 'excel.proxyURL'
        }
    }
};

/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    props: {
        filterableExtra: {
            type: Boolean,
            default: undefined,
            kComposite: 'filterable.extra'
        },
        filterableMessagesAnd: {
            type: String,
            default: undefined,
            kComposite: 'filterable.messages.and'
        },
        filterableMessagesClear: {
            type: String,
            default: undefined,
            kComposite: 'filterable.messages.clear'
        },
        filterableMessagesFilter: {
            type: String,
            default: undefined,
            kComposite: 'filterable.messages.filter'
        },
        filterableMessagesInfo: {
            type: String,
            default: undefined,
            kComposite: 'filterable.messages.info'
        },
        filterableMessagesIsFalse: {
            type: String,
            default: undefined,
            kComposite: 'filterable.messages.isFalse'
        },
        filterableMessagesIsTrue: {
            type: String,
            default: undefined,
            kComposite: 'filterable.messages.isTrue'
        },
        filterableMessagesOr: {
            type: String,
            default: undefined,
            kComposite: 'filterable.messages.or'
        },
        filterableMessagesSearch: {
            type: String,
            default: undefined,
            kComposite: 'filterable.messages.search'
        },
        filterableMessagesSelectValue: {
            type: String,
            default: undefined,
            kComposite: 'filterable.messages.selectValue'
        },
        filterableMessagesCancel: {
            type: String,
            default: undefined,
            kComposite: 'filterable.messages.cancel'
        },
        filterableMessagesSelectedItemsFormat: {
            type: String,
            default: undefined,
            kComposite: 'filterable.messages.selectedItemsFormat'
        },
        filterableMessagesOperator: {
            type: String,
            default: undefined,
            kComposite: 'filterable.messages.operator'
        },
        filterableMessagesValue: {
            type: String,
            default: undefined,
            kComposite: 'filterable.messages.value'
        },
        filterableMessagesCheckAll: {
            type: String,
            default: undefined,
            kComposite: 'filterable.messages.checkAll'
        },
        filterableMode: {
            type: String,
            default: undefined,
            kComposite: 'filterable.mode'
        },
        filterableOperatorsStringEq: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.string.eq'
        },
        filterableOperatorsStringNeq: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.string.neq'
        },
        filterableOperatorsStringIsnull: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.string.isnull'
        },
        filterableOperatorsStringIsnotnull: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.string.isnotnull'
        },
        filterableOperatorsStringIsempty: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.string.isempty'
        },
        filterableOperatorsStringIsnotempty: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.string.isnotempty'
        },
        filterableOperatorsStringStartswith: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.string.startswith'
        },
        filterableOperatorsStringContains: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.string.contains'
        },
        filterableOperatorsStringDoesnotcontain: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.string.doesnotcontain'
        },
        filterableOperatorsStringEndswith: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.string.endswith'
        },
        filterableOperatorsNumberEq: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.number.eq'
        },
        filterableOperatorsNumberNeq: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.number.neq'
        },
        filterableOperatorsNumberIsnull: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.number.isnull'
        },
        filterableOperatorsNumberIsnotnull: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.number.isnotnull'
        },
        filterableOperatorsNumberGte: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.number.gte'
        },
        filterableOperatorsNumberGt: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.number.gt'
        },
        filterableOperatorsNumberLte: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.number.lte'
        },
        filterableOperatorsNumberLt: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.number.lt'
        },
        filterableOperatorsDateEq: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.date.eq'
        },
        filterableOperatorsDateNeq: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.date.neq'
        },
        filterableOperatorsDateIsnull: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.date.isnull'
        },
        filterableOperatorsDateIsnotnull: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.date.isnotnull'
        },
        filterableOperatorsDateGte: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.date.gte'
        },
        filterableOperatorsDateGt: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.date.gt'
        },
        filterableOperatorsDateLte: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.date.lte'
        },
        filterableOperatorsDateLt: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.date.lt'
        },
        filterableOperatorsEnumsEq: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.enums.eq'
        },
        filterableOperatorsEnumsNeq: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.enums.neq'
        },
        filterableOperatorsEnumsIsnull: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.enums.isnull'
        },
        filterableOperatorsEnumsIsnotnull: {
            type: String,
            default: undefined,
            kComposite: 'filterable.operators.enums.isnotnull'
        }
    }
};

/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    props: {
        groupableEnabled: {
            type: Boolean,
            default: undefined,
            kComposite: 'groupable.enabled'
        },
        groupableShowFooter: {
            type: Boolean,
            default: undefined,
            kComposite: 'groupable.showFooter'
        },
        groupableSortCompare: {
            type: Function,
            default: undefined,
            kComposite: 'groupable.sort.compare'
        },
        groupableSortDir: {
            type: String,
            default: undefined,
            kComposite: 'groupable.sort.dir'
        },
        groupableMessagesEmpty: {
            type: String,
            default: undefined,
            kComposite: 'groupable.messages.empty'
        }
    }
};

/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    props: {
        messagesCommandsCancel: {
            type: String,
            default: undefined,
            kComposite: 'messages.commands.cancel'
        },
        messagesCommandsCanceledit: {
            type: String,
            default: undefined,
            kComposite: 'messages.commands.canceledit'
        },
        messagesCommandsCreate: {
            type: String,
            default: undefined,
            kComposite: 'messages.commands.create'
        },
        messagesCommandsDestroy: {
            type: String,
            default: undefined,
            kComposite: 'messages.commands.destroy'
        },
        messagesCommandsEdit: {
            type: String,
            default: undefined,
            kComposite: 'messages.commands.edit'
        },
        messagesCommandsExcel: {
            type: String,
            default: undefined,
            kComposite: 'messages.commands.excel'
        },
        messagesCommandsSave: {
            type: String,
            default: undefined,
            kComposite: 'messages.commands.save'
        },
        messagesCommandsUpdate: {
            type: String,
            default: undefined,
            kComposite: 'messages.commands.update'
        },
        messagesNoRecords: {
            type: String,
            default: undefined,
            kComposite: 'messages.noRecords'
        },
        messagesExpandCollapseColumnHeader: {
            type: String,
            default: undefined,
            kComposite: 'messages.expandCollapseColumnHeader'
        }
    }
};

/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    props: {
        noRecordsTemplate: {
            type: [String, Function],
            default: undefined,
            kComposite: 'noRecords.template'
        }
    }
};

/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    props: {
        pageableAlwaysVisible: {
            type: Boolean,
            default: undefined,
            kComposite: 'pageable.alwaysVisible'
        },
        pageablePageSize: {
            type: Number,
            default: undefined,
            kComposite: 'pageable.pageSize'
        },
        pageablePreviousNext: {
            type: Boolean,
            default: undefined,
            kComposite: 'pageable.previousNext'
        },
        pageableNumeric: {
            type: Boolean,
            default: undefined,
            kComposite: 'pageable.numeric'
        },
        pageableButtonCount: {
            type: Number,
            default: undefined,
            kComposite: 'pageable.buttonCount'
        },
        pageableInput: {
            type: Boolean,
            default: undefined,
            kComposite: 'pageable.input'
        },
        pageablePageSizes: {
            type: [Boolean, Array],
            default: undefined,
            kComposite: 'pageable.pageSizes'
        },
        pageableRefresh: {
            type: Boolean,
            default: undefined,
            kComposite: 'pageable.refresh'
        },
        pageableResponsive: {
            type: Boolean,
            default: undefined,
            kComposite: 'pageable.responsive'
        },
        pageableInfo: {
            type: Boolean,
            default: undefined,
            kComposite: 'pageable.info'
        },
        pageableMessagesDisplay: {
            type: String,
            default: undefined,
            kComposite: 'pageable.messages.display'
        },
        pageableMessagesEmpty: {
            type: String,
            default: undefined,
            kComposite: 'pageable.messages.empty'
        },
        pageableMessagesPage: {
            type: String,
            default: undefined,
            kComposite: 'pageable.messages.page'
        },
        pageableMessagesOf: {
            type: String,
            default: undefined,
            kComposite: 'pageable.messages.of'
        },
        pageableMessagesItemsPerPage: {
            type: String,
            default: undefined,
            kComposite: 'pageable.messages.itemsPerPage'
        },
        pageableMessagesFirst: {
            type: String,
            default: undefined,
            kComposite: 'pageable.messages.first'
        },
        pageableMessagesLast: {
            type: String,
            default: undefined,
            kComposite: 'pageable.messages.last'
        },
        pageableMessagesNext: {
            type: String,
            default: undefined,
            kComposite: 'pageable.messages.next'
        },
        pageableMessagesPrevious: {
            type: String,
            default: undefined,
            kComposite: 'pageable.messages.previous'
        },
        pageableMessagesRefresh: {
            type: String,
            default: undefined,
            kComposite: 'pageable.messages.refresh'
        },
        pageableMessagesMorePages: {
            type: String,
            default: undefined,
            kComposite: 'pageable.messages.morePages'
        }
    }
};

/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    props: {
        pdfAllPages: {
            type: Boolean,
            default: undefined,
            kComposite: 'pdf.allPages'
        },
        pdfAuthor: {
            type: String,
            default: undefined,
            kComposite: 'pdf.author'
        },
        pdfAvoidLinks: {
            type: [Boolean, String],
            default: undefined,
            kComposite: 'pdf.avoidLinks'
        },
        pdfCreator: {
            type: String,
            default: undefined,
            kComposite: 'pdf.creator'
        },
        pdfDate: {
            type: Date,
            default: undefined,
            kComposite: 'pdf.date'
        },
        pdfFileName: {
            type: String,
            default: undefined,
            kComposite: 'pdf.fileName'
        },
        pdfForceProxy: {
            type: Boolean,
            default: undefined,
            kComposite: 'pdf.forceProxy'
        },
        pdfKeywords: {
            type: String,
            default: undefined,
            kComposite: 'pdf.keywords'
        },
        pdfLandscape: {
            type: Boolean,
            default: undefined,
            kComposite: 'pdf.landscape'
        },
        pdfMarginBottom: {
            type: [Number, String],
            default: undefined,
            kComposite: 'pdf.margin.bottom'
        },
        pdfMarginLeft: {
            type: [Number, String],
            default: undefined,
            kComposite: 'pdf.margin.left'
        },
        pdfMarginRight: {
            type: [Number, String],
            default: undefined,
            kComposite: 'pdf.margin.right'
        },
        pdfMarginTop: {
            type: [Number, String],
            default: undefined,
            kComposite: 'pdf.margin.top'
        },
        pdfPaperSize: {
            type: [String, Array],
            default: undefined,
            kComposite: 'pdf.paperSize'
        },
        pdfTemplate: {
            type: String,
            default: undefined,
            kComposite: 'pdf.template'
        },
        pdfRepeatHeaders: {
            type: Boolean,
            default: undefined,
            kComposite: 'pdf.repeatHeaders'
        },
        pdfScale: {
            type: Number,
            default: undefined,
            kComposite: 'pdf.scale'
        },
        pdfProxyURL: {
            type: String,
            default: undefined,
            kComposite: 'pdf.proxyURL'
        },
        pdfProxyTarget: {
            type: String,
            default: undefined,
            kComposite: 'pdf.proxyTarget'
        },
        pdfSubject: {
            type: String,
            default: undefined,
            kComposite: 'pdf.subject'
        },
        pdfTitle: {
            type: String,
            default: undefined,
            kComposite: 'pdf.title'
        }
    }
};

/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    props: {
        scrollableVirtual: {
            type: Boolean,
            default: undefined,
            kComposite: 'scrollable.virtual'
        },
        scrollableEndless: {
            type: Boolean,
            default: undefined,
            kComposite: 'scrollable.endless'
        }
    }
};

/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = {
    props: {
        sortableAllowUnsort: {
            type: Boolean,
            default: undefined,
            kComposite: 'sortable.allowUnsort'
        },
        sortableShowIndexes: {
            type: Boolean,
            default: undefined,
            kComposite: 'sortable.showIndexes'
        },
        sortableInitialDirection: {
            type: String,
            default: undefined,
            kComposite: 'sortable.initialDirection'
        },
        sortableMode: {
            type: String,
            default: undefined,
            kComposite: 'sortable.mode'
        }
    }
};

/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _KendoGrid = __webpack_require__(2);

var _KendoGrid2 = _interopRequireDefault(_KendoGrid);

var _KendoGridColumn = __webpack_require__(1);

var _KendoGridColumn2 = _interopRequireDefault(_KendoGridColumn);

var _KendoGridToolbar = __webpack_require__(3);

var _KendoGridToolbar2 = _interopRequireDefault(_KendoGridToolbar);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var KendoGridInstaller = function () {
    function KendoGridInstaller() {
        _classCallCheck(this, KendoGridInstaller);
    }

    _createClass(KendoGridInstaller, null, [{
        key: 'install',
        value: function install(Vue) {
            Vue.component(_KendoGrid2.default.name, _KendoGrid2.default);
            Vue.component(_KendoGridColumn2.default.name, _KendoGridColumn2.default);
            Vue.component(_KendoGridToolbar2.default.name, _KendoGridToolbar2.default);
        }
    }]);

    return KendoGridInstaller;
}();

exports.default = KendoGridInstaller;

// Automatic installation if Vue has been added to the global scope.

if (typeof window !== 'undefined' && window.Vue && window.Vue.use) {
    window.Vue.use(KendoGridInstaller);
}

/***/ })
/******/ ]);
});
//# sourceMappingURL=kendo-grid-vue-wrapper.js.map