@testgorilla/tgo-ui 11.22.2 → 12.0.0

package/types/testgorilla-tgo-ui-components-infinite-scroll-table.d.ts

@@ -1,332 +1,458 @@
-import * as _angular_core from '@angular/core';
-import { TemplateRef, TrackByFunction, ElementRef } from '@angular/core';
-import * as i2 from '@angular/cdk/scrolling';
-import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
-import * as i1 from '@angular/common';
-
+import * as i2 from "@angular/cdk/scrolling";
+import { CdkVirtualScrollViewport } from "@angular/cdk/scrolling";
+import * as i0 from "@angular/core";
+import { ElementRef, TemplateRef, TrackByFunction } from "@angular/core";
+import * as i1 from "@angular/common";
 /**
  * The structural contract `selectable` puts on a row: the checkbox reflects `selected`, and `key` /
  * `rowIdKey` lookups read arbitrary fields. Declared once here rather than asserted at each read site, so
  * the requirement is discoverable from the types instead of only from the docs.
  */
-type InfiniteScrollTableRowLike = Record<string, unknown> & {
-    selected?: boolean;
+export type InfiniteScrollTableRowLike = Record<string, unknown> & {
+  selected?: boolean;
 };
-interface InfiniteScrollTableColumn<T> {
-    /** Also reads the default cell value. A plain string, so a synthetic column can have no matching field. */
-    key: string;
-    /** Header label rendered when no `headerCellTemplate` is provided. */
-    title?: string;
-    headerCellTemplate?: TemplateRef<InfiniteScrollTableHeaderCellContext<T>>;
-    rowCellTemplate?: TemplateRef<InfiniteScrollTableRowCellContext<T>>;
-    /**
-     * Pins the column. Only honoured on the **first** column (pins left) and the **last** column (pins
-     * right); anywhere else it is ignored, with a dev-mode warning.
-     */
-    isSticky?: boolean;
-    styles?: InfiniteScrollTableColumnStyles;
+export interface InfiniteScrollTableColumn<T> {
+  /** Also reads the default cell value. A plain string, so a synthetic column can have no matching field. */
+  key: string;
+  /** Header label rendered when no `headerCellTemplate` is provided. */
+  title?: string;
+  headerCellTemplate?: TemplateRef<InfiniteScrollTableHeaderCellContext<T>>;
+  rowCellTemplate?: TemplateRef<InfiniteScrollTableRowCellContext<T>>;
+  /**
+   * Pins the column. Only honoured on the **first** column (pins left) and the **last** column (pins
+   * right); anywhere else it is ignored, with a dev-mode warning.
+   */
+  isSticky?: boolean;
+  styles?: InfiniteScrollTableColumnStyles;
 }
-interface InfiniteScrollTableColumnStyles {
-    /**
-     * Authoritative column width (default `160px`), applied as `flex-basis`, `min-width` AND `max-width`:
-     * the column never grows or shrinks and overflowing content is clipped, which is what keeps the header
-     * and body scroll containers pixel-aligned. Leftover row width goes to a trailing spacer instead.
-     */
-    width?: string;
-    alignment?: InfiniteScrollTableColumnAlignment;
+export interface InfiniteScrollTableColumnStyles {
+  /**
+   * Authoritative column width (default `160px`), applied as `flex-basis`, `min-width` AND `max-width`:
+   * the column never grows or shrinks and overflowing content is clipped, which is what keeps the header
+   * and body scroll containers pixel-aligned. Leftover row width goes to a trailing spacer instead.
+   */
+  width?: string;
+  alignment?: InfiniteScrollTableColumnAlignment;
 }
-type InfiniteScrollTableColumnAlignment = 'left' | 'right' | 'center';
-interface InfiniteScrollTableRowCellContext<T> {
-    $implicit: T;
-    rowIndex: number;
+export type InfiniteScrollTableColumnAlignment = 'left' | 'right' | 'center';
+export interface InfiniteScrollTableRowCellContext<T> {
+  $implicit: T;
+  rowIndex: number;
 }
-interface InfiniteScrollTableHeaderCellContext<T> {
-    $implicit: string | undefined;
-    column: InfiniteScrollTableColumn<T>;
-    colIndex: number;
+export interface InfiniteScrollTableHeaderCellContext<T> {
+  $implicit: string | undefined;
+  column: InfiniteScrollTableColumn<T>;
+  colIndex: number;
 }
-interface InfiniteScrollTableErrorContext {
-    $implicit: () => void;
-    retry: () => void;
+export interface InfiniteScrollTableErrorContext {
+  $implicit: () => void;
+  retry: () => void;
 }
 /**
  * `row` is the consumer's own object by reference — not a copy — so class prototypes survive and a row's
  * own `index` field is never shadowed. Same for `InfiniteScrollTableRowSelection`.
  */
-interface InfiniteScrollTableRowClick<T> {
-    row: T;
-    index: number;
+export interface InfiniteScrollTableRowClick<T> {
+  row: T;
+  index: number;
 }
-interface InfiniteScrollTableRowSelection<T> {
-    row: T;
-    index: number;
-    selected: boolean;
+export interface InfiniteScrollTableRowSelection<T> {
+  row: T;
+  index: number;
+  selected: boolean;
 }
-
 /** Internal row wrapper so real rows and skeleton placeholders flow through one virtual list. */
 type RenderRow<T> = {
-    kind: 'data';
-    item: T;
-    index: number;
+  kind: 'data';
+  item: T;
+  index: number;
 } | {
-    kind: 'skeleton';
-    id: string;
+  kind: 'skeleton';
+  id: string;
 };
 /**
  * A generic, virtualized table with scroll-driven infinite loading. Independent of `ui-table`: it reuses
  * only stable leaf primitives (`ui-skeleton`) and duplicates the column/context type shapes so consumers
  * can migrate with a selector swap.
  */
-declare class InfiniteScrollTableComponent<T> {
-    /**
-     * Rows loaded so far. **Must change by reference** (`[...rows, ...page]`): a signal input cannot observe
-     * `rows.push(...)`, so an in-place append renders nothing and leaves `loadMore` disarmed.
-     */
-    readonly data: _angular_core.InputSignal<readonly T[]>;
-    readonly columns: _angular_core.InputSignal<InfiniteScrollTableColumn<T>[]>;
-    /** Fixed row height in px (the virtualization `itemSize`). Variable row heights are unsupported. */
-    readonly rowHeight: _angular_core.InputSignal<number>;
-    /** Stable row identity so recycled rows re-render correctly. Takes precedence over `rowIdKey`. */
-    readonly trackBy: _angular_core.InputSignal<TrackByFunction<T> | undefined>;
-    /** Key on each row holding a stable id. Used when `trackBy` is not provided. */
-    readonly rowIdKey: _angular_core.InputSignal<string | undefined>;
-    /**
-     * CDK's rendered buffers. Both default to a multiple of `rowHeight` (~5 and ~10 rows) rather than a
-     * fixed px value, which would mean a different row count at every `rowHeight`.
-     */
-    readonly minBufferPx: _angular_core.InputSignal<number | undefined>;
-    readonly maxBufferPx: _angular_core.InputSignal<number | undefined>;
-    /** Max height of the internal scroll region (e.g. `'70vh'`). The body shrinks to fit fewer rows. */
-    readonly maxHeight: _angular_core.InputSignal<string>;
-    /** Stretch to the parent's height instead of the content's; `maxHeight` becomes a cap, not the target. */
-    readonly fillHeight: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly isCondensed: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /**
-     * Prepends a left-pinned checkbox column driven by each row's `selected` property. Consumer-managed
-     * (like `ui-table`): toggling only emits `selectionChange`.
-     */
-    readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /**
-     * Makes rows focusable and activatable by click or Enter/Space. Off by default: a read-only table
-     * must not create a tab stop per rendered row or imply interactivity it does not have.
-     */
-    readonly rowsClickable: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** First-load state: renders a full body of skeleton rows. */
-    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Appends skeleton rows below the existing rows while the next page is fetched. */
-    readonly loadingMore: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Required, not defaulted: a silent "never load" default would disable the headline behaviour. */
-    readonly hasMore: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly skeletonRowCount: _angular_core.InputSignal<number>;
-    /** Number of skeleton rows appended below the loaded rows while `loadingMore` is true. */
-    readonly loadMoreSkeletonCount: _angular_core.InputSignal<number>;
-    /**
-     * Skeleton placeholder columns for a lazily-loaded column set. They deliberately sit OUTSIDE `columns`,
-     * so they cannot change which column is last and unpin a sticky last column.
-     */
-    readonly loadingColumnCount: _angular_core.InputSignalWithTransform<number, unknown>;
-    readonly loadMoreThreshold: _angular_core.InputSignal<number>;
-    /** Shown when `data` is empty and not loading. */
-    readonly noDataTemplate: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
-    /** Shown when `error` is `true`. Receives `{ $implicit: retry, retry }` as context. */
-    readonly errorTemplate: _angular_core.InputSignal<TemplateRef<InfiniteScrollTableErrorContext> | undefined>;
-    readonly error: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /**
-     * Shown once `hasMore` goes `false` with rows loaded. Deliberately has NO built-in fallback (unlike
-     * `noDataTemplate` / `errorTemplate`): a single-page list would otherwise flash "no more results".
-     */
-    readonly endOfListTemplate: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
-    readonly testId: _angular_core.InputSignal<string | null>;
-    readonly ariaLabel: _angular_core.InputSignal<string>;
-    /** Guarded: only when `hasMore && !loading && !loadingMore`, and only once per approach to the end. */
-    readonly loadMore: _angular_core.OutputEmitterRef<void>;
-    readonly retry: _angular_core.OutputEmitterRef<void>;
-    readonly rowClick: _angular_core.OutputEmitterRef<InfiniteScrollTableRowClick<T>>;
-    /** The consumer is expected to apply `selected` back onto its own data. */
-    readonly selectionChange: _angular_core.OutputEmitterRef<InfiniteScrollTableRowSelection<T>>;
-    protected readonly viewport: _angular_core.Signal<CdkVirtualScrollViewport | undefined>;
-    protected readonly headerScroll: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
-    protected readonly scrollStart: _angular_core.WritableSignal<boolean>;
-    protected readonly scrollEnd: _angular_core.WritableSignal<boolean>;
-    protected readonly horizontalScroll: _angular_core.WritableSignal<boolean>;
-    /** Reserved as right padding on the header, so its content width exactly equals the body's. */
-    protected readonly scrollbarWidth: _angular_core.WritableSignal<number>;
-    /** Added to the viewport height so on a short list the scrollbar doesn't eat into the rows. */
-    protected readonly hScrollbarHeight: _angular_core.WritableSignal<number>;
-    /**
-     * Paging latch. Three fields, one rule: `loadMore` emits at most once per page that lands while the
-     * user is inside the trigger zone. `isLoadMoreArmed` is the latch itself, written here and by
-     * `checkLoadMore`; `dataLengthAtEmit` records how long `data` was when the last emission went out, so
-     * "the requested page arrived" is a length comparison rather than a guess about scroll positions;
-     * `firstVisibleIndex` is where the user actually is.
-     *
-     * The invariant that matters: arming and firing must read the SAME trigger zone. They used to derive it
-     * from two different thresholds, which opened bands the latch could never leave.
-     */
-    private isLoadMoreArmed;
-    private dataLengthAtEmit;
-    /** In-place-mutation detector; see the effect that reads these for the discriminator. */
-    private wasLoadingMore;
-    private lastDataReference;
-    private lastDataLength;
-    /** Pending frame for a deferred CDK viewport re-measure, so repeated triggers coalesce to one. */
-    private remeasureFrame;
-    /** Pending frame for the deferred scroll reset. Cancelled on destroy, like every other frame here. */
-    private resetScrollFrame;
-    private previousHeadIdentity;
-    /** Latches once any non-empty `data` is seen, so only the very first render is exempt from resetting. */
-    private hasSeenHead;
-    /** Previous `loading` value, for spotting the false -> true edge that starts a reset. */
-    private wasLoading;
-    /**
-     * First visible row index, kept current from `viewport.scrolledIndexChange` (no layout read) rather
-     * than `viewport.getRenderedRange().start`, which includes CDK's read-ahead buffer.
-     */
-    private firstVisibleIndex;
-    protected readonly skeletonTheme: {
-        background: string;
-        'border-radius': string;
-        height: string;
-        'margin-bottom': string;
+export declare class InfiniteScrollTableComponent<T> {
+  /**
+   * Rows loaded so far. **Must change by reference** (`[...rows, ...page]`): a signal input cannot observe
+   * `rows.push(...)`, so an in-place append renders nothing and leaves `loadMore` disarmed.
+   */
+  readonly data: import("@angular/core").InputSignal<readonly T[]>;
+  readonly columns: import("@angular/core").InputSignal<InfiniteScrollTableColumn<T>[]>;
+  /** Fixed row height in px (the virtualization `itemSize`). Variable row heights are unsupported. */
+  readonly rowHeight: import("@angular/core").InputSignal<number>;
+  /** Stable row identity so recycled rows re-render correctly. Takes precedence over `rowIdKey`. */
+  readonly trackBy: import("@angular/core").InputSignal<TrackByFunction<T> | undefined>;
+  /** Key on each row holding a stable id. Used when `trackBy` is not provided. */
+  readonly rowIdKey: import("@angular/core").InputSignal<string | undefined>;
+  /**
+   * CDK's rendered buffers. Both default to a multiple of `rowHeight` (~5 and ~10 rows) rather than a
+   * fixed px value, which would mean a different row count at every `rowHeight`.
+   */
+  readonly minBufferPx: import("@angular/core").InputSignal<number | undefined>;
+  readonly maxBufferPx: import("@angular/core").InputSignal<number | undefined>;
+  /** Max height of the internal scroll region (e.g. `'70vh'`). The body shrinks to fit fewer rows. */
+  readonly maxHeight: import("@angular/core").InputSignal<string>;
+  /** Stretch to the parent's height instead of the content's; `maxHeight` becomes a cap, not the target. */
+  readonly fillHeight: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly isCondensed: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Prepends a left-pinned checkbox column driven by each row's `selected` property. Consumer-managed
+   * (like `ui-table`): toggling only emits `selectionChange`.
+   */
+  readonly selectable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Makes rows focusable and activatable by click or Enter/Space. Off by default: a read-only table
+   * must not create a tab stop per rendered row or imply interactivity it does not have.
+   */
+  readonly rowsClickable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** First-load state: renders a full body of skeleton rows. */
+  readonly loading: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Appends skeleton rows below the existing rows while the next page is fetched. */
+  readonly loadingMore: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Required, not defaulted: a silent "never load" default would disable the headline behaviour. */
+  readonly hasMore: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly skeletonRowCount: import("@angular/core").InputSignal<number>;
+  /** Number of skeleton rows appended below the loaded rows while `loadingMore` is true. */
+  readonly loadMoreSkeletonCount: import("@angular/core").InputSignal<number>;
+  /**
+   * Skeleton placeholder columns for a lazily-loaded column set. They deliberately sit OUTSIDE `columns`,
+   * so they cannot change which column is last and unpin a sticky last column.
+   */
+  readonly loadingColumnCount: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly loadMoreThreshold: import("@angular/core").InputSignal<number>;
+  /** Shown when `data` is empty and not loading. */
+  readonly noDataTemplate: import("@angular/core").InputSignal<TemplateRef<unknown> | undefined>;
+  /** Shown when `error` is `true`. Receives `{ $implicit: retry, retry }` as context. */
+  readonly errorTemplate: import("@angular/core").InputSignal<TemplateRef<InfiniteScrollTableErrorContext> | undefined>;
+  readonly error: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Shown once `hasMore` goes `false` with rows loaded. Deliberately has NO built-in fallback (unlike
+   * `noDataTemplate` / `errorTemplate`): a single-page list would otherwise flash "no more results".
+   */
+  readonly endOfListTemplate: import("@angular/core").InputSignal<TemplateRef<unknown> | undefined>;
+  readonly testId: import("@angular/core").InputSignal<string | null>;
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  /** Guarded: only when `hasMore && !loading && !loadingMore`, and only once per approach to the end. */
+  readonly loadMore: import("@angular/core").OutputEmitterRef<void>;
+  readonly retry: import("@angular/core").OutputEmitterRef<void>;
+  readonly rowClick: import("@angular/core").OutputEmitterRef<InfiniteScrollTableRowClick<T>>;
+  /** The consumer is expected to apply `selected` back onto its own data. */
+  readonly selectionChange: import("@angular/core").OutputEmitterRef<InfiniteScrollTableRowSelection<T>>;
+  protected readonly viewport: import("@angular/core").Signal<CdkVirtualScrollViewport | undefined>;
+  protected readonly headerScroll: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+  protected readonly scrollStart: import("@angular/core").WritableSignal<boolean>;
+  protected readonly scrollEnd: import("@angular/core").WritableSignal<boolean>;
+  protected readonly horizontalScroll: import("@angular/core").WritableSignal<boolean>;
+  /** Reserved as right padding on the header, so its content width exactly equals the body's. */
+  protected readonly scrollbarWidth: import("@angular/core").WritableSignal<number>;
+  /** Added to the viewport height so on a short list the scrollbar doesn't eat into the rows. */
+  protected readonly hScrollbarHeight: import("@angular/core").WritableSignal<number>;
+  /**
+   * Paging latch. Three fields, one rule: `loadMore` emits at most once per page that lands while the
+   * user is inside the trigger zone. `isLoadMoreArmed` is the latch itself, written here and by
+   * `checkLoadMore`; `dataLengthAtEmit` records how long `data` was when the last emission went out, so
+   * "the requested page arrived" is a length comparison rather than a guess about scroll positions;
+   * `firstVisibleIndex` is where the user actually is.
+   *
+   * The invariant that matters: arming and firing must read the SAME trigger zone. They used to derive it
+   * from two different thresholds, which opened bands the latch could never leave.
+   */
+  private isLoadMoreArmed;
+  private dataLengthAtEmit;
+  /** In-place-mutation detector; see the effect that reads these for the discriminator. */
+  private wasLoadingMore;
+  private lastDataReference;
+  private lastDataLength;
+  /** Pending frame for a deferred CDK viewport re-measure, so repeated triggers coalesce to one. */
+  private remeasureFrame;
+  /** Pending frame for the deferred scroll reset. Cancelled on destroy, like every other frame here. */
+  private resetScrollFrame;
+  private previousHeadIdentity;
+  /** Latches once any non-empty `data` is seen, so only the very first render is exempt from resetting. */
+  private hasSeenHead;
+  /** Previous `loading` value, for spotting the false -> true edge that starts a reset. */
+  private wasLoading;
+  /**
+   * First visible row index, kept current from `viewport.scrolledIndexChange` (no layout read) rather
+   * than `viewport.getRenderedRange().start`, which includes CDK's read-ahead buffer.
+   */
+  private firstVisibleIndex;
+  protected readonly skeletonTheme: {
+    background: string;
+    'border-radius': string;
+    height: string;
+    'margin-bottom': string;
+  };
+  protected readonly stickyStartKey: import("@angular/core").Signal<string | undefined>;
+  protected readonly stickyEndKey: import("@angular/core").Signal<string | undefined>;
+  protected readonly defaultColumnWidth = "160px";
+  protected readonly effectiveMinBufferPx: import("@angular/core").Signal<number>;
+  /**
+   * The `Math.max` is load-bearing: CDK throws in dev mode when `maxBufferPx < minBufferPx`, which a
+   * consumer triggers just by raising `minBufferPx` above the derived default.
+   */
+  protected readonly effectiveMaxBufferPx: import("@angular/core").Signal<number>;
+  /** Stable keys for the placeholder columns, so `@for` can track them across renders. */
+  protected readonly loadingColumns: import("@angular/core").Signal<string[]>;
+  protected readonly renderRows: import("@angular/core").Signal<RenderRow<T>[]>;
+  protected readonly hasData: import("@angular/core").Signal<boolean>;
+  protected readonly showViewport: import("@angular/core").Signal<boolean>;
+  /**
+   * `loadingMore` counts as loading here too: a consumer that retries a failed first page through the same
+   * flag it uses for every page would otherwise render "no rows" with `aria-busy` set and the live region
+   * announcing a fetch.
+   */
+  protected readonly showEmptyState: import("@angular/core").Signal<boolean>;
+  protected readonly showErrorState: import("@angular/core").Signal<boolean>;
+  protected readonly showErrorFooter: import("@angular/core").Signal<boolean>;
+  /**
+   * The negative clauses keep this out of slots other states own, and `!loadingMore()` closes a one-tick
+   * flash: a fetch completing and the consumer flipping `hasMore` need not land in the same cycle.
+   */
+  protected readonly showEndOfList: import("@angular/core").Signal<boolean>;
+  /**
+   * CSS `min()` because the cap mixes units. The scrollbar reserve stops a short list from growing a
+   * spurious vertical scrollbar; fill mode returns `null` so flex owns the sizing and the reserve is moot.
+   */
+  protected readonly viewportHeight: import("@angular/core").Signal<string | null>;
+  protected readonly translationContext = "INFINITE_SCROLL_TABLE.";
+  /** A translation key, resolved in the template: screen-reader users are not all English speakers. */
+  protected readonly statusMessageKey: import("@angular/core").Signal<string>;
+  protected readonly errorContext: InfiniteScrollTableErrorContext;
+  protected readonly renderRowTrackBy: TrackByFunction<RenderRow<T>>;
+  constructor();
+  private cancelResetScrollFrame;
+  /** No-ops only when no rows are rendered: the empty state, or an error with no rows. */
+  scrollToIndex(index: number, behavior?: ScrollBehavior): void;
+  scrollToTop(behavior?: ScrollBehavior): void;
+  /**
+   * The single place `T` is widened to its structural contract. Every field read on a row goes through
+   * here, so the assertion exists once instead of at each call site.
+   */
+  private asRowLike;
+  protected getCellValue(item: T, key: string): unknown;
+  /** Applied as `flex-basis`, `min-width` AND `max-width` on header and body cells alike — see the SCSS. */
+  protected columnWidth(column: InfiniteScrollTableColumn<T>): string;
+  protected emitRowClick(event: Event, row: RenderRow<T>): void;
+  protected rowTestId(row: RenderRow<T>): string | null;
+  protected cellTestId(row: RenderRow<T>, columnKey: string): string | null;
+  protected rowCheckboxTestId(row: RenderRow<T>): string | null;
+  protected isRowSelected(row: RenderRow<T>): boolean;
+  protected emitSelectionChange(row: RenderRow<T>, selected: boolean): void;
+  /** Reads `--ui-ist-checkbox-width` so the offset cannot drift from the checkbox column's own width. */
+  protected stickyStartLeft(column: InfiniteScrollTableColumn<T>): string | null;
+  /**
+   * Only the outermost start-pinned cell may cast the sticky shadow: the checkbox cell is pinned too, and
+   * shadowing both would drop a shadow across the column beside it.
+   */
+  protected isStickyStartEdge(column: InfiniteScrollTableColumn<T>): boolean;
+  protected activateRow(event: Event, row: RenderRow<T>): void;
+  /** A clickable row matches `[tabindex]` itself, so `currentTarget` must be excluded explicitly. */
+  private isInteractiveTarget;
+  /** Whether the user is selecting text, in which case a click is a selection gesture, not activation. */
+  private hasTextSelection;
+  /**
+   * Deferred a frame to read the settled layout and never trip "ResizeObserver loop limit exceeded";
+   * repeated triggers coalesce to one measure.
+   */
+  private scheduleViewportRemeasure;
+  /**
+   * The third `checkLoadMore` trigger, and the only one that survives a page landing without a rendered-range
+   * change. CDK emits a range only when the virtual-for LENGTH changes, so a page whose row count exactly
+   * replaces the load-more skeletons (`data + skeletons` before, `data` after) moves nothing CDK watches —
+   * and when the new rows add no scrollable height, no scroll event can ever arrive either. Runs after the
+   * re-measure so the zone is tested against the size CDK just settled on.
+   */
+  private settleLoadMore;
+  private emitRetry;
+  /**
+   * The index fallback is identity-in-name-only — it cannot tell rows apart after a reorder — which is why
+   * the automatic scroll reset cannot work without `trackBy` or `rowIdKey`.
+   */
+  private rowIdentity;
+  /**
+   * Assigning an absolute `scrollLeft` is drift-free by construction: it self-corrects every scroll event
+   * and the browser clamps when the header's maximum is momentarily smaller. A progress-normalized CSS
+   * scroll-timeline cannot guarantee that, which is why it was removed — do not reintroduce one.
+   */
+  private syncHorizontalScroll;
+  /**
+   * How many rows the viewport shows. Zero until CDK has measured, which callers must treat as
+   * "unknown" rather than "none".
+   */
+  private visibleRowCount;
+  /**
+   * Rows from the end that count as "approaching it". Capped at a screenful: a threshold wider than the
+   * viewport cannot mean approaching, and uncapped it made the zone unleavable at every scroll position,
+   * which is how an oversized `loadMoreThreshold` used to walk a whole dataset unattended. Clamped at 0 so
+   * a negative value can't push the trigger point past the end and disable paging outright.
+   */
+  private triggerZoneRows;
+  /**
+   * The rendered range includes CDK's read-ahead buffer, so measuring it conflates the user reaching the
+   * end with CDK merely pre-rendering it. The visible end has no such slack, so it tracks the user's
+   * actual scroll position instead.
+   */
+  private isInTriggerZone;
+  /**
+   * Re-arms the latch when something other than scrolling has to do it. Two cases, both of which used to
+   * be terminal stalls:
+   *
+   * - **The requested page landed.** `data` grew past its length at the last emission, so that emission is
+   *   spent. Without this, re-arming needed the user to scroll *out* of the zone and back — impossible when
+   *   the page was smaller than the threshold, and impossible to even attempt when the new rows added no
+   *   scrollable height.
+   * - **The zone can't be left.** `visibleEnd` bottoms out at `visibleRows`, so while that floor sits
+   *   inside the zone no amount of scrolling re-arms anything. Also covers a not-yet-measured viewport,
+   *   which must count as unleavable or the first fill never starts.
+   *
+   * Deliberately not driven by `loadingMore` or `error`: a failed fetch clears `loadingMore` without
+   * growing `data`, and must stay disarmed rather than re-fire in a loop.
+   */
+  private rearmLoadMoreIfUnreachable;
+  /** Emits at most once per page that lands while the user is inside the trigger zone. */
+  private checkLoadMore;
+  static ɵfac: i0.ɵɵFactoryDeclaration<InfiniteScrollTableComponent<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<InfiniteScrollTableComponent<any>, "ui-infinite-scroll-table", never, {
+    "data": {
+      "alias": "data";
+      "required": true;
+      "isSignal": true;
     };
-    protected readonly stickyStartKey: _angular_core.Signal<string | undefined>;
-    protected readonly stickyEndKey: _angular_core.Signal<string | undefined>;
-    protected readonly defaultColumnWidth = "160px";
-    protected readonly effectiveMinBufferPx: _angular_core.Signal<number>;
-    /**
-     * The `Math.max` is load-bearing: CDK throws in dev mode when `maxBufferPx < minBufferPx`, which a
-     * consumer triggers just by raising `minBufferPx` above the derived default.
-     */
-    protected readonly effectiveMaxBufferPx: _angular_core.Signal<number>;
-    /** Stable keys for the placeholder columns, so `@for` can track them across renders. */
-    protected readonly loadingColumns: _angular_core.Signal<string[]>;
-    protected readonly renderRows: _angular_core.Signal<RenderRow<T>[]>;
-    protected readonly hasData: _angular_core.Signal<boolean>;
-    protected readonly showViewport: _angular_core.Signal<boolean>;
-    /**
-     * `loadingMore` counts as loading here too: a consumer that retries a failed first page through the same
-     * flag it uses for every page would otherwise render "no rows" with `aria-busy` set and the live region
-     * announcing a fetch.
-     */
-    protected readonly showEmptyState: _angular_core.Signal<boolean>;
-    protected readonly showErrorState: _angular_core.Signal<boolean>;
-    protected readonly showErrorFooter: _angular_core.Signal<boolean>;
-    /**
-     * The negative clauses keep this out of slots other states own, and `!loadingMore()` closes a one-tick
-     * flash: a fetch completing and the consumer flipping `hasMore` need not land in the same cycle.
-     */
-    protected readonly showEndOfList: _angular_core.Signal<boolean>;
-    /**
-     * CSS `min()` because the cap mixes units. The scrollbar reserve stops a short list from growing a
-     * spurious vertical scrollbar; fill mode returns `null` so flex owns the sizing and the reserve is moot.
-     */
-    protected readonly viewportHeight: _angular_core.Signal<string | null>;
-    protected readonly translationContext = "INFINITE_SCROLL_TABLE.";
-    /** A translation key, resolved in the template: screen-reader users are not all English speakers. */
-    protected readonly statusMessageKey: _angular_core.Signal<string>;
-    protected readonly errorContext: InfiniteScrollTableErrorContext;
-    protected readonly renderRowTrackBy: TrackByFunction<RenderRow<T>>;
-    constructor();
-    private cancelResetScrollFrame;
-    /** No-ops only when no rows are rendered: the empty state, or an error with no rows. */
-    scrollToIndex(index: number, behavior?: ScrollBehavior): void;
-    scrollToTop(behavior?: ScrollBehavior): void;
-    /**
-     * The single place `T` is widened to its structural contract. Every field read on a row goes through
-     * here, so the assertion exists once instead of at each call site.
-     */
-    private asRowLike;
-    protected getCellValue(item: T, key: string): unknown;
-    /** Applied as `flex-basis`, `min-width` AND `max-width` on header and body cells alike — see the SCSS. */
-    protected columnWidth(column: InfiniteScrollTableColumn<T>): string;
-    protected emitRowClick(event: Event, row: RenderRow<T>): void;
-    protected rowTestId(row: RenderRow<T>): string | null;
-    protected cellTestId(row: RenderRow<T>, columnKey: string): string | null;
-    protected rowCheckboxTestId(row: RenderRow<T>): string | null;
-    protected isRowSelected(row: RenderRow<T>): boolean;
-    protected emitSelectionChange(row: RenderRow<T>, selected: boolean): void;
-    /** Reads `--ui-ist-checkbox-width` so the offset cannot drift from the checkbox column's own width. */
-    protected stickyStartLeft(column: InfiniteScrollTableColumn<T>): string | null;
-    /**
-     * Only the outermost start-pinned cell may cast the sticky shadow: the checkbox cell is pinned too, and
-     * shadowing both would drop a shadow across the column beside it.
-     */
-    protected isStickyStartEdge(column: InfiniteScrollTableColumn<T>): boolean;
-    protected activateRow(event: Event, row: RenderRow<T>): void;
-    /** A clickable row matches `[tabindex]` itself, so `currentTarget` must be excluded explicitly. */
-    private isInteractiveTarget;
-    /** Whether the user is selecting text, in which case a click is a selection gesture, not activation. */
-    private hasTextSelection;
-    /**
-     * Deferred a frame to read the settled layout and never trip "ResizeObserver loop limit exceeded";
-     * repeated triggers coalesce to one measure.
-     */
-    private scheduleViewportRemeasure;
-    /**
-     * The third `checkLoadMore` trigger, and the only one that survives a page landing without a rendered-range
-     * change. CDK emits a range only when the virtual-for LENGTH changes, so a page whose row count exactly
-     * replaces the load-more skeletons (`data + skeletons` before, `data` after) moves nothing CDK watches —
-     * and when the new rows add no scrollable height, no scroll event can ever arrive either. Runs after the
-     * re-measure so the zone is tested against the size CDK just settled on.
-     */
-    private settleLoadMore;
-    private emitRetry;
-    /**
-     * The index fallback is identity-in-name-only — it cannot tell rows apart after a reorder — which is why
-     * the automatic scroll reset cannot work without `trackBy` or `rowIdKey`.
-     */
-    private rowIdentity;
-    /**
-     * Assigning an absolute `scrollLeft` is drift-free by construction: it self-corrects every scroll event
-     * and the browser clamps when the header's maximum is momentarily smaller. A progress-normalized CSS
-     * scroll-timeline cannot guarantee that, which is why it was removed — do not reintroduce one.
-     */
-    private syncHorizontalScroll;
-    /**
-     * How many rows the viewport shows. Zero until CDK has measured, which callers must treat as
-     * "unknown" rather than "none".
-     */
-    private visibleRowCount;
-    /**
-     * Rows from the end that count as "approaching it". Capped at a screenful: a threshold wider than the
-     * viewport cannot mean approaching, and uncapped it made the zone unleavable at every scroll position,
-     * which is how an oversized `loadMoreThreshold` used to walk a whole dataset unattended. Clamped at 0 so
-     * a negative value can't push the trigger point past the end and disable paging outright.
-     */
-    private triggerZoneRows;
-    /**
-     * The rendered range includes CDK's read-ahead buffer, so measuring it conflates the user reaching the
-     * end with CDK merely pre-rendering it. The visible end has no such slack, so it tracks the user's
-     * actual scroll position instead.
-     */
-    private isInTriggerZone;
-    /**
-     * Re-arms the latch when something other than scrolling has to do it. Two cases, both of which used to
-     * be terminal stalls:
-     *
-     * - **The requested page landed.** `data` grew past its length at the last emission, so that emission is
-     *   spent. Without this, re-arming needed the user to scroll *out* of the zone and back — impossible when
-     *   the page was smaller than the threshold, and impossible to even attempt when the new rows added no
-     *   scrollable height.
-     * - **The zone can't be left.** `visibleEnd` bottoms out at `visibleRows`, so while that floor sits
-     *   inside the zone no amount of scrolling re-arms anything. Also covers a not-yet-measured viewport,
-     *   which must count as unleavable or the first fill never starts.
-     *
-     * Deliberately not driven by `loadingMore` or `error`: a failed fetch clears `loadingMore` without
-     * growing `data`, and must stay disarmed rather than re-fire in a loop.
-     */
-    private rearmLoadMoreIfUnreachable;
-    /** Emits at most once per page that lands while the user is inside the trigger zone. */
-    private checkLoadMore;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InfiniteScrollTableComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InfiniteScrollTableComponent<any>, "ui-infinite-scroll-table", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": true; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "rowIdKey": { "alias": "rowIdKey"; "required": false; "isSignal": true; }; "minBufferPx": { "alias": "minBufferPx"; "required": false; "isSignal": true; }; "maxBufferPx": { "alias": "maxBufferPx"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "fillHeight": { "alias": "fillHeight"; "required": false; "isSignal": true; }; "isCondensed": { "alias": "isCondensed"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "rowsClickable": { "alias": "rowsClickable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingMore": { "alias": "loadingMore"; "required": false; "isSignal": true; }; "hasMore": { "alias": "hasMore"; "required": true; "isSignal": true; }; "skeletonRowCount": { "alias": "skeletonRowCount"; "required": false; "isSignal": true; }; "loadMoreSkeletonCount": { "alias": "loadMoreSkeletonCount"; "required": false; "isSignal": true; }; "loadingColumnCount": { "alias": "loadingColumnCount"; "required": false; "isSignal": true; }; "loadMoreThreshold": { "alias": "loadMoreThreshold"; "required": false; "isSignal": true; }; "noDataTemplate": { "alias": "noDataTemplate"; "required": false; "isSignal": true; }; "errorTemplate": { "alias": "errorTemplate"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "endOfListTemplate": { "alias": "endOfListTemplate"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "loadMore": "loadMore"; "retry": "retry"; "rowClick": "rowClick"; "selectionChange": "selectionChange"; }, never, never, true, never>;
+    "columns": {
+      "alias": "columns";
+      "required": true;
+      "isSignal": true;
+    };
+    "rowHeight": {
+      "alias": "rowHeight";
+      "required": true;
+      "isSignal": true;
+    };
+    "trackBy": {
+      "alias": "trackBy";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowIdKey": {
+      "alias": "rowIdKey";
+      "required": false;
+      "isSignal": true;
+    };
+    "minBufferPx": {
+      "alias": "minBufferPx";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxBufferPx": {
+      "alias": "maxBufferPx";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxHeight": {
+      "alias": "maxHeight";
+      "required": false;
+      "isSignal": true;
+    };
+    "fillHeight": {
+      "alias": "fillHeight";
+      "required": false;
+      "isSignal": true;
+    };
+    "isCondensed": {
+      "alias": "isCondensed";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectable": {
+      "alias": "selectable";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowsClickable": {
+      "alias": "rowsClickable";
+      "required": false;
+      "isSignal": true;
+    };
+    "loading": {
+      "alias": "loading";
+      "required": false;
+      "isSignal": true;
+    };
+    "loadingMore": {
+      "alias": "loadingMore";
+      "required": false;
+      "isSignal": true;
+    };
+    "hasMore": {
+      "alias": "hasMore";
+      "required": true;
+      "isSignal": true;
+    };
+    "skeletonRowCount": {
+      "alias": "skeletonRowCount";
+      "required": false;
+      "isSignal": true;
+    };
+    "loadMoreSkeletonCount": {
+      "alias": "loadMoreSkeletonCount";
+      "required": false;
+      "isSignal": true;
+    };
+    "loadingColumnCount": {
+      "alias": "loadingColumnCount";
+      "required": false;
+      "isSignal": true;
+    };
+    "loadMoreThreshold": {
+      "alias": "loadMoreThreshold";
+      "required": false;
+      "isSignal": true;
+    };
+    "noDataTemplate": {
+      "alias": "noDataTemplate";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorTemplate": {
+      "alias": "errorTemplate";
+      "required": false;
+      "isSignal": true;
+    };
+    "error": {
+      "alias": "error";
+      "required": false;
+      "isSignal": true;
+    };
+    "endOfListTemplate": {
+      "alias": "endOfListTemplate";
+      "required": false;
+      "isSignal": true;
+    };
+    "testId": {
+      "alias": "testId";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "loadMore": "loadMore";
+    "retry": "retry";
+    "rowClick": "rowClick";
+    "selectionChange": "selectionChange";
+  }, never, never, true, never>;
 }
-
-declare class InfiniteScrollTableComponentModule {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InfiniteScrollTableComponentModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<InfiniteScrollTableComponentModule, never, [typeof i1.CommonModule, typeof i2.ScrollingModule, typeof InfiniteScrollTableComponent], [typeof InfiniteScrollTableComponent]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<InfiniteScrollTableComponentModule>;
+export declare class InfiniteScrollTableComponentModule {
+  static ɵfac: i0.ɵɵFactoryDeclaration<InfiniteScrollTableComponentModule, never>;
+  static ɵmod: i0.ɵɵNgModuleDeclaration<InfiniteScrollTableComponentModule, never, [typeof i1.CommonModule, typeof i2.ScrollingModule, typeof InfiniteScrollTableComponent], [typeof InfiniteScrollTableComponent]>;
+  static ɵinj: i0.ɵɵInjectorDeclaration<InfiniteScrollTableComponentModule>;
 }
-
-export { InfiniteScrollTableComponent, InfiniteScrollTableComponentModule };
-export type { InfiniteScrollTableColumn, InfiniteScrollTableColumnAlignment, InfiniteScrollTableColumnStyles, InfiniteScrollTableErrorContext, InfiniteScrollTableHeaderCellContext, InfiniteScrollTableRowCellContext, InfiniteScrollTableRowClick, InfiniteScrollTableRowLike, InfiniteScrollTableRowSelection };
+export {};