@ui-organized/angular-table 0.0.0-stage → 0.1.0

package/dist/types/ui-organized-angular-table.d.ts

@@ -0,0 +1,1455 @@
+import * as _ui_organized_table_core from '@ui-organized/table-core';
+import { RowData, BulkSelection, UioTableFeatures, TableRowModel, TableChrome, TableColumn as TableColumn$1, TableSize, TableVariant, SelectionMode, ReorderSetting, VirtualConfig, DataTableQuery, TableEditPatch, ResponsiveConfig, TableFilterCondition, FilterOperatorDef, TableMode, SelectionState, TableFilterType, ConditionDescription, TableFilterFacetOption, FilterOperatorArity, EditState, TableEditContext, DetailState, GridCursor, HorizontalScrollState, ReorderMode, DropSide, TableRowScope, Store, ElementProps, TableHeaderInstance, TableFilterValue } from '@ui-organized/table-core';
+export { DataTableQuery, ReorderSetting, ResponsiveConfig, SelectionMode, TableDateDef, TableDateSetting, TableFilterCondition, TableFilterType, TableMode, TableRowModel, TableRowScope, TableSize, TableVariant, VirtualConfig } from '@ui-organized/table-core';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Signal, WritableSignal, InjectionToken, Renderer2, OnInit } from '@angular/core';
+import * as _ui_organized_angular from '@ui-organized/angular';
+import { IconName, ButtonIntent, internalGlyph, AccordionItem } from '@ui-organized/angular';
+import { AngularTable, TableState } from '@tanstack/angular-table';
+import { AngularVirtualizer } from '@tanstack/angular-virtual';
+import * as _ui_organized_angular_table from '@ui-organized/angular-table';
+import * as _tanstack_table_core from '@tanstack/table-core';
+
+/**
+ * Anything Angular will render from a renderer function.
+ *
+ * The counterpart of React's `ReactNode` in the one place a framework type
+ * legitimately enters — a custom cell or edit renderer, which core declares as
+ * `unknown` precisely so each adapter can narrow it to its own. A `TemplateRef`
+ * is Angular's "a piece of markup you can hand around"; a string is the common
+ * case and costs the caller nothing.
+ */
+type AngularNode = TemplateRef<unknown> | string | number | null | undefined;
+/** The Angular column type. Identical to core's, with `meta.edit.render` narrowed. */
+type TableColumn<T extends RowData> = TableColumn$1<T>;
+type TableEditRenderer<T extends RowData> = (ctx: TableEditContext<T>) => AngularNode;
+/**
+ * A condition a table starts with. `id` is omitted because the table assigns
+ * them — deterministically, so baselines and assertions stay stable.
+ */
+type TableFilterInput = Omit<TableFilterCondition, "id">;
+/** One filterable column, as the "Add filter" list sees it. */
+interface FilterableField {
+    columnId: string;
+    label: string;
+    type: TableFilterType;
+    /** How many conditions already target it. Shown as a suffix in the list. */
+    count: number;
+}
+/**
+ * ── How this API is reactive ────────────────────────────────────────────────
+ *
+ * React's `DataTableApi` is a plain object rebuilt on every render, so its
+ * fields are values. Angular's factory runs **once**, so anything derived has to
+ * arrive as a `Signal` or it is a snapshot of the first frame that never updates
+ * again — the single most likely way to port this file wrongly, and one that
+ * fails silently: the table renders correctly and then never changes.
+ *
+ * So the rule is uniform and worth stating once: **derived state is a `Signal`,
+ * actions are plain functions.** A template reads `api.rows()` and calls
+ * `api.selection.toggle(...)`. Nothing in between is a bare value.
+ */
+interface FiltersApi {
+    /** Every applied condition, in the order added. What the chips render from. */
+    conditions: Signal<TableFilterCondition[]>;
+    /** Columns that may be filtered, in menu order. */
+    fields: Signal<FilterableField[]>;
+    /**
+     * Add a condition on a column, starting on its default operator. Returns the
+     * id it assigned, so the caller can open that chip's editor immediately.
+     */
+    add: (columnId: string) => string;
+    update: (id: string, patch: Partial<Omit<TableFilterCondition, "id" | "columnId">>) => void;
+    /**
+     * Move a condition to another column — the chip's field segment. Keeps the
+     * operator and value when both columns read them the same way, and starts
+     * over on the new column's default otherwise (`retargetCondition`).
+     */
+    changeField: (id: string, columnId: string) => void;
+    /** Put a condition back as it was — Escape in an open editor. */
+    restore: (condition: TableFilterCondition) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    /** The chip's words, decided in core so every adapter agrees. */
+    describe: (condition: TableFilterCondition) => ConditionDescription;
+    /** The operators a condition's column offers, in menu order. */
+    operatorsFor: (condition: TableFilterCondition) => {
+        id: string;
+        label: string;
+    }[];
+    /** Enum choices with faceted counts, and whether each would yield nothing. */
+    optionsFor: (condition: TableFilterCondition) => TableFilterFacetOption[];
+    /** The filter type of a condition's column. Decides which editor renders. */
+    typeOf: (condition: TableFilterCondition) => TableFilterType;
+    /** How many operands the condition's operator takes. Decides the editor's shape. */
+    arityOf: (condition: TableFilterCondition) => FilterOperatorArity;
+    /** Chips past the collapse limit are hidden until this is true. */
+    expanded: Signal<boolean>;
+    setExpanded: (expanded: boolean) => void;
+    /**
+     * The condition whose editor is open. `add` sets it, so a filter chosen from
+     * the header opens for editing without the two components having to know
+     * about each other.
+     */
+    editing: Signal<string | null>;
+    setEditing: (id: string | null) => void;
+    /** Announced in the live region on add, remove, change and clear. */
+    announcement: Signal<string>;
+}
+interface BulkAction<T extends RowData> {
+    id: string;
+    label: string;
+    /** The icon's native name in the active library (`"pencil"`), registered with `registerIcons`. */
+    icon?: IconName;
+    /** Routes through `AlertDialog` before running. */
+    destructive?: boolean;
+    /** Confirmation copy. Defaults are derived from `label`. */
+    confirm?: {
+        title?: string;
+        description?: string;
+        confirmLabel?: string;
+    };
+    onRun: (rows: T[], selection: BulkSelection) => void | Promise<void>;
+}
+/**
+ * A button in the table's header — "New user", "Import", "Refresh". The table's
+ * own actions, as opposed to a row's or a selection's.
+ */
+interface TableAction {
+    id: string;
+    label: string;
+    /** The icon's native name in the active library (`"pencil"`), registered with `registerIcons`. */
+    icon?: IconName;
+    /** Button hierarchy. Defaults to `tertiary` — chrome, not a call to action. */
+    intent?: ButtonIntent;
+    /** Drop the visible label and keep only the icon. `label` still names it. */
+    iconOnly?: boolean;
+    disabled?: boolean;
+    onRun: () => void | Promise<void>;
+}
+interface RowAction<T extends RowData> {
+    id: string;
+    label: string;
+    /** The icon's native name in the active library (`"pencil"`), registered with `registerIcons`. */
+    icon?: IconName;
+    destructive?: boolean;
+    disabled?: (row: T) => boolean;
+    onRun: (row: T) => void | Promise<void>;
+}
+interface DetailConfig<T extends RowData> {
+    render: (row: T) => AngularNode;
+    /** Sheet title. Defaults to the primary column's value. */
+    title?: (row: T) => string;
+    description?: (row: T) => string;
+    /** Footer actions, rendered after the built-in Close. */
+    footer?: (row: T) => AngularNode;
+}
+interface EmptyStateConfig {
+    title?: string;
+    description?: string;
+    action?: AngularNode;
+}
+/**
+ * The options, read reactively.
+ *
+ * Handed to `createDataTable` as a **getter** — `createDataTable(() => ({ ... }))`
+ * — so every field is read inside a `computed` and a signal-backed source keeps
+ * the table in step. A component built on this passes its own `input()` signals
+ * through the getter, which is what `<uio-data-table>` does.
+ */
+interface UseDataTableOptions<T extends RowData> {
+    data: readonly T[];
+    columns: readonly TableColumn<T>[];
+    /**
+     * The table's accessible name. Required, not optional: it becomes the
+     * `<caption>`, and a table announced as "table" and nothing else is the most
+     * common data-table accessibility failure there is.
+     */
+    label: string;
+    /** Show the caption instead of hiding it visually. */
+    captionVisible?: boolean;
+    /**
+     * Stable row identity. Selection, inline edit and the detail sheet are keyed
+     * by it; without one they follow row *position*, which breaks on every sort.
+     */
+    getRowId?: (row: T, index: number) => string;
+    size?: TableSize;
+    variant?: TableVariant;
+    selection?: SelectionMode;
+    sortable?: boolean;
+    filterable?: boolean;
+    searchable?: boolean;
+    paginated?: boolean;
+    pageSize?: number;
+    resizable?: boolean;
+    /**
+     * Lets people rearrange the columns by dragging a header, or with its move
+     * buttons (and Alt+Arrow on a focused header). Adds "Reset column order" to
+     * the Columns menu.
+     *
+     * - `true` / `"always"`: movable at any time; the move buttons appear on
+     *   hover and focus.
+     * - `"toggle"`: movable only in a reorder mode, switched from the toolbar.
+     *
+     * The table's own columns (selection, row actions) and pinned columns stay
+     * where they are.
+     */
+    reorderable?: ReorderSetting;
+    hideableColumns?: boolean;
+    /** The header's sort button. On by default whenever any column is sortable. */
+    sortMenu?: boolean;
+    /** Offer CSV download and clipboard copy in the toolbar. */
+    exportable?: boolean;
+    /** Row virtualization. `true` uses the defaults; an object tunes them. */
+    virtual?: boolean | VirtualConfig;
+    /** Caps the scroll viewport. A table with no cap cannot scroll or virtualize. */
+    maxHeight?: number | string;
+    loading?: boolean;
+    error?: AngularNode;
+    empty?: EmptyStateConfig;
+    /** Server-driven mode. Sorting, filtering and pagination stop happening locally. */
+    manual?: boolean;
+    /** Total matching rows. Required in `manual` mode — the client cannot count. */
+    rowCount?: number;
+    onQueryChange?: (query: DataTableQuery) => void;
+    /** Infinite scroll: fires as the viewport approaches the end of the rows. */
+    onLoadMore?: () => void;
+    onRowClick?: (row: T) => void;
+    onEdit?: (patch: TableEditPatch<T>) => void | Promise<void>;
+    rowActions?: RowAction<T>[];
+    bulkActions?: BulkAction<T>[];
+    /** The table's own actions, rendered in the header row. */
+    actions?: TableAction[];
+    detail?: DetailConfig<T>;
+    responsive?: ResponsiveConfig;
+    defaultSorting?: {
+        id: string;
+        desc: boolean;
+    }[];
+    defaultColumnVisibility?: Record<string, boolean>;
+    /**
+     * Conditions the table starts with. Also the only way to render a chip in a
+     * static surface — a visual baseline, an axe scan, a jsdom test.
+     */
+    defaultFilters?: TableFilterInput[];
+    /** Extra or replacement operators, including for localizing labels. */
+    filterOperators?: FilterOperatorDef[];
+}
+interface SelectionApi<T extends RowData> {
+    mode: Signal<SelectionMode>;
+    state: Signal<SelectionState>;
+    /** Rows the user believes are selected, including the all-matching case. */
+    count: Signal<number>;
+    /** Rows actually loaded and selected. */
+    rows: Signal<T[]>;
+    isSelected: (rowId: string) => boolean;
+    toggle: (rowId: string, checked: boolean, shift?: boolean) => void;
+    togglePage: (checked: boolean) => void;
+    selectAllMatching: () => void;
+    clear: () => void;
+    header: Signal<{
+        checked: boolean;
+        indeterminate: boolean;
+    }>;
+    /** True when the page is fully selected and more rows match beyond it. */
+    canSelectAllMatching: Signal<boolean>;
+    totalMatching: Signal<number>;
+    asBulk: () => BulkSelection;
+}
+interface EditApi<T extends RowData> {
+    enabled: Signal<boolean>;
+    state: Signal<EditState>;
+    isEditing: (rowId: string, columnId: string) => boolean;
+    start: (row: TableRowModel<T>, columnId: string) => void;
+    setValue: (value: unknown) => void;
+    commit: () => void;
+    cancel: () => void;
+    contextFor: (row: TableRowModel<T>, columnId: string) => TableEditContext<T> | null;
+}
+interface DetailApi<T extends RowData> {
+    enabled: Signal<boolean>;
+    state: Signal<DetailState>;
+    row: Signal<T | null>;
+    total: Signal<number>;
+    open: (rowId: string) => void;
+    close: () => void;
+    step: (direction: -1 | 1) => void;
+    canStep: (direction: -1 | 1) => boolean;
+    setDirty: (dirty: boolean) => void;
+    /** Answer the "discard unsaved changes?" prompt. */
+    resolveConfirm: (discard: boolean) => void;
+}
+interface FocusApi {
+    cursor: Signal<GridCursor>;
+    /**
+     * Follow focus that has already moved. Updates the cursor and takes no focus
+     * of its own — which is what keeps it from pulling focus back out of an open
+     * inline editor.
+     */
+    setCursor: (cursor: GridCursor) => void;
+    /** Move the cursor and take DOM focus with it. */
+    focusCell: (cursor: GridCursor) => void;
+    isFocused: (rowIndex: number, colIndex: number) => boolean;
+}
+interface VirtualApi {
+    enabled: Signal<boolean>;
+    /**
+     * The adapter's own proxy, not a signal wrapping one: it is callable — the
+     * raw virtualizer is `virtualizer()` — and its `getVirtualItems` and
+     * `getTotalSize` are already signals. Wrapping it again would add a `()` that
+     * bought nothing.
+     */
+    virtualizer: AngularVirtualizer<HTMLElement, HTMLElement>;
+    spacers: Signal<{
+        top: number;
+        bottom: number;
+    }>;
+}
+/**
+ * The viewport's horizontal overflow, live. `overflowing` is false whenever
+ * every column fits — which is what lets a scroll control render itself only
+ * when there is something to scroll to.
+ */
+interface HorizontalScrollApi {
+    state: Signal<HorizontalScrollState>;
+    /** Move most of a viewport width: `-1` towards the first column, `1` away. */
+    by: (direction: -1 | 1) => void;
+}
+/** A header drag in progress: what is moving, and where it would land. */
+interface ColumnDrag {
+    source: string;
+    target: string | null;
+    side: DropSide;
+}
+/** Same members as React's `ReorderApi`, with state as signals. */
+interface ReorderApi {
+    /** The `reorderable` setting, resolved. */
+    mode: Signal<ReorderMode>;
+    /** Columns can be moved right now: always, or inside toggle mode. */
+    active: Signal<boolean>;
+    /** Enters or leaves reorder mode. Only meaningful when `mode` is `"toggle"`. */
+    setActive: (active: boolean) => void;
+    /** Visible, not pinned, and not one of the table's own columns. */
+    isMovable: (columnId: string) => boolean;
+    canMove: (columnId: string, direction: -1 | 1) => boolean;
+    /** One place left or right, past the nearest movable visible column. */
+    move: (columnId: string, direction: -1 | 1) => void;
+    drop: (sourceId: string, targetId: string, side: DropSide) => void;
+    drag: Signal<ColumnDrag | null>;
+    setDrag: (drag: ColumnDrag | null) => void;
+}
+/** One row as the renderer sees it: the model, plus both of its indices. */
+interface RenderRow<T extends RowData> {
+    row: TableRowModel<T>;
+    /** The cursor coordinate: where the row sits on the current page. */
+    index: number;
+    /** What `aria-rowindex` reports: where it sits in the whole dataset. */
+    absoluteIndex: number;
+}
+interface DataTableApi<T extends RowData> {
+    /**
+     * The raw TanStack instance. Exposed deliberately as the escape hatch: every
+     * feature the wrapper does not cover is reachable through it, which is what
+     * stops a missing prop from being a fork.
+     *
+     * The *Angular* instance, so its signal-backed atoms come with it. Not a
+     * signal — the instance is created once and mutated in place; its reactivity
+     * lives in the atoms it holds.
+     */
+    table: AngularTable<UioTableFeatures, T>;
+    /**
+     * The controlled state — sorting, pagination, visibility, selection.
+     *
+     * React's adapter hangs a `state` getter off the table instance; Angular's
+     * exposes signal-backed `atoms` instead. It is handed back here rather than
+     * reached for on the engine because the table is controlled: these values are
+     * the source of truth and the engine is downstream of them.
+     */
+    state: Signal<Partial<TableState<UioTableFeatures>>>;
+    /** The rows to render — the current page, before virtualization. */
+    rows: Signal<TableRowModel<T>[]>;
+    /** The rows actually rendered, which under virtualization is a window. */
+    renderRows: Signal<RenderRow<T>[]>;
+    chrome: Signal<TableChrome>;
+    options: UseDataTableOptions<T>;
+    size: Signal<TableSize>;
+    variant: Signal<TableVariant>;
+    label: Signal<string>;
+    captionVisible: Signal<boolean>;
+    interactive: Signal<boolean>;
+    mode: Signal<TableMode>;
+    loading: Signal<boolean>;
+    /** The urgent search value. Bind an input to this, never to the deferred one. */
+    search: Signal<string>;
+    setSearch: (value: string) => void;
+    selection: SelectionApi<T>;
+    filters: FiltersApi;
+    edit: EditApi<T>;
+    detail: DetailApi<T>;
+    focus: FocusApi;
+    virtual: VirtualApi;
+    scroll: HorizontalScrollApi;
+    reorder: ReorderApi;
+    columnWidths: Signal<Record<string, number>>;
+    /**
+     * The root and viewport nodes, as writable signals a directive fills in.
+     *
+     * Angular has no per-element ref callback and `viewChild` cannot reach into a
+     * *projected* node, which the viewport is — so `UioTableElementRef` writes
+     * into these. A signal rather than a plain field because the resize and
+     * scroll observers below are `effect`s that have to re-run when the node
+     * arrives.
+     */
+    rootRef: WritableSignal<HTMLElement | null>;
+    viewportRef: WritableSignal<HTMLElement | null>;
+    exportCsv: (scope?: TableRowScope) => void;
+    copySelection: (scope?: TableRowScope) => Promise<boolean>;
+    onGridKeyDown: (event: KeyboardEvent) => void;
+    activate: (row: TableRowModel<T>) => void;
+    primaryColumnId: Signal<string | undefined>;
+}
+
+declare function createDataTable<T extends RowData>(options: () => UseDataTableOptions<T>): DataTableApi<T>;
+
+/**
+ * Binds one of core's framework-free stores to Angular signals.
+ *
+ * `@ui-organized/table-core`'s `state.ts` chose `{ getState, subscribe,
+ * dispatch }` because it is exactly what React's `useSyncExternalStore` wants —
+ * and the shape turns out to cost nothing anywhere else: Vue mirrors it with a
+ * `shallowRef`, Svelte with `$state`, and this with a `signal`.
+ *
+ * The store's two invariants are what make it safe: `getState()` returns the
+ * same reference until something actually changes, and a no-op action notifies
+ * nobody. So the mirror only ever changes when the state did.
+ *
+ * `DestroyRef` rather than `ngOnDestroy`, because this is called from an
+ * injection context rather than from a class that has lifecycle hooks.
+ */
+declare function trackStore<S, A>(store: Store<S, A>): Signal<S>;
+
+declare function createDeferred<T>(source: () => T): Signal<T>;
+
+/**
+ * The styled parts are usable on their own — that is the whole point of layer 2
+ * — so they need somewhere to find the table without every one of them taking
+ * the api as an input through four levels of markup.
+ *
+ * An `InjectionToken` on the element injector, which is Angular's spelling of
+ * the same arrangement React uses a context object for: the component that owns
+ * the table provides it, every part injects it, and a part rendered outside one
+ * says so with a message that names the fix.
+ */
+declare const UIO_DATA_TABLE: InjectionToken<DataTableApi<any>>;
+/** Providers for a component that owns a table. */
+declare function provideDataTable<T extends RowData>(factory: () => DataTableApi<T>): {
+    provide: InjectionToken<DataTableApi<any>>;
+    useFactory: () => DataTableApi<T>;
+};
+declare function injectDataTable<T extends RowData = RowData>(): DataTableApi<T>;
+/** For parts that are legitimately optional inside a table (toolbars reused elsewhere). */
+declare function injectOptionalDataTable<T extends RowData = RowData>(): DataTableApi<T> | null;
+
+/**
+ * The two columns the table adds for itself.
+ *
+ * They are built here rather than in the factory because their cells render real
+ * components — `Checkbox`, `Menu` — and each reads the table from the injector,
+ * which works because cells render inside the provider.
+ *
+ * `flexRenderComponent` rather than a bare component: the Angular adapter's
+ * `FlexRender` identifies a component by the wrapper this returns, which is how
+ * it tells "a component to mount" from "a string to print". The plan expected
+ * this to need hand-rolled `TemplateRef` plumbing; v9's adapter ships it.
+ */
+declare function selectionColumn<T extends RowData>(): TableColumn<T>;
+declare function actionsColumn<T extends RowData>(): TableColumn<T>;
+
+interface Applied {
+    attributes: Set<string>;
+    styles: Set<string>;
+}
+declare function applyElementProps(element: HTMLElement, renderer: Renderer2, props: ElementProps, previous: Applied): Applied;
+declare class UioTableProps {
+    readonly props: Signal<ElementProps>;
+    private readonly host;
+    private readonly renderer;
+    private applied;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableProps, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UioTableProps, "[uioTableProps]", never, { "props": { "alias": "uioTableProps"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Hand an element to a signal when it mounts, and `null` when it goes.
+ *
+ * React takes a callback ref for the root and the viewport; Vue binds a template
+ * ref and watches it; Svelte uses an action. Angular has neither a per-element
+ * ref callback nor a `viewChild` that can reach a **projected** node — and the
+ * viewport is projected, because `<uio-table-viewport>` is written by the caller
+ * inside `<uio-table>`. Writing into the api's own signal is what makes the
+ * node's arrival reactive, which the resize and scroll observers need.
+ *
+ * ```html
+ * <div [uioTableElementRef]="table.rootRef">
+ * ```
+ */
+declare class UioTableElementRef {
+    readonly target: _angular_core.InputSignal<WritableSignal<HTMLElement>>;
+    private readonly host;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableElementRef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UioTableElementRef, "[uioTableElementRef]", never, { "target": { "alias": "uioTableElementRef"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * ── Why the host is the `<span>` ────────────────────────────────────────────
+ *
+ * Both of these are rendered by `flexRenderComponent`, which creates the
+ * component's host element — so the host is a node in the table whether it is
+ * wanted or not. Selecting on `span[uioTableSelectCell]` rather than a custom
+ * element makes that unavoidable node *be* the hit target React renders, instead
+ * of an extra `<uio-table-select-cell>` wrapped around it.
+ *
+ * The same reasoning as everywhere else in this package: an Angular component
+ * always has a host element, so the only way to match React's DOM is to make the
+ * host the element React renders.
+ */
+/**
+ * The header's tri-state checkbox: from empty it selects the rows on screen;
+ * from checked or mixed it clears the selection. What the box shows decides
+ * the click, not the box's own next state — see `headerToggleTarget`.
+ */
+declare class UioTableSelectAllCell {
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly selectAllLabel: _angular_core.Signal<string>;
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableSelectAllCell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableSelectAllCell, "span[uioTableSelectAllCell]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * A row's selection checkbox, with shift-click range selection.
+ *
+ * Given a `UioCheckbox` with a closed prop API, the wrapper records `shiftKey`
+ * from the pointer or keyboard event that *precedes* the change, which the
+ * change handler then reads. It needs no change to `@ui-organized/angular`,
+ * which is the point: widening a component's API to serve one consumer is how a
+ * design system's props turn into a junk drawer.
+ */
+declare class UioTableSelectCell {
+    readonly rowId: _angular_core.InputSignal<string>;
+    readonly rowLabel: _angular_core.InputSignal<string>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    private shift;
+    protected remember(event: MouseEvent | KeyboardEvent): void;
+    protected change(checked: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableSelectCell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableSelectCell, "span[uioTableSelectCell]", never, { "rowId": { "alias": "rowId"; "required": true; "isSignal": true; }; "rowLabel": { "alias": "rowLabel"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The actions column's header: a name for assistive tech and nothing visible.
+ *
+ * A component rather than a plain string, because the string would be *shown* —
+ * a column of ellipsis buttons under a visible "Actions" heading is not what the
+ * design draws, and a column with no accessible name at all is worse.
+ */
+declare class UioTableActionsHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableActionsHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableActionsHeader, "uio-table-actions-header", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A part that applies core's prop bag to **its own host element**.
+ *
+ * `UioTableProps` is the directive for the ordinary case — a plain element in
+ * someone's template, `<td [uioTableProps]="…">`. It cannot serve a component
+ * that computes its own props, because `hostDirectives` exposes the input for
+ * *binding* and a component has no way to bind an input to itself.
+ *
+ * So the parts that own their props extend this instead. Subclasses declare
+ * `tableProps` as a `computed` and the effect below keeps the host in step,
+ * diffing exactly as the directive does — see `applyElementProps` for why
+ * diffing rather than assigning is load-bearing.
+ */
+declare abstract class UioTablePropsHost {
+    /** The bag this part puts on its own host element. */
+    protected abstract readonly tableProps: Signal<ElementProps>;
+    private readonly propsHost;
+    private readonly propsRenderer;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTablePropsHost, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UioTablePropsHost, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The parts, flat-exported — `UioTableHeader`, not `Table.Header`. That is the
+ * repo's convention everywhere else (`UioDialogContent`, `UioMenuItem`) and
+ * there is no reason for the table to be the exception.
+ *
+ * The DOM they compose to:
+ *
+ *   <div uioTable>              class="data-table"    root, size + variant
+ *     <div uioTableToolbar>     …
+ *     <div uioTableViewport>    class="data-table__viewport", then <table>
+ *       <thead uioTableHeader>
+ *       <tbody uioTableBody>    spacer / rows / spacer
+ *     <div uioTablePagination>
+ *
+ * ── Why every part is an attribute directive ────────────────────────────────
+ *
+ * `@ui-organized/angular` puts its components on the caller's own element
+ * (`<button uioButton>`, `<span uioChip>`) rather than on a custom element, and
+ * the table has two reasons of its own to do the same. A custom element between
+ * `<table>` and `<thead>` is invalid HTML — the browser hoists the `<thead>`
+ * straight back out — so `<uio-table-header>` cannot exist at all. And anywhere
+ * else, a host element is a DOM node the other three libraries do not render,
+ * which the parity gate reports as a difference on every case.
+ *
+ * So the caller writes the element and the part decorates it. Each one also
+ * binds core's prop bag through `UioTablePropsHost` rather than unpacking it
+ * field by field — see `../core/element-props.ts` for why that is the whole of
+ * Angular's "no prop spread" cost.
+ */
+/** The root: size, variant, and the element every part measures itself against. */
+declare class UioTable extends UioTablePropsHost {
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly tableProps: _angular_core.Signal<_ui_organized_table_core.ElementProps>;
+    private readonly element;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTable, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UioTable, "div[uioTable]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The scroll container and the `<table>` element, which are inseparable: a
+ * viewport with two tables in it means nothing, and `<caption>` and `<colgroup>`
+ * have to be emitted between them.
+ */
+declare class UioTableViewport extends UioTablePropsHost {
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly tableProps: _angular_core.Signal<_ui_organized_table_core.ElementProps | {
+        style: {
+            maxHeight: string | number;
+            width?: string | number;
+            minWidth?: string | number;
+            maxWidth?: string | number;
+            height?: string | number;
+            minHeight?: string | number;
+            left?: string | number;
+            right?: string | number;
+            top?: string | number;
+            position?: "sticky" | "relative" | "absolute" | "static";
+            tableLayout?: "fixed" | "auto";
+            textAlign?: "left" | "center" | "right" | "start" | "end";
+            zIndex?: number;
+            transform?: string;
+        };
+        className?: string;
+        role?: string;
+        tabIndex?: number;
+        id?: string;
+        scope?: "col" | "row" | "colgroup" | "rowgroup";
+        colSpan?: number;
+        hidden?: boolean;
+        title?: string;
+    }>;
+    protected readonly tableAttrs: _angular_core.Signal<_ui_organized_table_core.ElementProps>;
+    protected readonly caption: _angular_core.Signal<_ui_organized_table_core.ElementProps>;
+    protected readonly columns: _angular_core.Signal<_tanstack_table_core.Column<_ui_organized_table_core.UioTableFeatures, _tanstack_table_core.RowData, unknown>[]>;
+    private readonly element;
+    constructor();
+    protected colProps(columnId: string): _ui_organized_table_core.ElementProps;
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableViewport, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableViewport, "div[uioTableViewport]", never, {}, {}, never, ["*"], true, never>;
+}
+declare class UioTableHeader {
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly groups: _angular_core.Signal<_tanstack_table_core.HeaderGroup<_ui_organized_table_core.UioTableFeatures, _tanstack_table_core.RowData>[]>;
+    protected readonly rowProps: _ui_organized_table_core.ElementProps;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableHeader, "thead[uioTableHeader]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The body, and the four states it decides between on its own.
+ *
+ * Projected content wins: layer-2 composition is the point of these parts.
+ * Otherwise `<tbody uioTableBody>` alone is a complete table body — the error,
+ * the loading skeleton, the empty state and the rows are all its business.
+ */
+declare class UioTableBody {
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly spacers: _angular_core.Signal<{
+        top: number;
+        bottom: number;
+    }>;
+    protected readonly state: _angular_core.Signal<"error" | "loading" | "empty" | "rows">;
+    protected spacerRow(height: number): _ui_organized_table_core.ElementProps;
+    protected spacerCell(height: number): _ui_organized_table_core.ElementProps;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableBody, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableBody, "tbody[uioTableBody]", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Pointer drag and keyboard, on one control.
+ *
+ * The drag is TanStack's own handler; the keyboard is core's `resizeKeyDown`, so
+ * the two cannot drift. It is a `role="separator"` with `aria-valuenow`, which is
+ * what makes the column width something a screen reader can report rather than
+ * something only a mouse can discover.
+ */
+declare class UioTableResizeHandle<T extends RowData> extends UioTablePropsHost {
+    readonly header: _angular_core.InputSignal<TableHeaderInstance<T>>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<T>;
+    private readonly column;
+    private readonly bounds;
+    /** Applied to this button by `UioTablePropsHost`. */
+    protected readonly tableProps: _angular_core.Signal<_ui_organized_table_core.ElementProps>;
+    /** Stops the header's sort button from firing on the same press. */
+    protected startResize(event: MouseEvent | TouchEvent): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableResizeHandle<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableResizeHandle<any>, "button[uioTableResizeHandle]", never, { "header": { "alias": "header"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** One header cell: the sort control, the roving tab stop, and the resize grip. */
+declare class UioTableHeadCell<T extends RowData> extends UioTablePropsHost {
+    protected readonly glyph: typeof internalGlyph;
+    readonly header: _angular_core.InputSignal<TableHeaderInstance<T>>;
+    readonly index: _angular_core.InputSignal<number>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<T>;
+    protected readonly column: _angular_core.Signal<_tanstack_table_core.Column<_ui_organized_table_core.UioTableFeatures, T, any>>;
+    protected readonly sortable: _angular_core.Signal<boolean>;
+    protected readonly sorted: _angular_core.Signal<false | _tanstack_table_core.SortDirection>;
+    protected readonly interactive: _angular_core.Signal<boolean>;
+    protected readonly editable: _angular_core.Signal<boolean>;
+    protected readonly sortIcon: _angular_core.Signal<"sort-desc" | "sort-asc">;
+    private readonly focused;
+    protected readonly tabIndex: _angular_core.Signal<0 | -1>;
+    /** Applied to this `<th>` by `UioTablePropsHost`. */
+    protected readonly tableProps: _angular_core.Signal<_ui_organized_table_core.ElementProps>;
+    protected onFocus(): void;
+    protected readonly movable: _angular_core.Signal<boolean>;
+    protected readonly headerText: _angular_core.Signal<string>;
+    protected readonly dragging: _angular_core.Signal<boolean>;
+    protected readonly dropSide: _angular_core.Signal<_ui_organized_table_core.DropSide>;
+    protected onDragStart(event: DragEvent): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDrop(event: DragEvent): void;
+    protected onDragEnd(): void;
+    /**
+     * Re-rendering in the new order moves this header's DOM node, and a moved
+     * node drops focus. Put it back on the same button — or on the other one,
+     * when this move took the column to the end it pointed at. Only after a
+     * keyboard press: a mouse click does not leave focus on the button.
+     */
+    protected pressMove(direction: -1 | 1, event: MouseEvent, own: HTMLButtonElement, other: HTMLButtonElement): void;
+    protected toggleSort(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableHeadCell<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableHeadCell<any>, "th[uioTableHeadCell]", never, { "header": { "alias": "header"; "required": true; "isSignal": true; }; "index": { "alias": "index"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * One cell.
+ *
+ * The identifying column is a real row header, which is what makes a screen
+ * reader announce "Ada Lovelace, Role, Engineer" instead of just "Engineer" —
+ * so the row picks `th` or `td` and this decorates whichever it wrote. Angular
+ * has no dynamic element by name, and a component selector that matched both
+ * would be two selectors on one class, so the tag choice lives in the row's
+ * template and the behaviour lives here.
+ */
+declare class UioTableCell<T extends RowData> extends UioTablePropsHost {
+    readonly cell: _angular_core.InputSignal<_tanstack_table_core.Cell_Core<_ui_organized_table_core.UioTableFeatures, T, any>>;
+    readonly row: _angular_core.InputSignal<TableRowModel<T>>;
+    readonly index: _angular_core.InputSignal<number>;
+    readonly rowIndex: _angular_core.InputSignal<number>;
+    readonly primary: _angular_core.InputSignal<boolean>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<T>;
+    private readonly host;
+    protected readonly column: Signal<_tanstack_table_core.Column<_ui_organized_table_core.UioTableFeatures, T, any>>;
+    private readonly meta;
+    private readonly editable;
+    protected readonly editing: Signal<_ui_organized_table_core.TableEditContext<T>>;
+    private readonly focused;
+    /** Applied to this cell by `UioTablePropsHost`. */
+    protected readonly tableProps: Signal<_ui_organized_table_core.ElementProps>;
+    protected readonly editorTemplate: Signal<unknown>;
+    constructor();
+    protected onFocus(): void;
+    /**
+     * One click opens the editor. The click stops here either way: it must not
+     * also activate the row (open its detail sheet), and a click *inside* the open
+     * editor must not restart the edit and throw the draft away.
+     */
+    protected onClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableCell<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableCell<any>, "[uioTableCell]", never, { "cell": { "alias": "cell"; "required": true; "isSignal": true; }; "row": { "alias": "row"; "required": true; "isSignal": true; }; "index": { "alias": "index"; "required": true; "isSignal": true; }; "rowIndex": { "alias": "rowIndex"; "required": true; "isSignal": true; }; "primary": { "alias": "primary"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * One row.
+ *
+ * React memoizes this on a hand-written nine-field comparator, and threads every
+ * value it needs through props so the comparator can see them. Angular needs
+ * neither: a signal-driven template updates only what changed, so the row takes
+ * what genuinely *varies per row* as inputs and reads the rest from the
+ * injector.
+ */
+declare class UioTableRow<T extends RowData> extends UioTablePropsHost {
+    readonly row: _angular_core.InputSignal<TableRowModel<T>>;
+    readonly index: _angular_core.InputSignal<number>;
+    readonly absoluteIndex: _angular_core.InputSignal<number>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<T>;
+    private readonly host;
+    protected readonly cells: Signal<_tanstack_table_core.Cell_Core<_ui_organized_table_core.UioTableFeatures, T, unknown>[]>;
+    /** Applied to this `<tr>` by `UioTablePropsHost`. */
+    protected readonly tableProps: Signal<_ui_organized_table_core.ElementProps>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableRow<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableRow<any>, "tr[uioTableRow]", never, { "row": { "alias": "row"; "required": true; "isSignal": true; }; "index": { "alias": "index"; "required": true; "isSignal": true; }; "absoluteIndex": { "alias": "absoluteIndex"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Empty, loading and error all live *inside* `<tbody>` rather than replacing the
+ * table.
+ *
+ * Keeping the header on screen keeps the column widths, the scroll position and
+ * the filter controls exactly where they were — so clearing a filter that
+ * emptied the table does not also move every control the user was about to
+ * click.
+ */
+declare class UioTableEmpty {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly description: _angular_core.InputSignal<string>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly heading: _angular_core.Signal<string>;
+    protected readonly detail: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableEmpty, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableEmpty, "tr[uioTableEmpty]", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * Skeleton rows sized to the real row height, so the table does not resize when
+ * the data lands — which is the entire reason to prefer a skeleton to a spinner.
+ * (There is no Spinner in the library, which settles it anyway.)
+ */
+declare class UioTableLoading {
+    readonly rows: _angular_core.InputSignal<number>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly columns: _angular_core.Signal<_tanstack_table_core.Column<_ui_organized_table_core.UioTableFeatures, _tanstack_table_core.RowData, unknown>[]>;
+    protected readonly bars: _angular_core.Signal<number[]>;
+    protected readonly barHeight: _angular_core.Signal<10 | 12>;
+    protected widthFor(columnId: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableLoading, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableLoading, "[uioTableLoading]", never, { "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class UioTableError {
+    readonly title: _angular_core.InputSignal<string>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    /** The table's `error` option, when it is a plain string. */
+    protected readonly message: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableError, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableError, "tr[uioTableError]", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The row above the table: search, filters, and the controls that change what
+ * the table shows rather than what it contains.
+ *
+ * Not a `UioToolbar` — that is a `role="toolbar"` with roving focus, which is
+ * right for a cluster of icon buttons and wrong for a row containing a text
+ * input.
+ *
+ * ── Why the controls are inline rather than six exported parts ──────────────
+ *
+ * React, Vue and Svelte export `TableSearch`, `TableSortMenu`, `TableViewOptions`,
+ * `TableExportMenu`, `TableActions` and `TableScrollButtons` separately, and each
+ * renders exactly the element it is — a fragment, in effect. **An Angular
+ * component always has a host element**, so each of those would put a node in
+ * the DOM that the other three do not render, and every parity case would differ.
+ *
+ * A directive on the caller's element is the usual escape, and it does not work
+ * here: these parts configure themselves *from the table* rather than from
+ * bindings, so a host directive would need the caller to bind what the part
+ * already knows.
+ *
+ * So Angular's layer 2 is one part coarser here. The toolbar is still a part —
+ * `<div uioTableToolbar>` — and everything it composes is still core's decision;
+ * what a consumer loses is the ability to reorder the six controls, which the
+ * other three allow. Recorded rather than hidden.
+ */
+declare class UioTableToolbar {
+    protected readonly glyph: typeof internalGlyph;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly searchable: _angular_core.Signal<boolean>;
+    protected readonly hideable: _angular_core.Signal<boolean>;
+    protected readonly exportable: _angular_core.Signal<boolean>;
+    protected readonly filterable: _angular_core.Signal<boolean>;
+    protected readonly actions: _angular_core.Signal<TableAction[]>;
+    protected readonly scroll: _angular_core.Signal<_ui_organized_table_core.HorizontalScrollState>;
+    protected readonly cards: _angular_core.Signal<boolean>;
+    protected readonly hasSelection: _angular_core.Signal<boolean>;
+    protected readonly reorderToggle: _angular_core.Signal<boolean>;
+    /**
+     * The export menu's items report through `UioMenu (select)`, not their own:
+     * `UioMenuItem` has no `select` output, so `(select)` on an item binds a DOM
+     * event that never fires.
+     */
+    protected runExport(value: string): void;
+    protected readonly searchLabel: _angular_core.Signal<string>;
+    protected readonly filterFields: _angular_core.Signal<_ui_organized_angular_table.FilterableField[]>;
+    protected readonly sortableColumns: _angular_core.Signal<_tanstack_table_core.Column<_ui_organized_table_core.UioTableFeatures, _tanstack_table_core.RowData, unknown>[]>;
+    protected readonly toggleable: _angular_core.Signal<_ui_organized_table_core.TableColumnInstance<_tanstack_table_core.RowData>[]>;
+    protected readonly sortMenu: _angular_core.Signal<boolean>;
+    private readonly activeSort;
+    protected readonly activeSortId: _angular_core.Signal<string>;
+    protected readonly sortDirection: _angular_core.Signal<"asc" | "desc">;
+    protected readonly sortIcon: _angular_core.Signal<_ui_organized_angular.IconGlyph>;
+    protected iconOf(action: TableAction): IconName | undefined;
+    protected isIconOnly(action: TableAction): boolean;
+    protected headerOf(column: {
+        id: string;
+        columnDef: {
+            header?: unknown;
+        };
+    }): string;
+    protected chooseColumn(id: string): void;
+    protected chooseDirection(next: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableToolbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableToolbar, "div[uioTableToolbar]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Focus has to land somewhere deliberate when a chip disappears, or it falls to
+ * `<body>` and a keyboard user loses their place entirely.
+ */
+declare function focusAfterRemoval(removedId: string): void;
+/**
+ * The value half of a condition editor.
+ *
+ * Which control appears follows from **type and operator together**, never from
+ * the type alone — that is the whole point of separating the two. A date column
+ * shows one date field for "is before", two for "is between", and a number plus
+ * a unit for "is in the last".
+ */
+declare class UioTableFilterValueEditor {
+    readonly condition: _angular_core.InputSignal<TableFilterCondition>;
+    readonly arity: _angular_core.InputSignal<FilterOperatorArity>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly query: _angular_core.WritableSignal<string>;
+    protected readonly BOOLEAN_ITEMS: {
+        value: string;
+        label: string;
+    }[];
+    protected readonly UNITS: {
+        value: string;
+        label: string;
+    }[];
+    private readonly type;
+    /** One switch value rather than nested conditions, which a template cannot nest. */
+    protected readonly kind: _angular_core.Signal<"number" | "boolean" | "text" | "date" | "enum" | "none" | "relative-date">;
+    private readonly options;
+    protected readonly searchable: _angular_core.Signal<boolean>;
+    protected readonly listboxOptions: _angular_core.Signal<{
+        value: string;
+        label: string;
+        disabled: boolean;
+    }[]>;
+    protected readonly selectedValues: _angular_core.Signal<string[]>;
+    protected readonly booleanValue: _angular_core.Signal<string>;
+    protected numberAt(index: number): number | null;
+    protected stringAt(index: number): string;
+    private set;
+    protected setAt(index: number, value: TableFilterValue): void;
+    protected setBoolean(value: string): void;
+    protected setSelected(values: string[]): void;
+    protected setUnit(unit: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableFilterValueEditor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableFilterValueEditor, "[uioTableFilterValueEditor]", never, { "condition": { "alias": "condition"; "required": true; "isSignal": true; }; "arity": { "alias": "arity"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * One condition's value editor (Figma 2298:726): the value, then a rule and a
+ * remove. The field and the operator have segments of their own on the chip,
+ * so the editor carries only what the value segment opens.
+ */
+declare class UioTableFilterEditor {
+    protected readonly glyph: typeof internalGlyph;
+    readonly condition: _angular_core.InputSignal<TableFilterCondition>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly arity: _angular_core.Signal<FilterOperatorArity>;
+    protected remove(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableFilterEditor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableFilterEditor, "[uioTableFilterEditor]", never, { "condition": { "alias": "condition"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+type ChipMenu = "field" | "operator";
+/**
+ * One condition, as a segmented chip (Figma 2462:2636): "Name | is greater than
+ * | 30". Each segment opens the control for the one parameter it shows — the
+ * field menu, the operator menu, the value editor — so changing a filter is one
+ * click on the part you mean rather than a trip through a form.
+ *
+ * Removal lives in the field menu and at the foot of the value editor, not in a
+ * dismiss button: a fourth 24px target in a row of segments is a coin-flip on
+ * touch, and an operator that takes no value ("is empty") has no value editor to
+ * put it in.
+ */
+declare class UioTableFilterChip {
+    readonly condition: _angular_core.InputSignal<TableFilterCondition>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    private readonly editor;
+    protected readonly editing: _angular_core.Signal<boolean>;
+    private readonly settled;
+    protected readonly open: _angular_core.Signal<boolean>;
+    private readonly host;
+    protected readonly menu: _angular_core.WritableSignal<ChipMenu>;
+    protected readonly description: _angular_core.Signal<_ui_organized_table_core.ConditionDescription>;
+    protected readonly takesValue: _angular_core.Signal<boolean>;
+    protected readonly operators: _angular_core.Signal<{
+        id: string;
+        label: string;
+    }[]>;
+    private snapshot;
+    constructor();
+    protected setOpen(next: boolean): void;
+    protected setMenu(name: ChipMenu, next: boolean): void;
+    protected remove(): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableFilterChip, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableFilterChip, "[uioTableFilterChip]", never, { "condition": { "alias": "condition"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * The applied filters, on their own line under the header (Figma 2298:362).
+ *
+ * A *summary*, not a control panel: the filter button lives in the header above,
+ * and this line does not exist until the user has actually filtered something. A
+ * bar that is always present and usually empty is chrome that teaches people to
+ * stop looking at it.
+ */
+declare class UioTableFilters {
+    protected readonly glyph: typeof internalGlyph;
+    private readonly presence;
+    constructor();
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly conditions: _angular_core.Signal<TableFilterCondition[]>;
+    protected readonly filterFields: _angular_core.Signal<_ui_organized_angular_table.FilterableField[]>;
+    protected readonly render: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableFilters, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableFilters, "div[uioTableFilters]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Wraps the library's `Pagination`, which takes a page *count* — the conversion
+ * from row count and page size happens here so consumers never do that
+ * arithmetic themselves and get the off-by-one wrong.
+ */
+declare class UioTablePagination {
+    readonly showPageSize: _angular_core.InputSignal<boolean>;
+    readonly pageSizes: _angular_core.InputSignal<number[]>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    private readonly pagination;
+    protected readonly pageIndex: _angular_core.Signal<number>;
+    protected readonly pageSize: _angular_core.Signal<number>;
+    protected readonly pageSizeValue: _angular_core.Signal<string>;
+    private readonly total;
+    protected readonly pageCount: _angular_core.Signal<number>;
+    protected readonly status: _angular_core.Signal<string>;
+    protected readonly sizeOptions: _angular_core.Signal<{
+        value: string;
+        label: string;
+    }[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTablePagination, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTablePagination, "div[uioTablePagination]", never, { "showPageSize": { "alias": "showPageSize"; "required": false; "isSignal": true; }; "pageSizes": { "alias": "pageSizes"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Appears only while something is selected, and then takes the place of the
+ * toolbar's sort, filter and table actions: with rows selected, what to do
+ * with them is the decision in front of the user, so it sits where they were
+ * already looking rather than on a line of its own. The count, and the offer
+ * to select the rows off screen, are in `UioTableSelectionFooter` under the
+ * rows.
+ *
+ * Plain buttons in a labelled group, with no surface of its own. It shares the
+ * toolbar row with the search box, so `role="toolbar"`'s roving focus would
+ * make it the only cluster in that row that Tab skips through. Destructive
+ * actions route through `UioAlertDialog`; "archive 40,000 rows" is not an
+ * undo-able mis-click.
+ */
+declare class UioTableSelectionBar<T extends RowData> {
+    private readonly presence;
+    constructor();
+    readonly actions: _angular_core.InputSignal<BulkAction<T>[]>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<T>;
+    protected readonly confirming: _angular_core.WritableSignal<BulkAction<T>>;
+    protected readonly items: _angular_core.Signal<BulkAction<T>[]>;
+    protected readonly count: _angular_core.Signal<number>;
+    private readonly rowsWord;
+    protected readonly confirmTitle: _angular_core.Signal<string>;
+    protected readonly confirmDescription: _angular_core.Signal<string>;
+    protected readonly confirmLabel: _angular_core.Signal<string>;
+    protected iconOf(action: BulkAction<T>): IconName | undefined;
+    private run;
+    protected choose(action: BulkAction<T>): void;
+    protected runConfirmed(): void;
+    protected onOpenChange(open: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableSelectionBar<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableSelectionBar<any>, "div[uioTableSelectionBar]", never, { "actions": { "alias": "actions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Enters and leaves reorder mode, for `reorderable: "toggle"`.
+ *
+ * A directive on a `uioButton` rather than a component of its own: React's
+ * toggle is a single `<button>`, and an Angular component would put a host
+ * element around it. So the button is the caller's, and this supplies what it
+ * does and what it is called:
+ *
+ *   <button uioButton uioTableReorderToggle #reorder="uioTableReorderToggle"
+ *     [intent]="reorder.active() ? 'primary' : 'secondary'">{{ reorder.text() }}</button>
+ *
+ * The label says what a press does next — "Reorder", then "Done" — rather
+ * than carrying a pressed state, so it reads the same to a screen reader as
+ * it does on screen. Render it only while `table.reorder.mode()` is "toggle"
+ * and the table is not in card mode, as the toolbar does.
+ */
+declare class UioTableReorderToggle {
+    private readonly table;
+    readonly active: _angular_core.Signal<boolean>;
+    readonly text: _angular_core.Signal<"Done" | "Reorder">;
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableReorderToggle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UioTableReorderToggle, "button[uioTableReorderToggle]", ["uioTableReorderToggle"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Under the rows: how many are selected, and the offer to select the matching
+ * rows that are not on screen.
+ *
+ * At the bottom rather than in the toolbar, because that is where the user's
+ * eye is once they have ticked down a page — and where the visible rows run
+ * out is where "there are more of these" belongs. The bulk actions stay in the
+ * toolbar (see `UioTableSelectionBar`).
+ *
+ * The offer is a real button, and counts the rows it would *add*: "Select
+ * 99,981 hidden rows" says plainly that the ticks so far only reached what was
+ * visible.
+ */
+declare class UioTableSelectionFooter {
+    private readonly presence;
+    constructor();
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly count: _angular_core.Signal<number>;
+    protected readonly countLabel: _angular_core.Signal<string>;
+    protected readonly hiddenLabel: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableSelectionFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableSelectionFooter, "div[uioTableSelectionFooter]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The row under the toolbar: what is filtered.
+ *
+ * The selection's bulk actions used to share this line. They now replace the
+ * toolbar's own controls while anything is selected (see `UioTableToolbar`), so
+ * acting on the selection happens in the row the user was already reading.
+ *
+ * It renders nothing at all until there is a filter to show, so an empty row
+ * never takes a slice of the table's `gap` — and nothing in card mode, where
+ * the filter sheet holds them.
+ */
+declare class UioTableSubBar {
+    private readonly presence;
+    constructor();
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly render: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableSubBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableSubBar, "div[uioTableSubBar]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Per-row actions, as a menu rather than a row of buttons.
+ *
+ * A menu is one tab stop per row instead of three, which matters a great deal
+ * when there are two hundred rows — and it is the only affordance that survives
+ * card mode unchanged.
+ *
+ * The six menu parts this needs are the ones §E added to `@ui-organized/angular`
+ * before this package could exist.
+ */
+declare class UioTableRowActions<T extends RowData> {
+    protected readonly glyph: typeof internalGlyph;
+    /** The row the actions operate on. */
+    readonly row: _angular_core.InputSignal<T>;
+    /**
+     * Overrides the table's own `rowActions`. Only needed when the part is used
+     * outside a `<uio-data-table>`.
+     */
+    readonly actions: _angular_core.InputSignal<RowAction<T>[]>;
+    /** Accessible name for the trigger. Defaults to "Row actions". */
+    readonly label: _angular_core.InputSignal<string>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<T>;
+    protected readonly items: _angular_core.Signal<RowAction<T>[]>;
+    protected run(id: string): void;
+    protected iconOf(action: RowAction<T>): IconName | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableRowActions<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableRowActions<any>, "[uioTableRowActions]", never, { "row": { "alias": "row"; "required": true; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * One card: the row's title, its controls in the top-right corner, and every
+ * other visible column as a label and value.
+ *
+ * Title first, then the row's controls: the actions menu, and the checkbox
+ * last, in the corner a thumb reaches and where a ticked card is easiest to scan
+ * for down a list.
+ */
+declare class UioTableCard<T extends RowData> {
+    readonly row: _angular_core.InputSignal<TableRowModel<T>>;
+    readonly index: _angular_core.InputSignal<number>;
+    /** Column ids in card order — `cardFieldOrder`, computed once by the list. */
+    readonly fieldOrder: _angular_core.InputSignal<readonly string[]>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<T>;
+    private readonly host;
+    protected readonly selected: _angular_core.Signal<boolean>;
+    protected readonly selectable: _angular_core.Signal<boolean>;
+    protected readonly hasActions: _angular_core.Signal<boolean>;
+    protected readonly clickable: _angular_core.Signal<boolean>;
+    private readonly cells;
+    protected readonly primaryCell: _angular_core.Signal<_tanstack_table_core.Cell_Core<_ui_organized_table_core.UioTableFeatures, T, unknown>>;
+    /** The words the card's controls are named with: "Select Ada Lovelace". */
+    protected readonly titleText: _angular_core.Signal<string>;
+    protected readonly fields: _angular_core.Signal<{
+        id: string;
+        cell: _tanstack_table_core.Cell_Core<_ui_organized_table_core.UioTableFeatures, T, unknown>;
+        label: string;
+    }[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableCard<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableCard<any>, "li[uioTableCard]", never, { "row": { "alias": "row"; "required": true; "isSignal": true; }; "index": { "alias": "index"; "required": true; "isSignal": true; }; "fieldOrder": { "alias": "fieldOrder"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Card mode: one card per row, below the breakpoint.
+ *
+ * The table is *replaced*, not hidden — rendering both trees and hiding one with
+ * a container query would double the DOM and defeat virtualization on exactly
+ * the devices that can least afford it. Selection, row actions and the detail
+ * sheet all keep working, because they are table state rather than table markup.
+ *
+ * The host is `display: contents` and the list is inside it, because the list
+ * is a `<ul>` with rows and a `<table>` with the empty state without them, and
+ * an Angular host element cannot change its tag.
+ */
+declare class UioTableCards {
+    protected readonly table: _ui_organized_angular_table.DataTableApi<RowData>;
+    private readonly list;
+    protected readonly fieldOrder: _angular_core.Signal<string[]>;
+    protected readonly spacers: _angular_core.Signal<{
+        top: number;
+        bottom: number;
+    }>;
+    protected readonly maxHeight: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableCards, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableCards, "div[uioTableCards]", never, {}, {}, never, never, true, never>;
+}
+
+declare class UioTableSortSheet {
+    /** Button label and sheet title. */
+    readonly label: _angular_core.InputSignal<string>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly DIRECTIONS: {
+        value: string;
+        label: string;
+    }[];
+    protected readonly columns: Signal<_tanstack_table_core.Column<_ui_organized_table_core.UioTableFeatures, _tanstack_table_core.RowData, unknown>[]>;
+    protected readonly columnOptions: Signal<{
+        value: string;
+        label: string;
+    }[]>;
+    private readonly sorting;
+    protected readonly count: Signal<number>;
+    protected readonly activeId: Signal<string>;
+    protected readonly direction: Signal<"asc" | "desc">;
+    protected readonly icon: Signal<_ui_organized_angular.IconGlyph>;
+    private readonly sheet;
+    constructor();
+    protected chooseColumn(id: string): void;
+    protected chooseDirection(next: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableSortSheet, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableSortSheet, "[uioTableSortSheet]", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * One condition inside a field's section: its relation, its value, and a way
+ * to clear it. The field is the section, so there is no field control.
+ */
+declare class UioTableFilterSheetCondition {
+    protected readonly glyph: typeof internalGlyph;
+    readonly condition: _angular_core.InputSignal<TableFilterCondition>;
+    readonly fieldLabel: _angular_core.InputSignal<string>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    protected readonly description: Signal<_ui_organized_table_core.ConditionDescription>;
+    protected readonly arity: Signal<_ui_organized_table_core.FilterOperatorArity>;
+    protected readonly operatorOptions: Signal<{
+        value: string;
+        label: string;
+    }[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableFilterSheetCondition, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableFilterSheetCondition, "div[uioTableFilterSheetCondition]", never, { "condition": { "alias": "condition"; "required": true; "isSignal": true; }; "fieldLabel": { "alias": "fieldLabel"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Marks the template for one field's section, so the sheet can hand the
+ * accordion one `TemplateRef` per field. `AccordionItem.content` takes a
+ * template but passes it no context, so the field cannot be a template
+ * variable; a view created from this template keeps the `@for` iteration it
+ * was declared in, and with it the field.
+ */
+declare class UioTableSheetSection {
+    readonly field: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableSheetSection, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UioTableSheetSection, "ng-template[uioTableSheetSection]", never, { "field": { "alias": "uioTableSheetSection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Every filterable field at once, one accordion section each, so filtering on
+ * a phone is "open the field, pick the value" rather than "add a filter,
+ * choose its field, then pick the value".
+ *
+ * Each section edits a real condition. While the sheet is open every field has
+ * at least one, so its editor has something to write to: the sheet adds an
+ * empty draft for any field without one. A draft is an incomplete condition,
+ * which the filter model keeps but never applies, so drafts change nothing
+ * until they are given a value; the badge counts only complete conditions;
+ * and closing the sheet removes the drafts nobody filled in.
+ */
+declare class UioTableFilterSheet {
+    protected readonly glyph: typeof internalGlyph;
+    /** Button label and sheet title. */
+    readonly label: _angular_core.InputSignal<string>;
+    protected readonly table: _ui_organized_angular_table.DataTableApi<_tanstack_table_core.RowData>;
+    private readonly sheet;
+    private readonly sectionTemplates;
+    protected readonly fields: Signal<_ui_organized_angular_table.FilterableField[]>;
+    protected readonly allFields: Signal<string[]>;
+    private readonly applied;
+    protected readonly count: Signal<number>;
+    private readonly isOpen;
+    /** Sections the user has collapsed or expanded; null until they touch one. */
+    protected readonly expanded: _angular_core.WritableSignal<readonly (string | number)[]>;
+    /**
+     * The accordion's items. The title is the field, and once something is
+     * applied, what it is: "Role: is any of Admin". It has to be one string —
+     * `AccordionItem.title` takes no template — so the summary rides in the
+     * title rather than in a styled line of its own beneath it.
+     */
+    protected readonly sections: Signal<AccordionItem[]>;
+    constructor();
+    protected conditionsOf(columnId: string): TableFilterCondition[];
+    protected onOpenChange(open: boolean): void;
+    /** Only what is applied: the drafts stay, so every section keeps its editor. */
+    protected clearApplied(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioTableFilterSheet, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioTableFilterSheet, "[uioTableFilterSheet]", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Layer 3: the whole table from an input object.
+ *
+ * It composes exactly the parts a consumer would compose by hand — which is the
+ * test of whether layer 2 is real. Anything this does that the parts cannot is a
+ * gap in the parts, not a feature of the wrapper.
+ *
+ * ── Why the inputs are spelled out ──────────────────────────────────────────
+ *
+ * React, Vue and Svelte all hand their whole props object to the composable. An
+ * Angular component has no such object: `input()` is one signal per option, and
+ * the options getter below assembles them. That is the last of the three costs
+ * Angular carries, and it is the cheap one — it costs length, not correctness,
+ * and it buys a properly typed template API in exchange.
+ */
+declare class UioDataTable<T extends RowData> implements OnInit {
+    readonly data: _angular_core.InputSignal<readonly T[]>;
+    readonly columns: _angular_core.InputSignal<readonly TableColumn<T>[]>;
+    /**
+     * The table's accessible name. Required, not optional: it becomes the
+     * `<caption>`, and a table announced as "table" and nothing else is the most
+     * common data-table accessibility failure there is.
+     */
+    readonly label: _angular_core.InputSignal<string>;
+    readonly captionVisible: _angular_core.InputSignal<boolean>;
+    readonly getRowId: _angular_core.InputSignal<(row: T, index: number) => string>;
+    readonly size: _angular_core.InputSignal<TableSize>;
+    readonly variant: _angular_core.InputSignal<TableVariant>;
+    readonly selection: _angular_core.InputSignal<SelectionMode>;
+    readonly sortable: _angular_core.InputSignal<boolean>;
+    readonly filterable: _angular_core.InputSignal<boolean>;
+    readonly searchable: _angular_core.InputSignal<boolean>;
+    readonly paginated: _angular_core.InputSignal<boolean>;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly resizable: _angular_core.InputSignal<boolean>;
+    /**
+     * Lets people rearrange the columns by dragging a header, or with its move
+     * buttons (and Alt+Arrow on a focused header). Adds "Reset column order" to
+     * the Columns menu.
+     *
+     * - `true` / `"always"`: movable at any time; the move buttons appear on
+     *   hover and focus.
+     * - `"toggle"`: movable only in a reorder mode, switched from the toolbar.
+     *
+     * The table's own columns (selection, row actions) and pinned columns stay
+     * where they are.
+     */
+    readonly reorderable: _angular_core.InputSignal<ReorderSetting>;
+    readonly hideableColumns: _angular_core.InputSignal<boolean>;
+    readonly sortMenu: _angular_core.InputSignal<boolean>;
+    readonly exportable: _angular_core.InputSignal<boolean>;
+    readonly virtual: _angular_core.InputSignal<boolean | VirtualConfig>;
+    readonly maxHeight: _angular_core.InputSignal<string | number>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly error: _angular_core.InputSignal<AngularNode>;
+    readonly empty: _angular_core.InputSignal<EmptyStateConfig>;
+    readonly manual: _angular_core.InputSignal<boolean>;
+    readonly rowCount: _angular_core.InputSignal<number>;
+    readonly onQueryChange: _angular_core.InputSignal<(query: DataTableQuery) => void>;
+    readonly onLoadMore: _angular_core.InputSignal<() => void>;
+    readonly onRowClick: _angular_core.InputSignal<(row: T) => void>;
+    readonly onEdit: _angular_core.InputSignal<(patch: TableEditPatch<T>) => void | Promise<void>>;
+    readonly rowActions: _angular_core.InputSignal<RowAction<T>[]>;
+    readonly bulkActions: _angular_core.InputSignal<BulkAction<T>[]>;
+    readonly actions: _angular_core.InputSignal<TableAction[]>;
+    readonly detail: _angular_core.InputSignal<DetailConfig<T>>;
+    readonly responsive: _angular_core.InputSignal<ResponsiveConfig>;
+    readonly defaultSorting: _angular_core.InputSignal<{
+        id: string;
+        desc: boolean;
+    }[]>;
+    readonly defaultColumnVisibility: _angular_core.InputSignal<Record<string, boolean>>;
+    readonly defaultFilters: _angular_core.InputSignal<TableFilterInput[]>;
+    /** Every input, as the one object the shared factory reads. */
+    private readonly options;
+    private readonly injector;
+    /**
+     * Public because the provider above reads it; not part of the template API.
+     *
+     * Built in `ngOnInit` rather than in a field initialiser, and that is forced
+     * rather than chosen: `createDataTable` reads `data`, `columns` and `label`
+     * immediately — `injectTable` has to construct a table out of them — and a
+     * **required input has no value during construction**. Angular says so
+     * outright (NG0950), and the table simply failed to bootstrap.
+     *
+     * `runInInjectionContext` because `ngOnInit` is not one, and the factory needs
+     * `inject` for `DestroyRef`, `injectTable` and `injectVirtualizer`. The
+     * provider above resolves lazily — a child injects it while the view is being
+     * created, which is after this has run.
+     */
+    private created;
+    /**
+     * Built on first ask rather than in `ngOnInit`, so the order between this
+     * component's lifecycle and a child part's injection stops mattering. Either
+     * way the inputs are set by the time it runs, which is the whole constraint.
+     */
+    ensureApi(): DataTableApi<T>;
+    ngOnInit(): void;
+    protected readonly cards: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UioDataTable<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UioDataTable<any>, "div[uioDataTable]", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "captionVisible": { "alias": "captionVisible"; "required": false; "isSignal": true; }; "getRowId": { "alias": "getRowId"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "paginated": { "alias": "paginated"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "hideableColumns": { "alias": "hideableColumns"; "required": false; "isSignal": true; }; "sortMenu": { "alias": "sortMenu"; "required": false; "isSignal": true; }; "exportable": { "alias": "exportable"; "required": false; "isSignal": true; }; "virtual": { "alias": "virtual"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "empty": { "alias": "empty"; "required": false; "isSignal": true; }; "manual": { "alias": "manual"; "required": false; "isSignal": true; }; "rowCount": { "alias": "rowCount"; "required": false; "isSignal": true; }; "onQueryChange": { "alias": "onQueryChange"; "required": false; "isSignal": true; }; "onLoadMore": { "alias": "onLoadMore"; "required": false; "isSignal": true; }; "onRowClick": { "alias": "onRowClick"; "required": false; "isSignal": true; }; "onEdit": { "alias": "onEdit"; "required": false; "isSignal": true; }; "rowActions": { "alias": "rowActions"; "required": false; "isSignal": true; }; "bulkActions": { "alias": "bulkActions"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "detail": { "alias": "detail"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "defaultSorting": { "alias": "defaultSorting"; "required": false; "isSignal": true; }; "defaultColumnVisibility": { "alias": "defaultColumnVisibility"; "required": false; "isSignal": true; }; "defaultFilters": { "alias": "defaultFilters"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof UioTable; inputs: {}; outputs: {}; }]>;
+}
+
+export { UIO_DATA_TABLE, UioDataTable, UioTable, UioTableActionsHeader, UioTableBody, UioTableCard, UioTableCards, UioTableCell, UioTableElementRef, UioTableEmpty, UioTableError, UioTableFilterChip, UioTableFilterEditor, UioTableFilterSheet, UioTableFilterSheetCondition, UioTableFilterValueEditor, UioTableFilters, UioTableHeadCell, UioTableHeader, UioTableLoading, UioTablePagination, UioTableProps, UioTableReorderToggle, UioTableResizeHandle, UioTableRow, UioTableRowActions, UioTableSelectAllCell, UioTableSelectCell, UioTableSelectionBar, UioTableSelectionFooter, UioTableSheetSection, UioTableSortSheet, UioTableSubBar, UioTableToolbar, UioTableViewport, actionsColumn, applyElementProps, createDataTable, createDeferred, focusAfterRemoval, injectDataTable, injectOptionalDataTable, provideDataTable, selectionColumn, trackStore };
+export type { AngularNode, BulkAction, DataTableApi, DetailApi, DetailConfig, EditApi, EmptyStateConfig, FilterableField, FiltersApi, FocusApi, HorizontalScrollApi, RenderRow, RowAction, SelectionApi, TableAction, TableColumn, TableEditRenderer, TableFilterInput, UseDataTableOptions, VirtualApi };