import { EventEmitter } from '../../stencil-public-runtime';
import { Table, TableState, ColumnDef, PaginationState, ColumnSort, RowSelectionState, ColumnFilter, VisibilityState, ExpandedState } from '@tanstack/table-core';
import { LANGUAGE_TYPES } from "../../managers/language/constants";
import { MediaType, Size } from "../../managers/mediaType/constants";
import { CELL_CONTENT_TYPES, DATA_TABLE_CELL_CONTENT_TYPES, DATA_TABLE_MULTI_SORT_EVENT_TYPES, DATA_TABLE_PAGINATION_TYPES, DATA_TABLE_SELECTION_TYPES, DATA_TABLE_TABLE_STYLES, DATA_TABLE_TYPES, TYPES } from "../../utils/enums";
import { SdxButtonProps } from "../../utils/types";
import { RowSelectionEventProps } from './utils/types';
export declare class SlDataTable {
    private dataSize;
    private showStickyBulk;
    private resetPagination;
    private disconnectLanguageObserver;
    private disconnectWidthObserver;
    private theadRandomUUID;
    private handleRowClickCallback;
    private canClickOnRowCallback;
    private paginationChangeCallback;
    private sortingChangeCallback;
    private expandChangeCallback;
    private activateRowSelectionCallback;
    private rowSelectionChangeCallback;
    private dataSizeChangeCallback;
    /** Adapt look and feel to table or card */
    type: TYPES | DATA_TABLE_TYPES | `${DATA_TABLE_TYPES}`;
    /** Adapt look and feel of the table */
    tableStyle: DATA_TABLE_TABLE_STYLES | `${DATA_TABLE_TABLE_STYLES}`;
    /**
     * @deprecated Since version 1.15.0. Use lang instead.
     */
    language: LANGUAGE_TYPES | `${LANGUAGE_TYPES}`;
    columns: ColumnDef<object>[];
    data: object[];
    /** Function called when click is done on row */
    handleRowClick?: (event: globalThis.Event, dataRow: object, index: number) => void;
    /** Filter which row is clickable */
    canClickOnRow?: (dataRow: object) => boolean;
    /** Show header on UI */
    showHeader: boolean;
    /** Show pagination on UI. (Pagination is not disabled if set at false) */
    showPagination: boolean;
    /** Enable/Disable pagination */
    activatePagination: boolean;
    /** Enables manual pagination for the table. If this is true, you will be expected to paginate your data before it is passed to the table. This is useful if you are doing server-side sorting. */
    manualPagination: boolean;
    /** Function called when pagination state is updated */
    paginationChange?: (data: PaginationState) => void;
    /** Number of elements displayed per page if pagination is activated */
    pageSize: number;
    /** Total of elements. Use that when manual pagination (server side) is activated */
    totalOfElements: number;
    /** Pagination type */
    paginationType: DATA_TABLE_PAGINATION_TYPES | `${DATA_TABLE_PAGINATION_TYPES}`;
    /** Enable/Disable sorting */
    activateSorting: boolean;
    /** Enables manual sorting for the table. If this is true, you will be expected to sort your data before it is passed to the table. This is useful if you are doing server-side sorting. */
    manualSorting: boolean;
    /** Function called when sorting state is updated */
    sortingChange?: (data: ColumnSort[]) => void;
    /** Initial sorting state */
    sorting?: ColumnSort[];
    /** Enable column hiding */
    activateHiding: boolean;
    /** Enable column visibility (x must be the index of the row) */
    columnVisibility?: VisibilityState;
    /** Enable/Disable selection */
    activateRowSelection: boolean | ((dataRow: object) => boolean);
    /** Function called when row selection state is updated */
    rowSelectionChange?: (data: object[]) => void;
    /** Function called when data length is updated */
    dataSizeChange?: (size: number) => void;
    /** Init or update row selection state (x must be the index of the row) */
    rowSelection?: RowSelectionState;
    /** Define type of selection */
    selectionType: DATA_TABLE_SELECTION_TYPES | `${DATA_TABLE_SELECTION_TYPES}`;
    /** Enable/Disable filters */
    activateFilters: boolean;
    /** Global filter state */
    globalFilter?: string | string[];
    /** Enable/Disable highligh search value  */
    activateHighlightSearch: boolean;
    /** Highligh search value */
    highlightSearch?: string | string[];
    /** Column filters state */
    columnFilters?: ColumnFilter[];
    /** Enable/Disable expand */
    activateExpand: boolean;
    /** Initial expanded state (x must be the index of the row) */
    expanded: ExpandedState;
    /** EXPERIMENTAL : Enables manual expanding for the table. If this is true, you will be expected to provide expanded data when your data before it is passed to the table. This is useful if you are doing server-side expanding. */
    manualExpanding: boolean;
    /** If true expanded rows will be paginated along with the rest of the table (which means expanded rows may span multiple pages). If false expanded rows will not be considered for pagination (which means expanded rows will always render on their parents page. This also means more rows will be rendered than the set page size) */
    paginateExpandedRows: boolean;
    /** Function called when expanded state is updated */
    expandChange?: (data: ExpandedState) => void;
    /** Map widows size to media types */
    mapSizeToMediaTypes: MediaType;
    /** By default text is correctly displayed in two lines with wrapping inside cells. It's possible to disable this styling. */
    disableStylingOnCells: boolean;
    /** Enable and add button on bulk bar */
    bulkButtonsProps: SdxButtonProps[];
    /**
     * Determines the rendering type of cell's values. It can force the display as:
        - 'plain_text': Disregards any HTML and displays cell value as plain text.
        - 'sanitized_limited_html': Renders HTML sanitized securely for limited tags and attributes.
        - 'sanitized_full_html': Renders HTML sanitized securely for richer content, all tags and attributes.
     */
    cellsRenderType: CELL_CONTENT_TYPES | DATA_TABLE_CELL_CONTENT_TYPES | `${DATA_TABLE_CELL_CONTENT_TYPES}`;
    /** The maximum height of a row is not anymore fixed. The text in a cell is not anymore limited to two lines. */
    dynamicRowHeight: boolean;
    /** The disableSortingRemoval change the behavior of storing step on column. More info in documentation. */
    disableSortingRemoval: boolean;
    /** By default, there is a limit to the number of columns that can be sorted at once of 3. You can change this value if it's needed. */
    maxMultiSortColCount: number;
    /** By default, the shift key is used to trigger multi-sorting. You can change this behavior. */
    multiSortEventType: DATA_TABLE_MULTI_SORT_EVENT_TYPES | `${DATA_TABLE_MULTI_SORT_EVENT_TYPES}`;
    /** Event called when click is done on row */
    handleRowClickEvent: EventEmitter<RowSelectionEventProps>;
    /** Event called when pagination state is updated */
    paginationChangeEvent: EventEmitter<PaginationState>;
    /** Event called when sorting state is updated */
    sortingChangeEvent: EventEmitter<ColumnSort[]>;
    /** Event called when expanded state is updated */
    expandChangeEvent: EventEmitter<ExpandedState>;
    /** Event called when row selection state is updated */
    rowSelectionChangeEvent: EventEmitter<object[]>;
    /** Event called when data length is updated */
    dataSizeChangeEvent: EventEmitter<number>;
    /** Show selection on UI. (Selection is not disabled if set at false) */
    showSelection: boolean;
    table: Table<object>;
    tableState: TableState | any;
    /** Manage windows size modification */
    delayedMatchMediaId: any;
    /** List of different windows sizes */
    sizesList: Size[];
    /** Internal language coming from lang html attribute */
    internalLanguage: LANGUAGE_TYPES;
    el: HTMLSlDataTableElement;
    /** Activate loading internally if sorting is activated and in server side mode */
    serverSideSortingLoading: boolean | string;
    /** Activate loading internally if pagination is activated and in server side mode */
    serverSidePaginationLoading: boolean;
    watchCreateTableHandler(): void;
    watchColumnsHandler(): void;
    watchDataHandler(newValue: object[], oldValue: object[]): void;
    watchTableStateHandler(): void;
    watchTotalOfElementsHandler(newValue: number, oldValue: number): void;
    watchLanguageHandler(): void;
    watchDisableStylingOnCellsHandler(): void;
    watchCellsRenderTypeHandler(): void;
    watchDynamicRowHeightHandler(): void;
    watchTypeHandler(): void;
    watchSortingHandler(): void;
    watchExpandedHandler(): void;
    watchColumnVisibilityHandler(): void;
    watchGlobalFilterHandler(): void;
    watchColumnFiltersHandler(): void;
    watchRowSelectionHandler(): void;
    handleRowClickChanged(): void;
    canClickOnRowChanged(): void;
    paginationChangeChanged(): void;
    focusCallbackChanged(): void;
    expandCallbackChanged(): void;
    activateRowSelectionChanged(): void;
    rowSelectionChangeChanged(): void;
    dataSizeChangeChanged(): void;
    resetSelection(): Promise<void>;
    resetServerSideLoading(): Promise<void>;
    constructor();
    /**
     * Render the table for the first time.
     * The rendering will only happen when the promise will be resolved.
     */
    componentWillLoad(): void;
    componentDidLoad(): void;
    componentDidUpdate(): void;
    componentShouldUpdate(newVal: any, oldVal: any, propName: string): boolean;
    disconnectedCallback(): void;
    private setHandleRowClickCallback;
    private setCanClickOnRowCallback;
    private setPaginationChangeCallback;
    private setSortingChangeCallback;
    private setExpandChangeCallback;
    private setActivateRowSelectionCallback;
    private setRowSelectionChangeCallback;
    private setDataSizeChangeCallback;
    /**
     * Update language from observer
     * @param language
     */
    private updateSizeHeaderGroupObserver;
    /**
     * Update language from observer
     * @param language
     */
    private updateInternalLanguage;
    /**
     * Update when data size change
     */
    private onDateSizeChange;
    /**
     * Update start when table state change
     */
    private onStateChange;
    /**
     * Activate or not
     */
    private activateSelection;
    /**
     * Update start when table selection state change
     */
    private onRowSelectionChange;
    /**
     * Update start when table pagination state change
     */
    private onPaginationChange;
    /**
     * Update start when table sorting state change
     */
    private onSortingChange;
    private onPreSortingChange;
    /**
     * Update start when table expand state change
     */
    private onExpandedChange;
    /**
     * Update width of header groups when the header is resizing
     */
    private sizeHeaderGroupsChange;
    /**
     * Create a new table instance based on the component properties.
     */
    private generateOptions;
    /**
     * Update when data or columns change
     */
    private updateDataOrColumnsTable;
    /**
     * Reset pagination if the total of elements is reduced with server side rendering
     * @param isReduced
     */
    private updateResetPaginationIfNeeded;
    private createTable;
    private setOptions;
    /**
     * init the mediaName if the window of the size name.
     */
    private initMediaMediaSizeName;
    /**
     * Check if the event is a multi sort event
     * @param e
     */
    private isMultiSortEvent;
    /**
     * Update the mediaName if the window of the size is changing. Add a delay to avoid multiple call.
     * @param q
     */
    private handleMatchMediaChange;
    /** Hide the sticky bulk */
    private hideStickyBulk;
    render(): any;
}