import * as forty_cdk_core from 'forty-cdk/core';
import { WritingDirection } from 'forty-cdk/core';
import * as _angular_core from '@angular/core';
import { InjectionToken, Signal, Type, Provider, TemplateRef, Injector, ElementRef } from '@angular/core';
import * as forty_cdk_table from 'forty-cdk/table';
import * as i1 from 'forty-cdk/drag-drop';

/** ARIA pattern the table renders as. `'table'` is the static structure; `'grid'` / `'treegrid'` add roving + 2D keyboard navigation. */
type TableMode = 'table' | 'grid' | 'treegrid';
/** Row-selection mode for `ForTable`. `'none'` disables selection. */
type TableSelectionMode = 'none' | 'single' | 'multiple';
/** How a row click mutates selection. `'toggle'` flips it; `'replace'` replaces (modifier-aware). */
type TableSelectionBehavior = 'toggle' | 'replace';
/** Aggregate selection state across the table's selectable rows, for the select-all tri-state. */
type TableSelectAllState = 'none' | 'some' | 'all';
/** Sticky placement for a cell: pinned to the start edge (`true`), the end edge (`'end'`), or not sticky (`false`). */
type TableStickyValue = boolean | 'end';
/**
 * Consumer-facing coordination surface owned by `ForTable`: the resolved ARIA
 * mode / direction / selection mode, the row counts, and the selection /
 * expansion commands.
 *
 * It carries neither the piece-registration protocol nor the
 * roving-grid model: how header rows, header cells, data rows, the declarative
 * body's row count, the virtualization seams and the resized column widths wire
 * themselves into the root, and where the grid's single tab stop currently
 * sits, are the library's own business and change without notice.
 */
interface ForTableContext {
    /** The resolved ARIA mode; cells derive `role` (`cell` vs `gridcell`) from it, and navigation engages when it is not `'table'`. */
    readonly mode: Signal<TableMode>;
    /** The resolved writing direction (flips ArrowLeft / ArrowRight in `rtl`). */
    readonly dir: Signal<WritingDirection>;
    /** The active row-selection mode. `'none'` means selection is disabled. */
    readonly selectionMode: Signal<TableSelectionMode>;
    /** Returns whether `value` is currently in the selection. */
    isRowSelected(value: unknown): boolean;
    /** Toggles `value` in or out of the selection, respecting `selectionMode`. No-op in `'none'` mode. */
    toggleRowSelection(value: unknown): void;
    /**
     * Applies a row selection click with optional modifier keys, honoring `selectionBehavior`:
     * `'toggle'` always flips; `'replace'` replaces (Ctrl/Cmd toggles a single item,
     * Shift extends a range in multiple mode).
     */
    selectRow(value: unknown, modifiers?: {
        ctrlKey?: boolean;
        metaKey?: boolean;
        shiftKey?: boolean;
    }): void;
    /** Aggregate selection state across all selectable rows (`'none'` / `'some'` / `'all'`). */
    readonly selectAllState: Signal<TableSelectAllState>;
    /** Selects all selectable rows when not all are selected; clears when all are. No-op outside `'multiple'` mode. */
    toggleSelectAll(): void;
    /**
     * The resolved true total data-row count for `aria-rowcount` and the virtualized
     * scroll range, in resolution order: the explicit `[rowCount]` input when set,
     * else the declarative `<for-table-body>`'s dataset length when a body has
     * registered one, else `undefined` (readers fall back to the rendered row count).
     */
    readonly rowCount: Signal<number | undefined>;
    /**
     * The count of currently loaded data rows (the declarative `<for-table-body>`
     * dataset length), or `undefined` when no body has registered one (raw-primitive
     * rendering). Distinct from `rowCount`, which an explicit `[rowCount]` raises to a
     * server-known total larger than the loaded rows; cross-window navigation clamps
     * unmounted targets to this so a target beyond the loaded prefix cannot stash a
     * pending focus move that resolves only when a far page later loads.
     */
    readonly loadedRowCount: Signal<number | undefined>;
    /**
     * Absolute index of the row that owns the currently roving-focused cell, or `null`
     * when no cell is focused (or the focused row carries no `virtualIndex`). Read by
     * `[forTableVirtualized]` to keep the focused row mounted across recycling.
     */
    readonly focusedRowIndex: Signal<number | null>;
    /** Whether `value` is in the open-rows set (`treegrid` expansion). */
    isRowExpanded(value: unknown): boolean;
    /** Toggles a parent row's expansion in/out of `[(expanded)]`. No-op when value is undefined. */
    toggleRowExpansion(value: unknown): void;
}
/**
 * The table's piece-coordination surface: the 2D roving grid model the rows,
 * cells and header cells resolve their `tabindex` / `data-highlighted` /
 * keydown through, and the ARIA index arithmetic derived from it.
 *
 * **Not** part of {@link ForTableContext} and never exported from
 * `public-api.ts`. A consumer reads the selection and expansion state off the
 * token; where the grid's single tab stop currently sits is the library's own
 * navigation model, refactored without notice.
 */
interface TablePieceContext {
    /**
     * 1-based `aria-rowindex` for the header row in `grid` / `treegrid` mode (always
     * `1`, since ARIA counts the header row as the grid's first row), or `null` in
     * `mode="table"` where no row index space exists.
     */
    readonly headerRowIndex: Signal<number | null>;
    /**
     * Offset ARIA adds to every data row's 1-based `aria-rowindex` so the numbering
     * counts the header row: `1` when a header row participates in the row-index
     * space (`grid` / `treegrid` mode with a registered header row), else `0`.
     */
    readonly dataRowIndexOffset: Signal<number>;
    /** Roving `tabindex` (`0` for the single tab stop, `-1` otherwise) for a header cell in grid mode. */
    headerCellTabIndex(host: HTMLElement): 0 | -1;
    /** 0-based index of a header cell host among registered header cells in DOM order, or -1 if not registered. */
    headerCellIndexOf(host: HTMLElement): number;
    /**
     * Whether the registered header cells form a complete row that joins the body's
     * roving composite grid (`grid` / `treegrid` mode, header cell count matches the
     * data column count). Draggable header cells (`[forTableColumnReorder]`) participate
     * too, so a column-reorderable grid stays a single composite tab stop. `false` in
     * `table` mode or when no header cells registered.
     */
    readonly headerParticipatesInRoving: Signal<boolean>;
    /** 0-based index of a data row host in DOM order, or -1 if not registered. */
    rowIndexOf(host: HTMLElement): number;
    /** Roving `tabindex` (`0` for the single tab stop, `-1` otherwise) for a data cell in grid mode. */
    cellTabIndex(host: HTMLElement): 0 | -1;
    /** Whether a data cell is the currently roving-focused cell (drives `data-highlighted`). */
    isCellHighlighted(host: HTMLElement): boolean;
    /** Promotes a data cell to the active roving cell (called on the cell's `(focus)`). */
    activateCell(host: HTMLElement): void;
    /** Resolves and applies a keydown originating on a data cell: 2D move + focus. */
    handleCellKeydown(event: KeyboardEvent, host: HTMLElement): void;
    /**
     * Resolves grid navigation for a header cell that yields its host interaction to a
     * co-located `[forDraggable]`. `[forTableColumnReorder]` calls this from a
     * capture-phase listener for idle header cells so Arrow / Home / End / Page keys move
     * roving focus across the composite header + body grid, while Space / Enter fall
     * through to the draggable's lift. Returns `true` when the key was consumed as a grid
     * action, `false` otherwise (including outside a participating `grid` / `treegrid`).
     */
    handleHeaderCellKeydown(event: KeyboardEvent, host: HTMLElement): boolean;
    /** 1-based `aria-posinset` for a row host among its same-level siblings (treegrid). */
    rowPosinset(host: HTMLElement): number;
    /** Total `aria-setsize` of a row host's same-level sibling set (treegrid). */
    rowSetsize(host: HTMLElement): number;
}
/**
 * The table's internal coordination surface: everything {@link ForTableContext}
 * publishes plus the {@link TablePieceContext} grid model.
 *
 * Never exported from `public-api.ts`. It is the type the pieces read
 * {@link FOR_TABLE_CONTEXT} at, so a consumer who injects that token gets the
 * read surface while the pieces get the navigation model. `ForTable` declares
 * those members TS-`private`, which keeps them out of the emitted `.d.ts` while
 * `useExisting` still satisfies this contract at runtime.
 *
 * Distinct from the **piece-registration** protocol, which is the one surface
 * that genuinely needs a second token: it lives in `forty-cdk/core` because
 * `forty-cdk/table-virtualization` registers through it.
 */
interface TableContext extends ForTableContext, TablePieceContext {
}
/**
 * DI token for the table's coordination surface, provided by `[forTable]`.
 *
 * Publicly typed as the read surface {@link ForTableContext}, which is the whole of what
 * the token promises a consumer. The pieces read the same token at an internal type that
 * adds the roving grid model, so a wrapper re-providing it must alias it to the root:
 * `{ provide: FOR_TABLE_CONTEXT, useExisting: MyTable }`, where `MyTable` extends
 * `ForTable`. A value that merely satisfies the declared type resolves too, and is
 * rejected in dev mode by the first piece to reach the model.
 */
declare const FOR_TABLE_CONTEXT: InjectionToken<ForTableContext>;
/**
 * Per-row read surface owned by `ForTableRow`, injected by its data cells. The
 * cell-registration half lives on {@link TableRowContext}, so no `register*`
 * member reaches `ForTableRow`'s emitted public type.
 */
interface ForTableRowContext {
    /** 0-based index of a cell host within this row in DOM order, or -1 if not registered. */
    cellIndexOf(host: HTMLElement): number;
    /** The active row-selection mode from the root table. */
    readonly selectionMode: Signal<TableSelectionMode>;
    /** Whether this row is currently selected. */
    readonly selected: Signal<boolean>;
    /** Toggles this row's selection. No-op when the row has no `[value]` or mode is `'none'`. */
    toggleSelected(): void;
}

/**
 * Root of the Table primitive. Sets the ARIA `role` from `mode`, reflects
 * writing direction, and publishes the `--for-table-header-height` CSS custom
 * property (driven by a `ResizeObserver` on the first registered header row)
 * so consumers can `position: sticky` header cells without hard-coding offsets.
 *
 * Implements the [WAI-ARIA Table pattern](https://www.w3.org/WAI/ARIA/apg/patterns/table/)
 * and the [WAI-ARIA Grid pattern](https://www.w3.org/WAI/ARIA/apg/patterns/grid/).
 *
 * Use `mode="grid"` or `mode="treegrid"` for interactive grid semantics: a
 * single-tab-stop roving group with 2D arrow navigation over data cells.
 * The default `mode="table"` is the static read-only structure.
 */
declare class ForTable<T = unknown> implements ForTableContext {
    #private;
    /**
     * ARIA role emitted on the host. `'table'` is the default static read-only
     * structure. `'grid'` and `'treegrid'` provide single-tab-stop roving + 2D
     * arrow navigation over data cells.
     */
    readonly mode: _angular_core.InputSignal<TableMode>;
    /**
     * Accessible label for the table. When set, reflected as `aria-label`.
     * Consumers with a visible caption should prefer pointing native
     * `aria-labelledby` at it instead; this input is the reactive convenience
     * hook for cases where no visible label element exists.
     */
    readonly ariaLabel: _angular_core.InputSignal<string | null>;
    protected readonly resolvedAriaLabel: Signal<string | null>;
    /**
     * Writing direction. When unset (default `null`), the inherited ambient
     * direction is resolved from the nearest ancestor carrying a `dir` attribute
     * (or `<html dir>`), defaulting to `'ltr'`. An explicit `[dir]` always wins.
     * The resolved value is reflected to the host `dir` attribute.
     */
    readonly _dirInput: _angular_core.InputSignal<WritingDirection | null>;
    readonly dir: Signal<WritingDirection>;
    /**
     * Explicit override for the true total data-row count (`aria-rowcount` and the
     * virtualized scroll range). A declarative `<for-table-body>` supplies this
     * automatically from its `rows` dataset length, so bind `[rowCount]` only for a
     * server-known total larger than the loaded rows; when set it wins over the
     * body-derived count. Defaults to the body count, else the rendered data-row
     * count plus the header offset — so an empty non-virtualized grid with a header
     * row reports `aria-rowcount="1"`, because its rendered rows are all the rows it
     * has. A **windowed** grid rendering no data row is the one shape whose total is
     * unknowable, and there `aria-rowcount` reports `-1`, the value ARIA reserves for
     * an unknown total. An explicit value is emitted verbatim, including `0`. Ignored
     * in `mode="table"`.
     */
    readonly _rowCountInput: _angular_core.InputSignal<number | undefined>;
    /**
     * Resolved true total data-row count: the explicit `[rowCount]` input when set,
     * else the declarative `<for-table-body>`'s dataset length, else `undefined`
     * (readers fall back to the rendered count). Feeds `aria-rowcount`, the
     * cross-window navigation total, and the virtualizer's count.
     */
    readonly rowCount: Signal<number | undefined>;
    /**
     * The count of currently loaded data rows (the declarative `<for-table-body>`
     * dataset length), or `undefined` when no body has registered one (raw-primitive
     * rendering). Distinct from `rowCount`, which an explicit `[rowCount]` raises to a
     * server-known total larger than the loaded rows; cross-window navigation clamps
     * unmounted targets to this so a target beyond the loaded prefix cannot stash a
     * pending focus move that resolves — and steals focus — only when a far page later
     * loads.
     */
    readonly loadedRowCount: Signal<number | undefined>;
    /**
     * True total number of columns for `aria-colcount`. Defaults to the rendered
     * column count (the cells of the first data row that has any, else the registered
     * header cells) — and when no channel knows the count, `aria-colcount` reports
     * `-1`, the value ARIA reserves for an unknown total. That is the shape a
     * virtualized grid with no header row has until its first window resolves: no row
     * is rendered, so no cell has registered.
     *
     * Unlike `aria-rowcount`, that sentinel is **unconditional** — it is not gated on
     * the grid being windowed.
     * A non-windowed grid with no registered cell has rows without cells, or no markup
     * at all: degenerate either way, so there is no state where `0` is the resolved
     * answer rather than the missing one, and emitting it would re-open exactly the
     * "`0` reads as a real answer" defect the sentinel exists for.
     *
     * An explicit value is emitted verbatim, including `0`. Ignored in `mode="table"`.
     */
    readonly colCount: _angular_core.InputSignal<number | undefined>;
    /** Row selection mode. `'none'` (default) disables selection entirely. */
    readonly selectionMode: _angular_core.InputSignal<TableSelectionMode>;
    /**
     * How a row click changes the selection. `'toggle'` (default) flips the clicked
     * row. `'replace'` replaces the selection with the clicked row; Ctrl/Cmd-click
     * toggles a single row and Shift-click extends a range (multiple mode only).
     */
    readonly selectionBehavior: _angular_core.InputSignal<TableSelectionBehavior>;
    /**
     * Two-way bindable selected row values (each row's `[value]`). Single mode keeps
     * 0–1 entries. The implicit `valueChange` fires only on internal mutations
     * (selector / row click / Space / select-all), never on consumer writes. The
     * directive infers the row-value type `T` from this binding.
     */
    readonly value: _angular_core.ModelSignal<readonly T[]>;
    /** Equality comparator for row values. Defaults to `===`; supply id-based for objects. */
    readonly compareWith: _angular_core.InputSignal<(a: T, b: T) => boolean>;
    /**
     * Full ordered set of selectable row values (each row's `[value]`), for a
     * virtualized or server-paged table whose aggregate selection operations must
     * span rows beyond the rendered window. When `null` (default), the select-all
     * tri-state, `toggleSelectAll`, and Shift-click range selection compute against
     * the registered (rendered) rows only. When supplied, they use this set as the
     * universe of selectable values, so a range can span unmounted rows and the
     * tri-state reflects the true dataset. Per-row selection is unaffected.
     */
    readonly selectableValues: _angular_core.InputSignal<readonly T[] | null>;
    /**
     * Two-way bindable open parent-row values (each row's `[value]`), for
     * `mode="treegrid"`. The implicit `expandedChange` fires only on internal
     * expand/collapse (ArrowRight/ArrowLeft, `toggleRowExpansion`), never on
     * consumer writes through `[(expanded)]`. Ignored outside `treegrid` mode.
     */
    readonly expanded: _angular_core.ModelSignal<readonly T[]>;
    protected readonly headerSize: Signal<forty_cdk_core.ElementBox | null>;
    private readonly headerParticipatesInRoving;
    /** 1-based row offset ARIA applies to data rows because the header row occupies index 1. */
    private readonly dataRowIndexOffset;
    private readonly headerRowIndex;
    readonly selectAllState: Signal<TableSelectAllState>;
    /**
     * Absolute index of the row that owns the currently roving-focused cell, or `null`
     * when no cell is focused (or the focused row carries no `virtualIndex`). Used by
     * `[forTableVirtualized]` to keep the focused row mounted across recycling.
     */
    readonly focusedRowIndex: Signal<number | null>;
    protected readonly rowCountAttr: Signal<number | null>;
    protected readonly colCountAttr: Signal<number | null>;
    isRowExpanded(value: T): boolean;
    toggleRowExpansion(value: T): void;
    private rowPosinset;
    private rowSetsize;
    private rowIndexOf;
    private cellTabIndex;
    private headerCellTabIndex;
    private headerCellIndexOf;
    private isCellHighlighted;
    private activateCell;
    isRowSelected(value: T): boolean;
    toggleRowSelection(value: T): void;
    selectRow(value: T, modifiers?: {
        ctrlKey?: boolean;
        metaKey?: boolean;
        shiftKey?: boolean;
    }): void;
    toggleSelectAll(): void;
    private handleCellKeydown;
    /**
     * Resolves grid navigation for a header cell that yields its host interaction to a
     * co-located `[forDraggable]` (a `[forTableColumnReorder]` row). `[forTableColumnReorder]`
     * calls this from a capture-phase listener for idle (not-lifted) header cells, so Arrow /
     * Home / End / Page keys move roving focus across the composite header + body grid while
     * Space / Enter still fall through to the draggable's lift. Returns `true` when the key
     * resolved to a grid action (and was consumed), `false` otherwise. No-op (returns `false`)
     * outside `grid` / `treegrid` mode or when the header row does not join the composite grid.
     */
    private handleHeaderCellKeydown;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTable<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTable<any>, "[forTable]", ["forTable"], { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "_dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "_rowCountInput": { "alias": "rowCount"; "required": false; "isSignal": true; }; "colCount": { "alias": "colCount"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "selectionBehavior": { "alias": "selectionBehavior"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "selectableValues": { "alias": "selectableValues"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "expanded": "expandedChange"; }, never, never, true, never>;
}
/**
 * The providers a `[forTable]` root installs: the public
 * {@link FOR_TABLE_CONTEXT}, aliased to `root`, plus the internal
 * piece-registration wiring the table's pieces resolve.
 *
 * `ForTable` declares its own providers through this helper, so a wrapper that
 * **subclasses** the root has a single call to keep in step with it. That
 * matters because Angular does not inherit a directive's `providers`: a subclass
 * carrying its own `@Directive` metadata replaces the array wholesale, so
 * re-providing `FOR_TABLE_CONTEXT` alone leaves the registration wiring absent
 * and every piece — down to the root's own constructor — fails to resolve it.
 * The internal providers are unnameable outside the library, which is why the
 * wrapper cannot list them by hand.
 *
 * ```ts
 * providers: provideForTable(MyTable),
 * ```
 *
 * Wrapping through `hostDirectives: [ForTable]` needs none of this — a host
 * directive brings its own providers to the element.
 */
declare function provideForTable<T = unknown>(root: Type<ForTable<T>>): Provider[];

/**
 * Template context handed to each `[forTableCellDef]` stamped by `ForTableBody`:
 * the row datum (`let-row`) and its 0-based dataset index (`let-i="index"`).
 */
interface ForTableCellDefContext<T> {
    /** The row datum for this cell (`let-row`). */
    $implicit: T;
    /**
     * 0-based dataset index of the row (`let-i="index"`). In a non-virtualized
     * table this equals the row's rendered position; under `[forTableVirtualized]`
     * it is the **absolute** index into the full dataset, not the position within
     * the rendered window.
     */
    index: number;
}
/**
 * Marks the header-cell template of a column definition. Place on an
 * `<ng-template forTableHeaderCellDef>` inside a `[forTableColumnDef]`; its content is
 * stamped into the column's `[forTableHeaderCell]` by `ForTableBody`.
 */
declare class ForTableHeaderCellDef {
    /** The captured header-cell template. */
    readonly template: TemplateRef<unknown>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableHeaderCellDef, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableHeaderCellDef, "ng-template[forTableHeaderCellDef]", never, {}, {}, never, never, true, never>;
}
/**
 * Marks the data-cell template of a column definition. Place on an
 * `<ng-template forTableCellDef>` inside a `[forTableColumnDef]`; its content is stamped
 * into the column's `[forTableCell]` for every rendered row, with the row datum
 * and index exposed through `ForTableCellDefContext`.
 *
 * Bind `[forTableCellDefRow]` to the same array passed to `ForTableBody`'s `rows`
 * to type `let-row` — the input is read only for type inference, never at
 * runtime.
 *
 * When the row type is a discriminated union whose variant members render
 * through a `[forTableRowDef]` instead of the per-column cells, bind
 * `[forTableCellDefUnless]` to the same type guard(s) used on those defs' `[when]`
 * so `let-row` is narrowed to the variant-excluded members (`Exclude<T, V>`).
 */
declare class ForTableCellDef<T, V extends T = never> {
    /** The captured data-cell template, typed with `ForTableCellDefContext<T>`. */
    readonly template: TemplateRef<ForTableCellDefContext<T>>;
    /**
     * Type-inference hint: bind to the same collection as `ForTableBody`'s `rows`
     * so `let-row` is typed as the row type. Read only by the compiler; the
     * directive never touches its value.
     */
    readonly rowType: _angular_core.InputSignal<readonly T[]>;
    /**
     * Type-inference hint: bind the type guard(s) that match the variant rows
     * rendered by `[forTableRowDef]` (the same predicate used on their `[when]`) so
     * `let-row` is narrowed to `Exclude<T, V>` — the members this per-column
     * template actually receives. Compose several variants into one union guard
     * (`(r): r is A | B => …`). Read only by the compiler; the directive never
     * touches its value. Omitting it leaves `let-row` typed as the full `T`.
     */
    readonly excludeType: _angular_core.InputSignal<((row: T, index: number) => row is V) | null>;
    /** Narrows the template context type for `let-row` under strict template checking. */
    static ngTemplateContextGuard<T, V extends T>(_directive: ForTableCellDef<T, V>, _context: unknown): _context is ForTableCellDefContext<Exclude<T, V>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableCellDef<any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableCellDef<any, any>, "ng-template[forTableCellDef]", never, { "rowType": { "alias": "forTableCellDefRow"; "required": false; "isSignal": true; }; "excludeType": { "alias": "forTableCellDefUnless"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
/**
 * Marks the placeholder/skeleton template of a column definition. Optional;
 * place on an `<ng-template forTablePlaceholderCellDef>` inside a `[forTableColumnDef]`. When
 * `ForTableBody` is in its `loading` state it stamps this into the column's
 * `[forTableCell]` for each placeholder row.
 *
 * It is the first step of a three-step resolution: a column's own
 * `[forTablePlaceholderCellDef]` wins, else the body-level
 * `[forTablePlaceholderCellDefault]`, else the cell stays empty.
 */
declare class ForTablePlaceholderCellDef {
    /** The captured placeholder-cell template. */
    readonly template: TemplateRef<unknown>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTablePlaceholderCellDef, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTablePlaceholderCellDef, "ng-template[forTablePlaceholderCellDef]", never, {}, {}, never, never, true, never>;
}
/**
 * Marks the **body-level default** placeholder/skeleton template. Optional and
 * declared **once per body** (not per column); place on an
 * `<ng-template forTablePlaceholderCellDefault>` among the `[forTableColumnDef]`s.
 * `ForTableBody` stamps it into every displayed column that declares no
 * `[forTablePlaceholderCellDef]` of its own — most columns of a table share one skeleton
 * shape, so it is declared once rather than repeated per def.
 *
 * Resolution order per column, in both stamping paths (`[loading]` placeholder
 * rows and `placeholderCells` row variants): the column's own
 * `[forTablePlaceholderCellDef]` → this default → an empty cell when neither exists.
 * The template receives no context, exactly like `[forTablePlaceholderCellDef]`.
 *
 * It registers itself with the surrounding body's def registry at construction,
 * so a wrapping component can declare it (or project it) — see
 * {@link ForTableDefRegistry}. Declared outside any registry it throws.
 */
declare class ForTablePlaceholderCellDefault {
    /** The captured default placeholder-cell template. */
    readonly template: TemplateRef<unknown>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTablePlaceholderCellDefault, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTablePlaceholderCellDefault, "ng-template[forTablePlaceholderCellDefault]", never, {}, {}, never, never, true, never>;
}
/**
 * Marks the shared drag placeholder for the reorderable columns of a
 * `<for-table-body>`. Optional and declared **once per body** (not per column);
 * place on an `<ng-template forTableColumnDragPlaceholder>` among the `[forTableColumnDef]`s.
 * `ForTableBody` stamps it as every reorderable header cell's
 * `[forDragPlaceholder]`, so during a pointer reorder the dragged column's slot
 * shows this template. Omit it to keep drag-drop's default placeholder behaviour.
 *
 * It registers itself with the surrounding body's def registry at construction,
 * so a wrapping component can declare it (or project it) — see
 * {@link ForTableDefRegistry}. Declared outside any registry it throws.
 */
declare class ForTableColumnDragPlaceholder {
    /** The captured placeholder template rendered in a reordered column's slot. */
    readonly template: TemplateRef<unknown>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableColumnDragPlaceholder, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableColumnDragPlaceholder, "ng-template[forTableColumnDragPlaceholder]", never, {}, {}, never, never, true, never>;
}
/**
 * Declarative definition of a single table column, co-locating its header,
 * data, and (optional) placeholder templates plus its per-column config in one
 * place. Place `[forTableColumnDef]` on an `<ng-container>` inside a `<for-table-body>`;
 * the container renders nothing itself — `ForTableBody` harvests the defs and
 * stamps the header row and data rows from them.
 *
 * The def **registers itself** with the surrounding body through DI at
 * construction (and unregisters when destroyed), so it does not have to be
 * declared content of the `<for-table-body>` element: a preset column component
 * may declare it in its own view, and a scaffold wrapper may project it into a
 * body it owns. See {@link ForTableDefRegistry} for both recipes. A def with no
 * reachable registry throws.
 *
 * @example
 * ```html
 * <ng-container forTableColumnDef="name" sticky sortable resizable resizeAriaLabel="Resize name">
 *   <ng-template forTableHeaderCellDef>Name</ng-template>
 *   <ng-template forTableCellDef [forTableCellDefRow]="rows()" let-row>{{ row.name }}</ng-template>
 * </ng-container>
 * ```
 */
declare class ForTableColumnDef {
    /**
     * Column identifier — reflected as `data-column` on the stamped cells and used to key the resize
     * width var. Mandatory — an unbound def throws in dev mode.
     */
    readonly name: _angular_core.InputSignal<string>;
    /**
     * Sticky placement forwarded to both the header cell and every data cell:
     * `true` (or the bare `sticky` attribute) pins to the start edge, `'end'` to
     * the end edge, `false` (default) is not sticky. The consumer applies
     * `position: sticky` + offsets in CSS off the emitted `data-sticky` hook.
     */
    readonly sticky: _angular_core.InputSignalWithTransform<TableStickyValue, string | boolean>;
    /**
     * When set, the column's header cell becomes a sortable affordance: `ForTableBody`
     * applies `[forTableSortHeader]`, derives its direction from the body's `sort`
     * input, and re-emits activation through the body's `sortChange` output.
     */
    readonly sortable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * When set, `ForTableBody` renders a `[forTableColumnResizer]` inside the column's
     * header cell and re-emits its commits through the body's `resizeCommit` output.
     * Provide `resizeAriaLabel` so the handle is named. Tune the handle per column with
     * `resizeMin` / `resizeMax` / `resizeStep` / `autoFit` / `fitIncludesHeader`, and
     * seed / track its width through the body's `[(columnWidths)]`.
     */
    readonly resizable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * When set, the column's header cell becomes a drag-reorder handle: with at least
     * one `reorderable` column, `ForTableBody` applies `[forTableColumnReorder]` to the
     * stamped header row and `[forDraggable]` (with `[dragData]` set to this column's
     * `name`) to this header cell, and re-emits committed reorders through the body's
     * `columnReorder` output. Non-reorderable columns stay static (not draggable).
     * The body bundles `forty-cdk/drag-drop` whether or not a column is `reorderable`
     * (a measured 18.0 kB raw / 5.1 kB gzip — see the table README's bundle note).
     */
    readonly reorderable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Accessible name for the auto-wired resize handle (only meaningful with
     * `resizable`). Supplied by the consumer so it is localizable; `null` (default)
     * ships no `aria-label`.
     */
    readonly resizeAriaLabel: _angular_core.InputSignal<string | null>;
    /**
     * Minimum width (px) the auto-wired resize handle clamps to (only meaningful with
     * `resizable`). Forwarded to the stamped `[forTableColumnResizer]`'s `min`; drives
     * its `aria-valuemin`. Default `0`.
     */
    readonly resizeMin: _angular_core.InputSignal<number>;
    /**
     * Maximum width (px) the auto-wired resize handle clamps to (only meaningful with
     * `resizable`). Forwarded to the stamped `[forTableColumnResizer]`'s `max`; drives
     * its `aria-valuemax` (omitted when non-finite). Default `Infinity` (no upper bound).
     */
    readonly resizeMax: _angular_core.InputSignal<number>;
    /**
     * Pixels applied per `ArrowLeft` / `ArrowRight` press on the auto-wired resize
     * handle (only meaningful with `resizable`). Forwarded to the stamped
     * `[forTableColumnResizer]`'s `step`. Default `10`.
     */
    readonly resizeStep: _angular_core.InputSignal<number>;
    /**
     * Whether double-clicking the auto-wired resize handle fits the column to its
     * widest content (only meaningful with `resizable`). Forwarded to the stamped
     * `[forTableColumnResizer]`'s `autoFit`. Default `true` — the historical
     * hardcoded behaviour; set `false` to make the double-click a no-op.
     */
    readonly autoFit: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Whether header-inclusive auto-fit also accounts for the column header's label
     * (only meaningful with `resizable` + `autoFit`). Forwarded to the stamped
     * `[forTableColumnResizer]`'s `fitIncludesHeader`; isolate the header text with a
     * `[forTableColumnLabel]` inside the `[forTableHeaderCellDef]` template. Default `false`.
     */
    readonly fitIncludesHeader: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * `grid-template-columns` track fragment for this column (e.g. `'160px'`,
     * `'minmax(160px, 1fr)'`). When unset, `ForTableBody` falls back to the
     * published `--for-table-col-<name>-width` resize var with `fallbackWidth`
     * (or `minmax(0, 1fr)`) as the var's default, so a resized column drives its
     * own track. A static `width` **takes precedence** over that resize var — so
     * leave it unset on a `resizable` column whose width you drive through
     * `resizeCommit` or the body's `[(columnWidths)]`, otherwise the pinned track
     * ignores the resized width (the handle still reports `aria-valuenow` but the
     * column won't move). Dev-mode-guarded against fragments that would escape the
     * derived track string (see `fallbackWidth`).
     */
    readonly width: _angular_core.InputSignal<string | null>;
    /**
     * `grid-template-columns` track fragment used as the resize-var **fallback**
     * for a column with no explicit `width` — the track the column renders before
     * a width is committed or seeded (e.g. `'minmax(120px, 2.5fr)'` for a
     * weighted, floor-bounded fluid column). Unlike `width` it does not pin the
     * column, so the resizer (and the body's `[(columnWidths)]`) still drives it
     * and the first published width snaps the column to px. Ignored when `width`
     * is set. Defaults to `minmax(0, 1fr)`.
     *
     * Any open track vocabulary is accepted (`minmax()`, `fit-content()`,
     * `calc()`, `clamp()`, `var()`), but in dev mode a fragment that would escape
     * the derived `grid-template-columns` string throws instead of silently
     * collapsing the layout: an empty fragment (pass `null` to leave the track
     * unset), a `;` / `{` / `}` / quote / comment opener, or unbalanced
     * parentheses — a stray `)` here would close the enclosing `var(` early and
     * swallow the rest of the track.
     */
    readonly fallbackWidth: _angular_core.InputSignal<string | null>;
    /**
     * Static class(es) applied to this column's stamped `[forTableHeaderCell]`.
     * `ForTableBody` owns the header cell element, so this is the styling seam a
     * consumer (or wrapping design system) uses to reach it without scoping CSS to
     * the body's template internals. `null` (default) adds no class attribute.
     */
    readonly headerClass: _angular_core.InputSignal<string | null>;
    /**
     * Static class(es) applied to this column's stamped `[forTableCell]` on every
     * data **and** placeholder row. The styling seam for the cell box itself
     * (padding, truncation, alignment, sticky backgrounds) that `ForTableBody`
     * owns. Per-datum row styling is out of scope. `null` (default) adds no class
     * attribute.
     */
    readonly cellClass: _angular_core.InputSignal<string | null>;
    /** The column's header-cell template. */
    readonly header: _angular_core.Signal<ForTableHeaderCellDef>;
    /** The column's data-cell template. */
    readonly dataCell: _angular_core.Signal<ForTableCellDef<any, any>>;
    /**
     * The column's optional placeholder-cell template. When absent, `ForTableBody`
     * falls back to its `[forTablePlaceholderCellDefault]`, then to an empty cell.
     */
    readonly placeholderCell: _angular_core.Signal<ForTablePlaceholderCellDef | undefined>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableColumnDef, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableColumnDef, "[forTableColumnDef]", never, { "name": { "alias": "forTableColumnDef"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "resizeAriaLabel": { "alias": "resizeAriaLabel"; "required": false; "isSignal": true; }; "resizeMin": { "alias": "resizeMin"; "required": false; "isSignal": true; }; "resizeMax": { "alias": "resizeMax"; "required": false; "isSignal": true; }; "resizeStep": { "alias": "resizeStep"; "required": false; "isSignal": true; }; "autoFit": { "alias": "autoFit"; "required": false; "isSignal": true; }; "fitIncludesHeader": { "alias": "fitIncludesHeader"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "fallbackWidth": { "alias": "fallbackWidth"; "required": false; "isSignal": true; }; "headerClass": { "alias": "headerClass"; "required": false; "isSignal": true; }; "cellClass": { "alias": "cellClass"; "required": false; "isSignal": true; }; }, {}, ["header", "dataCell", "placeholderCell"], never, true, never>;
}

/**
 * Marks the content template of a full-span row variant. Place on an
 * `<ng-template forTableRowCellDef>` inside a `[forTableRowDef]`; its content is
 * stamped into a single cell that spans every column of the matched row, with the
 * row datum and its index exposed through `ForTableCellDefContext`.
 *
 * The spanning cell is presentational, so its template must **not** contain
 * interactive content (buttons, links, form controls) — the variant row stays
 * out of the grid's single-tab-stop roving order, so nested tabbables become
 * unreachable — nor a `[forTableCell]`, which would register a cell handle on
 * the variant row and make the roving grid ragged.
 *
 * Bind `[forTableRowCellDefRow]` to the same array passed to `ForTableBody`'s
 * `rows` to type `let-row` — the input is read only for type inference, never at
 * runtime.
 *
 * When the row type is a discriminated union, also bind `[forTableRowCellDefWhen]`
 * to the same type guard used on the def's `[when]` so `let-row` is narrowed to
 * the matched variant member (`V`) instead of staying the full union.
 */
declare class ForTableRowCellDef<T, V extends T = T> {
    /** The captured row-variant template, typed with `ForTableCellDefContext<T>`. */
    readonly template: TemplateRef<ForTableCellDefContext<T>>;
    /**
     * Type-inference hint: bind to the same collection as `ForTableBody`'s `rows`
     * so `let-row` is typed as the row type. Read only by the compiler; the
     * directive never touches its value.
     */
    readonly rowType: _angular_core.InputSignal<readonly T[]>;
    /**
     * Type-inference hint: bind the same type guard used on this def's `[when]`
     * so `let-row` is narrowed to the matched variant member (`V`). Read only by
     * the compiler; the directive never touches its value. Omitting it leaves
     * `let-row` typed as the full `T`.
     */
    readonly narrowType: _angular_core.InputSignal<((row: T, index: number) => row is V) | null>;
    /** Narrows the template context type for `let-row` under strict template checking. */
    static ngTemplateContextGuard<T, V extends T>(_directive: ForTableRowCellDef<T, V>, _context: unknown): _context is ForTableCellDefContext<V>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableRowCellDef<any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableRowCellDef<any, any>, "ng-template[forTableRowCellDef]", never, { "rowType": { "alias": "forTableRowCellDefRow"; "required": false; "isSignal": true; }; "narrowType": { "alias": "forTableRowCellDefWhen"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
/**
 * Declarative definition of a row variant for `<for-table-body>`. Place
 * `[forTableRowDef]` on an `<ng-container>` alongside the `[forTableColumnDef]`s and
 * bind a `[when]` predicate; for every datum the predicate matches, `ForTableBody`
 * renders this variant instead of the per-column data cells. A def comes in one of
 * two shapes, and must declare **exactly one** of them:
 *
 * - **Full-span** (a `[forTableRowCellDef]` template): the row's single cell spans every
 *   column — group headers, section separators, summary or empty-state rows. It carries
 *   the row's `role` plus `aria-colindex="1"` and an `aria-colspan` equal to the column
 *   count, but registers no cell handle, so roving arrow navigation steps over the row.
 * - **Placeholder cells** (the `placeholderCells` flag, no `[forTableRowCellDef]`): the row
 *   stamps one cell per displayed column from each column's `[forTablePlaceholderCellDef]`
 *   — skeleton rows for infinite-scroll or paginated tables. These keep the roving grid
 *   rectangular, and are stamped disabled so arrow navigation steps over them.
 *
 * Either way the variant row is presentational and non-selectable — its `value` stays `undefined` —
 * while still occupying a row slot and counting towards `aria-rowindex` / `aria-rowcount`.
 *
 * When several defs match a datum the first in DOM order wins; a datum matched by none renders the
 * standard per-column row.
 *
 * Like `[forTableColumnDef]`, the def registers itself with the surrounding body through DI at
 * construction, so a preset component may declare it in its own view and a scaffold wrapper may
 * project it into a body it owns — see {@link ForTableDefRegistry}. A def with no reachable
 * registry throws.
 *
 * @example
 * ```html
 * <for-table-body [rows]="rows()">
 *   <ng-container forTableColumnDef="name">
 *     <ng-template forTableHeaderCellDef>Name</ng-template>
 *     <ng-template forTableCellDef [forTableCellDefRow]="rows()" let-row>{{ row.name }}</ng-template>
 *     <ng-template forTablePlaceholderCellDef><span class="skeleton"></span></ng-template>
 *   </ng-container>
 *
 *   <!-- full-span group header -->
 *   <ng-container forTableRowDef [when]="isGroupHeader">
 *     <ng-template forTableRowCellDef [forTableRowCellDefRow]="rows()" let-row>{{ row.group }}</ng-template>
 *   </ng-container>
 *
 *   <!-- per-column skeleton rows while the next page loads -->
 *   <ng-container forTableRowDef [when]="isPlaceholder" placeholderCells />
 * </for-table-body>
 * ```
 */
declare class ForTableRowDef<T> {
    /**
     * Predicate selecting which data rows render this variant instead of the
     * per-column row. Receives the datum and its 0-based dataset index and returns
     * `true` to render the variant. In a non-virtualized table the index equals
     * the row's rendered position; under `[forTableVirtualized]` it is the
     * **absolute** index into the full dataset. Evaluated for every datum on each
     * change-detection pass, so keep it cheap and free of side effects.
     *
     * Mandatory — an unbound def throws in dev mode.
     */
    readonly when: _angular_core.InputSignal<(row: T, index: number) => boolean>;
    /**
     * The variant's full-span content template. Present for a full-span def; absent
     * (and unused) when `placeholderCells` is set. A def must declare exactly one of
     * a `[forTableRowCellDef]` template or `placeholderCells` — the body validates this and
     * throws a `[forty-cdk/table]` error otherwise.
     */
    readonly cell: _angular_core.Signal<ForTableRowCellDef<any, any> | undefined>;
    /**
     * Render this variant's matched rows as **per-column placeholder cells** instead
     * of a full-span `[forTableRowCellDef]`. Set it (the bare `placeholderCells` attribute)
     * for interleaved / trailing skeleton rows — infinite-scroll or paginated tables
     * that keep their loaded rows and append placeholder rows while the next page
     * loads. The body stamps one `[forTableCell]` per displayed column from that
     * column's `[forTablePlaceholderCellDef]` template (an empty cell when the column omits
     * it), exactly like the `loading` state, but stamps the cells disabled so
     * grid-mode arrow navigation steps over them and the roving grid stays
     * rectangular.
     *
     * A def must declare **exactly one** of a `[forTableRowCellDef]` template or
     * `placeholderCells`; declaring both or neither throws a `[forty-cdk/table]`
     * error.
     */
    readonly placeholderCells: _angular_core.InputSignalWithTransform<boolean, unknown>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableRowDef<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableRowDef<any>, "[forTableRowDef]", never, { "when": { "alias": "when"; "required": false; "isSignal": true; }; "placeholderCells": { "alias": "placeholderCells"; "required": false; "isSignal": true; }; }, {}, ["cell"], never, true, never>;
}

/**
 * The def registry a `<for-table-body>` renders from — the seam that lets a
 * **scaffold wrapper** own the table shell while its consumers keep declaring
 * plain `[forTableColumnDef]` / `[forTableRowDef]` blocks.
 *
 * Defs discover their registry through DI at construction, and element DI follows
 * the **declaration** tree: a def projected through a wrapper's `<ng-content>` is
 * a child of the wrapper's host, not of the `<for-table-body>` inside the
 * wrapper's template, so it never sees the body's own registry. A wrapper
 * therefore provides its own registry with `provideForTableDefRegistry()` and
 * hands it to its inner body through `[defs]`; projected defs register with it,
 * and the body renders them exactly as if they had been declared inside its own
 * tags. See the table README for the full recipe.
 *
 * A **preset column component** (`<ds-text-column name="code" …>` collapsing a
 * column's header / data templates into one line) needs none of this: the preset
 * host is declared inside the body's tags, so the def in the preset's view
 * resolves the body's registry through the element-injector chain.
 *
 * The read members here are the whole public surface. How defs wire themselves
 * into a registry is a separate, unexported protocol, so the library keeps
 * refactoring it; the only supported implementation is the one
 * `provideForTableDefRegistry()` installs, and `<for-table-body>` rejects any
 * other value bound to `[defs]`.
 */
interface ForTableDefRegistry {
    /**
     * The `name` of every registered `[forTableColumnDef]`, in document order — the
     * default column order a bound `<for-table-body>` renders. A wrapper can seed
     * its own `[displayedColumns]` from it (say, to move a fixed action column to
     * the end) without knowing which defs its consumer projected.
     *
     * Reading it resolves each def's `name` input, and a def whose binding is not
     * written yet is left out, so read it from a template, a `computed`, or an
     * `afterNextRender` — not from a constructor, where the projected defs' inputs
     * are not bound yet and the list would come back short.
     */
    readonly columnNames: Signal<readonly string[]>;
}
declare const FOR_TABLE_DEF_REGISTRY: InjectionToken<ForTableDefRegistry>;
/**
 * The provider set installing a def registry on a host: the registry itself, the
 * public {@link FOR_TABLE_DEF_REGISTRY} read token, and the internal
 * registration protocol the declarative defs resolve.
 *
 * `<for-table-body>` declares it so defs declared inside its own tags register
 * with it. A **scaffold wrapper** declares it too, so defs its consumers project
 * through `<ng-content>` reach a registry at all, and binds
 * `inject(FOR_TABLE_DEF_REGISTRY)` to its inner body's `[defs]`.
 */
declare function provideForTableDefRegistry(): Provider[];

/** Payload of `columnReorder`: the move's indices and the resulting column-name order. */
interface TableColumnReorderDescriptor {
    /**
     * Previous 0-based index into the **full displayed column order**, counting
     * non-reorderable columns; feed it (with `to`) to `moveItemInArray` over the
     * full displayed-columns array.
     */
    from: number;
    /**
     * New 0-based index into the **full displayed column order**, counting
     * non-reorderable columns; feed it (with `from`) to `moveItemInArray` over the
     * full displayed-columns array.
     */
    to: number;
    /**
     * The reorderable columns in their new order, read from each draggable header
     * cell's `dragData`. Equal to the full displayed order only when every displayed
     * column is reorderable; otherwise it omits the non-reorderable columns.
     */
    columns: readonly string[];
}
/**
 * Opt-in **column reordering** for `ForTable`, composed over the drag-drop primitive.
 *
 * Apply on the `[forTableHeaderRow]` element. It wraps `[forDropList]` (via
 * `hostDirectives`) so the header cells become a reorderable list, then translates
 * drag-drop's generic drop into the table-friendly `columnReorder` output. Mark each
 * `[forTableHeaderCell]` as `[forDraggable]` with `[dragData]` set to the column name.
 * On a committed drop (pointer or keyboard) it emits the previous / new index (into the
 * full displayed column order) and the reorderable columns' new order; the consumer
 * applies it to their own column array. **It never reorders columns itself** (BYO-data).
 *
 * The wrapped list defaults to `orientation="horizontal"` (a column reorder is always along
 * the row axis), so no `orientation` binding is needed. Bind `orientation="vertical"` to
 * override for the rare case.
 *
 * In `mode="grid"` / `mode="treegrid"` the draggable header cells join the table's composite
 * roving grid as its first row, so a sortable + column-reorderable grid keeps the **single
 * tab stop** the WAI-ARIA Data Grid pattern calls for: `Tab` enters the grid once, Arrow keys
 * cross between header and body, and `Space` on a header cell lifts it for keyboard reordering.
 * It hands its drop-list roving to the grid via `FOR_DROP_LIST_ROVING_DELEGATE` and routes idle
 * header navigation through the table's grid keyboard handler.
 *
 * When a header cell is both sortable (`[forTableSortHeader]`) and reorderable, the two
 * keyboard activations split along WAI-ARIA lines so a single key never both sorts and lifts:
 * `Space` lifts the column, `Enter` toggles the sort. The split is enforced via a
 * `FOR_DRAGGABLE_LIFT_GUARD` that defers `Enter` to the sort header on cells carrying the
 * `data-sortable` marker — detected by DOM marker, so `forty-cdk/drag-drop` needs no table
 * import. A reorder-only header (no sort header) still lifts on both `Enter` and `Space`.
 *
 * @example
 * ```html
 * <div forTableHeaderRow forTableColumnReorder (columnReorder)="columns.set($event.columns)">
 *   @for (col of columns(); track col) {
 *     <div forTableHeaderCell [name]="col" forDraggable [dragData]="col">{{ col }}</div>
 *   }
 * </div>
 * ```
 */
declare class ForTableColumnReorder {
    #private;
    protected readonly ctx: TableContext;
    /**
     * Fires once per committed reorder gesture (pointer drop or keyboard drop) with the
     * previous / new column index (into the full displayed column order, counting
     * non-reorderable columns) and the reorderable columns' new order after the move.
     */
    readonly columnReorder: _angular_core.OutputEmitterRef<TableColumnReorderDescriptor>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableColumnReorder, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableColumnReorder, "[forTableColumnReorder]", ["forTableColumnReorder"], {}, { "columnReorder": "columnReorder"; }, never, never, true, [{ directive: typeof i1.ForDropList; inputs: { "orientation": "orientation"; "dir": "dir"; "disabled": "disabled"; "autoScroll": "autoScroll"; "animateReorder": "animateReorder"; "liveSort": "liveSort"; "boundary": "boundary"; "lockAxis": "lockAxis"; }; outputs: {}; }]>;
}

/** Payload of `resizeCommit`: which column was resized and its committed width (px). */
interface TableResizeDescriptor {
    column: string;
    width: number;
}
/**
 * Turns a focusable element inside a `[forTableHeaderCell]` into a column-resize
 * handle. Supports pointer drag (with a dead-zone so a plain click is a no-op) and
 * `ArrowLeft` / `ArrowRight` keyboard resize, both constrained to `[min, max]`.
 * Pressing `Escape` (or a `pointercancel`) during a drag reverts the width to where
 * the gesture started and emits no `resizeCommit`. Being destroyed mid-drag reverts
 * too, reporting the pre-drag width through the `[widthRevert]` callback because the
 * `[(width)]` model can no longer emit during teardown.
 *
 * On every change it publishes the resolved width as the CSS custom property
 * `--for-table-col-<column>-width` on the table root, so the consumer can apply it
 * to their layout (`grid-template-columns` in `<div>` mode, a `<col>` / cell width
 * in native `<table>` mode). **It never lays out columns itself and never resizes
 * data** — it owns the affordance, accessibility, and the published width only.
 *
 * Reflects `data-resizing` (empty string) while a pointer drag is active. Carries
 * `role="separator"` with `aria-orientation="vertical"` and live `aria-value*`,
 * mirroring `[forPaneResizer]`. The consumer supplies `aria-label`. Before the first
 * gesture, `aria-valuenow` falls back to the header-cell width measured once on mount
 * (browser-only), so a separator with no `[width]` is never announced without a
 * current value; an explicit `[width]` always takes precedence.
 *
 * In `mode="grid"` / `"treegrid"` it yields its tab stop to the composite roving grid
 * (`tabindex="-1"`) and is reached via cell-entry (Enter / F2 focuses the first focusable
 * inside the header cell), so it must sit on a natively-focusable element (a `<button>`)
 * to stay cell-entry-reachable. In `mode="table"` it is a standalone tab stop
 * (`tabindex="0"`).
 *
 * Opt in to size-to-content with `[autoFit]`: double-clicking the handle then fits the
 * column to its widest data-cell content via `fitToContent()` (also callable imperatively
 * through `exportAs="forTableColumnResizer"`, e.g. from a column menu). Unset (default),
 * `dblclick` is a no-op and the resize behaviour is unchanged. Add `[fitIncludesHeader]`
 * to also account for the column header's label (marked with a sibling
 * `[forTableColumnLabel]`), fitting to `max(header label, …data cells)`.
 *
 * @example
 * ```html
 * <th forTableHeaderCell name="name">
 *   Name
 *   <button forTableColumnResizer column="name" [(width)]="nameWidth"
 *           aria-label="Resize Name column"></button>
 * </th>
 * ```
 */
declare class ForTableColumnResizer {
    #private;
    protected readonly ctx: TableContext;
    /** Column identity; included in the `resizeCommit` payload and the published CSS var name. */
    readonly column: _angular_core.InputSignal<string>;
    /**
     * Current column width in pixels. Two-way bindable via `[(width)]`. Acts as both
     * the controlled value and the base a pointer drag / arrow step is applied to.
     * When unset, the base for the first gesture is measured from the header cell.
     * Its implicit `widthChange` fires on every live update (drag tick, arrow press);
     * `resizeCommit` is the distinct column-aware gesture-end event.
     */
    readonly width: _angular_core.ModelSignal<number | undefined>;
    /** Minimum width in pixels. Default `0`. */
    readonly min: _angular_core.InputSignal<number>;
    /** Maximum width in pixels. Default `Infinity` (no upper bound). */
    readonly max: _angular_core.InputSignal<number>;
    /** Pixels applied per `ArrowLeft` / `ArrowRight` press. Default `10`. */
    readonly step: _angular_core.InputSignal<number>;
    /**
     * Opt-in size-to-content. When set, double-clicking the handle fits the column to
     * its widest data-cell content via `fitToContent()`. Unset (default), `dblclick` is
     * a no-op and the resize behaviour is unchanged.
     */
    readonly autoFit: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Opt-in: also account for the column header's label width when fitting to content,
     * so `fitToContent()` sizes to `max(header label, …data cells)` instead of data cells
     * only. The header label is isolated through a sibling `[forTableColumnLabel]` marker
     * (the resize handle / sort affordance are excluded). When set without a marker present,
     * it degrades to data-cells-only. Unset (default), the header is ignored.
     */
    readonly fitIncludesHeader: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Fires once per resize gesture — at pointer-up after a drag, and on every arrow
     * press — with the column identity and its committed width. Bind it to persist
     * the width; live updates during a drag come through `[(width)]` / `widthChange`.
     */
    readonly resizeCommit: _angular_core.OutputEmitterRef<TableResizeDescriptor>;
    /**
     * Teardown-only revert channel. Called with the pre-drag width when the handle is
     * destroyed mid-drag — the column is removed, or `resizable` is toggled off — so the
     * transient drag width never survives as the consumer's persisted value. On every
     * other revert path (`Escape`, `pointercancel`) the pre-drag width arrives through
     * `[(width)]` / `widthChange` as usual and this callback does not fire.
     *
     * Bound as a function reference (`[widthRevert]="onRevert"`), not as an event binding:
     * the `[(width)]` model — like any `output()` on this directive — is already destroyed
     * when the unmount revert happens, so an emitter-based channel cannot deliver it.
     */
    readonly widthRevert: _angular_core.InputSignal<((descriptor: TableResizeDescriptor) => void) | undefined>;
    /** `aria-valuemax`, omitted when `max` is non-finite (the default unbounded case). */
    protected readonly ariaValueMax: _angular_core.Signal<number | null>;
    protected readonly tabindex: _angular_core.Signal<0 | -1>;
    /** Whether a pointer drag is currently active (drives `data-resizing`). */
    protected readonly resizing: _angular_core.Signal<boolean>;
    /**
     * Header-cell width measured once on mount (browser-only). Backs `aria-valuenow`
     * before any explicit `[width]` so the focusable separator never ships without a
     * current value on the measured-fallback path; an explicit `[width]` still wins.
     */
    protected readonly measuredWidth: _angular_core.Signal<number | null>;
    constructor();
    /**
     * Sizes the column to its content: measures the widest natural width across the
     * column's data cells (resolved through the table context, browser-only) — and, when
     * `[fitIncludesHeader]` is set with a sibling `[forTableColumnLabel]` present, the
     * header label too, so the fit becomes `max(header label, …data cells)`. Clamps the
     * result to `[min, max]`, applies it as the new `[(width)]`, and emits `resizeCommit`.
     * Wired to a `dblclick` on the handle when `[autoFit]` is set, and callable
     * imperatively (e.g. from a column menu) via `exportAs="forTableColumnResizer"`.
     * Returns the applied width; a no-op returning the current width off the browser.
     */
    fitToContent(): number;
    protected onKeyDown(event: KeyboardEvent): void;
    protected onClick(event: MouseEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableColumnResizer, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableColumnResizer, "[forTableColumnResizer]", ["forTableColumnResizer"], { "column": { "alias": "column"; "required": true; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "autoFit": { "alias": "autoFit"; "required": false; "isSignal": true; }; "fitIncludesHeader": { "alias": "fitIncludesHeader"; "required": false; "isSignal": true; }; "widthRevert": { "alias": "widthRevert"; "required": false; "isSignal": true; }; }, { "width": "widthChange"; "resizeCommit": "resizeCommit"; }, never, never, true, never>;
}

/** Sort direction for a column header. `'none'` means unsorted (no aria-sort emitted). */
type TableSortDirection = 'ascending' | 'descending' | 'none';
/** Payload of `sortChange`: which column changed and its new direction. */
interface TableSortDescriptor {
    column: string;
    direction: TableSortDirection;
}
/**
 * Turns a `[forTableHeaderCell]` into a sortable affordance that emits `aria-sort`
 * and fires `sortChange` on activation (click, Enter, Space). The directive is
 * **self-contained**: it owns only its own `direction` state and does NOT register
 * with the table context or auto-reset sibling headers. The "one sorted column at a
 * time" guarantee is the consumer's responsibility — hold a single sort descriptor
 * signal and derive each header's `direction` from it. Apply this directive on the
 * same element as `[forTableHeaderCell]`.
 *
 * The directive emits its own `tabindex="0"` only in `mode="table"`. In `grid` /
 * `treegrid` mode the header cell owns the roving composite tab stop, so this directive
 * emits no `tabindex`; `aria-sort` / `data-sorted` and click / keyboard activation stay
 * on the cell. When a `[forDraggable]` (column reorder) shares the same host cell — in
 * either mode — this directive also yields its `tabindex` to the draggable's roving tab
 * stop so the two never collide on the host attribute, and the keyboard activation splits
 * along WAI-ARIA lines: `Space` lifts the column for reordering while `Enter` toggles the
 * sort, so a single key press never both sorts and starts a drag-lift. The draggable is
 * detected by DOM marker (the `forDraggable` / `forFreeDrag` attribute), not by a
 * drag-drop value-import.
 *
 * While `sortable`, the directive reflects the `data-sortable` marker (a CSS styling
 * hook, absent when `sortable` is `false`). In `grid` / `treegrid` mode the header cell
 * reads that marker to defer APG cell entry on `Enter`: `Enter` toggles the sort and
 * keeps focus on the cell, while `F2` remains the cell-entry key — so a sortable +
 * resizable header does not both sort and drop focus onto the resize handle.
 *
 * Cycle (default `firstClickDirection='ascending'`): `none → ascending → descending → none`.
 * With `disableClear`: `none → ascending → descending → ascending`.
 *
 * `firstClickDirection='descending'` flips the entry pole, so a freshly activated
 * column starts descending: `none → descending → ascending → none` (and with
 * `disableClear`: `none → descending → ascending → descending`) — the descending-first
 * behavior used by single-always-active sort descriptors.
 *
 * A `click`, `Space`, or `Enter` originating from an interactive descendant of the
 * header cell — a stamped `[forTableColumnResizer]` handle, or a consumer-placed
 * `button` / `a[href]` / `input` / `select` / `textarea` / `summary` / editable
 * `contenteditable` / role-based control — does not toggle the sort and leaves the
 * descendant's own activation intact. (A non-native custom handle carrying only
 * `role="separator"` / `tabindex` is not matched by the shared interactive-descendant
 * selector, so it would still bubble to sort; the stamped resize handle and the
 * documented example are native `<button>`s, so this is not a real path today.)
 */
declare class ForTableSortHeader {
    #private;
    protected readonly ctx: TableContext;
    /** Column identity included in the `sortChange` payload. */
    readonly column: _angular_core.InputSignal<string>;
    /**
     * Current sort direction. Acts as both the controlled value and the initial value.
     * Its implicit `directionChange` output fires on every internal update (via
     * `[(direction)]`). `sortChange` is the primary column-aware event consumers bind:
     * it carries a `{ column, direction }` descriptor and fires on every activation,
     * regardless of whether the consumer uses two-way binding.
     */
    readonly direction: _angular_core.ModelSignal<TableSortDirection>;
    /**
     * When `true`, the cycle skips the `'none'` step: `ascending → descending → ascending`.
     * Useful when clearing the sort is not allowed.
     */
    readonly disableClear: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Direction a previously-unsorted column enters on its first activation (the
     * `'none' → ?` step of the cycle). Defaults to `'ascending'`. Set to `'descending'`
     * for descending-first columns. The toggle between the two sorted directions and the
     * optional `'none'` step (`disableClear`) are unchanged.
     */
    readonly firstClickDirection: _angular_core.InputSignal<"ascending" | "descending">;
    /**
     * When `false`, the header is fully inert: no `tabindex`, no `aria-sort`, and click /
     * keyboard handlers are no-ops. Defaults to `true`.
     */
    readonly sortable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Fires on every activation with the column identity and the new direction.
     * Consumers bind this to update their own sort descriptor and reorder rows.
     */
    readonly sortChange: _angular_core.OutputEmitterRef<TableSortDescriptor>;
    /**
     * Truthy-only `aria-sort` / `data-sorted` value: `'ascending'` or `'descending'`
     * while sorted, `null` (absent) when `direction` is `'none'` or `sortable` is `false`.
     */
    protected readonly activeDirection: _angular_core.Signal<TableSortDirection | null>;
    constructor();
    /**
     * Handles pointer activation, forwarding to `activate()` unless the click
     * originated from an interactive descendant of the header cell (which owns its
     * own activation).
     */
    protected onClick(event: MouseEvent): void;
    /** Activates the sort: computes the next direction, updates the model, and emits `sortChange`. */
    protected activate(): void;
    /**
     * Handles Enter and Space keyboard activation, forwarding to `activate()`.
     * When a `[forDraggable]` (column reorder) shares the host cell, the two
     * activations split along WAI-ARIA lines: `Space` is reserved for the reorder
     * lift, and `Enter` while a keyboard drag is in progress (`data-dragging`)
     * for its drop, so this header only sorts on an idle `Enter`. A sort-only
     * header (no draggable) still sorts on both keys.
     */
    protected onKeyDown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableSortHeader, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableSortHeader, "[forTableSortHeader]", ["forTableSortHeader"], { "column": { "alias": "column"; "required": true; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "disableClear": { "alias": "disableClear"; "required": false; "isSignal": true; }; "firstClickDirection": { "alias": "firstClickDirection"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; }, { "direction": "directionChange"; "sortChange": "sortChange"; }, never, never, true, never>;
}

/**
 * Payload emitted by {@link ForTableBody.rowActivate} when a data row is
 * activated by a pointer click or the `Enter` key (whole-row navigation lists).
 */
interface TableRowActivateEvent<T> {
    /** The activated row's datum. */
    readonly row: T;
    /** The activated row's 0-based dataset index (absolute when virtualized). */
    readonly index: number;
    /** The originating DOM event — a `MouseEvent` for a click, a `KeyboardEvent` for `Enter`. */
    readonly event: Event;
}
/**
 * Payload emitted by {@link ForTableBody.rowContextMenu} when a data row receives
 * a `contextmenu` event (right-click or the context-menu key).
 */
interface TableRowContextMenuEvent<T> {
    /** The row's datum. */
    readonly row: T;
    /** The row's 0-based dataset index (absolute when virtualized). */
    readonly index: number;
    /** The originating `contextmenu` event; call `preventDefault()` to suppress the native menu. */
    readonly event: MouseEvent;
}
/** One row `<for-table-body>` renders, resolved from the static or virtualized path. */
interface RenderRow<T> {
    /** The row datum, passed to the data-cell template as `$implicit`. */
    readonly datum: T;
    /** Dataset index exposed to the data-cell template as `index` (absolute when virtualized). */
    readonly index: number;
    /** Absolute dataset index when virtualized (drives `[virtualIndex]`), else `null`. */
    readonly virtualIndex: number | null;
    /** Pixel offset for `translateY` when virtualized, else `null` (static flow layout). */
    readonly start: number | null;
    /** Selection identity from `rowKey`, or `undefined` when the row is not selectable (or a variant). */
    readonly value: unknown;
    /** `@for` tracking key: the selection identity, falling back to the dataset index. */
    readonly key: unknown;
    /** The matched full-span row variant, or `null` for a standard per-column row. */
    readonly variant: ForTableRowDef<unknown> | null;
}
/**
 * Ergonomic declarative renderer for the columns of a `[forTable]`.
 * Place `<for-table-body>` inside a `[forTable]` element and declare one
 * `[forTableColumnDef]` per column; the body harvests the defs and stamps the header
 * row and one data row per item out of the raw cell primitives, so a column is
 * authored in a single block instead of being smeared across header, data, and
 * placeholder rows.
 *
 * **Supported modes: `table` and `grid`.** Each stamped cell's role follows the table `mode`
 * (`cell` or `gridcell`). Choose `mode="grid"` for interactive cells with roving 2D navigation, and
 * the default `mode="table"` for read-only or whole-row navigation lists. `mode="treegrid"` is out
 * of scope — the body stamps no expansion affordances.
 *
 * It owns only the grid **structure**: `display: grid` plus the `grid-template-columns` track
 * derived from each def's `width` and the published `--for-table-col-<name>-width` resize var. All
 * visual styling stays the consumer's, off the `data-*` and role hooks. The host is
 * `display: contents`, so it introduces no box between `[forTable]` and its rows; consumers wanting
 * full DOM control keep using the raw cell primitives.
 *
 * **Defs register themselves through DI rather than being content-queried**, so a preset column
 * component can declare a def in its own view and a scaffold wrapper can project consumer defs into
 * a body it owns (see `defs`). Registrations are exposed in document order, including defs mounted
 * later by `@if` or reordered by `@for`; `displayedColumns` pins an explicit render order on top.
 *
 * **Subclassing is not a supported wrapping shape.** Angular inherits neither `template` nor
 * `imports`, so a subclass renders nothing of the body, and its own `providers` array replaces the
 * one installing the def registry — a subclass missing `provideForTableDefRegistry()` throws a
 * `[forty-cdk/table]` error naming it. Compose the body in a wrapper's template instead.
 *
 * Sort and resize affordances are auto-wired from the per-column `sortable` / `resizable` flags.
 * Sorting stays consumer-applied: the body derives each header's `aria-sort` from `sort` and
 * re-emits activation through `sortChange`. Resize width state can be owned by the body through
 * `[(columnWidths)]`, keyed by column name, with per-def `resizeMin` / `resizeMax` / `resizeStep` /
 * `autoFit` / `fitIncludesHeader` tuning; gesture-end commits still surface through `resizeCommit`.
 * Selection stays consumer-placed — drop `[forTableRowSelector]` / `[forTableSelectAll]` into the
 * cell templates and set `rowKey` to give each row a selection identity.
 *
 * **Virtualization is transparent.** Adding `[forTableVirtualized]` to the same `[forTable]`
 * switches the body to windowed rendering: it renders only the visible slice of `rows`, sizes the
 * rowgroup to the full scroll height and positions each row at its offset. Pass the whole dataset
 * to `rows` — the total is derived from its length, so `[rowCount]` is needed only for a
 * server-known total larger than the loaded rows. Rows are fixed-size by default; set
 * `measureRows` for variable heights, which feeds each rendered row's real height back to the
 * virtualizer.
 *
 * **Row variants.** Declare one or more `[forTableRowDef]` alongside the columns; for each datum
 * the body picks the first whose `[when]` predicate returns `true`, and unmatched data renders the
 * standard per-column row. A `[forTableRowCellDef]` template stamps a full-span row whose single
 * cell spans every column, while the `placeholderCells` flag stamps per-column skeleton cells from
 * each column's `[forTablePlaceholderCellDef]`, falling back to `[forTablePlaceholderCellDefault]`.
 * Variant rows are presentational and non-selectable but still count towards `aria-rowindex` /
 * `aria-rowcount`. A full-span cell registers no cell handle, so arrow keys step over the row;
 * placeholder cells keep the grid rectangular but are stamped disabled, so navigation steps over
 * them too.
 */
declare class ForTableBody<T = unknown> {
    #private;
    private readonly rowEls;
    constructor();
    /** The rows to render — already sorted / filtered / paged by the consumer (BYO-data). */
    readonly rows: _angular_core.InputSignal<readonly T[]>;
    /**
     * Row identity used both for `@for` tracking and each row's selection `[value]`.
     * Omit it for non-selectable, index-tracked tables.
     */
    readonly rowKey: _angular_core.InputSignal<((row: T, index: number) => unknown) | undefined>;
    /**
     * Which columns render, in order. Defaults to every registered `[forTableColumnDef]`
     * in document order. Names not matching a registered column are skipped.
     */
    readonly displayedColumns: _angular_core.InputSignal<readonly string[] | null>;
    /**
     * The single active sort descriptor. Each `sortable` column derives its
     * `aria-sort` from it (the "one sorted column" rule); the consumer updates it
     * from `sortChange` and re-sorts `rows`.
     */
    readonly sort: _angular_core.InputSignal<TableSortDescriptor | null>;
    /**
     * When set, render `placeholderRows` skeleton rows instead of data. Each cell
     * stamps the column's own `[forTablePlaceholderCellDef]`, else the body-level
     * `[forTablePlaceholderCellDefault]`, else nothing.
     */
    readonly loading: _angular_core.InputSignal<boolean>;
    /** Number of placeholder rows rendered while `loading`. Default `3`. */
    readonly placeholderRows: _angular_core.InputSignal<number>;
    /**
     * Opt in to **measured (variable) row heights** under `[forTableVirtualized]`.
     * When set, the body measures each stamped row after render and feeds its real
     * height back to the virtualizer, which replaces the `estimateRowSize` estimate
     * and re-aligns the offsets of the rows below — so a window mixing row shapes
     * (denser variant rows, group separators) stays contiguous after scroll.
     *
     * Off by default: a uniform-height table keeps the pure `estimateRowSize` fast
     * path with no per-row measurement work. Has no effect without
     * `[forTableVirtualized]` (there is no window to measure against).
     *
     * Measurement is not one-shot. The body's per-render measure is throttled per
     * `data-index`, so it covers only a row's initial post-render measurement and any
     * row recycled to a new index. Subsequent size changes of the **same mounted row**
     * (async content, image load, cell reflow) are re-measured automatically by the
     * virtualizer's own `ResizeObserver` — which re-aligns the offsets of the rows below
     * without any consumer action — so a row whose content loads asynchronously needs no
     * manual re-measure trigger.
     */
    readonly measureRows: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Fires when a `sortable` header is activated; forwarded from the internal `[forTableSortHeader]`. */
    readonly sortChange: _angular_core.OutputEmitterRef<TableSortDescriptor>;
    /** Fires when a `resizable` column commits a width; forwarded from the internal `[forTableColumnResizer]`. */
    readonly resizeCommit: _angular_core.OutputEmitterRef<TableResizeDescriptor>;
    /**
     * Fires once per committed column reorder gesture (pointer drop or keyboard drop),
     * forwarded unchanged from the internal `[forTableColumnReorder]`. Its `from` / `to`
     * are indices into the **full displayed column order** (counting non-reorderable
     * columns), so a table with fixed columns applies `moveItemInArray(displayedColumns,
     * from, to)` over the whole `displayedColumns` array. Its `columns` lists the
     * reorderable columns in their new order (equal to the full displayed order only when
     * every displayed column is `reorderable`) — setting `displayedColumns` directly to
     * `columns` is valid only in that all-reorderable case, otherwise the fixed columns
     * are dropped. Only present when at least one `[forTableColumnDef]` is `reorderable`.
     */
    readonly columnReorder: _angular_core.OutputEmitterRef<TableColumnReorderDescriptor>;
    /**
     * Two-way map of column widths (px), keyed by column `name`. It seeds each
     * `resizable` column's stamped handle `[width]` — so the `role="separator"`
     * handle exposes `aria-valuenow` from the first render and the column's grid
     * track picks up the seeded width immediately — and is updated immutably on
     * every live width change the handle reports (pointer drag, keyboard resize,
     * auto-fit), including the pre-drag revert of a handle destroyed mid-drag. Only
     * `resizable` columns participate; other names are ignored.
     *
     * The map is JSON-serializable, so persisting a user's column layout is
     * `[(columnWidths)]` plus one storage write. Together with `[displayedColumns]`
     * and `[sort]` it makes the full user-configurable table state three bindings.
     * Its implicit `columnWidthsChange` fires only on handle-driven updates, not on
     * consumer writes through `[(columnWidths)]`.
     */
    readonly columnWidths: _angular_core.ModelSignal<Readonly<Record<string, number>>>;
    /**
     * Opt-in whole-row interaction for **navigation lists**, active only in the
     * default `mode="table"`. When set, each data row becomes a focusable tab stop
     * (`tabindex="0"`) and a pointer click or `Enter` emits `rowActivate`, while a
     * `contextmenu` (right-click or the context-menu key) emits `rowContextMenu`.
     * Full-span `[forTableRowDef]` variant rows stay non-interactive. Ignored in `grid`
     * / `treegrid` mode, where roving 2D navigation and cell-entry own the keyboard
     * and whole-row activation would conflict.
     *
     * Interactive content inside a data cell owns its own events: a click or `Enter` originating from
     * a `button`, `a[href]`, `input`, `select`, `textarea`, `summary`, `label`,
     * `audio` / `video[controls]`, an editable `contenteditable` region, or an element carrying an
     * interactive ARIA role does **not** emit `rowActivate`, and its native default action is left
     * intact. The row still activates from anywhere else — cell text, the gaps between cells, or the
     * focused row host.
     *
     * `rowContextMenu` is unguarded, so a right-click over an inner control still offers
     * the row's context menu, matching native lists.
     */
    readonly interactiveRows: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Fires when a data row is activated by a pointer click or `Enter`, carrying
     * the row datum, its dataset index, and the originating event. Requires
     * `interactiveRows` and `mode="table"`.
     */
    readonly rowActivate: _angular_core.OutputEmitterRef<TableRowActivateEvent<T>>;
    /**
     * Fires when a data row receives a `contextmenu` event (right-click or the
     * context-menu key), carrying the row datum, its dataset index, and the event —
     * position your own overlay from it. Requires `interactiveRows` and
     * `mode="table"`.
     */
    readonly rowContextMenu: _angular_core.OutputEmitterRef<TableRowContextMenuEvent<T>>;
    /**
     * Per-row class hook, applied to data **and** variant rows in **every** mode.
     * Receives the row datum and its 0-based dataset index and returns the class(es)
     * to apply — a string, a `{ className: boolean }` map, or `undefined` for none.
     * This is the only seam for styling a body-owned row from its datum (an
     * "active" / "menu-open" highlight, error or dimmed rows). Evaluated on every
     * change-detection pass, so keep it cheap and free of side effects.
     */
    readonly rowClass: _angular_core.InputSignal<((row: T, index: number) => string | Record<string, boolean> | undefined) | undefined>;
    /**
     * Per-row attribute hook, applied to data **and** variant rows in **every**
     * mode. Receives the row datum and its 0-based dataset index and returns an
     * attribute map to reflect on the row host; a key mapped to `null` (or dropped
     * from a later map) removes that attribute. Evaluated on every change-detection
     * pass, so keep it cheap and free of side effects.
     */
    readonly rowAttrs: _angular_core.InputSignal<((row: T, index: number) => Record<string, string | null> | undefined) | undefined>;
    /**
     * An external def registry to render from, for a **scaffold wrapper**: a
     * component whose template owns the `[forTable]` shell and this body, and whose
     * consumers declare their `[forTableColumnDef]` / `[forTableRowDef]` blocks as projected
     * content. Those defs are content of the wrapper, not of this body, so they
     * register with the wrapper's own registry — provide one with
     * `provideForTableDefRegistry()` and bind `inject(FOR_TABLE_DEF_REGISTRY)` here.
     *
     * When set, this registry **replaces** the body's own: defs the wrapper declares
     * inside the `<for-table-body>` tags would register with the body instead and be
     * ignored, so the body throws rather than dropping them — declare a wrapper's
     * own defs next to the projected ones (outside the body element), where they
     * reach the same registry. Defaults to `null` (the body renders the defs
     * declared in its own content).
     */
    readonly defs: _angular_core.InputSignal<ForTableDefRegistry | null>;
    /** The registered column definitions, in document order. */
    protected readonly columns: Signal<readonly ForTableColumnDef[]>;
    /** The registered full-span row variants, in document order (first match wins per datum). */
    protected readonly rowDefs: Signal<readonly ForTableRowDef<unknown>[]>;
    /** The optional shared drag placeholder for reorderable columns, or `null`. */
    protected readonly columnDragPlaceholder: Signal<forty_cdk_table.ForTableColumnDragPlaceholder | null>;
    /** The optional body-level default placeholder-cell template, or `null`. */
    protected readonly placeholderCellDefault: Signal<forty_cdk_table.ForTablePlaceholderCellDefault | null>;
    /**
     * Resolves the placeholder template a column stamps into its cell, in both
     * stamping paths: the column's own `[forTablePlaceholderCellDef]`, else the body-level
     * `[forTablePlaceholderCellDefault]`, else `null` for an empty cell.
     */
    protected placeholderTemplateFor(col: ForTableColumnDef): TemplateRef<unknown> | null;
    /** The role a stamped cell carries: `'cell'` in `table` mode, `'gridcell'` otherwise. */
    protected readonly cellRole: Signal<"cell" | "gridcell">;
    /** The columns to render, resolved from `displayedColumns` (or all defs, in order). */
    protected readonly orderedColumns: Signal<readonly ForTableColumnDef[]>;
    /**
     * `true` when at least one displayed column is `reorderable`, switching the stamped
     * header row to the drag-reorder path (`[forTableColumnReorder]` + per-cell
     * `[forDraggable]`). A body with no reorderable column keeps the plain header row.
     */
    protected readonly hasReorderable: Signal<boolean>;
    /**
     * The derived `grid-template-columns` track, applied to the header row and every
     * data row and exposed for consumers who want to bind it elsewhere. Each column
     * contributes its `width`, or the published resize var falling back to the column's
     * `fallbackWidth` (`minmax(0, 1fr)` when that is unset too).
     */
    readonly track: Signal<string>;
    /**
     * The rows to render this change-detection pass. When `[forTableVirtualized]`
     * has published a window it maps the window's slice into `rows` (absolute
     * index + pixel offset per row); otherwise it maps every row in flow order.
     */
    protected readonly renderRows: Signal<readonly RenderRow<T>[]>;
    /** Full scroll height (px) applied to the rowgroup when virtualized, else `null` (natural height). */
    protected readonly sizerHeight: Signal<number | null>;
    protected readonly placeholderRange: Signal<number[]>;
    /** Resolves a `sortable` column's current direction from the single `sort` descriptor. */
    protected directionFor(column: string): TableSortDirection;
    /** Whether whole-row interaction is active: opted in via `interactiveRows` and in `table` mode. */
    protected readonly rowsInteractive: Signal<boolean>;
    /** The `tabindex` for a stamped row: `0` for an interactive data row, `null` otherwise. */
    protected rowTabIndex(row: RenderRow<T>): 0 | null;
    /** Resolves the `rowClass` hook for a stamped row, or `undefined` when unset. */
    protected rowClassFor(row: RenderRow<T>): string | Record<string, boolean> | undefined;
    /** Resolves the `rowAttrs` hook for a stamped row, or `undefined` when unset. */
    protected rowAttrsFor(row: RenderRow<T>): Record<string, string | null> | undefined;
    /**
     * Folds a stamped resizer's live width update into the `[(columnWidths)]` map
     * immutably, keyed by the column name. Ignores the resizer's initial unset
     * (`undefined`) emission and no-ops when the width is unchanged, so seeding the
     * handle from `columnWidths` never loops back into a redundant model write.
     */
    protected onColumnWidthChange(column: string, width: number | undefined): void;
    /**
     * Folds a stamped resizer's teardown revert into `[(columnWidths)]`, so a handle destroyed
     * mid-drag — its column dropped from `displayedColumns`, or `resizable` toggled off — does not
     * leave the transient drag width in the map.
     *
     * A function reference rather than an output, because the revert happens during the handle's
     * teardown. The body outlives it, so its own `columnWidthsChange` still reaches the consumer.
     */
    protected readonly onColumnWidthRevert: (descriptor: TableResizeDescriptor) => void;
    protected onRowClick(row: RenderRow<T>, event: MouseEvent): void;
    protected onRowEnter(row: RenderRow<T>, event: Event): void;
    protected onRowContextMenu(row: RenderRow<T>, event: MouseEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableBody<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ForTableBody<any>, "for-table-body", never, { "rows": { "alias": "rows"; "required": true; "isSignal": true; }; "rowKey": { "alias": "rowKey"; "required": false; "isSignal": true; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "placeholderRows": { "alias": "placeholderRows"; "required": false; "isSignal": true; }; "measureRows": { "alias": "measureRows"; "required": false; "isSignal": true; }; "columnWidths": { "alias": "columnWidths"; "required": false; "isSignal": true; }; "interactiveRows": { "alias": "interactiveRows"; "required": false; "isSignal": true; }; "rowClass": { "alias": "rowClass"; "required": false; "isSignal": true; }; "rowAttrs": { "alias": "rowAttrs"; "required": false; "isSignal": true; }; "defs": { "alias": "defs"; "required": false; "isSignal": true; }; }, { "sortChange": "sortChange"; "resizeCommit": "resizeCommit"; "columnReorder": "columnReorder"; "columnWidths": "columnWidthsChange"; "rowActivate": "rowActivate"; "rowContextMenu": "rowContextMenu"; }, never, ["*"], true, never>;
}

/**
 * Marks the header row of the table (`role="row"`). Registers its host
 * element with the root so `ForTable` can measure the header's height and
 * publish `--for-table-header-height` for sticky-cell CSS.
 *
 * In `grid` / `treegrid` mode the header row is the grid's first row for ARIA
 * numbering, so it emits `aria-rowindex="1"` and every data row's index shifts
 * up by one (matching the APG Data Grid example, where `aria-rowcount` counts
 * the header row too).
 */
declare class ForTableHeaderRow {
    #private;
    protected readonly ctx: TableContext;
    /** 1-based `aria-rowindex` for the header row (`1` in grid / treegrid mode, else absent). */
    protected readonly rowIndex: _angular_core.Signal<number | null>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableHeaderRow, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableHeaderRow, "[forTableHeaderRow]", ["forTableHeaderRow"], {}, {}, never, never, true, never>;
}

/**
 * Marks a data row (`role="row"`). Owns the registry of its data cells (for
 * `aria-colindex`) and registers itself with the root so it joins the row index
 * space and the 2D navigation grid. In `grid`/`treegrid` mode `aria-rowindex` is
 * 1-based and counts the header row as row 1, so the first data row is row 2 when
 * a header row is present (matching the APG Data Grid numbering).
 */
declare class ForTableRow implements ForTableRowContext {
    #private;
    protected readonly ctx: TableContext;
    /**
     * This row's element injector. Exposed so a declarative renderer stamping
     * full-span variant content from a projected `<ng-template>` (e.g.
     * `ForTableBody`) can pass it as `[ngTemplateOutletInjector]`, letting
     * row-context-dependent primitives inside that content resolve this row.
     */
    readonly injector: Injector;
    /** This row's selection identity, written into the table's `[(value)]`. Leave unset for non-selectable rows. */
    readonly value: _angular_core.InputSignal<unknown>;
    /** 1-based tree depth for `aria-level` in `mode="treegrid"`. Ignored in other modes. */
    readonly level: _angular_core.InputSignalWithTransform<number, unknown>;
    /** Marks this row as an expandable parent — emits `aria-expanded` + `data-state`. */
    readonly expandable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Absolute 0-based index of this row in the full virtualized dataset. Set by the
     * consumer when rendering a window via `[forTableVirtualized]`; drives the absolute
     * `aria-rowindex` and keeps the focused row mounted across recycling. Leave unset
     * (default `null`) for non-virtualized tables. Ignored in `mode="table"`.
     */
    readonly virtualIndex: _angular_core.InputSignalWithTransform<number | null, unknown>;
    protected readonly rowIndex: Signal<number | null>;
    readonly selectionMode: Signal<TableSelectionMode>;
    readonly selected: Signal<boolean>;
    protected readonly ariaSelected: Signal<"true" | "false" | null>;
    /** Whether this expandable row is currently open. False for non-expandable rows. */
    readonly expanded: Signal<boolean>;
    /** Toggles this row's expansion. No-op when the row is not expandable or has no `[value]`. */
    toggleExpanded(): void;
    protected readonly ariaLevel: Signal<number | null>;
    protected readonly posinset: Signal<number | null>;
    protected readonly setsize: Signal<number | null>;
    protected readonly ariaExpanded: Signal<"true" | "false" | null>;
    protected readonly expandState: Signal<"open" | "closed" | null>;
    constructor();
    private registerCell;
    private unregisterCell;
    cellIndexOf(host: HTMLElement): number;
    toggleSelected(): void;
    protected onClick(event: MouseEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableRow, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableRow, "[forTableRow]", ["forTableRow"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "virtualIndex": { "alias": "virtualIndex"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Marks a header cell (`role="columnheader"`). Requires a `name` input that
 * identifies the column — reflected as `data-column` for later phases (sort,
 * resize, reorder) to key off. Optionally sticky via the `sticky` input.
 *
 * In `grid` / `treegrid` mode the header cell joins the roving-navigation grid
 * as a cell of the grid's first row, so the header and body share a single
 * composite tab stop and Arrow keys navigate between them. The active header
 * cell carries `tabindex="0"` (others `-1`), reflects `data-highlighted` when
 * focused, and carries a 1-based `aria-colindex`.
 *
 * When a `[forDraggable]` shares the cell (a `[forTableColumnReorder]` row) the
 * cell still participates in that composite grid — `aria-colindex` and focus
 * activation stay on the cell — but it yields the host `tabindex`, keydown, and
 * `data-highlighted` to the draggable, so the grid keeps a single tab stop and
 * `[forTableColumnReorder]` routes idle Arrow navigation across it.
 */
declare class ForTableHeaderCell {
    #private;
    protected readonly ctx: TableContext;
    /**
     * The header cell's host element (`role="columnheader"`). Exposed so a descendant
     * `[forTableColumnResizer]` can resolve the enclosing cell through DI to measure its
     * base width — robust to `hostDirectives` composition, where the `[forTableHeaderCell]`
     * selector attribute is not reflected onto the wrapper's host element.
     */
    readonly el: ElementRef<HTMLElement>;
    /**
     * This header cell's element injector. Exposed so a declarative renderer stamping
     * header content from a projected `<ng-template>` (e.g. `ForTableBody`) can pass it
     * as `[ngTemplateOutletInjector]`, letting context-dependent primitives inside that
     * content resolve this cell and the table.
     */
    readonly injector: Injector;
    /** Column identifier, reflected as `data-column`. Required by later phases (sort, resize, reorder). */
    readonly name: _angular_core.InputSignal<string>;
    /**
     * Registers an intent that makes this header cell a `tabindex="0"` tab stop when
     * it is not participating in the roving composite grid. Called by
     * `[forTableSortHeader]` so the two never bind `[tabindex]` on the same host.
     */
    registerStandaloneTabStop(active: Signal<boolean>): void;
    /** Clears a previously registered standalone tab-stop intent. Reference-based. */
    unregisterStandaloneTabStop(active: Signal<boolean>): void;
    /**
     * The element a descendant `[forTableColumnLabel]` marks as this column's label
     * text, or `null` when no marker is present. A sibling `[forTableColumnResizer]`
     * reads it to measure the header label for header-inclusive auto-fit, isolating
     * the label from the resize handle / sort affordance without DOM assumptions.
     */
    readonly labelEl: Signal<HTMLElement | null>;
    /** Registers a descendant `[forTableColumnLabel]` as this header cell's label element. */
    registerLabel(el: HTMLElement): void;
    /** Unregisters the label element. Reference-based; safe to call if never registered. */
    unregisterLabel(el: HTMLElement): void;
    /**
     * Sticky placement for this header cell. `true` (or the bare `sticky`
     * attribute) pins to the start edge; `'end'` pins to the end edge; `false`
     * (default) is not sticky. The consumer applies `position: sticky` and the
     * appropriate `top` / `left` / `right` offset in CSS — this input only
     * provides the `data-sticky` hook.
     */
    readonly sticky: _angular_core.InputSignalWithTransform<TableStickyValue, string | boolean>;
    protected readonly tabindex: Signal<0 | -1 | null>;
    protected readonly colIndex: Signal<number | null>;
    protected readonly highlighted: Signal<boolean>;
    constructor();
    protected onFocus(): void;
    protected onKeyDown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableHeaderCell, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableHeaderCell, "[forTableHeaderCell]", ["forTableHeaderCell"], { "name": { "alias": "name"; "required": true; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Marks a data cell. The `role` is derived from the root's `mode`: `'cell'` in
 * `table` mode and `'gridcell'` in `grid` / `treegrid` mode. In grid / treegrid
 * mode the cell is a roving-tabindex target — the single active cell carries
 * `tabindex="0"` (others `-1`), reflects `data-highlighted` when focused, and
 * carries a 1-based `aria-colindex`. Arrow / Home / End / Ctrl+Home / Ctrl+End /
 * PageUp / PageDown move focus between cells. Requires a `name` input that
 * identifies the column — reflected as `data-column`. Optionally sticky and
 * optionally disabled (disabled cells are skipped during navigation).
 */
declare class ForTableCell {
    #private;
    protected readonly ctx: TableContext;
    protected readonly rowCtx: ForTableRowContext;
    /**
     * This cell's element injector. Exposed so a declarative renderer stamping cell
     * content from a projected `<ng-template>` (e.g. `ForTableBody`) can pass it as
     * `[ngTemplateOutletInjector]`, letting row-context-dependent primitives inside
     * that content (`[forTableRowSelector]`, …) resolve their `[forTableRow]`.
     */
    readonly injector: Injector;
    protected readonly role: _angular_core.Signal<"cell" | "gridcell">;
    /** Column identifier, reflected as `data-column`. Required by later phases (sort, resize, reorder). */
    readonly name: _angular_core.InputSignal<string>;
    /**
     * Sticky placement for this data cell. `true` (or the bare `sticky` attribute)
     * pins to the start edge; `'end'` pins to the end edge; `false` (default) is not
     * sticky. The consumer applies `position: sticky` and the offsets in CSS — this
     * input only provides the `data-sticky` hook.
     */
    readonly sticky: _angular_core.InputSignalWithTransform<TableStickyValue, string | boolean>;
    /**
     * Whether this data cell is disabled. Disabled cells are skipped during arrow-key
     * navigation, drop out of the tab order, and reflect `aria-disabled` / `data-disabled`.
     * Only meaningful in `grid` / `treegrid` mode.
     */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    protected readonly tabindex: _angular_core.Signal<number | null>;
    protected readonly colIndex: _angular_core.Signal<number | null>;
    protected readonly highlighted: _angular_core.Signal<boolean>;
    constructor();
    protected onFocus(): void;
    protected onKeyDown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableCell, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableCell, "[forTableCell]", ["forTableCell"], { "name": { "alias": "name"; "required": true; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Accessible per-row selection checkbox inside a `[forTableRow]`. Renders
 * `role="checkbox"` reflecting the row's selection via `aria-checked="true" | "false"`
 * and `data-state="checked" | "unchecked"` for styling. Clicking (or Space / Enter
 * while focused) toggles the row's selection.
 *
 * In `mode="table"` it is the focusable keyboard selection path: it is a standalone
 * tab stop (`tabindex="0"`), reached with `Tab` and toggled with `Space` / `Enter`.
 * In `grid` / `treegrid` mode it yields its tab stop to the composite roving grid
 * (`tabindex="-1"`) — selection is driven from the cell (`Space`) — but it stays a
 * named, non-hidden checkbox in the accessibility tree.
 *
 * Give it an accessible name via `ariaLabel` (or an external label). The enclosing
 * row still owns the row-level `aria-selected`.
 */
declare class ForTableRowSelector {
    protected readonly ctx: TableContext;
    protected readonly row: ForTableRowContext;
    /** Accessible label for the selection checkbox (e.g. "Select row"). Truthy-only. */
    readonly ariaLabel: _angular_core.InputSignal<string | null>;
    protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
    protected readonly tabindex: _angular_core.Signal<0 | -1>;
    protected readonly ariaChecked: _angular_core.Signal<"true" | "false">;
    protected readonly dataState: _angular_core.Signal<"checked" | "unchecked">;
    protected onClick(event: MouseEvent): void;
    protected onKeyDown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableRowSelector, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableRowSelector, "[forTableRowSelector]", ["forTableRowSelector"], { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Header "select all" checkbox for a `[forTable]` in `selectionMode="multiple"`.
 * Reflects `aria-checked="true" | "false" | "mixed"` and
 * `data-state="checked" | "unchecked" | "indeterminate"` derived from how many
 * selectable rows are selected. Clicking (or Space / Enter) selects all rows
 * when none/some are selected, and clears when all are. No-op outside multiple
 * mode.
 *
 * In `mode="table"` it is a standalone tab stop (`tabindex="0"`) and can sit on any
 * focusable element (a `<span>` you make tabbable, or a `<button type="button">`).
 * In `mode="grid"` / `"treegrid"` it yields its tab stop to the composite roving grid
 * (`tabindex="-1"`) and is reached via cell-entry (Enter / F2), so it must sit on a
 * natively-focusable element (a `<button type="button">`) — a `tabindex`-only `<span>`
 * is cell-entry-reachable only in `mode="table"`.
 */
declare class ForTableSelectAll {
    protected readonly ctx: TableContext;
    /** Accessible label for the control (e.g. "Select all rows"). Truthy-only. */
    readonly ariaLabel: _angular_core.InputSignal<string | null>;
    protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
    protected readonly tabindex: _angular_core.Signal<0 | -1>;
    protected readonly ariaChecked: _angular_core.Signal<"mixed" | "true" | "false">;
    protected readonly dataState: _angular_core.Signal<"checked" | "unchecked" | "indeterminate">;
    protected onClick(): void;
    protected onKeyDown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableSelectAll, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableSelectAll, "[forTableSelectAll]", ["forTableSelectAll"], { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Marks the element inside a `[forTableHeaderCell]` that carries the column's
 * label text. It owns no role, ARIA, or DOM of its own — it is a structure-agnostic
 * hook so a sibling `[forTableColumnResizer]` with `[fitIncludesHeader]` can measure
 * the header label in isolation, ignoring the resize handle, sort affordance, and any
 * other header chrome. Wrap only the text you want the header-inclusive auto-fit to
 * account for.
 *
 * @example
 * ```html
 * <th forTableHeaderCell name="dept">
 *   <span forTableColumnLabel>Department</span>
 *   <button forTableColumnResizer column="dept" fitIncludesHeader [(width)]="deptWidth"
 *           aria-label="Resize Department column"></button>
 * </th>
 * ```
 */
declare class ForTableColumnLabel {
    #private;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableColumnLabel, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableColumnLabel, "[forTableColumnLabel]", ["forTableColumnLabel"], {}, {}, never, never, true, never>;
}

/** Payload of `rowReorder`: the previous and new row index. */
interface TableRowReorderDescriptor {
    /** Previous row index (0-based). Absolute (dataset) index under virtualization, else rendered order. */
    from: number;
    /** New row index (0-based). Absolute (dataset) index under virtualization, else rendered order. */
    to: number;
}
/**
 * Opt-in **row reordering** for `ForTable`, composed over the drag-drop primitive.
 *
 * Apply on the rowgroup element that wraps the data rows (`<div role="rowgroup">` in
 * `<div>` mode, `<tbody>` in native `<table>` mode). It wraps `[forDropList]` (via
 * `hostDirectives`, vertical by default) so the rows become a reorderable list, then
 * translates drag-drop's generic drop into the table-friendly `rowReorder` output. Mark
 * each `[forTableRow]` as `[forDraggable]` with a `[dragData]`. On a committed drop it
 * emits the previous / new index; the consumer applies the move to their own row array
 * (e.g. `moveItemInArray`). **It never reorders rows itself** (BYO-data).
 *
 * In `mode="grid"` / `mode="treegrid"` the draggable rows **yield their tab stop** to the
 * table's composite roving grid, keeping the **single tab stop** the WAI-ARIA Data Grid
 * pattern calls for. Keyboard reordering is therefore initiated from a focused **cell**:
 * press `Ctrl`/`Cmd`+`Space` on any cell to lift the enclosing row, then `ArrowUp` /
 * `ArrowDown` (`Home` / `End`, `PageUp` / `PageDown`) move the target, `Space` / `Enter`
 * drop, and `Escape` / `Tab` cancel. Idle Arrow keys stay grid navigation, and `Space` still
 * selects the row when a selection mode is set. In the static `mode="table"` the rowgroup
 * keeps its own draggable-owned tab stop and the plain `Space` / `Enter` lift on a focused
 * row.
 *
 * Under `[forTableVirtualized]`, `rowReorder` emits **absolute** dataset indices so
 * `moveItemInArray` over the full array moves the right row; a non-virtualized table emits
 * rendered-order indices. Pointer drag works within the rendered window and reaches rows
 * beyond it via auto-scroll; keyboard reorder steps the target across the entire dataset,
 * scrolling unmounted rows into view. Holding **Shift** during a pointer drag engages
 * **windowed scrub** — the scroll viewport maps onto the whole dataset (top edge → row 0,
 * bottom edge → the last row) so a single gesture can drop the lifted row at an arbitrary
 * far row.
 *
 * Focus leaving the rowgroup cancels a keyboard lift. A window recycle that briefly blurs
 * the retained lifted row does not: focus returns to it once the window settles.
 *
 * **One gesture at a time.** Pointer and keyboard reorder are mutually exclusive: a live
 * keyboard lift stands the pointer channel down, and a lift key pressed during a pointer
 * drag is ignored.
 *
 * A pointer press is refused outright when the rowgroup is `disabled`, when a **mouse** press
 * uses a non-primary button (touch and pen presses keep whatever `button` their engine
 * reports), or when the pressed row carries no registered `[forDraggable]` or its draggable
 * is `[dragDisabled]`.
 *
 * @example
 * ```html
 * <div role="rowgroup" forTableRowReorder (rowReorder)="onReorder($event)">
 *   @for (row of rows(); track row.id) {
 *     <div forTableRow [value]="row.id" forDraggable [dragData]="row.id">…</div>
 *   }
 * </div>
 * ```
 */
declare class ForTableRowReorder {
    #private;
    protected readonly ctx: TableContext;
    /** Fires once per committed reorder gesture with the previous / new row index. */
    readonly rowReorder: _angular_core.OutputEmitterRef<TableRowReorderDescriptor>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableRowReorder, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableRowReorder, "[forTableRowReorder]", ["forTableRowReorder"], {}, { "rowReorder": "rowReorder"; }, never, never, true, [{ directive: typeof i1.ForDropList; inputs: { "dir": "dir"; "disabled": "disabled"; "autoScroll": "autoScroll"; "animateReorder": "animateReorder"; "liveSort": "liveSort"; "boundary": "boundary"; "lockAxis": "lockAxis"; }; outputs: {}; }]>;
}

export { FOR_TABLE_CONTEXT, FOR_TABLE_DEF_REGISTRY, ForTable, ForTableBody, ForTableCell, ForTableCellDef, ForTableColumnDef, ForTableColumnDragPlaceholder, ForTableColumnLabel, ForTableColumnReorder, ForTableColumnResizer, ForTableHeaderCell, ForTableHeaderCellDef, ForTableHeaderRow, ForTablePlaceholderCellDef, ForTablePlaceholderCellDefault, ForTableRow, ForTableRowCellDef, ForTableRowDef, ForTableRowReorder, ForTableRowSelector, ForTableSelectAll, ForTableSortHeader, provideForTable, provideForTableDefRegistry };
export type { ForTableCellDefContext, ForTableContext, ForTableDefRegistry, TableColumnReorderDescriptor, TableMode, TableResizeDescriptor, TableRowActivateEvent, TableRowContextMenuEvent, TableRowReorderDescriptor, TableSelectAllState, TableSelectionBehavior, TableSelectionMode, TableSortDescriptor, TableSortDirection, TableStickyValue };