import { Component, Prop, h, Watch, Element, Listen, Event, Method, State, Host } from '@stencil/core';
import reduce from 'lodash/reduce';
import each from 'lodash/each';
import ColumnDataProvider from '../../services/column.data.provider';
import { DataProvider } from '../../services/data.provider';
import { getVisibleSourceItem } from '../../store/dataSource/data.store';
import DimensionProvider from '../../services/dimension.provider';
import ViewportProvider from '../../services/viewport.provider';
import ThemeService from '../../themeManager/themeService';
import { timeout } from '../../utils/utils';
import AutoSize from '../../plugins/autoSizeColumn';
import { columnTypes } from '../../store/storeTypes';
import FilterPlugin from '../../plugins/filter/filter.plugin';
import SortingPlugin from '../../plugins/sorting/sorting.plugin';
import ExportFilePlugin from '../../plugins/export/export.plugin';
import GroupingRowPlugin from '../../plugins/groupingRow/grouping.row.plugin';
import { RevoViewPort } from './viewport';
import ViewportService from './viewport.service';
import { ViewPortSections } from './viewport.section';
import GridScrollingService from './viewport.scrolling.service';
import { UUID } from '../../utils/consts';
import SelectionStoreConnector from '../../services/selection.store.connector';
import StretchColumn, { isStretchPlugin } from '../../plugins/stretchPlugin';
export class RevoGridComponent {
  constructor() {
    /**
     * Defines how many rows/columns should be rendered outside visible area.
     */
    this.frameSize = 1;
    /**
     * Indicates default rgRow size.
     * By default 0, means theme package size will be applied
     */
    this.rowSize = 0;
    /** Indicates default column size. */
    this.colSize = 100;
    /** When true, user can range selection. */
    this.range = false;
    /** When true, grid in read only mode. */
    this.readonly = false;
    /** When true, columns are resizable. */
    this.resize = false;
    /** When true cell focus appear. */
    this.canFocus = true;
    /** When true enable clipboard. */
    this.useClipboard = true;
    /**
     * Columns - defines an array of grid columns.
     * Can be column or grouped column.
     */
    this.columns = [];
    /**
     * Source - defines main data source.
     * Can be an Object or 2 dimensional array([][]);
     * Keys/indexes referenced from columns Prop
     */
    this.source = [];
    /** Pinned top Source: {[T in ColumnProp]: any} - defines pinned top rows data source. */
    this.pinnedTopSource = [];
    /** Pinned bottom Source: {[T in ColumnProp]: any} - defines pinned bottom rows data source. */
    this.pinnedBottomSource = [];
    /** Row properies applied */
    this.rowDefinitions = [];
    /** Custom editors register */
    this.editors = {};
    /** Types
     *  Every type represent multiple column properties
     *  Types will be merged but can be replaced with column properties
     */
    this.columnTypes = {};
    /** Theme name */
    this.theme = 'default';
    /**
     * Row class property
     * Define this property in rgRow object and this will be mapped as rgRow class
     */
    this.rowClass = '';
    /**
     * Autosize config
     * Enable columns autoSize, for more details check @autoSizeColumn plugin
     * By default disabled, hence operation is not resource efficient
     * true to enable with default params (double header separator click for autosize)
     * or provide config
     */
    this.autoSizeColumn = false;
    /**
     * Enables filter plugin
     * Can be boolean
     * Can be filter collection
     */
    this.filter = false;
    /**
     * Trimmed rows
     * Functionality which allows to hide rows from main data set
     * @trimmedRows are physical rgRow indexes to hide
     */
    this.trimmedRows = {};
    /**
     * Enables export plugin
     * Can be boolean
     * Can be export options
     */
    this.exporting = false;
    /**
     * Defines stretch strategy for columns with @StretchColumn plugin
     * if there are more space on the right last column size would be increased
     */
    this.stretch = true;
    // --------------------------------------------------------------------------
    //
    //  Private Properties
    //
    // --------------------------------------------------------------------------
    // for internal plugin usage
    this.extraElements = [];
    this.uuid = null;
    this.viewport = null;
    /**
     * Plugins
     * Define plugins collection
     */
    this.internalPlugins = [];
    this.subscribers = {};
  }
  // --------------------------------------------------------------------------
  //
  //  Methods
  //
  // --------------------------------------------------------------------------
  /**
   * Refreshes data viewport.
   * Can be specific part as rgRow or pinned rgRow or 'all' by default.
   */
  async refresh(type = 'all') {
    this.dataProvider.refresh(type);
  }
  /**  Scrolls view port to specified rgRow index */
  async scrollToRow(coordinate = 0) {
    const y = this.dimensionProvider.getViewPortPos({
      coordinate,
      dimension: 'rgRow',
    });
    await this.scrollToCoordinate({ y });
  }
  /** Scrolls view port to specified column index */
  async scrollToColumnIndex(coordinate = 0) {
    const x = this.dimensionProvider.getViewPortPos({
      coordinate,
      dimension: 'rgCol',
    });
    await this.scrollToCoordinate({ x });
  }
  /**  Scrolls view port to specified column prop */
  async scrollToColumnProp(prop) {
    const coordinate = this.columnProvider.getColumnIndexByProp(prop, 'rgCol');
    if (coordinate < 0) {
      // already on the screen
      return;
    }
    const x = this.dimensionProvider.getViewPortPos({
      coordinate,
      dimension: 'rgCol',
    });
    await this.scrollToCoordinate({ x });
  }
  /** Update columns */
  async updateColumns(cols) {
    this.columnProvider.updateColumns(cols);
  }
  /** Add trimmed by type */
  async addTrimmed(trimmed, trimmedType = 'external', type = 'rgRow') {
    const event = this.beforetrimmed.emit({
      trimmed,
      trimmedType,
      type,
    });
    if (event.defaultPrevented) {
      return event;
    }
    this.dataProvider.setTrimmed({ [trimmedType]: event.detail.trimmed }, type);
    this.aftertrimmed.emit();
    return event;
  }
  /**  Scrolls view port to coordinate */
  async scrollToCoordinate(cell) {
    var _a;
    (_a = this.viewport) === null || _a === void 0 ? void 0 : _a.scrollToCell(cell);
  }
  /**  Bring cell to edit mode */
  async setCellEdit(rgRow, prop, rowSource = 'rgRow') {
    var _a;
    const rgCol = ColumnDataProvider.getColumnByProp(this.columns, prop);
    if (!rgCol) {
      return;
    }
    await timeout();
    (_a = this.viewport) === null || _a === void 0 ? void 0 : _a.setEdit(rgRow, this.columnProvider.getColumnIndexByProp(prop, 'rgCol'), rgCol.pin || 'rgCol', rowSource);
  }
  /**
   * Register new virtual node inside of grid
   * Used for additional items creation such as plugin elements
   */
  async registerVNode(elements) {
    this.extraElements.push(...elements);
    this.extraElements = [...this.extraElements];
  }
  /**  Get data from source */
  async getSource(type = 'rgRow') {
    return this.dataProvider.stores[type].store.get('source');
  }
  /**
   * Get data from visible part of source
   * Trimmed/filtered rows will be excluded
   * @param type - type of source
   */
  async getVisibleSource(type = 'rgRow') {
    return getVisibleSourceItem(this.dataProvider.stores[type].store);
  }
  /**
   * Provides access to rows internal store observer
   * Can be used for plugin support
   * @param type - type of source
   */
  async getSourceStore(type = 'rgRow') {
    return this.dataProvider.stores[type].store;
  }
  /**
   * Provides access to column internal store observer
   * Can be used for plugin support
   * @param type - type of column
   */
  async getColumnStore(type = 'rgCol') {
    return this.columnProvider.stores[type].store;
  }
  /**
   * Update column sorting
   * @param column - full column details to update
   * @param index - virtual column index
   * @param order - order to apply
   */
  async updateColumnSorting(column, index, order, additive) {
    return this.columnProvider.updateColumnSorting(column, index, order, additive);
  }
  /**
   * Clears column sorting
   */
  async clearSorting() {
    this.columnProvider.clearSorting();
  }
  /**
   * Receive all columns in data source
   */
  async getColumns() {
    return this.columnProvider.getColumns();
  }
  /**
   * Clear current grid focus
   */
  async clearFocus() {
    var _a;
    const focused = await this.getFocused();
    const event = this.beforefocuslost.emit(focused);
    if (event.defaultPrevented) {
      return;
    }
    this.selectionStoreConnector.clearAll();
    (_a = this.viewport) === null || _a === void 0 ? void 0 : _a.clearFocused();
  }
  /**
   * Get all active plugins instances
   */
  async getPlugins() {
    return [...this.internalPlugins];
  }
  /**
   * Get all active plugins instances
   */
  async getFocused() {
    var _a;
    return (_a = this.viewport) === null || _a === void 0 ? void 0 : _a.getFocused();
  }
  // --------------------------------------------------------------------------
  //
  //  Listeners outside scope
  //
  // --------------------------------------------------------------------------
  /** Clear data which is outside of grid container */
  handleOutsideClick({ target }) {
    if (!(target === null || target === void 0 ? void 0 : target.closest(`[${UUID}="${this.uuid}"]`))) {
      this.clearFocus();
    }
  }
  // --------------------------------------------------------------------------
  //
  //  Listeners
  //
  // --------------------------------------------------------------------------
  /** DRAG AND DROP */
  onRowDragStarted(e) {
    var _a;
    e.cancelBubble = true;
    const dragStart = this.rowdragstart.emit(e.detail);
    if (dragStart.defaultPrevented) {
      e.preventDefault();
      return;
    }
    (_a = this.orderService) === null || _a === void 0 ? void 0 : _a.start(this.element, Object.assign(Object.assign({}, e.detail), dragStart.detail));
  }
  onRowDragEnd() {
    var _a;
    (_a = this.orderService) === null || _a === void 0 ? void 0 : _a.end();
  }
  onRowDrag({ detail }) {
    var _a;
    (_a = this.orderService) === null || _a === void 0 ? void 0 : _a.move(detail);
  }
  onRowMouseMove(e) {
    var _a;
    e.cancelBubble = true;
    (_a = this.orderService) === null || _a === void 0 ? void 0 : _a.moveTip(e.detail);
  }
  async onBeforeEdit(e) {
    e.cancelBubble = true;
    const { defaultPrevented, detail } = this.beforeedit.emit(e.detail);
    await timeout();
    // apply data
    if (!defaultPrevented) {
      this.dataProvider.setCellData(detail);
      this.afteredit.emit(detail);
    }
  }
  onBeforeRangeEdit(e) {
    e.cancelBubble = true;
    const { defaultPrevented } = this.beforerangeedit.emit(e.detail);
    if (defaultPrevented) {
      e.preventDefault();
      return;
    }
    this.afteredit.emit(e.detail);
  }
  onRangeChanged(e) {
    e.cancelBubble = true;
    const beforeaange = this.beforeaange.emit(e.detail);
    if (beforeaange.defaultPrevented) {
      e.preventDefault();
    }
    const beforeFill = this.beforeautofill.emit(e.detail);
    if (beforeFill.defaultPrevented) {
      return;
    }
  }
  onRowDropped(e) {
    e.cancelBubble = true;
    const { defaultPrevented } = this.roworderchanged.emit(e.detail);
    if (defaultPrevented) {
      e.preventDefault();
    }
  }
  onHeaderClick(e) {
    const { defaultPrevented } = this.headerclick.emit(Object.assign(Object.assign({}, e.detail.column), { originalEvent: e.detail.originalEvent }));
    if (defaultPrevented) {
      e.preventDefault();
    }
  }
  onCellFocus(e) {
    e.cancelBubble = true;
    const { defaultPrevented } = this.beforecellfocus.emit(e.detail);
    if (!this.canFocus || defaultPrevented) {
      e.preventDefault();
    }
  }
  columnChanged(newVal = []) {
    this.dimensionProvider.drop();
    const columnGather = ColumnDataProvider.getColumns(newVal, 0, this.columnTypes);
    this.beforecolumnsset.emit(columnGather);
    for (let type of columnTypes) {
      const items = columnGather.columns[type];
      this.dimensionProvider.setRealSize(items.length, type);
      this.dimensionProvider.setColumns(type, ColumnDataProvider.getSizes(items), type !== 'rgCol');
    }
    this.beforecolumnapplied.emit(columnGather);
    const columns = this.columnProvider.setColumns(columnGather);
    this.aftercolumnsset.emit({
      columns,
      order: this.columnProvider.order,
    });
  }
  themeChanged(t) {
    this.themeService.register(t);
    this.dimensionProvider.setSettings({ originItemSize: this.themeService.rowSize, frameOffset: this.frameSize || 0 }, 'rgRow');
    this.dimensionProvider.setSettings({ originItemSize: this.colSize, frameOffset: this.frameSize || 0 }, 'rgCol');
  }
  dataChanged(source = []) {
    let newSource = [...source];
    const beforesourceset = this.beforesourceset.emit({
      type: 'rgRow',
      source: newSource,
    });
    newSource = beforesourceset.detail.source;
    newSource = this.dataProvider.setData(newSource, 'rgRow');
    this.aftersourceset.emit({
      type: 'rgRow',
      source: newSource,
    });
  }
  dataBottomChanged(newVal = []) {
    this.dataProvider.setData(newVal, 'rowPinEnd');
  }
  dataTopChanged(newVal = []) {
    this.dataProvider.setData(newVal, 'rowPinStart');
  }
  rowDefChanged(newVal = []) {
    if (!newVal.length) {
      return;
    }
    const rows = reduce(newVal, (r, v) => {
      if (!r[v.type]) {
        r[v.type] = {};
      }
      if (v.size) {
        if (!r[v.type].sizes) {
          r[v.type].sizes = {};
        }
        r[v.type].sizes[v.index] = v.size;
      }
      return r;
    }, {});
    each(rows, (r, k) => {
      if (r.sizes) {
        this.dimensionProvider.setDimensionSize(k, r.sizes);
      }
    });
  }
  trimmedRowsChanged(newVal = {}) {
    this.addTrimmed(newVal);
  }
  groupingChanged(newVal = {}) {
    let grPlugin;
    for (let p of this.internalPlugins) {
      const isGrouping = p;
      if (isGrouping.setGrouping) {
        grPlugin = isGrouping;
        break;
      }
    }
    if (!grPlugin) {
      return;
    }
    grPlugin.setGrouping(newVal || {});
  }
  applyStretch(isStretch) {
    let stretch = this.internalPlugins.filter(p => isStretchPlugin(p))[0];
    if (isStretch) {
      if (!stretch) {
        this.internalPlugins.push(new StretchColumn(this.element, this.dimensionProvider));
      }
      else {
        stretch.applyStretch(this.columnProvider.getRawColumns());
      }
    }
    else if (stretch) {
      const index = this.internalPlugins.indexOf(stretch);
      this.internalPlugins.splice(index, 1);
    }
  }
  connectedCallback() {
    this.viewportProvider = new ViewportProvider();
    this.themeService = new ThemeService({
      rowSize: this.rowSize,
    });
    this.dimensionProvider = new DimensionProvider(this.viewportProvider);
    this.columnProvider = new ColumnDataProvider();
    this.dataProvider = new DataProvider(this.dimensionProvider);
    this.uuid = `${new Date().getTime()}-rvgrid`;
    if (this.autoSizeColumn) {
      this.internalPlugins.push(new AutoSize(this.element, {
        dataProvider: this.dataProvider,
        columnProvider: this.columnProvider,
        dimensionProvider: this.dimensionProvider,
      }, typeof this.autoSizeColumn === 'object' ? this.autoSizeColumn : undefined));
    }
    if (this.filter) {
      this.internalPlugins.push(new FilterPlugin(this.element, this.uuid, typeof this.filter === 'object' ? this.filter : undefined));
    }
    if (this.exporting) {
      this.internalPlugins.push(new ExportFilePlugin(this.element));
    }
    this.internalPlugins.push(new SortingPlugin(this.element));
    if (this.plugins) {
      this.plugins.forEach(p => {
        this.internalPlugins.push(new p(this.element));
      });
    }
    this.internalPlugins.push(new GroupingRowPlugin(this.element, {
      dataProvider: this.dataProvider,
      columnProvider: this.columnProvider,
    }));
    this.applyStretch(this.stretch);
    this.themeChanged(this.theme);
    this.columnChanged(this.columns);
    this.dataChanged(this.source);
    this.dataTopChanged(this.pinnedTopSource);
    this.dataBottomChanged(this.pinnedBottomSource);
    this.trimmedRowsChanged(this.trimmedRows);
    this.rowDefChanged(this.rowDefinitions);
    this.groupingChanged(this.grouping);
    this.selectionStoreConnector = new SelectionStoreConnector();
    this.scrollingService = new GridScrollingService((e) => {
      this.dimensionProvider.setViewPortCoordinate({
        coordinate: e.coordinate,
        type: e.dimension,
      });
      this.viewportscroll.emit(e);
    });
    this.subscribers = { 'click': this.handleOutsideClick.bind(this) };
    for (let type in this.subscribers) {
      document.addEventListener(type, this.subscribers[type]);
    }
  }
  disconnectedCallback() {
    // destroy plugins on element disconnect
    each(this.internalPlugins, p => p.destroy());
    this.internalPlugins = [];
    // clear events
    for (let type in this.subscribers) {
      document.removeEventListener(type, this.subscribers[type]);
      delete this.subscribers[type];
    }
  }
  render() {
    const contentHeight = this.dimensionProvider.stores['rgRow'].store.get('realSize');
    this.viewport = new ViewportService({
      columnProvider: this.columnProvider,
      dataProvider: this.dataProvider,
      dimensionProvider: this.dimensionProvider,
      viewportProvider: this.viewportProvider,
      uuid: this.uuid,
      scrollingService: this.scrollingService,
      orderService: this.orderService,
      selectionStoreConnector: this.selectionStoreConnector,
      resize: c => this.aftercolumnresize.emit(c)
    }, contentHeight);
    const views = [];
    if (this.rowHeaders) {
      const anyView = this.viewport.columns[0];
      views.push(h("revogr-row-headers", { height: contentHeight, resize: this.resize, dataPorts: anyView.dataPorts, headerProp: anyView.headerProp, uiid: anyView.prop[UUID], rowHeaderColumn: typeof this.rowHeaders === 'object' ? this.rowHeaders : undefined, onScrollViewport: ({ detail: e }) => this.scrollingService.onScroll(e, 'headerRow'), onElementToScroll: ({ detail: e }) => this.scrollingService.registerElement(e, 'headerRow') }));
    }
    views.push(h(ViewPortSections, { columnFilter: !!this.filter, resize: this.resize, readonly: this.readonly, range: this.range, rowClass: this.rowClass, editors: this.editors, useClipboard: this.useClipboard, columns: this.viewport.columns, onEdit: detail => {
        const event = this.beforeeditstart.emit(detail);
        if (!event.defaultPrevented) {
          this.selectionStoreConnector.setEdit(detail.isCancel ? false : detail.val);
        }
      }, registerElement: (e, k) => this.scrollingService.registerElement(e, k), onScroll: details => this.scrollingService.onScroll(details) }));
    return (h(Host, Object.assign({}, { [`${UUID}`]: this.uuid }),
      h(RevoViewPort, { viewports: this.viewportProvider.stores, dimensions: this.dimensionProvider.stores, orderRef: e => (this.orderService = e), registerElement: (e, k) => this.scrollingService.registerElement(e, k), nakedClick: () => this.viewport.clearEdit(), onScroll: details => this.scrollingService.onScroll(details) }, views),
      this.extraElements));
  }
  static get is() { return "revo-grid"; }
  static get originalStyleUrls() { return {
    "$": ["revo-grid-style.scss"]
  }; }
  static get styleUrls() { return {
    "$": ["revo-grid-style.css"]
  }; }
  static get properties() { return {
    "rowHeaders": {
      "type": "boolean",
      "mutable": false,
      "complexType": {
        "original": "RevoGrid.RowHeaders | boolean",
        "resolved": "RowHeaders | boolean",
        "references": {
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Excel like show rgRow indexe per rgRow"
      },
      "attribute": "row-headers",
      "reflect": false
    },
    "frameSize": {
      "type": "number",
      "mutable": false,
      "complexType": {
        "original": "number",
        "resolved": "number",
        "references": {}
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Defines how many rows/columns should be rendered outside visible area."
      },
      "attribute": "frame-size",
      "reflect": false,
      "defaultValue": "1"
    },
    "rowSize": {
      "type": "number",
      "mutable": false,
      "complexType": {
        "original": "number",
        "resolved": "number",
        "references": {}
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Indicates default rgRow size.\nBy default 0, means theme package size will be applied"
      },
      "attribute": "row-size",
      "reflect": false,
      "defaultValue": "0"
    },
    "colSize": {
      "type": "number",
      "mutable": false,
      "complexType": {
        "original": "number",
        "resolved": "number",
        "references": {}
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Indicates default column size."
      },
      "attribute": "col-size",
      "reflect": false,
      "defaultValue": "100"
    },
    "range": {
      "type": "boolean",
      "mutable": false,
      "complexType": {
        "original": "boolean",
        "resolved": "boolean",
        "references": {}
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "When true, user can range selection."
      },
      "attribute": "range",
      "reflect": false,
      "defaultValue": "false"
    },
    "readonly": {
      "type": "boolean",
      "mutable": false,
      "complexType": {
        "original": "boolean",
        "resolved": "boolean",
        "references": {}
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "When true, grid in read only mode."
      },
      "attribute": "readonly",
      "reflect": false,
      "defaultValue": "false"
    },
    "resize": {
      "type": "boolean",
      "mutable": false,
      "complexType": {
        "original": "boolean",
        "resolved": "boolean",
        "references": {}
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "When true, columns are resizable."
      },
      "attribute": "resize",
      "reflect": false,
      "defaultValue": "false"
    },
    "canFocus": {
      "type": "boolean",
      "mutable": false,
      "complexType": {
        "original": "boolean",
        "resolved": "boolean",
        "references": {}
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "When true cell focus appear."
      },
      "attribute": "can-focus",
      "reflect": false,
      "defaultValue": "true"
    },
    "useClipboard": {
      "type": "boolean",
      "mutable": false,
      "complexType": {
        "original": "boolean",
        "resolved": "boolean",
        "references": {}
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "When true enable clipboard."
      },
      "attribute": "use-clipboard",
      "reflect": false,
      "defaultValue": "true"
    },
    "columns": {
      "type": "unknown",
      "mutable": false,
      "complexType": {
        "original": "(RevoGrid.ColumnRegular | RevoGrid.ColumnGrouping)[]",
        "resolved": "(ColumnRegular | ColumnGrouping)[]",
        "references": {
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Columns - defines an array of grid columns.\nCan be column or grouped column."
      },
      "defaultValue": "[]"
    },
    "source": {
      "type": "unknown",
      "mutable": false,
      "complexType": {
        "original": "RevoGrid.DataType[]",
        "resolved": "DataType[]",
        "references": {
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Source - defines main data source.\nCan be an Object or 2 dimensional array([][]);\nKeys/indexes referenced from columns Prop"
      },
      "defaultValue": "[]"
    },
    "pinnedTopSource": {
      "type": "unknown",
      "mutable": false,
      "complexType": {
        "original": "RevoGrid.DataType[]",
        "resolved": "DataType[]",
        "references": {
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Pinned top Source: {[T in ColumnProp]: any} - defines pinned top rows data source."
      },
      "defaultValue": "[]"
    },
    "pinnedBottomSource": {
      "type": "unknown",
      "mutable": false,
      "complexType": {
        "original": "RevoGrid.DataType[]",
        "resolved": "DataType[]",
        "references": {
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Pinned bottom Source: {[T in ColumnProp]: any} - defines pinned bottom rows data source."
      },
      "defaultValue": "[]"
    },
    "rowDefinitions": {
      "type": "unknown",
      "mutable": false,
      "complexType": {
        "original": "RevoGrid.RowDefinition[]",
        "resolved": "RowDefinition[]",
        "references": {
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Row properies applied"
      },
      "defaultValue": "[]"
    },
    "editors": {
      "type": "unknown",
      "mutable": false,
      "complexType": {
        "original": "Edition.Editors",
        "resolved": "{ [name: string]: EditorCtr; }",
        "references": {
          "Edition": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Custom editors register"
      },
      "defaultValue": "{}"
    },
    "plugins": {
      "type": "unknown",
      "mutable": false,
      "complexType": {
        "original": "RevoPlugin.PluginClass[]",
        "resolved": "(typeof Plugin)[]",
        "references": {
          "RevoPlugin": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Custom grid plugins\nHas to be predefined during first grid init\nEvery plugin should be inherited from BasePlugin"
      }
    },
    "columnTypes": {
      "type": "unknown",
      "mutable": false,
      "complexType": {
        "original": "{ [name: string]: RevoGrid.ColumnType }",
        "resolved": "{ [name: string]: ColumnType; }",
        "references": {
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Types\nEvery type represent multiple column properties\nTypes will be merged but can be replaced with column properties"
      },
      "defaultValue": "{}"
    },
    "theme": {
      "type": "string",
      "mutable": true,
      "complexType": {
        "original": "ThemeSpace.Theme",
        "resolved": "\"compact\" | \"darkCompact\" | \"darkMaterial\" | \"default\" | \"material\"",
        "references": {
          "ThemeSpace": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Theme name"
      },
      "attribute": "theme",
      "reflect": true,
      "defaultValue": "'default'"
    },
    "rowClass": {
      "type": "string",
      "mutable": false,
      "complexType": {
        "original": "string",
        "resolved": "string",
        "references": {}
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Row class property\nDefine this property in rgRow object and this will be mapped as rgRow class"
      },
      "attribute": "row-class",
      "reflect": true,
      "defaultValue": "''"
    },
    "autoSizeColumn": {
      "type": "boolean",
      "mutable": false,
      "complexType": {
        "original": "boolean | AutoSizeColumnConfig",
        "resolved": "boolean | { mode?: ColumnAutoSizeMode; allColumns?: boolean; letterBlockSize?: number; preciseSize?: boolean; }",
        "references": {
          "AutoSizeColumnConfig": {
            "location": "import",
            "path": "../../plugins/autoSizeColumn"
          }
        }
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Autosize config\nEnable columns autoSize, for more details check @autoSizeColumn plugin\nBy default disabled, hence operation is not resource efficient\ntrue to enable with default params (double header separator click for autosize)\nor provide config"
      },
      "attribute": "auto-size-column",
      "reflect": false,
      "defaultValue": "false"
    },
    "filter": {
      "type": "boolean",
      "mutable": false,
      "complexType": {
        "original": "boolean | ColumnFilterConfig",
        "resolved": "boolean | { collection?: FilterCollection; include?: string[]; customFilters?: Record<string, CustomFilter>; }",
        "references": {
          "ColumnFilterConfig": {
            "location": "import",
            "path": "../../plugins/filter/filter.plugin"
          }
        }
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Enables filter plugin\nCan be boolean\nCan be filter collection"
      },
      "attribute": "filter",
      "reflect": false,
      "defaultValue": "false"
    },
    "trimmedRows": {
      "type": "unknown",
      "mutable": false,
      "complexType": {
        "original": "Record<number, boolean>",
        "resolved": "{ [x: number]: boolean; }",
        "references": {
          "Record": {
            "location": "global"
          }
        }
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [{
            "text": "are physical rgRow indexes to hide",
            "name": "trimmedRows"
          }],
        "text": "Trimmed rows\nFunctionality which allows to hide rows from main data set"
      },
      "defaultValue": "{}"
    },
    "exporting": {
      "type": "boolean",
      "mutable": false,
      "complexType": {
        "original": "boolean",
        "resolved": "boolean",
        "references": {}
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Enables export plugin\nCan be boolean\nCan be export options"
      },
      "attribute": "exporting",
      "reflect": false,
      "defaultValue": "false"
    },
    "grouping": {
      "type": "unknown",
      "mutable": false,
      "complexType": {
        "original": "GroupingOptions",
        "resolved": "{ props?: ColumnProp[]; expandedAll?: boolean; }",
        "references": {
          "GroupingOptions": {
            "location": "import",
            "path": "../../plugins/groupingRow/grouping.row.types"
          }
        }
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Group models by provided properties\nDefine properties to be groped by"
      }
    },
    "stretch": {
      "type": "any",
      "mutable": false,
      "complexType": {
        "original": "boolean|string",
        "resolved": "boolean | string",
        "references": {}
      },
      "required": false,
      "optional": false,
      "docs": {
        "tags": [],
        "text": "Defines stretch strategy for columns with @StretchColumn plugin\nif there are more space on the right last column size would be increased"
      },
      "attribute": "stretch",
      "reflect": false,
      "defaultValue": "true"
    }
  }; }
  static get states() { return {
    "extraElements": {}
  }; }
  static get events() { return [{
      "method": "beforeedit",
      "name": "beforeedit",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before edit event.\nTriggered before edit data applied.\nUse e.preventDefault() to prevent edit data set and use you own.\nUse e.val = {your value} to replace edit result with your own."
      },
      "complexType": {
        "original": "Edition.BeforeSaveDataDetails",
        "resolved": "{ prop: ColumnProp; model: DataType; val?: string; rowIndex: number; type: DimensionRows; }",
        "references": {
          "Edition": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "beforerangeedit",
      "name": "beforerangeedit",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before range edit event.\nTriggered before range data applied, when range selection happened.\nUse e.preventDefault() to prevent edit data set and use you own."
      },
      "complexType": {
        "original": "Edition.BeforeRangeSaveDataDetails",
        "resolved": "{ data: DataLookup; models: { [rowIndex: number]: DataType; }; type: DimensionRows; }",
        "references": {
          "Edition": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "afteredit",
      "name": "afteredit",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "After edit.\nTriggered when after data applied or Range changeged."
      },
      "complexType": {
        "original": "Edition.BeforeSaveDataDetails | Edition.BeforeRangeSaveDataDetails",
        "resolved": "{ data: DataLookup; models: { [rowIndex: number]: DataType; }; type: DimensionRows; } | { prop: ColumnProp; model: DataType; val?: string; rowIndex: number; type: DimensionRows; }",
        "references": {
          "Edition": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "beforeautofill",
      "name": "beforeautofill",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before autofill.\nTriggered before autofill applied.\nUse e.preventDefault() to prevent edit data apply."
      },
      "complexType": {
        "original": "Selection.ChangedRange",
        "resolved": "{ type: DimensionRows; newRange: RangeArea; oldRange: RangeArea; newProps: ColumnProp[]; oldProps: ColumnProp[]; newData: { [key: number]: DataType; }; }",
        "references": {
          "Selection": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "beforeaange",
      "name": "beforeaange",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before range apply.\nTriggered before range applied.\nUse e.preventDefault() to prevent range."
      },
      "complexType": {
        "original": "Selection.ChangedRange",
        "resolved": "{ type: DimensionRows; newRange: RangeArea; oldRange: RangeArea; newProps: ColumnProp[]; oldProps: ColumnProp[]; newData: { [key: number]: DataType; }; }",
        "references": {
          "Selection": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "roworderchanged",
      "name": "roworderchanged",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before rgRow order apply.\nUse e.preventDefault() to prevent rgRow order change."
      },
      "complexType": {
        "original": "{ from: number; to: number }",
        "resolved": "{ from: number; to: number; }",
        "references": {}
      }
    }, {
      "method": "beforesourcesortingapply",
      "name": "beforesourcesortingapply",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before source update sorting apply.\nUse this event if you intended to prevent sorting on data update.\nUse e.preventDefault() to prevent sorting data change during rows source update."
      },
      "complexType": {
        "original": "any",
        "resolved": "any",
        "references": {}
      }
    }, {
      "method": "beforesortingapply",
      "name": "beforesortingapply",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before sorting apply.\nUse e.preventDefault() to prevent sorting data change."
      },
      "complexType": {
        "original": "{\n    column: RevoGrid.ColumnRegular;\n    order: 'desc' | 'asc';\n    additive: boolean;\n  }",
        "resolved": "{ column: ColumnRegular; order: \"desc\" | \"asc\"; additive: boolean; }",
        "references": {
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "beforesorting",
      "name": "beforesorting",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before sorting event.\nInitial sorting triggered, if this event stops no other event called.\nUse e.preventDefault() to prevent sorting."
      },
      "complexType": {
        "original": "{\n    column: RevoGrid.ColumnRegular;\n    order: 'desc' | 'asc';\n    additive: boolean;\n  }",
        "resolved": "{ column: ColumnRegular; order: \"desc\" | \"asc\"; additive: boolean; }",
        "references": {
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "rowdragstart",
      "name": "rowdragstart",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Row order change started.\nUse e.preventDefault() to prevent rgRow order change.\nUse e.text = 'new name' to change item name on start."
      },
      "complexType": {
        "original": "{ pos: RevoGrid.PositionItem; text: string }",
        "resolved": "{ pos: PositionItem; text: string; }",
        "references": {
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "headerclick",
      "name": "headerclick",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "On header click."
      },
      "complexType": {
        "original": "RevoGrid.ColumnRegular",
        "resolved": "ColumnRegular",
        "references": {
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "beforecellfocus",
      "name": "beforecellfocus",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before cell focus changed.\nUse e.preventDefault() to prevent cell focus change."
      },
      "complexType": {
        "original": "Edition.BeforeSaveDataDetails",
        "resolved": "{ prop: ColumnProp; model: DataType; val?: string; rowIndex: number; type: DimensionRows; }",
        "references": {
          "Edition": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "beforefocuslost",
      "name": "beforefocuslost",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before grid focus lost happened.\nUse e.preventDefault() to prevent cell focus change."
      },
      "complexType": {
        "original": "FocusedData|null",
        "resolved": "{ model: any; cell: Cell; colType: DimensionCols; rowType: DimensionRows; column?: ColumnRegular; }",
        "references": {
          "FocusedData": {
            "location": "import",
            "path": "./viewport.service"
          }
        }
      }
    }, {
      "method": "beforesourceset",
      "name": "beforesourceset",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before data apply.\nYou can override data source here"
      },
      "complexType": {
        "original": "{\n    type: RevoGrid.DimensionRows;\n    source: RevoGrid.DataType[];\n  }",
        "resolved": "{ type: DimensionRows; source: DataType[]; }",
        "references": {
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "aftersourceset",
      "name": "aftersourceset",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "After rows updated"
      },
      "complexType": {
        "original": "{\n    type: RevoGrid.DimensionRows;\n    source: RevoGrid.DataType[];\n  }",
        "resolved": "{ type: DimensionRows; source: DataType[]; }",
        "references": {
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "beforecolumnsset",
      "name": "beforecolumnsset",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before column update"
      },
      "complexType": {
        "original": "ColumnCollection",
        "resolved": "{ columns: ColumnItems; columnGrouping: ColumnGrouping; maxLevel: number; sort: Record<ColumnProp, ColumnRegular>; }",
        "references": {
          "ColumnCollection": {
            "location": "import",
            "path": "../../services/column.data.provider"
          }
        }
      }
    }, {
      "method": "beforecolumnapplied",
      "name": "beforecolumnapplied",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before column applied but after column set gathered and viewport updated"
      },
      "complexType": {
        "original": "ColumnCollection",
        "resolved": "{ columns: ColumnItems; columnGrouping: ColumnGrouping; maxLevel: number; sort: Record<ColumnProp, ColumnRegular>; }",
        "references": {
          "ColumnCollection": {
            "location": "import",
            "path": "../../services/column.data.provider"
          }
        }
      }
    }, {
      "method": "aftercolumnsset",
      "name": "aftercolumnsset",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Column updated"
      },
      "complexType": {
        "original": "{\n    columns: ColumnCollection;\n    order: Record<RevoGrid.ColumnProp, 'asc' | 'desc'>;\n  }",
        "resolved": "{ columns: ColumnCollection; order: Record<ColumnProp, \"desc\" | \"asc\">; }",
        "references": {
          "ColumnCollection": {
            "location": "import",
            "path": "../../services/column.data.provider"
          },
          "Record": {
            "location": "global"
          },
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "beforefilterapply",
      "name": "beforefilterapply",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before filter applied to data source\nUse e.preventDefault() to prevent cell focus change\nUpdate @collection if you wish to change filters"
      },
      "complexType": {
        "original": "{ collection: FilterCollection }",
        "resolved": "{ collection: FilterCollection; }",
        "references": {
          "FilterCollection": {
            "location": "import",
            "path": "../../plugins/filter/filter.plugin"
          }
        }
      }
    }, {
      "method": "beforefiltertrimmed",
      "name": "beforefiltertrimmed",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before filter trimmed values\nUse e.preventDefault() to prevent value trimming and filter apply\nUpdate @collection if you wish to change filters\nUpdate @itemsToFilter if you wish to filter indexes of trimming"
      },
      "complexType": {
        "original": "{ collection: FilterCollection; itemsToFilter: Record<number, boolean> }",
        "resolved": "{ collection: FilterCollection; itemsToFilter: Record<number, boolean>; }",
        "references": {
          "FilterCollection": {
            "location": "import",
            "path": "../../plugins/filter/filter.plugin"
          },
          "Record": {
            "location": "global"
          }
        }
      }
    }, {
      "method": "beforetrimmed",
      "name": "beforetrimmed",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before trimmed values\nUse e.preventDefault() to prevent value trimming\nUpdate @trimmed if you wish to filter indexes of trimming"
      },
      "complexType": {
        "original": "{ trimmed: Record<number, boolean>; trimmedType: string; type: string }",
        "resolved": "{ trimmed: Record<number, boolean>; trimmedType: string; type: string; }",
        "references": {
          "Record": {
            "location": "global"
          }
        }
      }
    }, {
      "method": "aftertrimmed",
      "name": "aftertrimmed",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Notify trimmed applied"
      },
      "complexType": {
        "original": "any",
        "resolved": "any",
        "references": {}
      }
    }, {
      "method": "viewportscroll",
      "name": "viewportscroll",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Triggered when view port scrolled"
      },
      "complexType": {
        "original": "RevoGrid.ViewPortScrollEvent",
        "resolved": "{ dimension: DimensionType; coordinate: number; delta?: number; }",
        "references": {
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "beforeexport",
      "name": "beforeexport",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before export\nUse e.preventDefault() to prevent export\nReplace data in Event in case you want to modify it in export"
      },
      "complexType": {
        "original": "DataInput",
        "resolved": "{ data: DataType[]; } & ColSource",
        "references": {
          "DataInput": {
            "location": "import",
            "path": "../../plugins/export/types"
          }
        }
      }
    }, {
      "method": "beforeeditstart",
      "name": "beforeeditstart",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "Before edit started\nUse e.preventDefault() to prevent edit"
      },
      "complexType": {
        "original": "Edition.BeforeSaveDataDetails",
        "resolved": "{ prop: ColumnProp; model: DataType; val?: string; rowIndex: number; type: DimensionRows; }",
        "references": {
          "Edition": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }, {
      "method": "aftercolumnresize",
      "name": "aftercolumnresize",
      "bubbles": true,
      "cancelable": true,
      "composed": true,
      "docs": {
        "tags": [],
        "text": "After column resize\nGet resized columns"
      },
      "complexType": {
        "original": "Record<RevoGrid.ColumnProp, RevoGrid.ColumnRegular>",
        "resolved": "{ [x: string]: ColumnRegular; [x: number]: ColumnRegular; }",
        "references": {
          "Record": {
            "location": "global"
          },
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        }
      }
    }]; }
  static get methods() { return {
    "refresh": {
      "complexType": {
        "signature": "(type?: RevoGrid.DimensionRows | 'all') => Promise<void>",
        "parameters": [{
            "tags": [],
            "text": ""
          }],
        "references": {
          "Promise": {
            "location": "global"
          },
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        },
        "return": "Promise<void>"
      },
      "docs": {
        "text": "Refreshes data viewport.\nCan be specific part as rgRow or pinned rgRow or 'all' by default.",
        "tags": []
      }
    },
    "scrollToRow": {
      "complexType": {
        "signature": "(coordinate?: number) => Promise<void>",
        "parameters": [{
            "tags": [],
            "text": ""
          }],
        "references": {
          "Promise": {
            "location": "global"
          }
        },
        "return": "Promise<void>"
      },
      "docs": {
        "text": "Scrolls view port to specified rgRow index",
        "tags": []
      }
    },
    "scrollToColumnIndex": {
      "complexType": {
        "signature": "(coordinate?: number) => Promise<void>",
        "parameters": [{
            "tags": [],
            "text": ""
          }],
        "references": {
          "Promise": {
            "location": "global"
          }
        },
        "return": "Promise<void>"
      },
      "docs": {
        "text": "Scrolls view port to specified column index",
        "tags": []
      }
    },
    "scrollToColumnProp": {
      "complexType": {
        "signature": "(prop: RevoGrid.ColumnProp) => Promise<void>",
        "parameters": [{
            "tags": [],
            "text": ""
          }],
        "references": {
          "Promise": {
            "location": "global"
          },
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        },
        "return": "Promise<void>"
      },
      "docs": {
        "text": "Scrolls view port to specified column prop",
        "tags": []
      }
    },
    "updateColumns": {
      "complexType": {
        "signature": "(cols: RevoGrid.ColumnRegular[]) => Promise<void>",
        "parameters": [{
            "tags": [],
            "text": ""
          }],
        "references": {
          "Promise": {
            "location": "global"
          },
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        },
        "return": "Promise<void>"
      },
      "docs": {
        "text": "Update columns",
        "tags": []
      }
    },
    "addTrimmed": {
      "complexType": {
        "signature": "(trimmed: Record<number, boolean>, trimmedType?: string, type?: RevoGrid.DimensionRows) => Promise<CustomEvent<{ trimmed: Record<number, boolean>; trimmedType: string; type: string; }>>",
        "parameters": [{
            "tags": [],
            "text": ""
          }, {
            "tags": [],
            "text": ""
          }, {
            "tags": [],
            "text": ""
          }],
        "references": {
          "Promise": {
            "location": "global"
          },
          "CustomEvent": {
            "location": "global"
          },
          "Record": {
            "location": "global"
          },
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        },
        "return": "Promise<CustomEvent<{ trimmed: Record<number, boolean>; trimmedType: string; type: string; }>>"
      },
      "docs": {
        "text": "Add trimmed by type",
        "tags": []
      }
    },
    "scrollToCoordinate": {
      "complexType": {
        "signature": "(cell: Partial<Selection.Cell>) => Promise<void>",
        "parameters": [{
            "tags": [],
            "text": ""
          }],
        "references": {
          "Promise": {
            "location": "global"
          },
          "Partial": {
            "location": "global"
          },
          "Selection": {
            "location": "import",
            "path": "../../interfaces"
          }
        },
        "return": "Promise<void>"
      },
      "docs": {
        "text": "Scrolls view port to coordinate",
        "tags": []
      }
    },
    "setCellEdit": {
      "complexType": {
        "signature": "(rgRow: number, prop: RevoGrid.ColumnProp, rowSource?: RevoGrid.DimensionRows) => Promise<void>",
        "parameters": [{
            "tags": [],
            "text": ""
          }, {
            "tags": [],
            "text": ""
          }, {
            "tags": [],
            "text": ""
          }],
        "references": {
          "Promise": {
            "location": "global"
          },
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        },
        "return": "Promise<void>"
      },
      "docs": {
        "text": "Bring cell to edit mode",
        "tags": []
      }
    },
    "registerVNode": {
      "complexType": {
        "signature": "(elements: VNode[]) => Promise<void>",
        "parameters": [{
            "tags": [],
            "text": ""
          }],
        "references": {
          "Promise": {
            "location": "global"
          },
          "VNode": {
            "location": "import",
            "path": "@stencil/core"
          }
        },
        "return": "Promise<void>"
      },
      "docs": {
        "text": "Register new virtual node inside of grid\nUsed for additional items creation such as plugin elements",
        "tags": []
      }
    },
    "getSource": {
      "complexType": {
        "signature": "(type?: RevoGrid.DimensionRows) => Promise<RevoGrid.DataType[]>",
        "parameters": [{
            "tags": [],
            "text": ""
          }],
        "references": {
          "Promise": {
            "location": "global"
          },
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        },
        "return": "Promise<DataType[]>"
      },
      "docs": {
        "text": "Get data from source",
        "tags": []
      }
    },
    "getVisibleSource": {
      "complexType": {
        "signature": "(type?: RevoGrid.DimensionRows) => Promise<any[]>",
        "parameters": [{
            "tags": [{
                "text": "type - type of source",
                "name": "param"
              }],
            "text": "- type of source"
          }],
        "references": {
          "Promise": {
            "location": "global"
          },
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        },
        "return": "Promise<any[]>"
      },
      "docs": {
        "text": "Get data from visible part of source\nTrimmed/filtered rows will be excluded",
        "tags": [{
            "name": "param",
            "text": "type - type of source"
          }]
      }
    },
    "getSourceStore": {
      "complexType": {
        "signature": "(type?: RevoGrid.DimensionRows) => Promise<RowSource>",
        "parameters": [{
            "tags": [{
                "text": "type - type of source",
                "name": "param"
              }],
            "text": "- type of source"
          }],
        "references": {
          "Promise": {
            "location": "global"
          },
          "RowSource": {
            "location": "import",
            "path": "../data/columnService"
          },
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        },
        "return": "Promise<RowSource>"
      },
      "docs": {
        "text": "Provides access to rows internal store observer\nCan be used for plugin support",
        "tags": [{
            "name": "param",
            "text": "type - type of source"
          }]
      }
    },
    "getColumnStore": {
      "complexType": {
        "signature": "(type?: RevoGrid.DimensionCols) => Promise<ColumnSource>",
        "parameters": [{
            "tags": [{
                "text": "type - type of column",
                "name": "param"
              }],
            "text": "- type of column"
          }],
        "references": {
          "Promise": {
            "location": "global"
          },
          "ColumnSource": {
            "location": "import",
            "path": "../data/columnService"
          },
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        },
        "return": "Promise<ColumnSource>"
      },
      "docs": {
        "text": "Provides access to column internal store observer\nCan be used for plugin support",
        "tags": [{
            "name": "param",
            "text": "type - type of column"
          }]
      }
    },
    "updateColumnSorting": {
      "complexType": {
        "signature": "(column: RevoGrid.ColumnRegular, index: number, order: 'asc' | 'desc', additive: boolean) => Promise<RevoGrid.ColumnRegular>",
        "parameters": [{
            "tags": [{
                "text": "column - full column details to update",
                "name": "param"
              }],
            "text": "- full column details to update"
          }, {
            "tags": [{
                "text": "index - virtual column index",
                "name": "param"
              }],
            "text": "- virtual column index"
          }, {
            "tags": [{
                "text": "order - order to apply",
                "name": "param"
              }],
            "text": "- order to apply"
          }, {
            "tags": [],
            "text": ""
          }],
        "references": {
          "Promise": {
            "location": "global"
          },
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        },
        "return": "Promise<ColumnRegular>"
      },
      "docs": {
        "text": "Update column sorting",
        "tags": [{
            "name": "param",
            "text": "column - full column details to update"
          }, {
            "name": "param",
            "text": "index - virtual column index"
          }, {
            "name": "param",
            "text": "order - order to apply"
          }]
      }
    },
    "clearSorting": {
      "complexType": {
        "signature": "() => Promise<void>",
        "parameters": [],
        "references": {
          "Promise": {
            "location": "global"
          }
        },
        "return": "Promise<void>"
      },
      "docs": {
        "text": "Clears column sorting",
        "tags": []
      }
    },
    "getColumns": {
      "complexType": {
        "signature": "() => Promise<RevoGrid.ColumnRegular[]>",
        "parameters": [],
        "references": {
          "Promise": {
            "location": "global"
          },
          "RevoGrid": {
            "location": "import",
            "path": "../../interfaces"
          }
        },
        "return": "Promise<ColumnRegular[]>"
      },
      "docs": {
        "text": "Receive all columns in data source",
        "tags": []
      }
    },
    "clearFocus": {
      "complexType": {
        "signature": "() => Promise<void>",
        "parameters": [],
        "references": {
          "Promise": {
            "location": "global"
          }
        },
        "return": "Promise<void>"
      },
      "docs": {
        "text": "Clear current grid focus",
        "tags": []
      }
    },
    "getPlugins": {
      "complexType": {
        "signature": "() => Promise<RevoPlugin.Plugin[]>",
        "parameters": [],
        "references": {
          "Promise": {
            "location": "global"
          },
          "RevoPlugin": {
            "location": "import",
            "path": "../../interfaces"
          }
        },
        "return": "Promise<Plugin[]>"
      },
      "docs": {
        "text": "Get all active plugins instances",
        "tags": []
      }
    },
    "getFocused": {
      "complexType": {
        "signature": "() => Promise<FocusedData | null>",
        "parameters": [],
        "references": {
          "Promise": {
            "location": "global"
          },
          "FocusedData": {
            "location": "import",
            "path": "./viewport.service"
          }
        },
        "return": "Promise<FocusedData>"
      },
      "docs": {
        "text": "Get all active plugins instances",
        "tags": []
      }
    }
  }; }
  static get elementRef() { return "element"; }
  static get watchers() { return [{
      "propName": "columns",
      "methodName": "columnChanged"
    }, {
      "propName": "theme",
      "methodName": "themeChanged"
    }, {
      "propName": "source",
      "methodName": "dataChanged"
    }, {
      "propName": "pinnedBottomSource",
      "methodName": "dataBottomChanged"
    }, {
      "propName": "pinnedTopSource",
      "methodName": "dataTopChanged"
    }, {
      "propName": "rowDefinitions",
      "methodName": "rowDefChanged"
    }, {
      "propName": "trimmedRows",
      "methodName": "trimmedRowsChanged"
    }, {
      "propName": "grouping",
      "methodName": "groupingChanged"
    }, {
      "propName": "stretch",
      "methodName": "applyStretch"
    }]; }
  static get listeners() { return [{
      "name": "internalRowDragStart",
      "method": "onRowDragStarted",
      "target": undefined,
      "capture": false,
      "passive": false
    }, {
      "name": "internalRowDragEnd",
      "method": "onRowDragEnd",
      "target": undefined,
      "capture": false,
      "passive": false
    }, {
      "name": "internalRowDrag",
      "method": "onRowDrag",
      "target": undefined,
      "capture": false,
      "passive": false
    }, {
      "name": "internalRowMouseMove",
      "method": "onRowMouseMove",
      "target": undefined,
      "capture": false,
      "passive": false
    }, {
      "name": "internalCellEdit",
      "method": "onBeforeEdit",
      "target": undefined,
      "capture": false,
      "passive": false
    }, {
      "name": "internalRangeDataApply",
      "method": "onBeforeRangeEdit",
      "target": undefined,
      "capture": false,
      "passive": false
    }, {
      "name": "internalSelectionChanged",
      "method": "onRangeChanged",
      "target": undefined,
      "capture": false,
      "passive": false
    }, {
      "name": "initialRowDropped",
      "method": "onRowDropped",
      "target": undefined,
      "capture": false,
      "passive": false
    }, {
      "name": "initialHeaderClick",
      "method": "onHeaderClick",
      "target": undefined,
      "capture": false,
      "passive": false
    }, {
      "name": "internalFocusCell",
      "method": "onCellFocus",
      "target": undefined,
      "capture": false,
      "passive": false
    }]; }
}