import { Injectable, Component, ViewEncapsulation, NgZone, ViewChild, Input, NgModule } from '@angular/core';
import Handsontable from 'handsontable/base';

/**
 * @fileoverview added by tsickle
 * Generated from: lib/hot-table-registerer.service.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
var instances = new Map();
/** @type {?} */
var HOT_DESTROYED_WARNING = 'The Handsontable instance bound to this component was destroyed and cannot be' +
    ' used properly.';
var HotTableRegisterer = /** @class */ (function () {
    function HotTableRegisterer() {
    }
    /**
     * @param {?} id
     * @return {?}
     */
    HotTableRegisterer.prototype.getInstance = /**
     * @param {?} id
     * @return {?}
     */
    function (id) {
        /** @type {?} */
        var hotInstance = instances.get(id);
        if (hotInstance.isDestroyed) {
            console.warn(HOT_DESTROYED_WARNING);
            return null;
        }
        return hotInstance;
    };
    /**
     * @param {?} id
     * @param {?} instance
     * @return {?}
     */
    HotTableRegisterer.prototype.registerInstance = /**
     * @param {?} id
     * @param {?} instance
     * @return {?}
     */
    function (id, instance) {
        return instances.set(id, instance);
    };
    /**
     * @param {?} id
     * @return {?}
     */
    HotTableRegisterer.prototype.removeInstance = /**
     * @param {?} id
     * @return {?}
     */
    function (id) {
        return instances.delete(id);
    };
    HotTableRegisterer.decorators = [
        { type: Injectable }
    ];
    return HotTableRegisterer;
}());

/**
 * @fileoverview added by tsickle
 * Generated from: lib/hot-settings-resolver.service.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
var AVAILABLE_OPTIONS = Object.keys(Handsontable.DefaultSettings);
/** @type {?} */
var AVAILABLE_HOOKS = Handsontable.hooks.getRegistered();
var HotSettingsResolver = /** @class */ (function () {
    function HotSettingsResolver() {
    }
    /**
     * @param {?} component
     * @return {?}
     */
    HotSettingsResolver.prototype.mergeSettings = /**
     * @param {?} component
     * @return {?}
     */
    function (component) {
        /** @type {?} */
        var isSettingsObject = typeof component['settings'] === 'object';
        /** @type {?} */
        var mergedSettings = isSettingsObject ? component['settings'] : {};
        /** @type {?} */
        var options = AVAILABLE_HOOKS.concat(AVAILABLE_OPTIONS);
        options.forEach((/**
         * @param {?} key
         * @return {?}
         */
        function (key) {
            /** @type {?} */
            var isHook = AVAILABLE_HOOKS.indexOf(key) > -1;
            /** @type {?} */
            var option;
            if (isSettingsObject && isHook) {
                option = component['settings'][key];
            }
            if (component[key] !== void 0) {
                option = component[key];
            }
            if (option === void 0) {
                return;
            }
            else if (typeof option === 'function' && isHook) {
                mergedSettings[key] = (/**
                 * @param {...?} args
                 * @return {?}
                 */
                function () {
                    var _this = this;
                    var args = [];
                    for (var _i = 0; _i < arguments.length; _i++) {
                        args[_i] = arguments[_i];
                    }
                    return component._ngZone.run((/**
                     * @return {?}
                     */
                    function () {
                        return option.apply(_this, args);
                    }));
                });
            }
            else {
                mergedSettings[key] = option;
            }
        }));
        return mergedSettings;
    };
    /**
     * @param {?} changes
     * @return {?}
     */
    HotSettingsResolver.prototype.prepareChanges = /**
     * @param {?} changes
     * @return {?}
     */
    function (changes) {
        /** @type {?} */
        var result = {};
        /** @type {?} */
        var parameters = Object.keys(changes);
        parameters.forEach((/**
         * @param {?} param
         * @return {?}
         */
        function (param) {
            if (changes.hasOwnProperty(param)) {
                result[param] = changes[param].currentValue;
            }
        }));
        return result;
    };
    HotSettingsResolver.decorators = [
        { type: Injectable }
    ];
    return HotSettingsResolver;
}());

/**
 * @fileoverview added by tsickle
 * Generated from: lib/hot-table.component.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var HotTableComponent = /** @class */ (function () {
    function HotTableComponent(_ngZone, _hotTableRegisterer, _hotSettingsResolver) {
        this._ngZone = _ngZone;
        this._hotTableRegisterer = _hotTableRegisterer;
        this._hotSettingsResolver = _hotSettingsResolver;
        this.__hotInstance = null;
        this.columnsComponents = [];
        this.hotId = '';
    }
    Object.defineProperty(HotTableComponent.prototype, "hotInstance", {
        get: /**
         * @private
         * @return {?}
         */
        function () {
            if (!this.__hotInstance || (this.__hotInstance && !this.__hotInstance.isDestroyed)) {
                // Will return the Handsontable instance or `null` if it's not yet been created.
                return this.__hotInstance;
            }
            else {
                this._hotTableRegisterer.removeInstance(this.hotId);
                console.warn(HOT_DESTROYED_WARNING);
                return null;
            }
        },
        set: /**
         * @private
         * @param {?} hotInstance
         * @return {?}
         */
        function (hotInstance) {
            this.__hotInstance = hotInstance;
        },
        enumerable: true,
        configurable: true
    });
    /**
     * @return {?}
     */
    HotTableComponent.prototype.ngAfterViewInit = /**
     * @return {?}
     */
    function () {
        var _this = this;
        /** @type {?} */
        var options = this._hotSettingsResolver.mergeSettings(this);
        if (this.columnsComponents.length > 0) {
            /** @type {?} */
            var columns_1 = [];
            this.columnsComponents.forEach((/**
             * @param {?} column
             * @return {?}
             */
            function (column) {
                columns_1.push(_this._hotSettingsResolver.mergeSettings(column));
            }));
            options['columns'] = columns_1;
        }
        this._ngZone.runOutsideAngular((/**
         * @return {?}
         */
        function () {
            _this.hotInstance = new Handsontable.Core(_this.container.nativeElement, options);
            if (_this.hotId) {
                _this._hotTableRegisterer.registerInstance(_this.hotId, _this.hotInstance);
            }
            // @ts-ignore
            _this.hotInstance.init();
        }));
    };
    /**
     * @param {?} changes
     * @return {?}
     */
    HotTableComponent.prototype.ngOnChanges = /**
     * @param {?} changes
     * @return {?}
     */
    function (changes) {
        if (this.hotInstance === null) {
            return;
        }
        /** @type {?} */
        var newOptions = this._hotSettingsResolver.prepareChanges(changes);
        this.updateHotTable(newOptions);
    };
    /**
     * @return {?}
     */
    HotTableComponent.prototype.ngOnDestroy = /**
     * @return {?}
     */
    function () {
        var _this = this;
        this._ngZone.runOutsideAngular((/**
         * @return {?}
         */
        function () {
            if (_this.hotInstance) {
                _this.hotInstance.destroy();
            }
        }));
        if (this.hotId) {
            this._hotTableRegisterer.removeInstance(this.hotId);
        }
    };
    /**
     * @param {?} newSettings
     * @return {?}
     */
    HotTableComponent.prototype.updateHotTable = /**
     * @param {?} newSettings
     * @return {?}
     */
    function (newSettings) {
        var _this = this;
        if (!this.hotInstance) {
            return;
        }
        this._ngZone.runOutsideAngular((/**
         * @return {?}
         */
        function () {
            _this.hotInstance.updateSettings(newSettings, false);
        }));
    };
    /**
     * @return {?}
     */
    HotTableComponent.prototype.onAfterColumnsChange = /**
     * @return {?}
     */
    function () {
        var _this = this;
        if (this.columnsComponents === void 0) {
            return;
        }
        if (this.columnsComponents.length > 0) {
            /** @type {?} */
            var columns_2 = [];
            this.columnsComponents.forEach((/**
             * @param {?} column
             * @return {?}
             */
            function (column) {
                columns_2.push(_this._hotSettingsResolver.mergeSettings(column));
            }));
            /** @type {?} */
            var newOptions = {
                columns: columns_2
            };
            this.updateHotTable(newOptions);
        }
    };
    /**
     * @return {?}
     */
    HotTableComponent.prototype.onAfterColumnsNumberChange = /**
     * @return {?}
     */
    function () {
        var _this = this;
        /** @type {?} */
        var columns = [];
        if (this.columnsComponents.length > 0) {
            this.columnsComponents.forEach((/**
             * @param {?} column
             * @return {?}
             */
            function (column) {
                columns.push(_this._hotSettingsResolver.mergeSettings(column));
            }));
        }
        this.updateHotTable({ columns: columns });
    };
    /**
     * @param {?} column
     * @return {?}
     */
    HotTableComponent.prototype.addColumn = /**
     * @param {?} column
     * @return {?}
     */
    function (column) {
        this.columnsComponents.push(column);
        this.onAfterColumnsNumberChange();
    };
    /**
     * @param {?} column
     * @return {?}
     */
    HotTableComponent.prototype.removeColumn = /**
     * @param {?} column
     * @return {?}
     */
    function (column) {
        /** @type {?} */
        var index = this.columnsComponents.indexOf(column);
        this.columnsComponents.splice(index, 1);
        this.onAfterColumnsNumberChange();
    };
    HotTableComponent.decorators = [
        { type: Component, args: [{
                    selector: 'hot-table',
                    template: '<div #container [id]="hotId"></div>',
                    encapsulation: ViewEncapsulation.None,
                    providers: [HotTableRegisterer, HotSettingsResolver]
                }] }
    ];
    /** @nocollapse */
    HotTableComponent.ctorParameters = function () { return [
        { type: NgZone },
        { type: HotTableRegisterer },
        { type: HotSettingsResolver }
    ]; };
    HotTableComponent.propDecorators = {
        container: [{ type: ViewChild, args: ['container', { static: false },] }],
        settings: [{ type: Input }],
        hotId: [{ type: Input }],
        activeHeaderClassName: [{ type: Input }],
        allowEmpty: [{ type: Input }],
        allowHtml: [{ type: Input }],
        allowInsertColumn: [{ type: Input }],
        allowInsertRow: [{ type: Input }],
        allowInvalid: [{ type: Input }],
        allowRemoveColumn: [{ type: Input }],
        allowRemoveRow: [{ type: Input }],
        autoColumnSize: [{ type: Input }],
        autoRowSize: [{ type: Input }],
        autoWrapCol: [{ type: Input }],
        autoWrapRow: [{ type: Input }],
        bindRowsWithHeaders: [{ type: Input }],
        cell: [{ type: Input }],
        cells: [{ type: Input }],
        checkedTemplate: [{ type: Input }],
        className: [{ type: Input }],
        colHeaders: [{ type: Input }],
        collapsibleColumns: [{ type: Input }],
        columnHeaderHeight: [{ type: Input }],
        columns: [{ type: Input }],
        columnSorting: [{ type: Input }],
        columnSummary: [{ type: Input }],
        colWidths: [{ type: Input }],
        commentedCellClassName: [{ type: Input }],
        comments: [{ type: Input }],
        contextMenu: [{ type: Input }],
        copyable: [{ type: Input }],
        copyPaste: [{ type: Input }],
        correctFormat: [{ type: Input }],
        currentColClassName: [{ type: Input }],
        currentHeaderClassName: [{ type: Input }],
        currentRowClassName: [{ type: Input }],
        customBorders: [{ type: Input }],
        data: [{ type: Input }],
        dataSchema: [{ type: Input }],
        dateFormat: [{ type: Input }],
        defaultDate: [{ type: Input }],
        disableVisualSelection: [{ type: Input }],
        dragToScroll: [{ type: Input }],
        dropdownMenu: [{ type: Input }],
        editor: [{ type: Input }],
        enterBeginsEditing: [{ type: Input }],
        enterMoves: [{ type: Input }],
        fillHandle: [{ type: Input }],
        filter: [{ type: Input }],
        filteringCaseSensitive: [{ type: Input }],
        filters: [{ type: Input }],
        fixedColumnsLeft: [{ type: Input }],
        fixedColumnsStart: [{ type: Input }],
        fixedRowsBottom: [{ type: Input }],
        fixedRowsTop: [{ type: Input }],
        formulas: [{ type: Input }],
        fragmentSelection: [{ type: Input }],
        height: [{ type: Input }],
        hiddenColumns: [{ type: Input }],
        hiddenRows: [{ type: Input }],
        invalidCellClassName: [{ type: Input }],
        label: [{ type: Input }],
        language: [{ type: Input }],
        layoutDirection: [{ type: Input }],
        licenseKey: [{ type: Input }],
        manualColumnFreeze: [{ type: Input }],
        manualColumnMove: [{ type: Input }],
        manualColumnResize: [{ type: Input }],
        manualRowMove: [{ type: Input }],
        manualRowResize: [{ type: Input }],
        maxCols: [{ type: Input }],
        maxRows: [{ type: Input }],
        mergeCells: [{ type: Input }],
        minCols: [{ type: Input }],
        minRows: [{ type: Input }],
        minSpareCols: [{ type: Input }],
        minSpareRows: [{ type: Input }],
        multiColumnSorting: [{ type: Input }],
        nestedHeaders: [{ type: Input }],
        nestedRows: [{ type: Input }],
        noWordWrapClassName: [{ type: Input }],
        numericFormat: [{ type: Input }],
        observeDOMVisibility: [{ type: Input }],
        outsideClickDeselects: [{ type: Input }],
        persistentState: [{ type: Input }],
        placeholder: [{ type: Input }],
        placeholderCellClassName: [{ type: Input }],
        preventOverflow: [{ type: Input }],
        preventWheel: [{ type: Input }],
        readOnly: [{ type: Input }],
        readOnlyCellClassName: [{ type: Input }],
        renderAllRows: [{ type: Input }],
        renderer: [{ type: Input }],
        rowHeaders: [{ type: Input }],
        rowHeaderWidth: [{ type: Input }],
        rowHeights: [{ type: Input }],
        search: [{ type: Input }],
        selectionMode: [{ type: Input }],
        selectOptions: [{ type: Input }],
        skipColumnOnPaste: [{ type: Input }],
        skipRowOnPaste: [{ type: Input }],
        sortByRelevance: [{ type: Input }],
        source: [{ type: Input }],
        startCols: [{ type: Input }],
        startRows: [{ type: Input }],
        stretchH: [{ type: Input }],
        strict: [{ type: Input }],
        tableClassName: [{ type: Input }],
        tabMoves: [{ type: Input }],
        title: [{ type: Input }],
        trimDropdown: [{ type: Input }],
        trimRows: [{ type: Input }],
        trimWhitespace: [{ type: Input }],
        type: [{ type: Input }],
        uncheckedTemplate: [{ type: Input }],
        undo: [{ type: Input }],
        validator: [{ type: Input }],
        viewportColumnRenderingOffset: [{ type: Input }],
        viewportRowRenderingOffset: [{ type: Input }],
        visibleRows: [{ type: Input }],
        width: [{ type: Input }],
        wordWrap: [{ type: Input }],
        afterAddChild: [{ type: Input }],
        afterAutofill: [{ type: Input }],
        afterBeginEditing: [{ type: Input }],
        afterCellMetaReset: [{ type: Input }],
        afterChange: [{ type: Input }],
        afterChangesObserved: [{ type: Input }],
        afterColumnCollapse: [{ type: Input }],
        afterColumnExpand: [{ type: Input }],
        afterColumnMove: [{ type: Input }],
        afterColumnResize: [{ type: Input }],
        afterColumnSort: [{ type: Input }],
        afterContextMenuDefaultOptions: [{ type: Input }],
        afterContextMenuHide: [{ type: Input }],
        afterContextMenuShow: [{ type: Input }],
        afterCopy: [{ type: Input }],
        afterCopyLimit: [{ type: Input }],
        afterCreateCol: [{ type: Input }],
        afterCreateRow: [{ type: Input }],
        afterCut: [{ type: Input }],
        afterDeselect: [{ type: Input }],
        afterDestroy: [{ type: Input }],
        afterDetachChild: [{ type: Input }],
        afterDocumentKeyDown: [{ type: Input }],
        afterDrawSelection: [{ type: Input }],
        afterDropdownMenuDefaultOptions: [{ type: Input }],
        afterDropdownMenuHide: [{ type: Input }],
        afterDropdownMenuShow: [{ type: Input }],
        afterFilter: [{ type: Input }],
        afterGetCellMeta: [{ type: Input }],
        afterGetColHeader: [{ type: Input }],
        afterGetColumnHeaderRenderers: [{ type: Input }],
        afterGetRowHeader: [{ type: Input }],
        afterGetRowHeaderRenderers: [{ type: Input }],
        afterHideColumns: [{ type: Input }],
        afterHideRows: [{ type: Input }],
        afterInit: [{ type: Input }],
        afterLanguageChange: [{ type: Input }],
        afterListen: [{ type: Input }],
        afterLoadData: [{ type: Input }],
        afterMergeCells: [{ type: Input }],
        afterModifyTransformEnd: [{ type: Input }],
        afterModifyTransformStart: [{ type: Input }],
        afterMomentumScroll: [{ type: Input }],
        afterOnCellContextMenu: [{ type: Input }],
        afterOnCellCornerDblClick: [{ type: Input }],
        afterOnCellCornerMouseDown: [{ type: Input }],
        afterOnCellMouseDown: [{ type: Input }],
        afterOnCellMouseOut: [{ type: Input }],
        afterOnCellMouseOver: [{ type: Input }],
        afterOnCellMouseUp: [{ type: Input }],
        afterPaste: [{ type: Input }],
        afterPluginsInitialized: [{ type: Input }],
        afterRedo: [{ type: Input }],
        afterRedoStackChange: [{ type: Input }],
        afterRefreshDimensions: [{ type: Input }],
        afterRemoveCellMeta: [{ type: Input }],
        afterRemoveCol: [{ type: Input }],
        afterRemoveRow: [{ type: Input }],
        afterRender: [{ type: Input }],
        afterRenderer: [{ type: Input }],
        afterRowMove: [{ type: Input }],
        afterRowResize: [{ type: Input }],
        afterScrollHorizontally: [{ type: Input }],
        afterScrollVertically: [{ type: Input }],
        afterSelection: [{ type: Input }],
        afterSelectionByProp: [{ type: Input }],
        afterSelectionEnd: [{ type: Input }],
        afterSelectionEndByProp: [{ type: Input }],
        afterSetCellMeta: [{ type: Input }],
        afterSetDataAtCell: [{ type: Input }],
        afterSetDataAtRowProp: [{ type: Input }],
        afterSetSourceDataAtCell: [{ type: Input }],
        afterTrimRow: [{ type: Input }],
        afterUndo: [{ type: Input }],
        afterUndoStackChange: [{ type: Input }],
        afterUnhideColumns: [{ type: Input }],
        afterUnhideRows: [{ type: Input }],
        afterUnlisten: [{ type: Input }],
        afterUnmergeCells: [{ type: Input }],
        afterUntrimRow: [{ type: Input }],
        afterUpdateSettings: [{ type: Input }],
        afterValidate: [{ type: Input }],
        afterViewportColumnCalculatorOverride: [{ type: Input }],
        afterViewportRowCalculatorOverride: [{ type: Input }],
        afterViewRender: [{ type: Input }],
        beforeAddChild: [{ type: Input }],
        beforeAutofill: [{ type: Input }],
        beforeAutofillInsidePopulate: [{ type: Input }],
        beforeCellAlignment: [{ type: Input }],
        beforeChange: [{ type: Input }],
        beforeChangeRender: [{ type: Input }],
        beforeColumnCollapse: [{ type: Input }],
        beforeColumnExpand: [{ type: Input }],
        beforeColumnMove: [{ type: Input }],
        beforeColumnResize: [{ type: Input }],
        beforeColumnSort: [{ type: Input }],
        beforeContextMenuSetItems: [{ type: Input }],
        beforeContextMenuShow: [{ type: Input }],
        beforeCopy: [{ type: Input }],
        beforeCreateCol: [{ type: Input }],
        beforeCreateRow: [{ type: Input }],
        beforeCut: [{ type: Input }],
        beforeDetachChild: [{ type: Input }],
        beforeDrawBorders: [{ type: Input }],
        beforeDropdownMenuSetItems: [{ type: Input }],
        beforeDropdownMenuShow: [{ type: Input }],
        beforeFilter: [{ type: Input }],
        beforeGetCellMeta: [{ type: Input }],
        beforeHideColumns: [{ type: Input }],
        beforeHideRows: [{ type: Input }],
        beforeInit: [{ type: Input }],
        beforeInitWalkontable: [{ type: Input }],
        beforeKeyDown: [{ type: Input }],
        beforeLanguageChange: [{ type: Input }],
        beforeLoadData: [{ type: Input }],
        beforeMergeCells: [{ type: Input }],
        beforeOnCellContextMenu: [{ type: Input }],
        beforeOnCellMouseDown: [{ type: Input }],
        beforeOnCellMouseOut: [{ type: Input }],
        beforeOnCellMouseOver: [{ type: Input }],
        beforeOnCellMouseUp: [{ type: Input }],
        beforePaste: [{ type: Input }],
        beforeRedo: [{ type: Input }],
        beforeRedoStackChange: [{ type: Input }],
        beforeRefreshDimensions: [{ type: Input }],
        beforeRemoveCellClassNames: [{ type: Input }],
        beforeRemoveCellMeta: [{ type: Input }],
        beforeRemoveCol: [{ type: Input }],
        beforeRemoveRow: [{ type: Input }],
        beforeRender: [{ type: Input }],
        beforeRenderer: [{ type: Input }],
        beforeRowMove: [{ type: Input }],
        beforeRowResize: [{ type: Input }],
        beforeSetCellMeta: [{ type: Input }],
        beforeSetRangeEnd: [{ type: Input }],
        beforeSetRangeStart: [{ type: Input }],
        beforeSetRangeStartOnly: [{ type: Input }],
        beforeStretchingColumnWidth: [{ type: Input }],
        beforeTouchScroll: [{ type: Input }],
        beforeTrimRow: [{ type: Input }],
        beforeUndo: [{ type: Input }],
        beforeUndoStackChange: [{ type: Input }],
        beforeUnhideColumns: [{ type: Input }],
        beforeUnhideRows: [{ type: Input }],
        beforeUnmergeCells: [{ type: Input }],
        beforeUntrimRow: [{ type: Input }],
        beforeValidate: [{ type: Input }],
        beforeValueRender: [{ type: Input }],
        beforeViewRender: [{ type: Input }],
        construct: [{ type: Input }],
        init: [{ type: Input }],
        modifyAutoColumnSizeSeed: [{ type: Input }],
        modifyAutofillRange: [{ type: Input }],
        modifyColHeader: [{ type: Input }],
        modifyColumnHeaderHeight: [{ type: Input }],
        modifyColWidth: [{ type: Input }],
        modifyCopyableRange: [{ type: Input }],
        modifyData: [{ type: Input }],
        modifyGetCellCoords: [{ type: Input }],
        modifyRowData: [{ type: Input }],
        modifyRowHeader: [{ type: Input }],
        modifyRowHeaderWidth: [{ type: Input }],
        modifyRowHeight: [{ type: Input }],
        modifySourceData: [{ type: Input }],
        modifyTransformEnd: [{ type: Input }],
        modifyTransformStart: [{ type: Input }],
        persistentStateLoad: [{ type: Input }],
        persistentStateReset: [{ type: Input }],
        persistentStateSave: [{ type: Input }]
    };
    return HotTableComponent;
}());
if (false) {
    /** @type {?} */
    HotTableComponent.prototype.container;
    /**
     * @type {?}
     * @private
     */
    HotTableComponent.prototype.__hotInstance;
    /**
     * @type {?}
     * @private
     */
    HotTableComponent.prototype.columnsComponents;
    /** @type {?} */
    HotTableComponent.prototype.settings;
    /** @type {?} */
    HotTableComponent.prototype.hotId;
    /** @type {?} */
    HotTableComponent.prototype.activeHeaderClassName;
    /** @type {?} */
    HotTableComponent.prototype.allowEmpty;
    /** @type {?} */
    HotTableComponent.prototype.allowHtml;
    /** @type {?} */
    HotTableComponent.prototype.allowInsertColumn;
    /** @type {?} */
    HotTableComponent.prototype.allowInsertRow;
    /** @type {?} */
    HotTableComponent.prototype.allowInvalid;
    /** @type {?} */
    HotTableComponent.prototype.allowRemoveColumn;
    /** @type {?} */
    HotTableComponent.prototype.allowRemoveRow;
    /** @type {?} */
    HotTableComponent.prototype.autoColumnSize;
    /** @type {?} */
    HotTableComponent.prototype.autoRowSize;
    /** @type {?} */
    HotTableComponent.prototype.autoWrapCol;
    /** @type {?} */
    HotTableComponent.prototype.autoWrapRow;
    /** @type {?} */
    HotTableComponent.prototype.bindRowsWithHeaders;
    /** @type {?} */
    HotTableComponent.prototype.cell;
    /** @type {?} */
    HotTableComponent.prototype.cells;
    /** @type {?} */
    HotTableComponent.prototype.checkedTemplate;
    /** @type {?} */
    HotTableComponent.prototype.className;
    /** @type {?} */
    HotTableComponent.prototype.colHeaders;
    /** @type {?} */
    HotTableComponent.prototype.collapsibleColumns;
    /** @type {?} */
    HotTableComponent.prototype.columnHeaderHeight;
    /** @type {?} */
    HotTableComponent.prototype.columns;
    /** @type {?} */
    HotTableComponent.prototype.columnSorting;
    /** @type {?} */
    HotTableComponent.prototype.columnSummary;
    /** @type {?} */
    HotTableComponent.prototype.colWidths;
    /** @type {?} */
    HotTableComponent.prototype.commentedCellClassName;
    /** @type {?} */
    HotTableComponent.prototype.comments;
    /** @type {?} */
    HotTableComponent.prototype.contextMenu;
    /** @type {?} */
    HotTableComponent.prototype.copyable;
    /** @type {?} */
    HotTableComponent.prototype.copyPaste;
    /** @type {?} */
    HotTableComponent.prototype.correctFormat;
    /** @type {?} */
    HotTableComponent.prototype.currentColClassName;
    /** @type {?} */
    HotTableComponent.prototype.currentHeaderClassName;
    /** @type {?} */
    HotTableComponent.prototype.currentRowClassName;
    /** @type {?} */
    HotTableComponent.prototype.customBorders;
    /** @type {?} */
    HotTableComponent.prototype.data;
    /** @type {?} */
    HotTableComponent.prototype.dataSchema;
    /** @type {?} */
    HotTableComponent.prototype.dateFormat;
    /** @type {?} */
    HotTableComponent.prototype.defaultDate;
    /** @type {?} */
    HotTableComponent.prototype.disableVisualSelection;
    /** @type {?} */
    HotTableComponent.prototype.dragToScroll;
    /** @type {?} */
    HotTableComponent.prototype.dropdownMenu;
    /** @type {?} */
    HotTableComponent.prototype.editor;
    /** @type {?} */
    HotTableComponent.prototype.enterBeginsEditing;
    /** @type {?} */
    HotTableComponent.prototype.enterMoves;
    /** @type {?} */
    HotTableComponent.prototype.fillHandle;
    /** @type {?} */
    HotTableComponent.prototype.filter;
    /** @type {?} */
    HotTableComponent.prototype.filteringCaseSensitive;
    /** @type {?} */
    HotTableComponent.prototype.filters;
    /** @type {?} */
    HotTableComponent.prototype.fixedColumnsLeft;
    /** @type {?} */
    HotTableComponent.prototype.fixedColumnsStart;
    /** @type {?} */
    HotTableComponent.prototype.fixedRowsBottom;
    /** @type {?} */
    HotTableComponent.prototype.fixedRowsTop;
    /** @type {?} */
    HotTableComponent.prototype.formulas;
    /** @type {?} */
    HotTableComponent.prototype.fragmentSelection;
    /** @type {?} */
    HotTableComponent.prototype.height;
    /** @type {?} */
    HotTableComponent.prototype.hiddenColumns;
    /** @type {?} */
    HotTableComponent.prototype.hiddenRows;
    /** @type {?} */
    HotTableComponent.prototype.invalidCellClassName;
    /** @type {?} */
    HotTableComponent.prototype.label;
    /** @type {?} */
    HotTableComponent.prototype.language;
    /** @type {?} */
    HotTableComponent.prototype.layoutDirection;
    /** @type {?} */
    HotTableComponent.prototype.licenseKey;
    /** @type {?} */
    HotTableComponent.prototype.manualColumnFreeze;
    /** @type {?} */
    HotTableComponent.prototype.manualColumnMove;
    /** @type {?} */
    HotTableComponent.prototype.manualColumnResize;
    /** @type {?} */
    HotTableComponent.prototype.manualRowMove;
    /** @type {?} */
    HotTableComponent.prototype.manualRowResize;
    /** @type {?} */
    HotTableComponent.prototype.maxCols;
    /** @type {?} */
    HotTableComponent.prototype.maxRows;
    /** @type {?} */
    HotTableComponent.prototype.mergeCells;
    /** @type {?} */
    HotTableComponent.prototype.minCols;
    /** @type {?} */
    HotTableComponent.prototype.minRows;
    /** @type {?} */
    HotTableComponent.prototype.minSpareCols;
    /** @type {?} */
    HotTableComponent.prototype.minSpareRows;
    /** @type {?} */
    HotTableComponent.prototype.multiColumnSorting;
    /** @type {?} */
    HotTableComponent.prototype.nestedHeaders;
    /** @type {?} */
    HotTableComponent.prototype.nestedRows;
    /** @type {?} */
    HotTableComponent.prototype.noWordWrapClassName;
    /** @type {?} */
    HotTableComponent.prototype.numericFormat;
    /** @type {?} */
    HotTableComponent.prototype.observeDOMVisibility;
    /** @type {?} */
    HotTableComponent.prototype.outsideClickDeselects;
    /** @type {?} */
    HotTableComponent.prototype.persistentState;
    /** @type {?} */
    HotTableComponent.prototype.placeholder;
    /** @type {?} */
    HotTableComponent.prototype.placeholderCellClassName;
    /** @type {?} */
    HotTableComponent.prototype.preventOverflow;
    /** @type {?} */
    HotTableComponent.prototype.preventWheel;
    /** @type {?} */
    HotTableComponent.prototype.readOnly;
    /** @type {?} */
    HotTableComponent.prototype.readOnlyCellClassName;
    /** @type {?} */
    HotTableComponent.prototype.renderAllRows;
    /** @type {?} */
    HotTableComponent.prototype.renderer;
    /** @type {?} */
    HotTableComponent.prototype.rowHeaders;
    /** @type {?} */
    HotTableComponent.prototype.rowHeaderWidth;
    /** @type {?} */
    HotTableComponent.prototype.rowHeights;
    /** @type {?} */
    HotTableComponent.prototype.search;
    /** @type {?} */
    HotTableComponent.prototype.selectionMode;
    /** @type {?} */
    HotTableComponent.prototype.selectOptions;
    /** @type {?} */
    HotTableComponent.prototype.skipColumnOnPaste;
    /** @type {?} */
    HotTableComponent.prototype.skipRowOnPaste;
    /** @type {?} */
    HotTableComponent.prototype.sortByRelevance;
    /** @type {?} */
    HotTableComponent.prototype.source;
    /** @type {?} */
    HotTableComponent.prototype.startCols;
    /** @type {?} */
    HotTableComponent.prototype.startRows;
    /** @type {?} */
    HotTableComponent.prototype.stretchH;
    /** @type {?} */
    HotTableComponent.prototype.strict;
    /** @type {?} */
    HotTableComponent.prototype.tableClassName;
    /** @type {?} */
    HotTableComponent.prototype.tabMoves;
    /** @type {?} */
    HotTableComponent.prototype.title;
    /** @type {?} */
    HotTableComponent.prototype.trimDropdown;
    /** @type {?} */
    HotTableComponent.prototype.trimRows;
    /** @type {?} */
    HotTableComponent.prototype.trimWhitespace;
    /** @type {?} */
    HotTableComponent.prototype.type;
    /** @type {?} */
    HotTableComponent.prototype.uncheckedTemplate;
    /** @type {?} */
    HotTableComponent.prototype.undo;
    /** @type {?} */
    HotTableComponent.prototype.validator;
    /** @type {?} */
    HotTableComponent.prototype.viewportColumnRenderingOffset;
    /** @type {?} */
    HotTableComponent.prototype.viewportRowRenderingOffset;
    /** @type {?} */
    HotTableComponent.prototype.visibleRows;
    /** @type {?} */
    HotTableComponent.prototype.width;
    /** @type {?} */
    HotTableComponent.prototype.wordWrap;
    /** @type {?} */
    HotTableComponent.prototype.afterAddChild;
    /** @type {?} */
    HotTableComponent.prototype.afterAutofill;
    /** @type {?} */
    HotTableComponent.prototype.afterBeginEditing;
    /** @type {?} */
    HotTableComponent.prototype.afterCellMetaReset;
    /** @type {?} */
    HotTableComponent.prototype.afterChange;
    /** @type {?} */
    HotTableComponent.prototype.afterChangesObserved;
    /** @type {?} */
    HotTableComponent.prototype.afterColumnCollapse;
    /** @type {?} */
    HotTableComponent.prototype.afterColumnExpand;
    /** @type {?} */
    HotTableComponent.prototype.afterColumnMove;
    /** @type {?} */
    HotTableComponent.prototype.afterColumnResize;
    /** @type {?} */
    HotTableComponent.prototype.afterColumnSort;
    /** @type {?} */
    HotTableComponent.prototype.afterContextMenuDefaultOptions;
    /** @type {?} */
    HotTableComponent.prototype.afterContextMenuHide;
    /** @type {?} */
    HotTableComponent.prototype.afterContextMenuShow;
    /** @type {?} */
    HotTableComponent.prototype.afterCopy;
    /** @type {?} */
    HotTableComponent.prototype.afterCopyLimit;
    /** @type {?} */
    HotTableComponent.prototype.afterCreateCol;
    /** @type {?} */
    HotTableComponent.prototype.afterCreateRow;
    /** @type {?} */
    HotTableComponent.prototype.afterCut;
    /** @type {?} */
    HotTableComponent.prototype.afterDeselect;
    /** @type {?} */
    HotTableComponent.prototype.afterDestroy;
    /** @type {?} */
    HotTableComponent.prototype.afterDetachChild;
    /** @type {?} */
    HotTableComponent.prototype.afterDocumentKeyDown;
    /** @type {?} */
    HotTableComponent.prototype.afterDrawSelection;
    /** @type {?} */
    HotTableComponent.prototype.afterDropdownMenuDefaultOptions;
    /** @type {?} */
    HotTableComponent.prototype.afterDropdownMenuHide;
    /** @type {?} */
    HotTableComponent.prototype.afterDropdownMenuShow;
    /** @type {?} */
    HotTableComponent.prototype.afterFilter;
    /** @type {?} */
    HotTableComponent.prototype.afterGetCellMeta;
    /** @type {?} */
    HotTableComponent.prototype.afterGetColHeader;
    /** @type {?} */
    HotTableComponent.prototype.afterGetColumnHeaderRenderers;
    /** @type {?} */
    HotTableComponent.prototype.afterGetRowHeader;
    /** @type {?} */
    HotTableComponent.prototype.afterGetRowHeaderRenderers;
    /** @type {?} */
    HotTableComponent.prototype.afterHideColumns;
    /** @type {?} */
    HotTableComponent.prototype.afterHideRows;
    /** @type {?} */
    HotTableComponent.prototype.afterInit;
    /** @type {?} */
    HotTableComponent.prototype.afterLanguageChange;
    /** @type {?} */
    HotTableComponent.prototype.afterListen;
    /** @type {?} */
    HotTableComponent.prototype.afterLoadData;
    /** @type {?} */
    HotTableComponent.prototype.afterMergeCells;
    /** @type {?} */
    HotTableComponent.prototype.afterModifyTransformEnd;
    /** @type {?} */
    HotTableComponent.prototype.afterModifyTransformStart;
    /** @type {?} */
    HotTableComponent.prototype.afterMomentumScroll;
    /** @type {?} */
    HotTableComponent.prototype.afterOnCellContextMenu;
    /** @type {?} */
    HotTableComponent.prototype.afterOnCellCornerDblClick;
    /** @type {?} */
    HotTableComponent.prototype.afterOnCellCornerMouseDown;
    /** @type {?} */
    HotTableComponent.prototype.afterOnCellMouseDown;
    /** @type {?} */
    HotTableComponent.prototype.afterOnCellMouseOut;
    /** @type {?} */
    HotTableComponent.prototype.afterOnCellMouseOver;
    /** @type {?} */
    HotTableComponent.prototype.afterOnCellMouseUp;
    /** @type {?} */
    HotTableComponent.prototype.afterPaste;
    /** @type {?} */
    HotTableComponent.prototype.afterPluginsInitialized;
    /** @type {?} */
    HotTableComponent.prototype.afterRedo;
    /** @type {?} */
    HotTableComponent.prototype.afterRedoStackChange;
    /** @type {?} */
    HotTableComponent.prototype.afterRefreshDimensions;
    /** @type {?} */
    HotTableComponent.prototype.afterRemoveCellMeta;
    /** @type {?} */
    HotTableComponent.prototype.afterRemoveCol;
    /** @type {?} */
    HotTableComponent.prototype.afterRemoveRow;
    /** @type {?} */
    HotTableComponent.prototype.afterRender;
    /** @type {?} */
    HotTableComponent.prototype.afterRenderer;
    /** @type {?} */
    HotTableComponent.prototype.afterRowMove;
    /** @type {?} */
    HotTableComponent.prototype.afterRowResize;
    /** @type {?} */
    HotTableComponent.prototype.afterScrollHorizontally;
    /** @type {?} */
    HotTableComponent.prototype.afterScrollVertically;
    /** @type {?} */
    HotTableComponent.prototype.afterSelection;
    /** @type {?} */
    HotTableComponent.prototype.afterSelectionByProp;
    /** @type {?} */
    HotTableComponent.prototype.afterSelectionEnd;
    /** @type {?} */
    HotTableComponent.prototype.afterSelectionEndByProp;
    /** @type {?} */
    HotTableComponent.prototype.afterSetCellMeta;
    /** @type {?} */
    HotTableComponent.prototype.afterSetDataAtCell;
    /** @type {?} */
    HotTableComponent.prototype.afterSetDataAtRowProp;
    /** @type {?} */
    HotTableComponent.prototype.afterSetSourceDataAtCell;
    /** @type {?} */
    HotTableComponent.prototype.afterTrimRow;
    /** @type {?} */
    HotTableComponent.prototype.afterUndo;
    /** @type {?} */
    HotTableComponent.prototype.afterUndoStackChange;
    /** @type {?} */
    HotTableComponent.prototype.afterUnhideColumns;
    /** @type {?} */
    HotTableComponent.prototype.afterUnhideRows;
    /** @type {?} */
    HotTableComponent.prototype.afterUnlisten;
    /** @type {?} */
    HotTableComponent.prototype.afterUnmergeCells;
    /** @type {?} */
    HotTableComponent.prototype.afterUntrimRow;
    /** @type {?} */
    HotTableComponent.prototype.afterUpdateSettings;
    /** @type {?} */
    HotTableComponent.prototype.afterValidate;
    /** @type {?} */
    HotTableComponent.prototype.afterViewportColumnCalculatorOverride;
    /** @type {?} */
    HotTableComponent.prototype.afterViewportRowCalculatorOverride;
    /** @type {?} */
    HotTableComponent.prototype.afterViewRender;
    /** @type {?} */
    HotTableComponent.prototype.beforeAddChild;
    /** @type {?} */
    HotTableComponent.prototype.beforeAutofill;
    /** @type {?} */
    HotTableComponent.prototype.beforeAutofillInsidePopulate;
    /** @type {?} */
    HotTableComponent.prototype.beforeCellAlignment;
    /** @type {?} */
    HotTableComponent.prototype.beforeChange;
    /** @type {?} */
    HotTableComponent.prototype.beforeChangeRender;
    /** @type {?} */
    HotTableComponent.prototype.beforeColumnCollapse;
    /** @type {?} */
    HotTableComponent.prototype.beforeColumnExpand;
    /** @type {?} */
    HotTableComponent.prototype.beforeColumnMove;
    /** @type {?} */
    HotTableComponent.prototype.beforeColumnResize;
    /** @type {?} */
    HotTableComponent.prototype.beforeColumnSort;
    /** @type {?} */
    HotTableComponent.prototype.beforeContextMenuSetItems;
    /** @type {?} */
    HotTableComponent.prototype.beforeContextMenuShow;
    /** @type {?} */
    HotTableComponent.prototype.beforeCopy;
    /** @type {?} */
    HotTableComponent.prototype.beforeCreateCol;
    /** @type {?} */
    HotTableComponent.prototype.beforeCreateRow;
    /** @type {?} */
    HotTableComponent.prototype.beforeCut;
    /** @type {?} */
    HotTableComponent.prototype.beforeDetachChild;
    /** @type {?} */
    HotTableComponent.prototype.beforeDrawBorders;
    /** @type {?} */
    HotTableComponent.prototype.beforeDropdownMenuSetItems;
    /** @type {?} */
    HotTableComponent.prototype.beforeDropdownMenuShow;
    /** @type {?} */
    HotTableComponent.prototype.beforeFilter;
    /** @type {?} */
    HotTableComponent.prototype.beforeGetCellMeta;
    /** @type {?} */
    HotTableComponent.prototype.beforeHideColumns;
    /** @type {?} */
    HotTableComponent.prototype.beforeHideRows;
    /** @type {?} */
    HotTableComponent.prototype.beforeInit;
    /** @type {?} */
    HotTableComponent.prototype.beforeInitWalkontable;
    /** @type {?} */
    HotTableComponent.prototype.beforeKeyDown;
    /** @type {?} */
    HotTableComponent.prototype.beforeLanguageChange;
    /** @type {?} */
    HotTableComponent.prototype.beforeLoadData;
    /** @type {?} */
    HotTableComponent.prototype.beforeMergeCells;
    /** @type {?} */
    HotTableComponent.prototype.beforeOnCellContextMenu;
    /** @type {?} */
    HotTableComponent.prototype.beforeOnCellMouseDown;
    /** @type {?} */
    HotTableComponent.prototype.beforeOnCellMouseOut;
    /** @type {?} */
    HotTableComponent.prototype.beforeOnCellMouseOver;
    /** @type {?} */
    HotTableComponent.prototype.beforeOnCellMouseUp;
    /** @type {?} */
    HotTableComponent.prototype.beforePaste;
    /** @type {?} */
    HotTableComponent.prototype.beforeRedo;
    /** @type {?} */
    HotTableComponent.prototype.beforeRedoStackChange;
    /** @type {?} */
    HotTableComponent.prototype.beforeRefreshDimensions;
    /** @type {?} */
    HotTableComponent.prototype.beforeRemoveCellClassNames;
    /** @type {?} */
    HotTableComponent.prototype.beforeRemoveCellMeta;
    /** @type {?} */
    HotTableComponent.prototype.beforeRemoveCol;
    /** @type {?} */
    HotTableComponent.prototype.beforeRemoveRow;
    /** @type {?} */
    HotTableComponent.prototype.beforeRender;
    /** @type {?} */
    HotTableComponent.prototype.beforeRenderer;
    /** @type {?} */
    HotTableComponent.prototype.beforeRowMove;
    /** @type {?} */
    HotTableComponent.prototype.beforeRowResize;
    /** @type {?} */
    HotTableComponent.prototype.beforeSetCellMeta;
    /** @type {?} */
    HotTableComponent.prototype.beforeSetRangeEnd;
    /** @type {?} */
    HotTableComponent.prototype.beforeSetRangeStart;
    /** @type {?} */
    HotTableComponent.prototype.beforeSetRangeStartOnly;
    /** @type {?} */
    HotTableComponent.prototype.beforeStretchingColumnWidth;
    /** @type {?} */
    HotTableComponent.prototype.beforeTouchScroll;
    /** @type {?} */
    HotTableComponent.prototype.beforeTrimRow;
    /** @type {?} */
    HotTableComponent.prototype.beforeUndo;
    /** @type {?} */
    HotTableComponent.prototype.beforeUndoStackChange;
    /** @type {?} */
    HotTableComponent.prototype.beforeUnhideColumns;
    /** @type {?} */
    HotTableComponent.prototype.beforeUnhideRows;
    /** @type {?} */
    HotTableComponent.prototype.beforeUnmergeCells;
    /** @type {?} */
    HotTableComponent.prototype.beforeUntrimRow;
    /** @type {?} */
    HotTableComponent.prototype.beforeValidate;
    /** @type {?} */
    HotTableComponent.prototype.beforeValueRender;
    /** @type {?} */
    HotTableComponent.prototype.beforeViewRender;
    /** @type {?} */
    HotTableComponent.prototype.construct;
    /** @type {?} */
    HotTableComponent.prototype.init;
    /** @type {?} */
    HotTableComponent.prototype.modifyAutoColumnSizeSeed;
    /** @type {?} */
    HotTableComponent.prototype.modifyAutofillRange;
    /** @type {?} */
    HotTableComponent.prototype.modifyColHeader;
    /** @type {?} */
    HotTableComponent.prototype.modifyColumnHeaderHeight;
    /** @type {?} */
    HotTableComponent.prototype.modifyColWidth;
    /** @type {?} */
    HotTableComponent.prototype.modifyCopyableRange;
    /** @type {?} */
    HotTableComponent.prototype.modifyData;
    /** @type {?} */
    HotTableComponent.prototype.modifyGetCellCoords;
    /** @type {?} */
    HotTableComponent.prototype.modifyRowData;
    /** @type {?} */
    HotTableComponent.prototype.modifyRowHeader;
    /** @type {?} */
    HotTableComponent.prototype.modifyRowHeaderWidth;
    /** @type {?} */
    HotTableComponent.prototype.modifyRowHeight;
    /** @type {?} */
    HotTableComponent.prototype.modifySourceData;
    /** @type {?} */
    HotTableComponent.prototype.modifyTransformEnd;
    /** @type {?} */
    HotTableComponent.prototype.modifyTransformStart;
    /** @type {?} */
    HotTableComponent.prototype.persistentStateLoad;
    /** @type {?} */
    HotTableComponent.prototype.persistentStateReset;
    /** @type {?} */
    HotTableComponent.prototype.persistentStateSave;
    /**
     * @type {?}
     * @private
     */
    HotTableComponent.prototype._ngZone;
    /**
     * @type {?}
     * @private
     */
    HotTableComponent.prototype._hotTableRegisterer;
    /**
     * @type {?}
     * @private
     */
    HotTableComponent.prototype._hotSettingsResolver;
}

/**
 * @fileoverview added by tsickle
 * Generated from: lib/hot-column.component.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var HotColumnComponent = /** @class */ (function () {
    function HotColumnComponent(parentComponent) {
        this.parentComponent = parentComponent;
        this.firstRun = true;
    }
    /**
     * @return {?}
     */
    HotColumnComponent.prototype.ngOnInit = /**
     * @return {?}
     */
    function () {
        this.firstRun = false;
        this.parentComponent.addColumn(this);
    };
    /**
     * @return {?}
     */
    HotColumnComponent.prototype.ngOnChanges = /**
     * @return {?}
     */
    function () {
        if (this.firstRun) {
            return;
        }
        this.parentComponent.onAfterColumnsChange();
    };
    /**
     * @return {?}
     */
    HotColumnComponent.prototype.ngOnDestroy = /**
     * @return {?}
     */
    function () {
        this.parentComponent.removeColumn(this);
    };
    HotColumnComponent.decorators = [
        { type: Component, args: [{
                    selector: 'hot-column',
                    template: ''
                }] }
    ];
    /** @nocollapse */
    HotColumnComponent.ctorParameters = function () { return [
        { type: HotTableComponent }
    ]; };
    HotColumnComponent.propDecorators = {
        allowEmpty: [{ type: Input }],
        allowHtml: [{ type: Input }],
        allowInvalid: [{ type: Input }],
        checkedTemplate: [{ type: Input }],
        className: [{ type: Input }],
        columnSorting: [{ type: Input }],
        colWidths: [{ type: Input }],
        commentedCellClassName: [{ type: Input }],
        copyable: [{ type: Input }],
        correctFormat: [{ type: Input }],
        data: [{ type: Input }],
        dateFormat: [{ type: Input }],
        defaultDate: [{ type: Input }],
        editor: [{ type: Input }],
        filteringCaseSensitive: [{ type: Input }],
        invalidCellClassName: [{ type: Input }],
        label: [{ type: Input }],
        language: [{ type: Input }],
        noWordWrapClassName: [{ type: Input }],
        numericFormat: [{ type: Input }],
        placeholder: [{ type: Input }],
        placeholderCellClassName: [{ type: Input }],
        readOnly: [{ type: Input }],
        readOnlyCellClassName: [{ type: Input }],
        renderer: [{ type: Input }],
        selectOptions: [{ type: Input }],
        skipColumnOnPaste: [{ type: Input }],
        sortByRelevance: [{ type: Input }],
        source: [{ type: Input }],
        strict: [{ type: Input }],
        title: [{ type: Input }],
        trimDropdown: [{ type: Input }],
        type: [{ type: Input }],
        uncheckedTemplate: [{ type: Input }],
        validator: [{ type: Input }],
        visibleRows: [{ type: Input }],
        width: [{ type: Input }],
        wordWrap: [{ type: Input }]
    };
    return HotColumnComponent;
}());
if (false) {
    /**
     * @type {?}
     * @private
     */
    HotColumnComponent.prototype.firstRun;
    /** @type {?} */
    HotColumnComponent.prototype.allowEmpty;
    /** @type {?} */
    HotColumnComponent.prototype.allowHtml;
    /** @type {?} */
    HotColumnComponent.prototype.allowInvalid;
    /** @type {?} */
    HotColumnComponent.prototype.checkedTemplate;
    /** @type {?} */
    HotColumnComponent.prototype.className;
    /** @type {?} */
    HotColumnComponent.prototype.columnSorting;
    /** @type {?} */
    HotColumnComponent.prototype.colWidths;
    /** @type {?} */
    HotColumnComponent.prototype.commentedCellClassName;
    /** @type {?} */
    HotColumnComponent.prototype.copyable;
    /** @type {?} */
    HotColumnComponent.prototype.correctFormat;
    /** @type {?} */
    HotColumnComponent.prototype.data;
    /** @type {?} */
    HotColumnComponent.prototype.dateFormat;
    /** @type {?} */
    HotColumnComponent.prototype.defaultDate;
    /** @type {?} */
    HotColumnComponent.prototype.editor;
    /** @type {?} */
    HotColumnComponent.prototype.filteringCaseSensitive;
    /** @type {?} */
    HotColumnComponent.prototype.invalidCellClassName;
    /** @type {?} */
    HotColumnComponent.prototype.label;
    /** @type {?} */
    HotColumnComponent.prototype.language;
    /** @type {?} */
    HotColumnComponent.prototype.noWordWrapClassName;
    /** @type {?} */
    HotColumnComponent.prototype.numericFormat;
    /** @type {?} */
    HotColumnComponent.prototype.placeholder;
    /** @type {?} */
    HotColumnComponent.prototype.placeholderCellClassName;
    /** @type {?} */
    HotColumnComponent.prototype.readOnly;
    /** @type {?} */
    HotColumnComponent.prototype.readOnlyCellClassName;
    /** @type {?} */
    HotColumnComponent.prototype.renderer;
    /** @type {?} */
    HotColumnComponent.prototype.selectOptions;
    /** @type {?} */
    HotColumnComponent.prototype.skipColumnOnPaste;
    /** @type {?} */
    HotColumnComponent.prototype.sortByRelevance;
    /** @type {?} */
    HotColumnComponent.prototype.source;
    /** @type {?} */
    HotColumnComponent.prototype.strict;
    /** @type {?} */
    HotColumnComponent.prototype.title;
    /** @type {?} */
    HotColumnComponent.prototype.trimDropdown;
    /** @type {?} */
    HotColumnComponent.prototype.type;
    /** @type {?} */
    HotColumnComponent.prototype.uncheckedTemplate;
    /** @type {?} */
    HotColumnComponent.prototype.validator;
    /** @type {?} */
    HotColumnComponent.prototype.visibleRows;
    /** @type {?} */
    HotColumnComponent.prototype.width;
    /** @type {?} */
    HotColumnComponent.prototype.wordWrap;
    /**
     * @type {?}
     * @private
     */
    HotColumnComponent.prototype.parentComponent;
}

/**
 * @fileoverview added by tsickle
 * Generated from: lib/hot-table.module.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var HotTableModule = /** @class */ (function () {
    function HotTableModule() {
    }
    /**
     * @return {?}
     */
    HotTableModule.forRoot = /**
     * @return {?}
     */
    function () {
        return {
            ngModule: HotTableModule,
            providers: [HotTableRegisterer],
        };
    };
    HotTableModule.version = '0.0.0-next-eb8360c-20221024';
    HotTableModule.decorators = [
        { type: NgModule, args: [{
                    declarations: [
                        HotTableComponent,
                        HotColumnComponent,
                    ],
                    exports: [
                        HotTableComponent,
                        HotColumnComponent,
                    ]
                },] }
    ];
    return HotTableModule;
}());
if (false) {
    /** @type {?} */
    HotTableModule.version;
}

/**
 * @fileoverview added by tsickle
 * Generated from: public_api.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

/**
 * @fileoverview added by tsickle
 * Generated from: tmp-hot-angular.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

export { HOT_DESTROYED_WARNING, HotColumnComponent, HotSettingsResolver, HotTableComponent, HotTableModule, HotTableRegisterer };
//# sourceMappingURL=tmp-hot-angular.js.map