@swimlane/ngx-datatable

readonly columnInputChanges$: Observable<void>;

static ɵfac: i0.ɵɵFactoryDeclaration<ColumnChangesService, never>;

static ɵprov: i0.ɵɵInjectableDeclaration<ColumnChangesService>;

onInputChange: () => void;

constructor(element: ElementRef, cd: ChangeDetectorRef);

activate: EventEmitter<any>;

activateFn: any;

cellContext: any;

cellTemplate: ViewContainerRef;

column: TableColumn;

readonly columnCssClasses: any;

displayCheck: (row: any, column?: TableColumn, value?: any) => boolean;

expanded: boolean;

group: any;

readonly height: string | number;

isFocused: boolean;

isSelected: boolean;

readonly maxWidth: number;

readonly minWidth: number;

onCheckboxChangeFn: any;

static ɵcmp: i0.ɵɵComponentDeclaration<
    DataTableBodyCellComponent,
    'datatable-body-cell',
    never,
    {
        displayCheck: 'displayCheck';
        group: 'group';
        rowHeight: 'rowHeight';
        isSelected: 'isSelected';
        expanded: 'expanded';
        rowIndex: 'rowIndex';
        column: 'column';
        row: 'row';
        sorts: 'sorts';
        treeStatus: 'treeStatus';
    },
    { activate: 'activate'; treeAction: 'treeAction' },
    never,
    never
>;

static ɵfac: i0.ɵɵFactoryDeclaration<DataTableBodyCellComponent, never>;

row: any;

rowHeight: number;

rowIndex: number;

sanitizedValue: any;

sortDir: SortDirection;

sorts: any[];

treeAction: EventEmitter<any>;

treeStatus: TreeStatus;

value: any;

readonly width: number;

calcLeftMargin: (column: any, row: any) => number;

calcSortDir: (sorts: any[]) => any;

checkValueUpdates: () => void;

ngDoCheck: () => void;

ngOnDestroy: () => void;

onBlur: () => void;

onCheckboxChange: (event: any) => void;

onClick: (event: MouseEvent) => void;

onDblClick: (event: MouseEvent) => void;

onFocus: () => void;

onKeyDown: (event: KeyboardEvent) => void;

onTreeAction: () => void;

stripHtml: (html: string) => string;

constructor(cd: ChangeDetectorRef);

activate: EventEmitter<any>;

bodyHeight: any;

readonly bodyWidth: string;

columnGroupWidths: any;

columnGroupWidthsWithoutGroup: any;

columns: any[];

detailToggle: EventEmitter<any>;

displayCheck: any;

emptyMessage: string;

externalPaging: boolean;

getDetailRowHeight: (row?: any, index?: any) => number;

groupedRows: any;

groupExpansionDefault: boolean;

groupHeader: any;

groupRowsBy: string;

indexes: any;

innerWidth: number;

listener: any;

loadingIndicator: boolean;

offset: number;

offsetX: number;

offsetY: number;

static ɵcmp: i0.ɵɵComponentDeclaration<
    DataTableBodyComponent,
    'datatable-body',
    never,
    {
        scrollbarV: 'scrollbarV';
        scrollbarH: 'scrollbarH';
        loadingIndicator: 'loadingIndicator';
        externalPaging: 'externalPaging';
        rowHeight: 'rowHeight';
        offsetX: 'offsetX';
        emptyMessage: 'emptyMessage';
        selectionType: 'selectionType';
        selected: 'selected';
        rowIdentity: 'rowIdentity';
        rowDetail: 'rowDetail';
        groupHeader: 'groupHeader';
        selectCheck: 'selectCheck';
        displayCheck: 'displayCheck';
        trackByProp: 'trackByProp';
        rowClass: 'rowClass';
        groupedRows: 'groupedRows';
        groupExpansionDefault: 'groupExpansionDefault';
        innerWidth: 'innerWidth';
        groupRowsBy: 'groupRowsBy';
        virtualization: 'virtualization';
        summaryRow: 'summaryRow';
        summaryPosition: 'summaryPosition';
        summaryHeight: 'summaryHeight';
        pageSize: 'pageSize';
        rows: 'rows';
        columns: 'columns';
        offset: 'offset';
        rowCount: 'rowCount';
        bodyHeight: 'bodyHeight';
    },
    {
        scroll: 'scroll';
        page: 'page';
        activate: 'activate';
        select: 'select';
        detailToggle: 'detailToggle';
        rowContextmenu: 'rowContextmenu';
        treeAction: 'treeAction';
    },
    never,
    never
>;

static ɵfac: i0.ɵɵFactoryDeclaration<DataTableBodyComponent, never>;

page: EventEmitter<any>;

pageSize: number;

rowClass: any;

rowContextmenu: EventEmitter<{ event: MouseEvent; row: any }>;

rowCount: number;

rowDetail: any;

rowExpansions: any[];

rowHeight: number | 'auto' | ((row?: any) => number);

rowHeightsCache: RowHeightCache;

rowIdentity: any;

rowIndexes: any;

rows: any[];

rowTrackingFn: any;

scroll: EventEmitter<any>;

scrollbarH: boolean;

scrollbarV: boolean;

scroller: ScrollerComponent;

readonly scrollHeight: number;

select: EventEmitter<any>;

selectCheck: any;

selected: any[];

readonly selectEnabled: boolean;

selectionType: SelectionType;

summaryHeight: number;

summaryPosition: string;

summaryRow: boolean;

temp: any[];

trackByProp: string;

treeAction: EventEmitter<any>;

virtualization: boolean;

columnTrackingFn: (index: number, column: any) => any;

getAdjustedViewPortIndex: () => number;

getBottomSummaryRowStyles: () => any;

getGroupHeight: (group: any) => number;

getRowAndDetailHeight: (row: any) => number;

getRowExpanded: (row: any) => boolean;

getRowExpandedIdx: (row: any, expanded: any[]) => number;

getRowHeight: (row: any) => number;

getRowIndex: (row: any) => number;

getRowsStyles: (rows: any) => any;

hideIndicator: () => void;

ngOnDestroy: () => void;

ngOnInit: () => void;

onBodyScroll: (event: any) => void;

onTreeAction: (row: any) => void;

recalcLayout: () => void;

refreshRowHeightCache: () => void;

stylesByGroup: (group: string) => { width: string };

toggleAllRows: (expanded: boolean) => void;

toggleRowExpansion: (row: any) => void;

updateIndexes: () => void;

updateOffsetY: (offset?: number) => void;

updatePage: (direction: string) => void;

updateRows: () => void;

constructor(
    differs: KeyValueDiffers,
    scrollbarHelper: ScrollbarHelper,
    cd: ChangeDetectorRef,
    element: ElementRef
);

activate: EventEmitter<any>;

columns: any[];

readonly columnsTotalWidths: string;

readonly cssClass: string;

displayCheck: any;

expanded: boolean;

group: any;

innerWidth: number;

isSelected: boolean;

offsetX: number;

static ɵcmp: i0.ɵɵComponentDeclaration<
    DataTableBodyRowComponent,
    'datatable-body-row',
    never,
    {
        columns: 'columns';
        innerWidth: 'innerWidth';
        expanded: 'expanded';
        rowClass: 'rowClass';
        row: 'row';
        group: 'group';
        isSelected: 'isSelected';
        rowIndex: 'rowIndex';
        displayCheck: 'displayCheck';
        treeStatus: 'treeStatus';
        offsetX: 'offsetX';
        rowHeight: 'rowHeight';
    },
    { activate: 'activate'; treeAction: 'treeAction' },
    never,
    never
>;

static ɵfac: i0.ɵɵFactoryDeclaration<
    DataTableBodyRowComponent,
    [null, { skipSelf: true }, null, null]
>;

row: any;

rowClass: any;

rowHeight: number;

rowIndex: number;

treeAction: EventEmitter<any>;

treeStatus: TreeStatus;

buildStylesByGroup: () => void;

calcStylesByGroup: (group: string) => { width: string };

columnTrackingFn: (index: number, column: any) => any;

ngDoCheck: () => void;

onActivate: (event: any, index: number) => void;

onKeyDown: (event: KeyboardEvent) => void;

onMouseenter: (event: any) => void;

onTreeAction: () => void;

recalculateColumns: (val?: any[]) => void;

trackByGroups: (index: number, colGroup: any) => any;

constructor(template: TemplateRef<any>);

static ɵdir: i0.ɵɵDirectiveDeclaration<
    DataTableColumnCellDirective,
    '[ngx-datatable-cell-template]',
    never,
    {},
    {},
    never
>;

static ɵfac: i0.ɵɵFactoryDeclaration<DataTableColumnCellDirective, never>;

template: TemplateRef<any>;

constructor(template: TemplateRef<any>);

static ɵdir: i0.ɵɵDirectiveDeclaration<
    DataTableColumnCellTreeToggle,
    '[ngx-datatable-tree-toggle]',
    never,
    {},
    {},
    never
>;

static ɵfac: i0.ɵɵFactoryDeclaration<DataTableColumnCellTreeToggle, never>;

template: TemplateRef<any>;

constructor(columnChangesService: ColumnChangesService);

canAutoResize: boolean;

cellClass: string | ((data: any) => string | any);

readonly cellTemplate: TemplateRef<any>;

checkboxable: boolean;

comparator: any;

draggable: boolean;

flexGrow: number;

frozenLeft: any;

frozenRight: any;

headerCheckboxable: boolean;

headerClass: string | ((data: any) => string | any);

readonly headerTemplate: TemplateRef<any>;

isTreeColumn: boolean;

maxWidth: number;

minWidth: number;

name: string;

static ɵdir: i0.ɵɵDirectiveDeclaration<
    DataTableColumnDirective,
    'ngx-datatable-column',
    never,
    {
        name: 'name';
        prop: 'prop';
        frozenLeft: 'frozenLeft';
        frozenRight: 'frozenRight';
        flexGrow: 'flexGrow';
        resizeable: 'resizeable';
        comparator: 'comparator';
        pipe: 'pipe';
        sortable: 'sortable';
        draggable: 'draggable';
        canAutoResize: 'canAutoResize';
        minWidth: 'minWidth';
        width: 'width';
        maxWidth: 'maxWidth';
        checkboxable: 'checkboxable';
        headerCheckboxable: 'headerCheckboxable';
        headerClass: 'headerClass';
        cellClass: 'cellClass';
        isTreeColumn: 'isTreeColumn';
        treeLevelIndent: 'treeLevelIndent';
        summaryFunc: 'summaryFunc';
        summaryTemplate: 'summaryTemplate';
        _cellTemplateInput: 'cellTemplate';
        _headerTemplateInput: 'headerTemplate';
        _treeToggleTemplateInput: 'treeToggleTemplate';
    },
    {},
    ['_cellTemplateQuery', '_headerTemplateQuery', '_treeToggleTemplateQuery']
>;