import { CurrencyPipe, DatePipe, DecimalPipe } from '@angular/common';
import { HttpClient, HttpErrorResponse, HttpParams } from '@angular/common/http';
import { AfterViewInit, ChangeDetectorRef, EventEmitter, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
import { ControlValueAccessor, FormControl, NgControl } from '@angular/forms';
import { MatDialog } from '@angular/material/dialog';
import { MatIconRegistry } from '@angular/material/icon';
import { MatPaginator } from '@angular/material/paginator';
import { MatSort } from '@angular/material/sort';
import { MatTable } from '@angular/material/table';
import { DomSanitizer, SafeHtml, SafeUrl } from '@angular/platform-browser';
import { TranslateService } from '@ngx-translate/core';
import { BehaviorSubject, Observable } from 'rxjs';
import { ID } from '../core';
import { SCBaseComponent } from '../core/sc-basecomponent.component';
import { SCCoreService } from '../core/sc-core.service';
import { DisplayByPipe } from '../pipes/displayBy';
import { NumbersReplacePipe } from '../pipes/numbers-replace';
import { ValueByPipe } from '../pipes/valueBy';
import { SCCustomInputsDialogService } from '../sc-custom-inputs-dialog/service/sc-custom-inputs-dialog.service';
import { SCInputConfig, SCInputType } from '../sc-input';
import { SCDataUrlConfig, SCSelectConfig } from '../sc-select';
import { SCTableService } from './sc-table.service';
import { Options } from '@angular-slider/ngx-slider';
import * as i0 from "@angular/core";
export interface SCTableConfig {
    paginationConfig: SCTablePaginationConfig;
    sortConfig: SCTableSortConfig;
    searchConfig: SCTableSearchConfig;
    filterConfig?: SCTableFilterConfig;
    dataConfig?: SCTableDataConfig;
    selectionConfig?: SCTableSelectionConfig;
    displayHeadersConfig?: SCSelectDisplayHeadersConfig;
}
export interface SCSelectDisplayHeadersConfig {
    active: boolean;
    usedTableHeaders?: string[];
    position?: 'filter-menu' | 'default';
}
export interface SCTableUrlConfig {
    tableDataUrl?: string;
    tableConfigUrl?: string;
    tableDefaultConfigUrl?: string;
    tableHeadersUrl?: string;
    tableHeadersDisplayedUrl?: string;
    tableActionsUrl?: string;
    footerTableHeadersUrl?: string;
    footerTableHeadersDisplayedUrl?: string;
    footerTableDataUrl?: string;
    dataUrl?: string;
    httpParams?: {
        key: string;
        values: string[];
    }[];
    cacheConfig?: {
        cacheConfigTime?: number;
        cacheDataTime?: number;
    };
}
export interface SCTableStorageConfig {
    storageKey: string;
    useLocalStorage?: boolean;
    configHelper?: TableConfigHelper;
    storageUrlConfig?: SCTableStorageUrlConfig;
    selectedStorageConfigString?: SCTableConfigString;
}
export interface SCTableConfigString {
    id: ID;
    table_config_string: string;
    name: string;
    storage_key: string;
}
export interface SCTableStorageUrlConfig {
    urlConfig: SCDataUrlConfig;
    displayBy: string;
    compareBy: string;
    valueBy: string;
    lazyLoading: boolean;
    saveConfigStringsUrl: string;
}
export interface SCTableUrlData {
    tableHeaders?: SCTableHeader[];
    tableHeadersDisplayed?: string[];
    tableConfig?: SCTableConfig;
    tableDefaultConfig?: SCTableConfig;
    tableActions?: SCTableAction[];
    tableData?: any[];
    footerTableHeaders?: SCTableHeader[];
    footerTableHeadersDisplayed?: string[];
    footerTableData?: any;
}
export interface SCTablePaginationConfig {
    length: number;
    pageSize: number;
    index: number;
    active?: boolean;
}
export interface SCTableSortConfig {
    index: string;
    direction: 'asc' | 'desc' | '';
    active?: boolean;
}
export interface SCTableSearchConfig {
    search: string;
    active: boolean;
    searchFieldAppearance?: 'legacy' | 'standard' | 'fill' | 'outline';
    searchFieldFloatLabel?: 'always' | 'never' | 'auto';
    searchFields?: SCTableSearchField[];
}
export interface SCTableFilterConfig {
    filtersActive?: boolean;
    quickfilters?: SCTableFilter[];
    filters?: SCTableFilter[];
    categories?: SCTableFilterCategory[];
    filterDependencies?: SCTableFilterDependency[];
}
export interface SCTableFilterDependency {
    filterIndexes: string[];
    data: SCTableFilterData[];
    selected: string;
    _dependencyPos?: 'single' | 'start' | 'mid' | 'end';
}
export interface SCTableDataConfig {
    showEmptyDataMessage?: boolean;
    emptyDataMessage?: string;
    locale?: string;
}
export interface SCTableSelectionConfig {
    active: boolean;
    valueBy: string;
    compareBy: string;
    selectionType: 'TOGGLE' | 'ARRAY' | 'SINGLE_SELECT';
    toggleOnRowClick: boolean;
}
export interface SCTableFilterCategory {
    index: string;
    label: string;
    filters: SCTableFilter[];
}
export interface SCTableFilter<T = any> {
    index: string;
    label: string;
    type: 'slider' | 'sliderrange' | 'select' | 'multiselect' | 'datetime' | 'date' | 'toggle' | 'multitoggle' | 'checkbox' | 'input' | 'inputrange';
    subType?: SCInputType;
    labelAlt?: string;
    prefixText?: string;
    suffixText?: string;
    data?: SCTableFilterData[];
    dataSource?: Observable<SCTableFilterData[] | any>;
    filterBy?: string;
    valueBy?: string;
    displayBy?: string;
    compareBy?: string;
    displayByArray?: string;
    selected?: T | Array<T>;
    options?: {
        compareWith?: '<' | '>' | '<=' | '>=' | '==';
    };
    additionalOptions?: Options;
    isLazyLoading?: boolean;
    searchControl?: FormControl;
    ignoreFilter?: boolean;
    deletable?: boolean;
    selectIfSingleData?: boolean;
    preloadData?: boolean;
    defaultValue?: T;
    urlConfig?: SCDataUrlConfig;
    httpParams?: {
        key: string;
        values: string[];
    }[];
    getValueBy?: string;
    getLabelBy?: string;
    getIconBy?: string;
    forceSentFilter?: boolean;
    _dependency?: SCTableFilterDependency;
}
export interface SCTableFilterData<T = any> {
    value: T;
    label?: string;
    icon?: string;
    matIcon?: string;
    fontIcon?: string;
}
export interface SCTableFilterAction {
    index: string;
    label?: string;
    actionType?: 'SET_CONFIG' | 'RESET_CONFIG' | 'TOGGLE_FILTER_ACTIVE';
    icon?: string;
    iconType?: 'MAT' | 'SVG' | 'FONT';
}
export declare type SCTableHeaderType = 'string' | 'number' | 'date' | 'currency' | 'boolean' | 'percent' | 'input' | 'select' | 'autocomplete';
export interface SCTableHeaderBasic {
    title?: string;
    displayBy?: string;
    displayArrayBy?: string;
    concatWith?: string;
    concatArrayWith?: string;
    type?: SCTableHeaderType;
    decimalInfo?: string;
    htmlTemplate?: string;
    variables?: SCTableHeaderVariable[];
    booleanValues?: {
        displayTrue: string;
        displayFalse: string;
    };
    inputConfig?: {
        dataValueBy: string;
        scInputConfig: SCInputConfig;
    };
    selectConfig?: {
        dataValueBy: string;
        scSelectConfig: SCSelectConfig;
        data?: any[];
        urlConfigParams?: {
            key: string;
            valueBy?: string;
        }[];
    };
    inputOptions?: {
        disabled?: boolean;
        disabledConditions?: SCTableCondition[];
        checkConditionsOnInit?: boolean;
    };
    link?: {
        url?: string;
        style?: string;
        styles?: {
            style: string;
            conditions?: SCTableCondition[];
        }[];
        inlineStyles?: {
            style: string;
            conditions?: SCTableCondition[];
            variables: SCTableHeaderVariable[];
        }[];
        variables?: SCTableHeaderVariable[];
    };
    tooltip?: SCTableHeaderTooltip;
    isInput?: boolean;
}
export interface SCTableHeader extends SCTableHeaderBasic {
    index: string;
    sticky?: boolean;
    stickyEnd?: boolean;
    img?: SCTableHeaderImg;
    icon?: SCTableHeaderIcon;
    icons?: SCTableHeaderIcon[];
    iconConfigs?: {
        displayArrayBy?: string;
        icon: SCTableHeaderIcon;
    }[];
    truncateAfter?: number;
    dateFormat?: string;
    currencyCodeDisplayBy?: string;
    currencyCode?: string;
    align?: 'left' | 'right';
    style?: string;
    styles?: {
        style: string;
        conditions?: SCTableCondition[];
    }[];
    inlineStyles?: {
        style: string;
        conditions?: SCTableCondition[];
        variables: SCTableHeaderVariable[];
    }[];
    filters?: SCTableFilter[];
    filterCategories?: SCTableFilterCategory[];
    filterIndexes?: string[];
    filterCategoryIndexes?: SCTableHeaderFilterCategory[];
    disableSort?: boolean;
    disableSearch?: boolean;
    sortType?: 'alphanumerical';
    sortFunction?: (a: any, b: any) => 0 | 1 | -1;
    subtitle?: SCTableHeaderBasic;
    subtitles?: {
        disableSort?: boolean;
        index: string;
        title: string;
    }[];
    headerInlineStyle?: string;
    width?: string;
    /**
     * @deprecated These attributes should not be used
     */
    subtitleTitle?: string;
    /**
     * @deprecated These attributes should not be used
     */
    subtitleDisplayBy?: string;
    /**
     * @deprecated These attributes should not be used
     */
    subtitleDisplayArrayBy?: string;
    /**
     * @deprecated These attributes should not be used
     */
    subtitleConcatWith?: string;
    /**
     * @deprecated These attributes should not be used
     */
    subtitleConcatArrayWith?: string;
    /**
     * @deprecated These attributes should not be used
     */
    subtitleType?: 'string' | 'number' | 'date' | 'currency' | 'boolean';
    /**
     * @deprecated These attributes should not be used
     */
    subtitleHtmlTemplate?: string;
    /**
     * @deprecated These attributes should not be used
     */
    subtitleVariables?: SCTableHeaderVariable[];
    /**
     * @deprecated These attributes should not be used
     */
    subtitleBooleanValues?: {
        displayTrue: string;
        displayFalse: string;
    };
}
export interface SCTableHeaderTooltip {
    displayBy?: string;
}
export interface SCTableHeaderFilterCategory {
    index: string;
    filterIndexes?: string[];
}
export interface SCTableSearchField {
    index: string;
    label: string;
    searchBy?: string;
    concatWith?: string;
    type?: SCTableHeaderType;
    isActive: boolean;
}
export declare type SCTableConditionType = 'string' | 'number' | 'date' | 'currency' | 'boolean' | 'percent';
export interface SCTableConditionValue<T = any> {
    compare?: '==' | '<' | '>' | '<=' | '>=' | '!=' | 'contains' | 'excludes';
    value?: T;
    valueBy?: string;
}
export interface SCTableCondition<T = any> extends SCTableConditionValue {
    compareBy: string;
    value?: T;
    values?: SCTableConditionValue[];
    type?: SCTableConditionType;
}
export interface SCTableHeaderVariable {
    displayBy: string;
    concatWith?: string;
    variableKey: string;
}
export interface SCTablePermission {
    module_key: string;
    permission_key: string;
    permission: number;
}
export interface SCTableHeaderImg {
    useUrl?: boolean;
    url: string;
    style: 'square' | 'rounded';
    variables?: SCTableHeaderVariable[];
}
export interface SCTableHeaderIcon {
    icon?: string;
    matIcon?: string;
    fontIcon?: string;
    tooltip?: string;
    tooltipVariables?: SCTableHeaderVariable[];
    style?: string;
    styles?: {
        style: string;
        conditions?: SCTableCondition[];
    }[];
    variables?: SCTableHeaderVariable[];
    conditions?: SCTableCondition[];
    link?: {
        url?: string;
        style?: string;
        styles?: {
            style: string;
            conditions?: SCTableCondition[];
        }[];
        inlineStyles?: {
            style: string;
            conditions?: SCTableCondition[];
            variables: SCTableHeaderVariable[];
        }[];
        variables?: SCTableHeaderVariable[];
    };
}
export interface SCTableData<T = any> {
    data: T;
    selected: boolean;
    parsedActions: SCTableAction[];
    parsedData: SCTableDataParsed;
}
export interface SCTableDataParsed {
    [details: string]: SCTableDataParsedData;
}
export interface SCTableDataParsedData {
    display: string;
    displayHtml: SafeHtml;
    subtitleDisplay?: string;
    subtitleDisplayHtml?: SafeHtml;
    img?: SafeUrl;
    icon?: SCTableDataParsedDataIcon;
    icons?: SCTableDataParsedDataIcon[];
    style: string;
    inlineStyle: string;
    value?: any;
    urlConfig?: SCDataUrlConfig;
    data?: any[];
    link?: {
        url?: string;
        style: string;
        inlineStyle: string;
    };
    tooltip: string;
    disabled?: boolean;
}
export interface SCTableDataParsedDataIcon {
    icon?: string;
    fontIcon?: string;
    matIcon?: string;
    style?: string;
    tooltip?: string;
    link?: {
        url?: string;
        style: string;
        inlineStyle: string;
    };
}
export interface SCTableAction {
    index: string;
    label?: string;
    icon?: string;
    matIcon?: string;
    fontIcon?: string;
    conditions?: SCTableCondition[];
    permissions?: SCTablePermission[];
    dropdown?: SCTableAction[];
    tooltip?: string;
    tooltipPosition?: 'below' | 'above' | 'left' | 'right';
    tooltipShowDelay?: number;
    tooltipHideDelay?: number;
}
export interface SCTableActionClickedEvent<T = any> {
    action: SCTableAction;
    data: T;
    event: MouseEvent;
    currentIndex: number;
    totalIndex: number;
}
export interface SCTableRowClickedEvent<T = any> {
    data: SCTableData;
    event: MouseEvent;
    currentIndex: number;
    totalIndex: number;
    header: SCTableHeader;
    headerIndex: string;
}
export interface SCTableLinkClickedEvent<T = any> {
    data: SCTableData;
    event: MouseEvent;
    currentIndex: number;
    totalIndex: number;
    header: SCTableHeader;
    headerIndex: string;
}
export interface SCTableFilterActionClickedEvent {
    action: SCTableFilterAction;
    event: MouseEvent;
}
export interface SCTableSelectionChangedEvent {
    data: any;
    selected: boolean;
}
export interface SCTableValueChangedEvent {
    data: SCTableData;
    header: SCTableHeader;
}
export interface SCTableFilterChangedEvent {
    filter: SCTableFilter;
    /**
     * Boolean if changed in open Dialog
     */
    changedInDialog: boolean;
    /**
     * Boolean if changed from closing the dialog
     */
    changedFromDialog: boolean;
    category?: SCTableFilterCategory;
    filterLocation: 'quickfilters' | 'categories' | 'filters' | 'filterDependencies';
}
export interface SCTableSelectedConfigChangedEvent {
    selectedConfig: SCTableConfig;
    /**
     * Boolean if changed in open Dialog
     */
    changedInDialog: boolean;
    /**
     * Boolean if changed from closing the dialog
     */
    changedFromDialog: boolean;
}
export declare class TableConfigHelper {
    scTableConfig: TableConfigHelperConfig;
    constructor();
}
export declare class TableConfigHelperConfig {
    paginationConfig?: TableConfigHelperConfigPagination;
    sortConfig?: TableConfigHelperConfigSort;
    searchConfig?: TableConfigHelperConfigSearch;
    filterConfig?: TableConfigHelperConfigFilter;
    setSelectionEnabled?: boolean;
    displayHeadersConfig?: TableConfigHelperConfigDisplayHeaders;
    constructor();
}
export declare class TableConfigHelperConfigPagination {
    setLength?: boolean;
    setPageSize?: boolean;
    setIndex?: boolean;
    constructor();
}
export declare class TableConfigHelperConfigSort {
    setDirection?: boolean;
    setIndex?: boolean;
    constructor();
}
export declare class TableConfigHelperConfigSearch {
    setSearch?: boolean;
    setSearchFields?: boolean;
    specificSearchFields?: TableConfigHelperConfigSearchField[];
    constructor();
}
export declare class TableConfigHelperConfigSearchField {
    index: string;
}
export declare class TableConfigHelperConfigFilter {
    setQuickfilters?: boolean;
    setFilters?: boolean;
    setCategories?: boolean;
    setFiltersActive?: boolean;
    constructor();
}
export declare class TableConfigHelperConfigDisplayHeaders {
    setActive: boolean;
    setUsedHeaders: boolean;
    constructor();
}
export declare function compareConfigWithString(config: SCTableConfig, configString: string): boolean;
export declare function compareConfig(config: SCTableConfig, config2: SCTableConfig): boolean;
export declare function configToString(config: SCTableConfig): string;
export declare function tableHeadersToSearchFields(headers: SCTableHeader[]): SCTableSearchField[];
export declare function getHttpParamsForFilter(filter: SCTableFilter): HttpParams;
export declare function getParamsForDependencies(filter: SCTableFilter, params: HttpParams): HttpParams;
export declare function appendHttpParams(params: HttpParams, newParams: HttpParams): HttpParams;
export declare function getHttpParamsForConfig(config: SCTableConfig, includeFilters?: boolean, includeSearch?: boolean, includePagination?: boolean, includeSort?: boolean): HttpParams;
export declare const DefaultFilterActions: SCTableFilterAction[];
export declare function defineTableConfig(storageKey: string, previousTableConfig: SCTableConfig, savedConfigOr?: SCTableConfig, config?: TableConfigHelper): SCTableConfig;
export declare function saveTableConfig(storageKey: string, tableConfig: SCTableConfig, storage?: Storage): void;
export declare function cleanFilterConfigSelected(config: SCTableConfig): SCTableConfig;
export declare function fixTableConfig(config: SCTableConfig): SCTableConfig;
export declare function fixTableFilter(filter: SCTableFilter): SCTableFilter<any>;
export declare const SCTableDefaultConfig: SCTableConfig;
export declare class SCTableComponent extends SCBaseComponent implements ControlValueAccessor, AfterViewInit, OnChanges, OnDestroy {
    private cdref;
    private displayByPipe;
    private valueByPipe;
    private datepipe;
    private currencyPipe;
    private numbersReplacePipe;
    private decimalPipe;
    private sanitizer;
    private http;
    private dialogService;
    private scTableService;
    private scCoreService;
    private scCustomInputsDialogService;
    private iconRegistry;
    private translateSerivce;
    ngControl: NgControl;
    dataIn: any[];
    data$: Observable<any>;
    tableHeaders: SCTableHeader[];
    tableHeadersDisplayed: string[];
    customFooter: boolean;
    footerDataIn: any;
    footerTableHeaders: SCTableHeader[];
    footerTableHeadersDisplayed: string[];
    additionalTableInfo: string;
    tableActions: SCTableAction[];
    filterActions: SCTableFilterAction[];
    showFilterActions: boolean;
    configIn: SCTableConfig;
    defaultConfig: SCTableConfig;
    urlConfig: SCTableUrlConfig;
    storageConfig: SCTableStorageConfig;
    isLazyLoading: boolean;
    isLoadingResults: boolean;
    enableLoadingIndicator: boolean;
    customTable: boolean;
    customHeader: boolean;
    enableToggleSearchFields: boolean;
    striped: boolean;
    allSelected: boolean;
    compareBy: string;
    mapFunction: (data: any) => any;
    mapFooterFunction: (data: any) => any;
    showOneRowSelected: boolean;
    config: SCTableConfig;
    data: SCTableData[];
    filteredData: BehaviorSubject<SCTableData<any>[]>;
    parsedTableHeaders: SCTableHeader[];
    hasFilterDependencies: boolean;
    dataFooter: SCTableData;
    parsedFooterTableHeaders: SCTableHeader[];
    hasSubtitles: boolean;
    tableHeaderSubtitles: string[];
    tableHeaderSubtitlesDisplayed: string[];
    private dataSubscription;
    /**
     * @deprecated Since version 9.1
     */
    sortPageChanged: EventEmitter<SCTableConfig>;
    configChanged: EventEmitter<SCTableConfig>;
    actionClicked: EventEmitter<SCTableActionClickedEvent<any>>;
    rowClicked: EventEmitter<SCTableRowClickedEvent<any>>;
    linkClicked: EventEmitter<SCTableLinkClickedEvent<any>>;
    iconClicked: EventEmitter<SCTableLinkClickedEvent<any>>;
    filterActionClicked: EventEmitter<SCTableFilterActionClickedEvent>;
    dataFiltered: EventEmitter<any[]>;
    selectionChanged: EventEmitter<SCTableSelectionChangedEvent>;
    allSelectedChanged: EventEmitter<boolean>;
    valueChanged: EventEmitter<SCTableValueChangedEvent>;
    filterChanged: EventEmitter<SCTableFilterChangedEvent>;
    selectedStorageConfigChanged: EventEmitter<SCTableSelectedConfigChangedEvent>;
    dataLoadError: EventEmitter<HttpErrorResponse>;
    filterCategoresDialogOpened: EventEmitter<{
        categories: SCTableFilterCategory[];
    }>;
    filterCategoresDialogClosed: EventEmitter<{
        closedAction: 'accept' | 'cancel';
    }>;
    filterCategoresDialogOpen: boolean;
    internalPageinationConfig: {
        showFirstLastButtons: boolean;
        pageSizeOptions: number[];
    };
    private config$;
    private filterChangedSubjects;
    paginator: MatPaginator;
    sort: MatSort;
    private scTableContainter;
    table: MatTable<any>;
    showFilters: boolean;
    showSubtitles: boolean;
    countSelectedFilters: number;
    countActiveActions: number;
    private imgCache;
    hasCustomSearchFields: boolean;
    private value;
    private isInit;
    private lastConfig;
    get hasNoData(): boolean;
    get footerDisplays(): string[];
    initialTableHeadersDisplay: string[];
    selectedRowIndex: number;
    searchFieldSettings: any;
    containsData: {
        tableActions: boolean;
        tableHeaders: boolean;
        tableHeadersDisplayed: boolean;
        footerTableHeaders: boolean;
        footerTableHeadersDisplayed: boolean;
    };
    constructor(cdref: ChangeDetectorRef, displayByPipe: DisplayByPipe, valueByPipe: ValueByPipe, datepipe: DatePipe, currencyPipe: CurrencyPipe, numbersReplacePipe: NumbersReplacePipe, decimalPipe: DecimalPipe, sanitizer: DomSanitizer, http: HttpClient, dialogService: MatDialog, scTableService: SCTableService, scCoreService: SCCoreService, scCustomInputsDialogService: SCCustomInputsDialogService, iconRegistry: MatIconRegistry, translateSerivce: TranslateService, ngControl: NgControl);
    ngAfterViewInit(): void;
    ngOnChanges(event: SimpleChanges): void;
    ngOnDestroy(): void;
    renderData(): void;
    renderFooterData(): void;
    parseFooterData(data: any): SCTableData;
    parseData(data: any[]): SCTableData<any>[];
    parseTableHeader(resultData: {
        data: any;
        parsedActions: SCTableAction[];
        parsedData: any;
    }, header: SCTableHeader): SCTableDataParsedData;
    parseTableHeaderHelper(data: any, displayBy: string, arrayDisplayBy: string, concatWith: string, concatArrayWith: string, type: string, decimalInfo: string, htmlTemplate: string, variables: SCTableHeaderVariable[], dateFormat: string, currencyCode: string, currencyCodeDisplayBy: string, booleanValues: any): {
        display: string;
        displayHtml: SafeHtml;
    };
    parseFooterTableHeaders(footerTableHeaders: SCTableHeader[]): any[];
    parseTableHeaders(tableHeaders: SCTableHeader[]): SCTableHeader[];
    parseTableSearchFields(tableHeaders: SCTableHeader[], searchFields: SCTableSearchField[]): SCTableSearchField[];
    parseTableActions(data: any, actionsInput: SCTableAction[]): SCTableAction[];
    filterConditions(data: any, conditions: SCTableCondition[]): any;
    getConditionValue(data: any, condition: SCTableCondition | SCTableConditionValue, type: SCTableConditionType): boolean;
    parseSelectedValues(): void;
    getFilterDataWithSearch(data: SCTableData[]): SCTableData<any>[];
    getData(data: SCTableData[]): void;
    searchData(data: SCTableData[], searchString: string): SCTableData<any>[];
    filterData(data: SCTableData[], filterConfig: SCTableFilterConfig): SCTableData<any>[];
    filterHelper(data: SCTableData, filter: SCTableFilter): boolean;
    countFilters(config: SCTableFilterConfig): number;
    handleFilterDependencyClicked(filter: any, event: MouseEvent): void;
    sortData(data: SCTableData[]): SCTableData<any>[];
    paginateData(data: SCTableData[], index: number, pageSize: number): SCTableData<any>[];
    handleSearchKeyUp(event: KeyboardEvent): void;
    handleSearchFieldClicked(event: MouseEvent, field: SCTableSearchField): void;
    handleSearchFieldChanged(): void;
    handleSearchFieldCheckboxClicked(event: MouseEvent, field: SCTableSearchField): void;
    handleSelectedStorageConfigChange(selectedStorageConfigChaned: SCTableConfig): void;
    handleFilterChange(event: any, filterChanged: SCTableFilter): void;
    emitFilterChanged(filterChanged: SCTableFilterChangedEvent): void;
    filterChangedHelper(filterChanged: SCTableFilter, eventData: {
        filterLocation: 'quickfilters' | 'categories' | 'filters' | 'filterDependencies';
        inDialog: boolean;
        fromDialog: boolean;
    }): void;
    handleActionClicked(event: MouseEvent, action: SCTableAction, data: SCTableData, index: number): void;
    handleFilterActionClicked(event: MouseEvent, action: SCTableFilterAction): void;
    handleRowClicked(event: MouseEvent, data: any, index: number): void;
    handleColClicked(event: MouseEvent, data: SCTableData, header: SCTableHeader, headerIndex: string, index: number, rowIndex?: number): void;
    handleIconClicked(event: MouseEvent, data: SCTableData, header: SCTableHeader, headerIndex: string, index: number): void;
    handleLinkClicked(event: MouseEvent, data: SCTableData, header: SCTableHeader, headerIndex: string, index: number): void;
    handleAllSelectedChanged(): void;
    handleSelectionChanged(event: any, data: SCTableData, index: number): void;
    setAllSelected(): void;
    headerIsInput(header: SCTableHeader): boolean;
    handleInputValueChanged(event: any, data: SCTableData, header: SCTableHeader): void;
    handleSelectValueChanged(event: any, data: SCTableData, header: SCTableHeader): void;
    toggleShowFilter(): void;
    toggleSubtitles(event: MouseEvent): void;
    toggleFilter(scFilter: SCTableFilter): void;
    openHeaderFilterCategoriesDialog(event: MouseEvent, header: SCTableHeader): void;
    openHeaderFilterCategoriesDialogHelper(categories: SCTableFilterCategory[], header?: SCTableHeader, width?: string): void;
    emitConfig(): void;
    setFilterDependencies(config: SCTableConfig, filters: SCTableFilter[]): void;
    insertionSort(inputArr: any): any;
    setConfig(config: SCTableConfig, emit?: boolean): void;
    openHeaderFilterCategoriesDialogForIndex(headerIndex: string): void;
    getUrlData(): void;
    getUrlConfig(): void;
    getUrlDefaultConfig(): void;
    getUrlHeaders(): void;
    getUrlHeadersDisplayed(): void;
    getUrlFooterHeaders(): void;
    getUrlFooterHeadersDisplayed(): void;
    handleNewFooterTableHeaders(newFooterHeaders: SCTableHeader[]): void;
    handleNewFooterTableHeadersDisplayed(newFooterTableHeadersDisplayed: string[]): void;
    getUrlActions(): void;
    getUrlTableData(withCaching?: boolean): void;
    getUrlFooterTableData(): void;
    get httpHeaders(): import("@angular/common/http").HttpHeaders;
    get httpParams(): HttpParams;
    handleNewTableConfig(newConfig: SCTableConfig): void;
    saveSelectedStorageConfig(): void;
    selectSavedStorageConfig(): void;
    handleConfigFilterCategoriessssChanged(filterCategoriesChanged: SCTableFilterCategory[]): void;
    openStorageConfigDialog(forSelection?: boolean): Observable<any>;
    handleNewStorageConfig(newStorageConfig: SCTableStorageConfig): void;
    handleNewTableDefaultConfig(newDefaultConfig: SCTableConfig): void;
    handleNewTableHeaders(newHeaders: SCTableHeader[]): void;
    openChangeHeaderDialog(): void;
    setUsedTableHeaders(tableHeaders: any, setInitialTableHeaders?: boolean): void;
    handleNewTableHeadersDisplayed(newTableHeadersDisplayed: string[]): void;
    handleNewTableActions(newActions: SCTableAction[]): void;
    handleNewTableData(newData: any[]): void;
    handleNewTable$Data(newData$: Observable<any>): void;
    handleNewFooterData(newData: any): void;
    handleNewUrlConfig(newUrlConfig: SCTableUrlConfig): void;
    setLoadingIndicatorState(): void;
    handleMoreActionButtonclicked(event: MouseEvent): void;
    handleConfigFilterCategoriesChanged(filterCategoriesChanged: SCTableFilterCategory[]): void;
    scrollToTop(): void;
    scrollTo(position: number): void;
    setLastScrollPosition(): void;
    scrollToLastPosition(): void;
    setLastSearchFieldValue(tableActionClicked?: boolean): void;
    patchLastSearchFieldValue(): void;
    removeKeyFromSessionStorage(keyName: string): void;
    getCurrentScrollPosition(): number;
    getDataFromSCTableData(data: SCTableData[]): any[];
    checkSameData(currentSCData: any[], newSCData: any[]): boolean;
    onChange: (value: any) => void;
    onTouched: () => void;
    writeValue(value: any): void;
    emitValue(): void;
    registerOnChange(fn: (rating: number) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState?(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SCTableComponent, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, { optional: true; self: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SCTableComponent, "sc-table", never, { "dataIn": "data"; "data$": "data$"; "tableHeaders": "tableHeaders"; "tableHeadersDisplayed": "tableHeadersDisplayed"; "customFooter": "customFooter"; "footerDataIn": "footerData"; "footerTableHeaders": "footerTableHeaders"; "footerTableHeadersDisplayed": "footerTableHeadersDisplayed"; "additionalTableInfo": "additionalTableInfo"; "tableActions": "tableActions"; "filterActions": "filterActions"; "showFilterActions": "showFilterActions"; "configIn": "config"; "defaultConfig": "defaultConfig"; "urlConfig": "urlConfig"; "storageConfig": "storageConfig"; "isLazyLoading": "isLazyLoading"; "isLoadingResults": "isLoadingResults"; "enableLoadingIndicator": "enableLoadingIndicator"; "customTable": "customTable"; "customHeader": "customHeader"; "enableToggleSearchFields": "enableToggleSearchFields"; "striped": "striped"; "allSelected": "allSelected"; "compareBy": "compareBy"; "mapFunction": "mapFunction"; "mapFooterFunction": "mapFooterFunction"; "showOneRowSelected": "showOneRowSelected"; }, { "sortPageChanged": "sortPageChanged"; "configChanged": "configChanged"; "actionClicked": "actionClicked"; "rowClicked": "rowClicked"; "linkClicked": "linkClicked"; "iconClicked": "iconClicked"; "filterActionClicked": "filterActionClicked"; "dataFiltered": "dataFiltered"; "selectionChanged": "selectionChanged"; "allSelectedChanged": "allSelectedChanged"; "valueChanged": "valueChanged"; "filterChanged": "filterChanged"; "selectedStorageConfigChanged": "selectedStorageConfigChanged"; "dataLoadError": "dataLoadError"; "filterCategoresDialogOpened": "filterCategoresDialogOpened"; "filterCategoresDialogClosed": "filterCategoresDialogClosed"; }, never, ["*", "[footer]"]>;
}