import * as i0 from '@angular/core';
import { TemplateRef, InputSignal, OnDestroy, AfterViewInit, Signal, ChangeDetectorRef, ModelSignal, PipeTransform } from '@angular/core';
import { Observable } from 'rxjs';
import { Primitive } from 'tableau-ui-angular/types';
import * as i23 from 'tableau-ui-angular/tooltip';
import { TooltipArgs } from 'tableau-ui-angular/tooltip';
import * as i20 from '@angular/common';
import * as i21 from 'tableau-ui-angular/icon';
import * as i22 from 'tableau-ui-angular/button';
import * as i24 from 'tableau-ui-angular/checkbox';

interface CellContext<TData> {
    row: TData;
    meta: CellMetaContext<TData>;
    maxRowCount: number;
}
interface CellMetaContext<TData> {
    columnDef: ColumnDefDirective<TData>;
    index: number;
    first: boolean;
    last: boolean;
    even: boolean;
    odd: boolean;
    count: number;
    columnIndex: number;
    columnFirst: boolean;
    columnLast: boolean;
    columnEven: boolean;
    columnOdd: boolean;
    columnCount: number;
}
interface CellTooltipContext<TData> extends CellContext<TData> {
    cellTemplate: TemplateRef<{
        $implicit: CellContext<TData>;
    }>;
    isRowCellClamped: boolean;
}

declare class CellDefDirective<TData> {
    readonly table: i0.InputSignal<TableComponent<TData>>;
    /**
     * When true, it will clamp the text content in the template to fit the cell height.
     * It will add an ellipsis (...) to the end of the text if it overflows.
     * This is useful for preventing overflow in table cells.
     * This will clamp to the maximum number of lines that can fit in the cell, respecting the height and padding of the cell.
     * It will also show a default tooltip with the full value of the cell uinless its turned off.
     * Only works if the cell template ONLY contains text, no HTML elements.
     * @default true
     */
    readonly $textClamping: i0.InputSignal<boolean>;
    templateRef: TemplateRef<{
        $implicit: CellContext<TData>;
    }>;
    static ngTemplateContextGuard<TData>(dir: CellDefDirective<TData>, ctx: unknown): ctx is {
        $implicit: CellContext<TData>;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<CellDefDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CellDefDirective<any>, "[tabCellDef]", never, { "table": { "alias": "tabCellDef"; "required": true; "isSignal": true; }; "$textClamping": { "alias": "textClamping"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

interface DataSort {
    property: string;
    direction: 'asc' | 'desc';
}

interface HeaderContext<TData> {
    columnDef: ColumnDefDirective<TData>;
    meta: HeaderContextMeta;
}
interface HeaderContextMeta {
    index: number;
    first: boolean;
    last: boolean;
    even: boolean;
    odd: boolean;
    count: number;
}
interface HeaderTooltipContext<TData> extends HeaderContext<TData> {
    headerTemplate?: TemplateRef<{
        $implicit: HeaderContext<TData>;
    }>;
    sortMode: 'multi' | 'single';
    sortable: boolean;
    sortOrder: SortOrderPair;
    currentSort: {
        info: DataSort;
        index: number;
    } | undefined;
    allSorts: DataSort[];
}

declare class HeaderDefDirective<TData> {
    readonly table: i0.InputSignal<TableComponent<TData>>;
    templateRef: TemplateRef<{
        $implicit: HeaderContext<TData>;
    }>;
    static ngTemplateContextGuard<TData>(dir: HeaderDefDirective<TData>, ctx: unknown): ctx is {
        $implicit: HeaderContext<TData>;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderDefDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HeaderDefDirective<any>, "[tabHeaderDef]", never, { "table": { "alias": "tabHeaderDef"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class HeaderToolipDefDirective<TData> {
    readonly table: i0.InputSignal<TableComponent<TData>>;
    readonly $showTooltip: i0.InputSignal<boolean | ((ctx: HeaderContext<TData>) => boolean)>;
    readonly $tooltipPosition: i0.InputSignal<"bottom" | "left" | "right" | "top">;
    readonly $tooltipMargin: i0.InputSignal<string>;
    templateRef: TemplateRef<any>;
    static ngTemplateContextGuard<TData>(dir: HeaderToolipDefDirective<TData>, ctx: unknown): ctx is {
        $implicit: HeaderTooltipContext<TData>;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderToolipDefDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HeaderToolipDefDirective<any>, "[tabHeaderTooltipDef]", never, { "table": { "alias": "tabHeaderTooltipDef"; "required": true; "isSignal": true; }; "$showTooltip": { "alias": "showTooltip"; "required": false; "isSignal": true; }; "$tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "$tooltipMargin": { "alias": "tooltipMargin"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class CellToolipDefDirective<TData> {
    readonly table: i0.InputSignal<TableComponent<TData>>;
    readonly $showTooltip: i0.InputSignal<boolean | ((ctx: CellContext<TData>, isClamped: boolean) => boolean)>;
    readonly $tooltipPosition: i0.InputSignal<"bottom" | "left" | "right" | "top">;
    readonly $tooltipMargin: i0.InputSignal<string>;
    readonly templateRef: TemplateRef<any>;
    static ngTemplateContextGuard<TData>(dir: CellToolipDefDirective<TData>, ctx: unknown): ctx is {
        $implicit: CellTooltipContext<TData>;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<CellToolipDefDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CellToolipDefDirective<any>, "[tabCellTooltipDef]", never, { "table": { "alias": "tabCellTooltipDef"; "required": true; "isSignal": true; }; "$showTooltip": { "alias": "showTooltip"; "required": false; "isSignal": true; }; "$tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "$tooltipMargin": { "alias": "tooltipMargin"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class ColumnDefDirective<TData> {
    /**
     * The unique identifier for the column.
     */
    readonly $id: InputSignal<string>;
    /**
     * The property name of the column, used for sorting purposes.
     * If not provided, it will default to the column ID.
     * @default undefined
     */
    readonly $propertyName: InputSignal<string | undefined>;
    /**
     * The CSS width of the column.
     * Can be a string representing a CSS value (e.g., '100px', '20%', '1rem') or a number repesenting flex-grow (fill space).
     * @default "1"
     */
    readonly $width: InputSignal<string | number>;
    /**
     * The CSS minimum width of the column.
     * Can be a string representing a CSS value (e.g., '100px', '20%', '1rem'). If no unit is provided, it will be treated as pixels.
     * @default "100px"
     */
    readonly $minWidth: InputSignal<string>;
    /**
     * The CSS maximum width of the column.
     * Can be a string representing a CSS value (e.g., '100px', '20%', '1rem'). If no unit is provided, it will be treated as pixels.
     * If undefined, there is no maximum width.
     * @default undefined
     */
    readonly $maxWidth: InputSignal<string | undefined>;
    /**
     * Whether the column is resizable by the user.
     * @default true
     */
    readonly $resizable: InputSignal<boolean>;
    /**
     * Whether the column is sortable by the user.
     * @default true
     */
    readonly $sortable: InputSignal<boolean>;
    /**
     * The sort order of the column when it is sorted.
     * Can be 'asc' for ascending, 'desc' for descending, or an array of two values to indicate the order of sorting.
     * @default "['asc', 'desc']"
     */
    readonly $sortOrder: InputSignal<SortOrderPair>;
    /**
     * The CSS class to apply to the column header.
     * Can be a string or a function that returns a string based on the header context.
     * If undefined, no class will be applied.
     * @default undefined
     */
    readonly $headerClass: InputSignal<string | ((ctx: HeaderContext<TData>) => string | undefined) | undefined>;
    /**
     * The CSS class to apply to the column cells.
     * Can be a string or a function that returns a string based on the cell context.
     * If undefined, no class will be applied.
     * @default undefined
     */
    readonly $cellClass: InputSignal<string | ((ctx: CellContext<TData>) => string | undefined) | undefined>;
    /**
     * Show automatic header tooltip when no tabHeaderTooltipDef is provided on the column.
     * @default true
     */
    readonly $showAutoHeaderTooltip: InputSignal<boolean>;
    /**
     * Show automatic cell tooltip when no tabCellTooltipDef is provided on the column.
     * The auto cell tooltip displays the column value when it's clipped. Only works for tabCellDefs with $textClipping() enabled.
     * If the cell value is not clipped, no automatic tooltip will be shown.
     * When a tabCellTooltipDef overrides the automatic tooltip, this setting has no effect.
     * @default true
     */
    readonly $showAutoCellTooltip: InputSignal<boolean>;
    readonly $cell: i0.Signal<CellDefDirective<TData>>;
    readonly $header: i0.Signal<HeaderDefDirective<TData>>;
    readonly $headerTooltip: i0.Signal<HeaderToolipDefDirective<TData>>;
    readonly $cellTooltip: i0.Signal<CellToolipDefDirective<TData>>;
    buildHeaderContext(index: number, first: boolean, last: boolean, even: boolean, odd: boolean, count: number): HeaderContext<TData>;
    buildCellContext(value: TData, maxRowCount: number, index: number, first: boolean, last: boolean, even: boolean, odd: boolean, count: number, columnIndex: number, columnFirst: boolean, columnLast: boolean, columnEven: boolean, columnOdd: boolean, columnCount: number): CellContext<TData>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnDefDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ColumnDefDirective<any>, "[tabColumnDef]", never, { "$id": { "alias": "tabColumnDef"; "required": true; "isSignal": true; }; "$propertyName": { "alias": "propertyName"; "required": false; "isSignal": true; }; "$width": { "alias": "width"; "required": false; "isSignal": true; }; "$minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "$maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "$resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "$sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "$sortOrder": { "alias": "sortOrder"; "required": false; "isSignal": true; }; "$headerClass": { "alias": "headerClass"; "required": false; "isSignal": true; }; "$cellClass": { "alias": "cellClass"; "required": false; "isSignal": true; }; "$showAutoHeaderTooltip": { "alias": "showAutoHeaderTooltip"; "required": false; "isSignal": true; }; "$showAutoCellTooltip": { "alias": "showAutoCellTooltip"; "required": false; "isSignal": true; }; }, {}, ["$cell", "$header", "$headerTooltip", "$cellTooltip"], never, false, never>;
}
type SortOrderPair = ['asc', 'desc'] | ['desc', 'asc'];
interface HeaderTooltipArgs<TData> {
    ctx: HeaderContext<TData>;
    template: TemplateRef<HeaderContext<TData>>;
    sortMode: 'multi' | 'single';
    sortable: boolean;
    sortOrder: SortOrderPair;
    currentSort: {
        info: DataSort;
        index: number;
    } | undefined;
    allSorts: DataSort[];
}
interface CellTooltipArgs<TData> {
    ctx: CellContext<TData>;
    template: TemplateRef<CellContext<TData>>;
}

declare class ColRenderedWidthDirective implements OnDestroy, AfterViewInit {
    readonly columnId: i0.InputSignal<string>;
    private readonly element;
    private readonly _renderedWidth;
    get renderedWidth(): Observable<number>;
    private observer;
    get isObserving(): boolean;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColRenderedWidthDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ColRenderedWidthDirective, "[colRenderedWidth]", never, { "columnId": { "alias": "colRenderedWidth"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class DataBlock<TData> {
    readonly id: number;
    readonly abort: AbortController | undefined;
    private readonly blockRowCount;
    private readonly getKey;
    readonly dataPromise: Promise<{
        key: Primitive;
        data: TData;
    }[]>;
    private readonly $_status;
    get $status(): Signal<'canceled' | 'error' | 'loading' | 'success'>;
    private readonly $response;
    readonly $data: Signal<{
        key: Primitive;
        data: TData;
    }[]>;
    get offset(): number;
    constructor(id: number, abort: AbortController | undefined, blockRowCount: number, getKey: (data: TData) => Primitive, dataPromise: Promise<{
        key: Primitive;
        data: TData;
    }[]>);
}

interface FullDataRequest {
    readonly sort: readonly DataSort[];
    readonly abort: AbortSignal;
}
interface IncrementalDataRequest extends FullDataRequest {
    readonly offset: number;
    readonly count: number;
}

interface FullDataResponse<TData> {
    readonly data: TData[];
}
interface IncrementalDataResponse<TData> extends FullDataResponse<TData> {
    readonly total: number;
}

declare class BaseDataOptions<TData> {
    readonly getRowKey: (row: TData) => Primitive;
    constructor(getRowKey: (row: TData) => Primitive);
}
declare class IncrementalDataOptions<TData> extends BaseDataOptions<TData> {
    readonly getDataBlock: (req: IncrementalDataRequest) => Promise<IncrementalDataResponse<TData>>;
    constructor(getRowKey: (row: TData) => Primitive, getDataBlock: (req: IncrementalDataRequest) => Promise<IncrementalDataResponse<TData>>);
}
declare class FullDataOptions<TData> extends BaseDataOptions<TData> {
    readonly getAllData: (req: FullDataRequest) => Promise<FullDataResponse<TData>>;
    constructor(getRowKey: (row: TData) => Primitive, getAllData: (req: FullDataRequest) => Promise<FullDataResponse<TData>>);
}
type DataOptions<TData> = IncrementalDataOptions<TData> | FullDataOptions<TData>;

declare class DataManager<TData> {
    private readonly cdr;
    constructor(cdr: ChangeDetectorRef);
    private dataRowHeightPx;
    private dataWindowHeightPx;
    private sort;
    private dataBlockWindow;
    private dataBlockHeightPx;
    private blockRowCount;
    private _totalRowCount;
    get totalRowCount(): number;
    private dataOptions;
    private readonly $_blocks;
    get $blocks(): Signal<BlocksInfo<TData>>;
    private _allDataInfo;
    get allDataInfo(): AllDataInfo<TData> | undefined;
    private resetting;
    reset(dataWindowHeightPx: number, dataRowHeightPx: number, sort: DataSort[], dataBlockWindow: number, dataOptions: DataOptions<TData>): Promise<void>;
    private getBlock;
    setScrollPosition(topPx: number): void;
}
interface BlocksInfo<TData> {
    prePixels: number;
    blocks: DataBlock<TData>[];
    postPixels: number;
}
declare class AllDataInfo<TData> {
    readonly promise: Promise<{
        key: Primitive;
        data: TData;
    }[]>;
    readonly abort: AbortController;
    private readonly $_allKeys;
    get $allKeys(): Signal<Set<Primitive>>;
    private readonly $_status;
    get $status(): Signal<'canceled' | 'error' | 'loading' | 'success'>;
    constructor(promise: Promise<{
        key: Primitive;
        data: TData;
    }[]>, abort: AbortController);
}

declare class CommonSelectionOptions {
    readonly selectionMode: 'checkbox' | 'row-and-checkbox';
    readonly clearSelectedKeysOnManualReset: boolean;
    readonly clearSelectedKeysOnAnyReset: boolean;
    constructor(selectionMode?: 'checkbox' | 'row-and-checkbox', clearSelectedKeysOnManualReset?: boolean, clearSelectedKeysOnAnyReset?: boolean);
}
declare class SingleSelectionOptions extends CommonSelectionOptions {
    constructor(
    /**
     * Selection mode for the table.
     * - 'checkbox': Only checkbox selection is allowed.
     * - 'row-and-checkbox': Both row and checkbox selection are allowed.
     *
     */
    selectionMode?: 'checkbox' | 'row-and-checkbox', 
    /**
     * Clear the selected keys when a manual reset is triggered.
     * @default true
     */
    clearSelectedRowsOnManualReset?: boolean, 
    /**
     * Clear the selected keys when any reset is triggered.
     * This includes manual resets and automatic resets (e.g., when size/sort/displayed cols, etc changes).
     * @default false
     */
    clearSelectedRowsOnAnyReset?: boolean);
}
declare class MultiSelectionOptions extends CommonSelectionOptions {
    /**
     * Configuration for the header checkbox mode.
     * This determines how the header checkbox behaves.
     * - 'none': No header checkbox is displayed.
     * - 'selectNone': A header checkbox is displayed that can only unselect all rows that have been selected
     * - `SelectAll`: A header checkbox is displayed that can select all rows that have been selected. Requires FullDataOptions to be used which can lead to performance issues with large datasets.
     */
    readonly headerCheckboxMode: 'none' | 'selectNone' | 'selectAll';
    constructor(
    /**
     * Configuration for the header checkbox mode.
     * This determines how the header checkbox behaves.
     * - 'none': No header checkbox is displayed.
     * - 'selectNone': A header checkbox is displayed that can only unselect all rows that have been selected
     * - `SelectAll`: A header checkbox is displayed that can select all rows that have been selected. Requires FullDataOptions to be used which can lead to performance issues with large datasets.
     */
    headerCheckboxMode: 'none' | 'selectNone' | 'selectAll', 
    /**
     * Selection mode for the table.
     * - 'checkbox': Only checkbox selection is allowed.
     * - 'row-and-checkbox': Both row and checkbox selection are allowed.
     *
     */
    selectionMode?: 'checkbox' | 'row-and-checkbox', 
    /**
     * Clear the selected keys when a manual reset is triggered.
     * @default true
     */
    clearSelectedKeysOnManualReset?: boolean, 
    /**
     * Clear the selected keys when any reset is triggered.
     * This includes manual resets and automatic resets (e.g., when size/sort/displayed cols, etc changes).
     * @default false
     */
    clearSelectedKeysOnAnyReset?: boolean);
}
type SelectionOptions = SingleSelectionOptions | MultiSelectionOptions;

declare class TableComponent<TData = number> {
    protected readonly checkboxColWidth = "2.5em";
    readonly self: this;
    /**
     * The column IDs to display in the table. The order of the IDs determines the order of the columns.
     * If undefined, all columns will be displayed in the order they are defined in the table.
     * @default undefined
     */
    readonly $displayedColumns: ModelSignal<string[] | undefined>;
    readonly $dataOptions: InputSignal<DataOptions<TData>>;
    /**
     * The number of data blocks to load before and after the currently displayed block(s) based on scroll position.
     * This is used to determine how many blocks to load in advance for smooth scrolling.
     * A data block is a chunk of data that is loaded from the server. It's size is is whatever fits the current viewport.
     * @default 3
     */
    readonly $dataBlockWindow: InputSignal<number>;
    /**
     * The height of the table data row.
     * This must be a valid CSS value.
     * Fixed height is required for virtual scrolling to work properly.
     * If the height is not fixed, the table will not be able to calculate the row heights and will not be able to scroll properly.
     * @default '2.5em'
     */
    readonly $dataRowHeight: InputSignal<string>;
    /**
     * The margin for all header cells
     * @default '0.5em'
     */
    readonly $headerPadding: InputSignal<string>;
    /**
     * The margin for all data cells
     * @default '0 0.5em'
     */
    readonly $dataPadding: InputSignal<string>;
    /**
     * The sorting mode. When multi sort is enabled, holding SHIFT when clicking a column header will add it to the sort list
     * @default single
     */
    readonly $sortMode: InputSignal<"multi" | "single">;
    /**
     * The sort models. Initial sort mode can be provided here.
     * This gets updated when the sort is changed by the user on the UI dynamically
     * @default []
     */
    readonly $sort: ModelSignal<DataSort[]>;
    /**
     * The column ID to pin to the left side of the table.
     * If undefined, no column will be pinned to the left.
     * @default undefined
     */
    readonly $pinnedLeftColumn: ModelSignal<string | undefined>;
    /**
     * The column ID to pin to the right side of the table.
     * If undefined, no column will be pinned to the right.
     * @default undefined
     */
    readonly $pinnedRightColumn: ModelSignal<string | undefined>;
    /**
     * Whether to show a striped table.
     * This will alternate the background color of the rows.
     * @default false
     */
    readonly $striped: ModelSignal<boolean>;
    /**
     * The template to use when there is no data to display.
     * If 'default', a default template will be used.
     * If a TemplateRef is provided, it will be used as the no data template.
     * @default 'default'
     */
    readonly $noDataTemplate: InputSignal<string | TemplateRef<unknown>>;
    /**
     * The options for the selection mode.
     * If undefined, no selection will be enabled.
     * If a SingleSelectionOptions is provided, single selection will be enabled.
     * If a MultiSelectionOptions is provided, multi selection will be enabled.
     * @default undefined
     */
    readonly $selectionOptions: InputSignal<SelectionOptions | undefined>;
    /**
     * The selected rows.
     * This is used to determine which rows are selected in the table.
     * If the selection options are set to single selection, this will only contain a maximum of one row.
     * If the selection options are set to multi selection, this can contain multiple rows.
     * This is updated when the selection changes.
     * @default []
     * @see {@link $selectionOptions}
     */
    readonly $selectedRows: ModelSignal<Map<Primitive, TData>>;
    readonly $columnDefs: i0.Signal<readonly ColumnDefDirective<TData>[]>;
    protected readonly $displayedColumnDefs: i0.Signal<{
        id: string;
        col: ColumnDefDirective<TData>;
        pinnedLeft: boolean;
        pinnedRight: boolean;
        sortOrder: SortOrderPair;
    }[]>;
    protected readonly $columnWidthDirectives: i0.Signal<readonly ColRenderedWidthDirective[]>;
    private readonly hostElement;
    private readonly cdr;
    private readonly $headerRow;
    private readonly $dataRowSizer;
    protected readonly _dataManager: DataManager<TData>;
    get dataManager(): DataManager<TData>;
    private loaded;
    private dataWindowHeightPx;
    private dataRowHeightPx;
    /**
     * Loads the table data. Only callable once. If the table is already loaded, this will do nothing.
     * This will calculate the available window and row height and reset() the table.
     * Use this to load the table initially
     * Use reload() to reload the table data if the table size or row size changes
     */
    load(): Promise<boolean>;
    /**
     * Reloads the table data.
     * This will re-calculate the available window and row height and reset() the table.
     * Use this to reload the table data if the table size or row size changes
     */
    reload(): Promise<boolean>;
    private readonly dataManagerReset;
    private resetInternal;
    /**
     * Resets the table to its initial state.
     * This will reset the scroll position, data, and optionally selection.
     * If resetSort is true, the sort will also be reset to the initial state.
     * @param resetSort Whether to reset the sort to the initial state
     * @returns A promise that resolves to true if the reset was successful, false otherwise.
     */
    reset(resetSort?: boolean): Promise<boolean>;
    protected onColumnHeaderClick(e: MouseEvent, def: ColumnDefDirective<TData>): void;
    private onScroll;
    protected readonly $selectionMultiHeaderCheckboxSelected: ModelSignal<boolean | "partial">;
    selectionMultiHeaderCheckboxSelectNoneChanged(): void;
    selectionMultiHeaderCheckboxSelectAllChanged(val: boolean | 'partial'): Promise<void>;
    private readonly updateSelectionMultiHeaderCheckboxSelected;
    protected rowClicked(row: TData, e: MouseEvent): void;
    protected checkboxClicked(e: MouseEvent): void;
    protected checkboxSelectChange(row: TData, checked: boolean | 'partial'): void;
    protected readonly $lineClampRows: i0.WritableSignal<number>;
    protected readonly $lineClampElementHeightPx: i0.WritableSignal<number>;
    private initializeLineClamp;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "tab-table", never, { "$displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "$dataOptions": { "alias": "dataOptions"; "required": true; "isSignal": true; }; "$dataBlockWindow": { "alias": "dataBlockWindow"; "required": false; "isSignal": true; }; "$dataRowHeight": { "alias": "dataRowHeight"; "required": false; "isSignal": true; }; "$headerPadding": { "alias": "headerPadding"; "required": false; "isSignal": true; }; "$dataPadding": { "alias": "dataPadding"; "required": false; "isSignal": true; }; "$sortMode": { "alias": "sortMode"; "required": false; "isSignal": true; }; "$sort": { "alias": "sort"; "required": false; "isSignal": true; }; "$pinnedLeftColumn": { "alias": "pinnedLeftColumn"; "required": false; "isSignal": true; }; "$pinnedRightColumn": { "alias": "pinnedRightColumn"; "required": false; "isSignal": true; }; "$striped": { "alias": "striped"; "required": false; "isSignal": true; }; "$noDataTemplate": { "alias": "noDataTemplate"; "required": false; "isSignal": true; }; "$selectionOptions": { "alias": "selectionOptions"; "required": false; "isSignal": true; }; "$selectedRows": { "alias": "selectedRows"; "required": false; "isSignal": true; }; "$selectionMultiHeaderCheckboxSelected": { "alias": "$selectionMultiHeaderCheckboxSelected"; "required": false; "isSignal": true; }; }, { "$displayedColumns": "displayedColumnsChange"; "$sort": "sortChange"; "$pinnedLeftColumn": "pinnedLeftColumnChange"; "$pinnedRightColumn": "pinnedRightColumnChange"; "$striped": "stripedChange"; "$selectedRows": "selectedRowsChange"; "$selectionMultiHeaderCheckboxSelected": "$selectionMultiHeaderCheckboxSelectedChange"; }, ["$columnDefs"], never, false, never>;
}

declare class SortInfoPipe implements PipeTransform {
    transform(sorts: DataSort[], colId: string, propertyName: string | undefined): {
        info: DataSort;
        index: number;
    } | undefined;
    static getSortInfo(sorts: DataSort[], colId: string, propertyName: string | undefined): {
        info: DataSort;
        index: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<SortInfoPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SortInfoPipe, "sortInfo", false>;
}

declare class HeaderTooltipPipe implements PipeTransform {
    transform<TData>(columnDef: ColumnDefDirective<TData>, table: TableComponent<TData>, headerContext: HeaderContext<TData>, autoHeaderTooltipTemplate: TemplateRef<{
        $implicit: HeaderTooltipContext<TData>;
    }>, contextParams: {
        sortMode: 'multi' | 'single';
        sortable: boolean;
        sortOrder: SortOrderPair;
        currentSort: {
            info: DataSort;
            index: number;
        } | undefined;
        allSorts: DataSort[];
    }): () => TooltipArgs<{
        $implicit: HeaderTooltipContext<TData>;
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderTooltipPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<HeaderTooltipPipe, "headerTooltip", false>;
}

declare class HeaderContextPipe implements PipeTransform {
    transform<TData>(value: ColumnDefDirective<TData>, index: number, first: boolean, last: boolean, even: boolean, odd: boolean, count: number): {
        $implicit: HeaderContext<TData>;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderContextPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<HeaderContextPipe, "headerContext", false>;
}

declare class HeaderClassPipe implements PipeTransform {
    transform<TData>(ctx: HeaderContext<TData>): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderClassPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<HeaderClassPipe, "headerClass", false>;
}

declare class CellContextPipe implements PipeTransform {
    transform<TData>(value: TData, maxRowCount: number, def: ColumnDefDirective<TData>, index: number, first: boolean, last: boolean, even: boolean, odd: boolean, count: number, columnIndex: number, columnFirst: boolean, columnLast: boolean, columnEven: boolean, columnOdd: boolean, columnCount: number): {
        $implicit: CellContext<TData>;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<CellContextPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CellContextPipe, "cellContext", false>;
}

declare class CellClassPipe implements PipeTransform {
    transform<TData>(ctx: CellContext<TData>): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<CellClassPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CellClassPipe, "cellClass", false>;
}

declare class CellTooltipPipe implements PipeTransform {
    transform<TData>(cellElement: HTMLDivElement, columnDef: ColumnDefDirective<TData>, cellContext: CellContext<TData>, block: DataBlock<TData>): () => TooltipArgs<{
        $implicit: CellTooltipContext<TData>;
    }>;
    isClamped(cellElement: HTMLDivElement): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CellTooltipPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CellTooltipPipe, "cellTooltip", false>;
}

declare class ColWidthPipe implements PipeTransform {
    transform(value: number | string | undefined, mode: 'flexGrowOnly' | 'width' | 'widthUnitsOnly'): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColWidthPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ColWidthPipe, "colWidth", false>;
}

declare class CellWidthPipe implements PipeTransform {
    transform(directives: readonly ColRenderedWidthDirective[], colId: string, padding: string): Observable<string>;
    private parsePadding;
    static ɵfac: i0.ɵɵFactoryDeclaration<CellWidthPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CellWidthPipe, "cellWidth", false>;
}

declare class ResizerDirective {
    readonly $columnElement: i0.InputSignal<HTMLElement>;
    readonly $enabled: i0.InputSignal<boolean>;
    private readonly resizerElement;
    private readonly renderer;
    private dragging;
    onMouseDown(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizerDirective, "[resizerFor]", never, { "$columnElement": { "alias": "resizerFor"; "required": true; "isSignal": true; }; "$enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class HeaderCheckboxModePipe implements PipeTransform {
    transform(selectionOptions: SelectionOptions | undefined): 'none' | 'selectNone' | 'selectAll' | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderCheckboxModePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<HeaderCheckboxModePipe, "headerCheckboxMode", false>;
}

declare class RowSelectedPipe<TData> implements PipeTransform {
    transform(row: TData, selectedRows: Map<Primitive, TData>, dataOptions: DataOptions<TData>): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<RowSelectedPipe<any>, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RowSelectedPipe<any>, "rowSelected", false>;
}

declare class TableauUiTableModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TableauUiTableModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TableauUiTableModule, [typeof TableComponent, typeof HeaderDefDirective, typeof HeaderToolipDefDirective, typeof HeaderTooltipPipe, typeof HeaderContextPipe, typeof HeaderClassPipe, typeof ColumnDefDirective, typeof CellDefDirective, typeof CellContextPipe, typeof CellClassPipe, typeof CellToolipDefDirective, typeof CellTooltipPipe, typeof SortInfoPipe, typeof ColWidthPipe, typeof ColRenderedWidthDirective, typeof CellWidthPipe, typeof ResizerDirective, typeof HeaderCheckboxModePipe, typeof RowSelectedPipe], [typeof i20.CommonModule, typeof i21.TableauUiIconModule, typeof i22.TableauUiButtonModule, typeof i23.TableauUiTooltipModule, typeof i24.TableauUiCheckboxModule], [typeof TableComponent, typeof HeaderDefDirective, typeof HeaderToolipDefDirective, typeof ColumnDefDirective, typeof CellDefDirective, typeof CellToolipDefDirective, typeof SortInfoPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TableauUiTableModule>;
}

export { CellDefDirective, CellToolipDefDirective, ColumnDefDirective, FullDataOptions, HeaderDefDirective, HeaderToolipDefDirective, IncrementalDataOptions, MultiSelectionOptions, SingleSelectionOptions, SortInfoPipe, TableComponent, TableauUiTableModule };
export type { CellContext, CellMetaContext, CellTooltipArgs, CellTooltipContext, DataOptions, DataSort, FullDataRequest, FullDataResponse, HeaderContext, HeaderContextMeta, HeaderTooltipArgs, HeaderTooltipContext, IncrementalDataRequest, IncrementalDataResponse, SelectionOptions, SortOrderPair };