import * as i0 from '@angular/core';
import { InputSignal, OnDestroy, OnInit, ElementRef, Signal } from '@angular/core';
import * as _qualcomm_ui_core_table from '@qualcomm-ui/core/table';
import { ColumnMeta, CellContext, HeaderContext, Cell, Header, SortDirection, Row, RowData, TableInstance, TableOptions } from '@qualcomm-ui/core/table';
import * as _qualcomm_ui_qds_core_table from '@qualcomm-ui/qds-core/table';
import { QdsTableCellProps, QdsTableColumnDropIndicatorProps, QdsTableColumnFilterProps, QdsTableColumnResizerProps, QdsTableColumnSortActionProps, QdsTableHeaderCellProps, QdsTableApiProps, QdsTableSize, QdsTableRowDropIndicatorProps, QdsTableRowExpandButtonProps, QdsTableRowProps } from '@qualcomm-ui/qds-core/table';
import { Booleanish } from '@qualcomm-ui/utils/coercion';
import * as _qualcomm_ui_angular_core_machine from '@qualcomm-ui/angular-core/machine';
import * as _qualcomm_ui_qds_core_inline_icon_button from '@qualcomm-ui/qds-core/inline-icon-button';
import { LucideIconOrString } from '@qualcomm-ui/angular-core/lucide';
import { SignalifyInput } from '@qualcomm-ui/angular-core/signals';
import { PaginationRootDirective } from '@qualcomm-ui/angular/pagination';
import * as i29 from '@qualcomm-ui/angular/icon';

interface CellComponentContext<TData extends object, TValue = any, TColumnMeta = ColumnMeta> {
    context: CellContext<TData, TValue, TColumnMeta> | InputSignal<CellContext<TData, TValue, TColumnMeta>>;
}
interface HeaderComponentContext<TData extends object, TValue = any, TColumnMeta = ColumnMeta> {
    context: HeaderContext<TData, TValue, TColumnMeta> | InputSignal<HeaderContext<TData, TValue, TColumnMeta>>;
}

declare class CellComponentContextDirective<TableData extends object, ColumnValue = any, TableColumnMeta = ColumnMeta> implements CellComponentContext<TableData, ColumnValue, TableColumnMeta> {
    readonly context: i0.InputSignal<CellContext<TableData, ColumnValue, TableColumnMeta>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CellComponentContextDirective<any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CellComponentContextDirective<any, any, any>, never, never, { "context": { "alias": "context"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class HeaderComponentContextDirective<TableData extends object, ColumnValue = any, TableColumnMeta = ColumnMeta> implements HeaderComponentContext<TableData, ColumnValue, TableColumnMeta> {
    readonly context: i0.InputSignal<HeaderContext<TableData, ColumnValue, TableColumnMeta>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderComponentContextDirective<any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HeaderComponentContextDirective<any, any, any>, never, never, { "context": { "alias": "context"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const qdsTableApi: _qualcomm_ui_qds_core_table.QdsTableApi;

declare class RenderCellDirective implements OnDestroy {
    private readonly templateRef;
    private readonly viewContainerRef;
    /**
     * The cell data model.
     */
    readonly renderCell: i0.InputSignal<Cell<any, any, _qualcomm_ui_core_table.ColumnMeta>>;
    /**
     * Additional input properties to pass to the underlying column's cell. Only
     * applicable if the cell is a Component type.
     */
    readonly renderCellComponentInput: i0.InputSignal<Record<string, any> | undefined>;
    /**
     * If `true`, the cell is aggregated.
     * TODO: link to aggregated cell docs.
     */
    readonly renderCellIsAggregated: i0.InputSignalWithTransform<boolean | undefined, Booleanish>;
    constructor();
    ngOnDestroy(): void;
    private render;
    static ɵfac: i0.ɵɵFactoryDeclaration<RenderCellDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RenderCellDirective, "[renderCell]", never, { "renderCell": { "alias": "renderCell"; "required": true; "isSignal": true; }; "renderCellComponentInput": { "alias": "renderCellComponentInput"; "required": false; "isSignal": true; }; "renderCellIsAggregated": { "alias": "renderCellIsAggregated"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class RenderFooterDirective implements OnDestroy {
    private readonly templateRef;
    private readonly viewContainerRef;
    /**
     * The footer data model.
     */
    readonly renderFooter: i0.InputSignal<Header<any, any, _qualcomm_ui_core_table.ColumnMeta>>;
    constructor();
    ngOnDestroy(): void;
    private render;
    static ɵfac: i0.ɵɵFactoryDeclaration<RenderFooterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RenderFooterDirective, "[renderFooter]", never, { "renderFooter": { "alias": "renderFooter"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class RenderHeaderDirective implements OnDestroy {
    private readonly templateRef;
    private readonly viewContainerRef;
    /**
     * The header data model.
     */
    readonly renderHeader: i0.InputSignal<Header<any, any, _qualcomm_ui_core_table.ColumnMeta>>;
    constructor();
    ngOnDestroy(): void;
    private render;
    static ɵfac: i0.ɵɵFactoryDeclaration<RenderHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RenderHeaderDirective, "[renderHeader]", never, { "renderHeader": { "alias": "renderHeader"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableActionBarDirective implements OnInit {
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableActionBarDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableActionBarDirective, "[q-table-action-bar]", never, {}, {}, never, never, false, never>;
}

declare class TableBodyDirective implements OnInit {
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableBodyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableBodyDirective, "[q-table-body]", never, {}, {}, never, never, false, never>;
}

declare class TableCellActionDirective implements OnInit {
    /**
     * Lucide icon to display inside the button.
     */
    readonly icon: i0.InputSignal<LucideIconOrString>;
    protected readonly inlineIconButtonApi: i0.Signal<_qualcomm_ui_qds_core_inline_icon_button.QdsInlineIconButtonApi>;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellActionDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableCellActionDirective, "[q-table-cell-action]", never, { "icon": { "alias": "icon"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableCellDirective implements OnInit, SignalifyInput<QdsTableCellProps> {
    /**
     * The data model for this cell.
     */
    readonly cell: i0.InputSignal<Cell<any, unknown, _qualcomm_ui_core_table.ColumnMeta> | undefined>;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableCellDirective, "[q-table-cell]", never, { "cell": { "alias": "cell"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableColumnDragHandleDirective implements OnInit {
    /**
     * Lucide icon to display inside the button.
     *
     * @default "GripVertical"
     */
    readonly icon: i0.InputSignal<LucideIconOrString>;
    protected readonly inlineIconButtonApi: i0.Signal<_qualcomm_ui_qds_core_inline_icon_button.QdsInlineIconButtonApi>;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnDragHandleDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnDragHandleDirective, "[q-table-column-drag-handle]", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableColumnDragPreviewDirective implements OnInit {
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    protected readonly elementRef: ElementRef<any>;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnDragPreviewDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableColumnDragPreviewDirective, "[q-table-column-drag-preview]", never, {}, {}, never, never, false, never>;
}

declare class TableColumnDropIndicatorDirective implements OnInit, SignalifyInput<QdsTableColumnDropIndicatorProps> {
    /**
     * The closest edge of the column that the indicator is being dragged over.
     */
    readonly closestEdge: i0.InputSignal<"top" | "bottom" | "left" | "right" | undefined>;
    /**
     * The index of the column that the indicator belongs to.
     */
    readonly columnIndex: i0.InputSignalWithTransform<number | undefined, unknown>;
    /**
     * The index of the column being dragged.
     */
    readonly sourceColumnIndex: i0.InputSignalWithTransform<number | undefined, unknown>;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnDropIndicatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableColumnDropIndicatorDirective, "[q-table-column-drop-indicator]", never, { "closestEdge": { "alias": "closestEdge"; "required": false; "isSignal": true; }; "columnIndex": { "alias": "columnIndex"; "required": false; "isSignal": true; }; "sourceColumnIndex": { "alias": "sourceColumnIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableColumnFilterActionDirective implements OnInit, SignalifyInput<QdsTableColumnFilterProps> {
    /**
     * Whether the column can be filtered. Pass in the state from the column:
     *
     * @example
     * ```angular-html
     * <button
     *   q-table-column-filter-action
     *   [canFilter]="header.column.getCanFilter()"
     * ></button>
     * ```
     */
    readonly canFilter: i0.InputSignalWithTransform<boolean | undefined, Booleanish>;
    /**
     * Whether the column is filtered. Pass in the state from the column:
     *
     * @example
     * ```angular-html
     * <button
     *   q-table-column-filter-action
     *   [isFiltered]="header.column.getIsFiltered()"
     * ></button>
     * ```
     */
    readonly isFiltered: i0.InputSignalWithTransform<boolean | undefined, Booleanish>;
    /**
     * The column header associated with the filter.
     */
    readonly header: i0.InputSignal<Header<any, unknown, _qualcomm_ui_core_table.ColumnMeta> | undefined>;
    /**
     * Lucide icon to display inside the button.
     *
     * @default "Funnel"
     */
    readonly icon: i0.InputSignal<LucideIconOrString>;
    protected readonly filterable: i0.Signal<boolean | undefined>;
    protected readonly inlineIconButtonApi: i0.Signal<_qualcomm_ui_qds_core_inline_icon_button.QdsInlineIconButtonApi>;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnFilterActionDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnFilterActionDirective, "[q-table-column-filter-action]", never, { "canFilter": { "alias": "canFilter"; "required": false; "isSignal": true; }; "isFiltered": { "alias": "isFiltered"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableColumnHeaderActionDirective implements OnInit {
    /**
     * Lucide icon to display inside the button.
     */
    readonly icon: i0.InputSignal<LucideIconOrString>;
    protected readonly inlineIconButtonApi: i0.Signal<_qualcomm_ui_qds_core_inline_icon_button.QdsInlineIconButtonApi>;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnHeaderActionDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnHeaderActionDirective, "[q-table-column-header-action]", never, { "icon": { "alias": "icon"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableColumnResizeHandleDirective implements OnInit, SignalifyInput<QdsTableColumnResizerProps> {
    /**
     * The column header associated with the resize handle.
     */
    readonly header: i0.InputSignal<Header<any, unknown, _qualcomm_ui_core_table.ColumnMeta>>;
    /**
     * Lucide icon to display inside the button.
     *
     * @default "UnfoldHorizontal"
     */
    readonly icon: i0.InputSignal<LucideIconOrString>;
    protected readonly inlineIconButtonApi: i0.Signal<_qualcomm_ui_qds_core_inline_icon_button.QdsInlineIconButtonApi>;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnResizeHandleDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnResizeHandleDirective, "[q-table-column-resize-handle]", never, { "header": { "alias": "header"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableColumnSortActionDirective implements OnInit, SignalifyInput<QdsTableColumnSortActionProps> {
    /**
     * Whether the column is sorted. Pass in the state from the column:
     *
     * @example
     * ```angular-html
     * <button
     *   q-table-column-sort-action
     *   [isSorted]="column.getIsSorted()">
     * </button>
     * ```
     */
    readonly isSorted: i0.InputSignal<false | SortDirection>;
    /**
     * The column header associated with the sort action.
     */
    readonly header: i0.InputSignal<Header<any, unknown, _qualcomm_ui_core_table.ColumnMeta>>;
    protected readonly canSort: i0.Signal<boolean>;
    protected readonly sortIcon: i0.Signal<LucideIconOrString>;
    protected readonly inlineIconButtonApi: i0.Signal<_qualcomm_ui_qds_core_inline_icon_button.QdsInlineIconButtonApi>;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnSortActionDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnSortActionDirective, "[q-table-column-sort-action]", never, { "isSorted": { "alias": "isSorted"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableFooterDirective implements OnInit {
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableFooterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableFooterDirective, "[q-table-footer]", never, {}, {}, never, never, false, never>;
}

declare class TableHeaderCellDirective implements OnInit, SignalifyInput<QdsTableHeaderCellProps> {
    /**
     * The order of this column header in the table.
     */
    readonly columnIndex: i0.InputSignalWithTransform<number | undefined, unknown>;
    /**
     * If `true`, the column header is currently being dragged.
     */
    readonly isDragging: i0.InputSignalWithTransform<boolean | undefined, Booleanish>;
    /**
     * If `true`, another column header is being dragged over this header.
     */
    readonly isDraggingOver: i0.InputSignalWithTransform<boolean | undefined, Booleanish>;
    /**
     * If `true`, the header is currently being resized.
     */
    readonly isResizing: i0.InputSignalWithTransform<boolean | undefined, Booleanish>;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderCellDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableHeaderCellDirective, "[q-table-header-cell]", never, { "columnIndex": { "alias": "columnIndex"; "required": false; "isSignal": true; }; "isDragging": { "alias": "isDragging"; "required": false; "isSignal": true; }; "isDraggingOver": { "alias": "isDraggingOver"; "required": false; "isSignal": true; }; "isResizing": { "alias": "isResizing"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableHeaderDirective implements OnInit {
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableHeaderDirective, "[q-table-header]", never, {}, {}, never, never, false, never>;
}

declare class TablePaginationDirective extends PaginationRootDirective {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TablePaginationDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TablePaginationDirective, "[q-table-pagination]", never, {}, {}, never, never, false, never>;
}

declare class TableRootDirective implements OnInit, SignalifyInput<QdsTableApiProps> {
    /**
     * Whether to show column dividers
     */
    readonly showColumnDivider: i0.InputSignalWithTransform<boolean | undefined, Booleanish>;
    /**
     * Governs the size and padding of table elements and text.
     *
     * @default 'md'
     */
    readonly size: i0.InputSignal<QdsTableSize | undefined>;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableRootDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableRootDirective, "[q-table-root]", never, { "showColumnDivider": { "alias": "showColumnDivider"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableRowDragHandleDirective implements OnInit {
    /**
     * Lucide icon to display inside the button.
     *
     * @default "GripHorizontal"
     */
    readonly icon: i0.InputSignal<LucideIconOrString>;
    protected readonly inlineIconButtonApi: i0.Signal<_qualcomm_ui_qds_core_inline_icon_button.QdsInlineIconButtonApi>;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowDragHandleDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableRowDragHandleDirective, "[q-table-row-drag-handle]", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableRowDragPreviewDirective implements OnInit {
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowDragPreviewDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableRowDragPreviewDirective, "[q-table-row-drag-preview]", never, {}, {}, never, never, false, never>;
}

declare class TableRowDropIndicatorDirective implements OnInit, SignalifyInput<QdsTableRowDropIndicatorProps> {
    /**
     * The closest edge of the row that the indicator is being dragged over.
     */
    readonly closestEdge: i0.InputSignal<"top" | "bottom" | "left" | "right" | undefined>;
    /**
     * The index of the row that the indicator belongs to.
     */
    readonly rowIndex: i0.InputSignalWithTransform<number | undefined, unknown>;
    /**
     * The index of the row being dragged.
     */
    readonly sourceIndex: i0.InputSignalWithTransform<number | undefined, unknown>;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowDropIndicatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableRowDropIndicatorDirective, "[q-table-row-drop-indicator]", never, { "closestEdge": { "alias": "closestEdge"; "required": false; "isSignal": true; }; "rowIndex": { "alias": "rowIndex"; "required": false; "isSignal": true; }; "sourceIndex": { "alias": "sourceIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableRowExpandButtonDirective implements OnInit, SignalifyInput<QdsTableRowExpandButtonProps> {
    /**
     * Whether the row is expanded. Pass in the state from the row:
     *
     * @example
     * ```angular-html
     * <button
     *   q-table-row-expand-button
     *   [isExpanded]="row.getIsExpanded()"
     * ></button>
     * ```
     */
    readonly isExpanded: i0.InputSignalWithTransform<boolean | undefined, Booleanish>;
    /**
     * The row associated with the expand button.
     */
    readonly row: i0.InputSignal<Row<any>>;
    /**
     * Lucide icon to display inside the button.
     *
     * @default "ChevronRight"
     */
    readonly icon: i0.InputSignal<LucideIconOrString>;
    protected readonly inlineIconButtonApi: i0.Signal<_qualcomm_ui_qds_core_inline_icon_button.QdsInlineIconButtonApi>;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowExpandButtonDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableRowExpandButtonDirective, "[q-table-row-expand-button]", never, { "isExpanded": { "alias": "isExpanded"; "required": false; "isSignal": true; }; "row": { "alias": "row"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableRowDirective implements OnInit, SignalifyInput<QdsTableRowProps> {
    /**
     * If `true`, the row is currently being dragged.
     */
    readonly isDragging: i0.InputSignalWithTransform<boolean | undefined, Booleanish>;
    /**
     * If `true`, another row is being dragged over this row.
     */
    readonly isDraggingOver: i0.InputSignalWithTransform<boolean | undefined, Booleanish>;
    /**
     * If `true`, the row is currently selected.
     */
    readonly isSelected: i0.InputSignalWithTransform<boolean | undefined, Booleanish>;
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableRowDirective, "[q-table-row]", never, { "isDragging": { "alias": "isDragging"; "required": false; "isSignal": true; }; "isDraggingOver": { "alias": "isDraggingOver"; "required": false; "isSignal": true; }; "isSelected": { "alias": "isSelected"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class TableScrollContainerDirective implements OnInit {
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableScrollContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableScrollContainerDirective, "[q-table-scroll-container]", never, {}, {}, never, never, false, never>;
}

declare class TableTableDirective implements OnInit {
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableTableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableTableDirective, "[q-table-table]", never, {}, {}, never, never, false, never>;
}

declare class TableTitleBarDirective implements OnInit {
    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
        setDisabled: (disabled: boolean) => void;
    };
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableTitleBarDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableTitleBarDirective, "[q-table-title-bar]", never, {}, {}, never, never, false, never>;
}

declare class TableModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TableModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TableModule, [typeof TableActionBarDirective, typeof TableBodyDirective, typeof TableCellActionDirective, typeof TableCellDirective, typeof TableColumnDragHandleDirective, typeof TableColumnDragPreviewDirective, typeof TableColumnDropIndicatorDirective, typeof TableColumnFilterActionDirective, typeof TableColumnHeaderActionDirective, typeof TableColumnResizeHandleDirective, typeof TableColumnSortActionDirective, typeof TableFooterDirective, typeof TableHeaderCellDirective, typeof TableHeaderDirective, typeof TablePaginationDirective, typeof TableRootDirective, typeof TableRowDirective, typeof TableRowDragHandleDirective, typeof TableRowDragPreviewDirective, typeof TableRowDropIndicatorDirective, typeof TableRowExpandButtonDirective, typeof TableScrollContainerDirective, typeof TableTableDirective, typeof TableTitleBarDirective, typeof RenderCellDirective, typeof RenderHeaderDirective, typeof RenderFooterDirective], [typeof _qualcomm_ui_angular_core_machine.QBindDirective, typeof i29.IconDirective], [typeof TableActionBarDirective, typeof TableBodyDirective, typeof TableCellActionDirective, typeof TableCellDirective, typeof TableColumnDragHandleDirective, typeof TableColumnDragPreviewDirective, typeof TableColumnDropIndicatorDirective, typeof TableColumnFilterActionDirective, typeof TableColumnHeaderActionDirective, typeof TableColumnResizeHandleDirective, typeof TableColumnSortActionDirective, typeof TableFooterDirective, typeof TableHeaderCellDirective, typeof TableHeaderDirective, typeof TablePaginationDirective, typeof TableRootDirective, typeof TableRowDirective, typeof TableRowDragHandleDirective, typeof TableRowDragPreviewDirective, typeof TableRowDropIndicatorDirective, typeof TableRowExpandButtonDirective, typeof TableScrollContainerDirective, typeof TableTableDirective, typeof TableTitleBarDirective, typeof RenderCellDirective, typeof RenderHeaderDirective, typeof RenderFooterDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TableModule>;
}

interface AngularTable<TData extends RowData> extends TableInstance<TData>, Signal<TableInstance<TData>> {
}
declare function createAngularTable<TData extends RowData>(options: () => TableOptions<TData>): AngularTable<TData>;

interface CreateTablePaginationOptions {
    /**
     * The total number of data items. When using manual pagination, you must provide
     * this for accurate page counts.
     */
    totalCount?: Signal<number>;
}
interface TablePagination {
    count: Signal<number>;
    onPageChange: (page: number) => void;
    onPageSizeChange: (rows: number) => void;
    page: Signal<number>;
    pageSize: Signal<number>;
}
/**
 * A helper function that creates an object. The properties on the object derive the
 * QUI Pagination state from the current table state, or update it.
 */
declare function createTablePagination<TData extends RowData>(table: AngularTable<TData>, opts?: CreateTablePaginationOptions): TablePagination;

export { CellComponentContextDirective, HeaderComponentContextDirective, RenderCellDirective, RenderFooterDirective, RenderHeaderDirective, TableActionBarDirective, TableBodyDirective, TableCellActionDirective, TableCellDirective, TableColumnDragHandleDirective, TableColumnDragPreviewDirective, TableColumnDropIndicatorDirective, TableColumnFilterActionDirective, TableColumnHeaderActionDirective, TableColumnResizeHandleDirective, TableColumnSortActionDirective, TableFooterDirective, TableHeaderCellDirective, TableHeaderDirective, TableModule, TablePaginationDirective, TableRootDirective, TableRowDirective, TableRowDragHandleDirective, TableRowDragPreviewDirective, TableRowDropIndicatorDirective, TableRowExpandButtonDirective, TableScrollContainerDirective, TableTableDirective, TableTitleBarDirective, createAngularTable, createTablePagination, qdsTableApi };
export type { AngularTable, CellComponentContext, CreateTablePaginationOptions, HeaderComponentContext, TablePagination };
//# sourceMappingURL=qualcomm-ui-angular-table.d.ts.map