@openreachtech/furo-vue 1.3.1

package/types/generated/components/organisms/FuroTable/FuroTableContext.d.ts

@@ -0,0 +1,1035 @@
+/**
+ * Context class for FuroTable organism.
+ *
+ * Presentational, domain-agnostic table. Sort and selection are controlled by
+ * the consumer (the table emits intent and re-reads its parcel); it never sorts
+ * or fetches data itself.
+ *
+ * @extends {BaseFuroContext<null, Props, EmitEventName>}
+ */
+export default class FuroTableContext extends BaseFuroContext<null, Props, "SORT_CHANGE" | "SELECTION_CHANGE" | "UPDATE_SELECTED_ROW_KEYS" | "RANGE_CHANGE" | "REACH_END" | "ROW_CLICK"> {
+    /**
+     * Factory method.
+     *
+     * @template {X extends typeof FuroTableContext ? X : never} T, X
+     * @override
+     * @param {FuroTableContextFactoryParams} params - Parameters of this factory method.
+     * @returns {InstanceType<T>} An instance of this class.
+     * @this {T}
+     */
+    static override create<T extends X extends typeof FuroTableContext ? X : never, X>(this: T, { props, componentContext, refHash, }: FuroTableContextFactoryParams): InstanceType<T>;
+    /**
+     * Build ref hash.
+     *
+     * @override
+     * @returns {FuroTableContextParams['refHash']}
+     */
+    static override buildRefHash(): FuroTableContextParams["refHash"];
+    /**
+     * Schedule a callback on the next animation frame.
+     *
+     * Wrapped as a static hook so scroll throttling can be driven deterministically
+     * in tests (spy on this method) instead of depending on the browser global.
+     *
+     * @param {FrameRequestCallback} callback - Callback to run on the next frame.
+     * @returns {number} The frame request id.
+     */
+    static requestFrame(callback: FrameRequestCallback): number;
+    /**
+     * Cancel a scheduled animation frame.
+     *
+     * Wrapped as a static hook (mirrors `requestFrame`) so teardown can be driven
+     * deterministically in tests.
+     *
+     * @param {number} frameId - The frame request id to cancel.
+     * @returns {void}
+     */
+    static cancelFrame(frameId: number): void;
+    /**
+     * Get emit event name.
+     *
+     * @override
+     * @returns {Readonly<{
+     *   SORT_CHANGE: 'sort:change'
+     *   SELECTION_CHANGE: 'selection:change'
+     *   UPDATE_SELECTED_ROW_KEYS: 'update:selectedRowKeys'
+     *   RANGE_CHANGE: 'range:change'
+     *   REACH_END: 'reach-end'
+     *   ROW_CLICK: 'row:click'
+     * }>}
+     */
+    static override get EMIT_EVENT_NAME(): Readonly<{
+        SORT_CHANGE: "sort:change";
+        SELECTION_CHANGE: "selection:change";
+        UPDATE_SELECTED_ROW_KEYS: "update:selectedRowKeys";
+        RANGE_CHANGE: "range:change";
+        REACH_END: "reach-end";
+        ROW_CLICK: "row:click";
+    }>;
+    /**
+     * Get emit options.
+     *
+     * @returns {{
+     *   'sort:change': (payload: {
+     *     field: string
+     *     direction: 'asc' | 'desc' | null
+     *   }) => void
+     *   'selection:change': (payload: {
+     *     selectedRowKeys: Array<string | number>
+     *   }) => void
+     *   'update:selectedRowKeys': (selectedRowKeys: Array<string | number>) => void
+     *   'range:change': (payload: {
+     *     first: number
+     *     last: number
+     *   }) => void
+     *   'reach-end': (payload: {
+     *     first: number
+     *     last: number
+     *     loadedCount: number
+     *     totalRecords: number
+     *   }) => void
+     *   'row:click': (payload: {
+     *     row: Record<string, unknown>
+     *     rowKey: string | number | null
+     *   }) => void
+     * }}
+     */
+    static get EMIT_EVENT_HASH(): {
+        "sort:change": (payload: {
+            field: string;
+            direction: "asc" | "desc" | null;
+        }) => void;
+        "selection:change": (payload: {
+            selectedRowKeys: Array<string | number>;
+        }) => void;
+        "update:selectedRowKeys": (selectedRowKeys: Array<string | number>) => void;
+        "range:change": (payload: {
+            first: number;
+            last: number;
+        }) => void;
+        "reach-end": (payload: {
+            first: number;
+            last: number;
+            loadedCount: number;
+            totalRecords: number;
+        }) => void;
+        "row:click": (payload: {
+            row: Record<string, unknown>;
+            rowKey: string | number | null;
+        }) => void;
+    };
+    /**
+     * Constructor.
+     *
+     * @param {FuroTableContextParams} params - Parameters of this constructor.
+     */
+    constructor({ props, componentContext, refHash, }: FuroTableContextParams);
+    refHash: {
+        selectedRowKeysRef: import("vue").Ref<Array<string | number>>;
+        pendingSelectionRef: import("vue").Ref<PendingSelection | null>;
+        scrollTopRef: import("vue").Ref<number>;
+        columnWidthsRef: import("vue").Ref<Record<string, number>>;
+    };
+    /** @type {{ first: number, last: number } | null} */
+    lastEmittedRange: {
+        first: number;
+        last: number;
+    } | null;
+    /**
+     * The loaded-window end (`rowOffset + rows.length`) for which `reach-end`
+     * was last emitted. Guards against re-emitting until the loaded window grows.
+     *
+     * @type {number | null}
+     */
+    lastReachEndLoadedEnd: number | null;
+    /**
+     * @type {{
+     *   field: string
+     *   startX: number
+     *   startWidth: number
+     *   nextField: string
+     *   nextStartWidth: number
+     * } | null}
+     */
+    resizeState: {
+        field: string;
+        startX: number;
+        startWidth: number;
+        nextField: string;
+        nextStartWidth: number;
+    } | null;
+    /** @type {number | null} */
+    scrollFrameId: number | null;
+    pendingScrollTop: number;
+    /**
+     * get: Constructor of this class.
+     *
+     * @override
+     * @returns {typeof FuroTableContext}
+     */
+    override get Ctor(): typeof FuroTableContext;
+    /**
+     * Get internal selected row keys ref (uncontrolled mode).
+     *
+     * @returns {import('vue').Ref<Array<string | number>>}
+     */
+    get selectedRowKeysRef(): import("vue").Ref<Array<string | number>>;
+    /**
+     * Get the ref holding the last selection this table emitted.
+     *
+     * @returns {import('vue').Ref<PendingSelection | null>}
+     */
+    get pendingSelectionRef(): import("vue").Ref<PendingSelection | null>;
+    /**
+     * Get the scroll-top ref driving virtual windowing.
+     *
+     * @returns {import('vue').Ref<number>}
+     */
+    get scrollTopRef(): import("vue").Ref<number>;
+    /**
+     * Get the per-column width overrides (px) set by resizing.
+     *
+     * @returns {import('vue').Ref<Record<string, number>>}
+     */
+    get columnWidthsRef(): import("vue").Ref<Record<string, number>>;
+    /**
+     * Extract the column configuration.
+     *
+     * @returns {Array<FuroTableColumn>}
+     */
+    extractColumns(): Array<FuroTableColumn>;
+    /**
+     * Extract the raw row records.
+     *
+     * @returns {Array<Record<string, unknown>>}
+     */
+    extractRows(): Array<Record<string, unknown>>;
+    /**
+     * Extract the field used as the unique row key.
+     *
+     * @returns {string}
+     */
+    extractRowKey(): string;
+    /**
+     * Extract the empty-state text.
+     *
+     * @returns {string}
+     */
+    extractEmptyText(): string;
+    /**
+     * Extract the error message, when present.
+     *
+     * @returns {string | null}
+     */
+    extractErrorMessage(): string | null;
+    /**
+     * Total rendered column count (data columns plus the selection column).
+     *
+     * @returns {number}
+     */
+    extractTotalColumnCount(): number;
+    /**
+     * Extract how many columns a placeholder row's skeleton spans.
+     *
+     * Data columns only, so an unloaded row keeps its selection and actions cells.
+     *
+     * @returns {number}
+     */
+    extractPlaceholderColumnCount(): number;
+    /**
+     * Whether a trailing row-actions column is rendered.
+     *
+     * True when the consumer provides a `row-actions` slot; the column then holds
+     * that slot's per-row content (edit/delete buttons, an action menu, etc.).
+     *
+     * @returns {boolean}
+     */
+    hasRowActionsColumn(): boolean;
+    /**
+     * Whether a footer region is rendered.
+     *
+     * True when the consumer provides a `footer` slot (bulk-action bar, summary
+     * row, etc.).
+     *
+     * @returns {boolean}
+     */
+    hasFooterSlot(): boolean;
+    /**
+     * Extract the header label for the row-actions column.
+     *
+     * @returns {string}
+     */
+    extractRowActionsLabel(): string;
+    /**
+     * Extract the `<col>` inline style for the row-actions column.
+     *
+     * @returns {Record<string, string>}
+     */
+    extractRowActionsColStyle(): Record<string, string>;
+    /**
+     * Extract root class names.
+     *
+     * @returns {Record<string, boolean>}
+     */
+    extractRootClassNames(): Record<string, boolean>;
+    /**
+     * Whether the table renders in the compact (denser) density.
+     *
+     * @returns {boolean}
+     */
+    isCompact(): boolean;
+    /**
+     * Whether the table renders vertical grid lines between columns.
+     *
+     * @returns {boolean}
+     */
+    hasGridLines(): boolean;
+    /**
+     * Extract the label rendered in a column header.
+     *
+     * @param {{
+     *   column: FuroTableColumn
+     * }} params - Parameters of this method.
+     * @returns {string}
+     */
+    extractColumnLabel({ column, }: {
+        column: FuroTableColumn;
+    }): string;
+    /**
+     * Extract the text alignment for a column.
+     *
+     * @param {{
+     *   column: FuroTableColumn
+     * }} params - Parameters of this method.
+     * @returns {'start' | 'center' | 'end'}
+     */
+    extractColumnAlign({ column, }: {
+        column: FuroTableColumn;
+    }): "start" | "center" | "end";
+    /**
+     * Whether columns can be resized by dragging their right edge.
+     *
+     * @returns {boolean}
+     */
+    isResizable(): boolean;
+    /**
+     * Extract the `<col>` inline style for the selection column.
+     *
+     * @returns {Record<string, string>}
+     */
+    extractSelectionColStyle(): Record<string, string>;
+    /**
+     * Extract the `<col>` inline style for a data column. A resized width wins
+     * over a configured `column.width`; otherwise the column is unsized (the
+     * fixed table layout shares remaining width).
+     *
+     * @param {{
+     *   column: FuroTableColumn
+     * }} params - Parameters of this method.
+     * @returns {Record<string, string>}
+     */
+    extractColumnColStyle({ column, }: {
+        column: FuroTableColumn;
+    }): Record<string, string>;
+    /**
+     * Whether row selection is enabled.
+     *
+     * @returns {boolean}
+     */
+    isSelectable(): boolean;
+    /**
+     * Whether the table is in the loading state.
+     *
+     * @returns {boolean}
+     */
+    isLoading(): boolean;
+    /**
+     * Whether interaction with the table body is blocked.
+     *
+     * @returns {boolean}
+     */
+    isInteractionBlocked(): boolean;
+    /**
+     * Extract the `inert` attribute for the scroll viewport. Any present value
+     * makes the subtree inert, so absence must be `null` and never `false`.
+     *
+     * @returns {true | null}
+     */
+    extractInertAttribute(): true | null;
+    /**
+     * Extract the `aria-busy` attribute for the table root.
+     *
+     * @returns {'true' | null}
+     */
+    extractAriaBusyAttribute(): "true" | null;
+    /**
+     * Whether the table is in the error state.
+     *
+     * @returns {boolean}
+     */
+    hasError(): boolean;
+    /**
+     * Whether the error state should render.
+     *
+     * @returns {boolean}
+     */
+    shouldShowError(): boolean;
+    /**
+     * Whether the in-body loading spinner should render. Only the first load (no
+     * rows yet) shows the centered spinner row; a refresh over existing rows keeps
+     * the rows mounted and shows the floating overlay instead (see
+     * `shouldShowLoadingOverlay`), so the layout never collapses.
+     *
+     * @returns {boolean}
+     */
+    shouldShowLoading(): boolean;
+    /**
+     * Whether the floating loading overlay should render. Used on a refresh, when
+     * rows are already present: the overlay is layered above the whole table
+     * (out of flow) so it dims and blocks the current rows without a layout shift.
+     *
+     * @returns {boolean}
+     */
+    shouldShowLoadingOverlay(): boolean;
+    /**
+     * Whether the empty state should render.
+     *
+     * @returns {boolean}
+     */
+    shouldShowEmpty(): boolean;
+    /**
+     * Whether the data rows should render.
+     *
+     * @returns {boolean}
+     */
+    shouldShowRows(): boolean;
+    /**
+     * Whether a column header is sortable.
+     *
+     * @param {{
+     *   column: FuroTableColumn
+     * }} params - Parameters of this method.
+     * @returns {boolean}
+     */
+    isColumnSortable({ column, }: {
+        column: FuroTableColumn;
+    }): boolean;
+    /**
+     * Extract the controlled sort indicator.
+     *
+     * @returns {FuroTableSort | null}
+     */
+    extractSort(): FuroTableSort | null;
+    /**
+     * Extract the active sort direction for a column, when sorted by it.
+     *
+     * @param {{
+     *   column: FuroTableColumn
+     * }} params - Parameters of this method.
+     * @returns {'asc' | 'desc' | null}
+     */
+    extractSortDirectionFor({ column, }: {
+        column: FuroTableColumn;
+    }): "asc" | "desc" | null;
+    /**
+     * Whether the table is currently sorted by a column.
+     *
+     * @param {{
+     *   column: FuroTableColumn
+     * }} params - Parameters of this method.
+     * @returns {boolean}
+     */
+    isSortedBy({ column, }: {
+        column: FuroTableColumn;
+    }): boolean;
+    /**
+     * Extract the sort indicator icon name for a column. Returns a neutral
+     * (bidirectional) icon when the column is sortable but not the active sort,
+     * and a directional icon when it is.
+     *
+     * @param {{
+     *   column: FuroTableColumn
+     * }} params - Parameters of this method.
+     * @returns {string}
+     */
+    extractSortIconName({ column, }: {
+        column: FuroTableColumn;
+    }): string;
+    /**
+     * Extract the controlled selected row keys.
+     *
+     * @returns {Array<string | number>}
+     */
+    extractSelectedRowKeys(): Array<string | number>;
+    /**
+     * Extract the number of currently selected rows.
+     *
+     * Exposed to the `footer` slot so a bulk-action bar can render "N selected".
+     *
+     * @returns {number}
+     */
+    extractSelectedCount(): number;
+    /**
+     * Extract the scope object passed to the `footer` slot.
+     *
+     * A single object (single-word slot key) so a bulk-action bar can read the
+     * selected keys and count without any kebab/camel binding ambiguity.
+     *
+     * @returns {{
+     *   keys: Array<string | number>
+     *   count: number
+     * }}
+     */
+    extractFooterSelection(): {
+        keys: Array<string | number>;
+        count: number;
+    };
+    /**
+     * Extract the keys of every row.
+     *
+     * @returns {Array<string | number>}
+     */
+    extractAllRowKeys(): Array<string | number>;
+    /**
+     * Whether selection is controlled by the parent (via `parcel.selectedRowKeys`).
+     *
+     * @returns {boolean}
+     */
+    isSelectionControlled(): boolean;
+    /**
+     * Whether every row is currently selected.
+     *
+     * @returns {boolean}
+     */
+    hasAllRowsSelected(): boolean;
+    /**
+     * Whether some (but not all) rows are selected.
+     *
+     * @returns {boolean}
+     */
+    hasIndeterminateSelection(): boolean;
+    /**
+     * Resolve the parcel for the select-all header checkbox.
+     *
+     * @returns {{
+     *   value: boolean
+     *   indeterminate: boolean
+     *   disabled: boolean
+     * }}
+     */
+    extractSelectAllParcel(): {
+        value: boolean;
+        indeterminate: boolean;
+        disabled: boolean;
+    };
+    /**
+     * Whether the select-all header checkbox is disabled. Disabled while loading
+     * (interaction is blocked during a refresh) and when there are no rows.
+     *
+     * @returns {boolean}
+     */
+    isSelectAllDisabled(): boolean;
+    /**
+     * Resolve the parcel for a single row's selection checkbox.
+     *
+     * @param {{
+     *   rowContext: FuroTableRowItemContext
+     * }} params - Parameters of this method.
+     * @returns {{
+     *   value: boolean
+     *   disabled: boolean
+     * }}
+     */
+    extractRowSelectionParcel({ rowContext, }: {
+        rowContext: FuroTableRowItemContext;
+    }): {
+        value: boolean;
+        disabled: boolean;
+    };
+    /**
+     * Create the per-row presentation contexts for the current rows.
+     *
+     * @returns {Array<FuroTableRowItemContext>}
+     */
+    createRowItemContexts(): Array<FuroTableRowItemContext>;
+    /**
+     * Resolve the next sort direction in the tri-state cycle:
+     * unsorted → ascending → descending → unsorted.
+     *
+     * @param {{
+     *   current: 'asc' | 'desc' | null
+     * }} params - Parameters of this method.
+     * @returns {'asc' | 'desc' | null}
+     */
+    resolveNextSortDirection({ current, }: {
+        current: "asc" | "desc" | null;
+    }): "asc" | "desc" | null;
+    /**
+     * Handle a sortable header click. Cycles ascending → descending → cleared and
+     * emits the sort intent upward; the parent re-sorts and re-passes the parcel.
+     * A `null` direction restores the default (unsorted) order.
+     *
+     * @param {{
+     *   column: FuroTableColumn
+     * }} params - Parameters of this method.
+     */
+    onHeaderClick({ column, }: {
+        column: FuroTableColumn;
+    }): void;
+    /**
+     * Toggle selection of a single row. A `null` key (row without an identifier)
+     * is ignored.
+     *
+     * @param {{
+     *   rowKey: string | number | null
+     * }} params - Parameters of this method.
+     */
+    onToggleRow({ rowKey, }: {
+        rowKey: string | number | null;
+    }): void;
+    /**
+     * Toggle selection of every row (select-all / clear-all).
+     */
+    onToggleSelectAll(): void;
+    /**
+     * Extract the selection a toggle must build on.
+     *
+     * When controlled, `parcel.selectedRowKeys` lags a tick behind the emit, so
+     * consecutive toggles must accumulate onto the last emitted selection instead.
+     *
+     * @returns {Array<string | number>}
+     */
+    extractPendingSelectedRowKeys(): Array<string | number>;
+    /**
+     * Remember a just-emitted selection so a follow-up toggle builds on it.
+     *
+     * @param {{
+     *   selectedRowKeys: Array<string | number>
+     * }} params - Parameters of this method.
+     */
+    rememberPendingSelection({ selectedRowKeys, }: {
+        selectedRowKeys: Array<string | number>;
+    }): void;
+    /**
+     * Whether every row is selected in the pending selection.
+     *
+     * @returns {boolean}
+     */
+    hasAllPendingRowsSelected(): boolean;
+    /**
+     * Apply a selection change: update internal state when uncontrolled, then
+     * emit the change upward.
+     *
+     * @param {{
+     *   selectedRowKeys: Array<string | number>
+     * }} params - Parameters of this method.
+     */
+    applySelection({ selectedRowKeys, }: {
+        selectedRowKeys: Array<string | number>;
+    }): void;
+    /**
+     * Handle a click on a data row. Emits the row and its key so the consumer can
+     * react (e.g. navigate to a detail view). The built-in selection cell stops
+     * propagation; interactive cell-slot content should `@click.stop` to opt out.
+     *
+     * @param {{
+     *   rowContext: FuroTableRowItemContext
+     * }} params - Parameters of this method.
+     */
+    onRowClick({ rowContext, }: {
+        rowContext: FuroTableRowItemContext;
+    }): void;
+    /**
+     * Handle a click on a virtual-window row. Placeholder rows (no loaded context)
+     * are ignored.
+     *
+     * @param {{
+     *   entry: {
+     *     index: number
+     *     rowContext: FuroTableRowItemContext | null
+     *   }
+     * }} params - Parameters of this method.
+     */
+    onVirtualRowClick({ entry, }: {
+        entry: {
+            index: number;
+            rowContext: FuroTableRowItemContext | null;
+        };
+    }): void;
+    /**
+     * Whether fixed-height virtual scrolling is enabled.
+     *
+     * @returns {boolean}
+     */
+    isVirtual(): boolean;
+    /**
+     * Extract the virtual-scroll configuration, when enabled.
+     *
+     * @returns {FuroTableVirtual | null}
+     */
+    extractVirtualConfig(): FuroTableVirtual | null;
+    /**
+     * Extract the fixed row height in pixels.
+     *
+     * @returns {number}
+     */
+    extractItemSize(): number;
+    /**
+     * Extract the scroll viewport height in pixels.
+     *
+     * @returns {number}
+     */
+    extractViewportHeight(): number;
+    /**
+     * Extract how many extra rows render above and below the viewport.
+     *
+     * @returns {number}
+     */
+    extractOverscan(): number;
+    /**
+     * Extract the global index of the first loaded row (sparse windows).
+     *
+     * @returns {number}
+     */
+    extractRowOffset(): number;
+    /**
+     * Extract the total row count of the full dataset. Falls back to the loaded
+     * row count when not provided.
+     *
+     * @returns {number}
+     */
+    extractTotalRowCount(): number;
+    /**
+     * Extract the global index one past the last loaded row.
+     *
+     * @returns {number}
+     */
+    extractLoadedEnd(): number;
+    /**
+     * Extract how close (in rows) to the end of the loaded window a downward
+     * scroll must get before `reach-end` fires.
+     *
+     * @returns {number}
+     */
+    extractEndThreshold(): number;
+    /**
+     * Extract the inline style for the scroll container.
+     *
+     * @returns {Record<string, string>}
+     */
+    extractScrollStyle(): Record<string, string>;
+    /**
+     * Extract the inline style for a fixed-height virtual row.
+     *
+     * @returns {Record<string, string>}
+     */
+    extractRowStyle(): Record<string, string>;
+    /**
+     * Extract the number of rows that fit in the viewport.
+     *
+     * @returns {number}
+     */
+    extractVisibleCount(): number;
+    /**
+     * Extract the first global row index to render (overscan applied).
+     *
+     * @returns {number}
+     */
+    extractFirstIndex(): number;
+    /**
+     * Compute the first global row index (overscan applied) for a scroll offset.
+     *
+     * Kept separate from {@link extractFirstIndex} so `onScroll` can test a
+     * prospective offset against the current window without mutating state.
+     *
+     * @param {number} scrollTop - Scroll offset in pixels.
+     * @returns {number}
+     */
+    computeFirstIndex(scrollTop: number): number;
+    /**
+     * Extract the last global row index to render (overscan applied).
+     *
+     * @returns {number}
+     */
+    extractLastIndex(): number;
+    /**
+     * Extract the leading spacer height (rows skipped above the window).
+     *
+     * @returns {number}
+     */
+    extractLeadingSpacerHeight(): number;
+    /**
+     * Extract the trailing spacer height (rows skipped below the window).
+     *
+     * @returns {number}
+     */
+    extractTrailingSpacerHeight(): number;
+    /**
+     * Create the per-row contexts for the visible virtual window. Entries whose
+     * row is not in the loaded sparse window carry a `null` context (placeholder).
+     *
+     * @returns {Array<{
+     *   index: number
+     *   rowContext: FuroTableRowItemContext | null
+     * }>}
+     */
+    createVirtualRowItemContexts(): Array<{
+        index: number;
+        rowContext: FuroTableRowItemContext | null;
+    }>;
+    /**
+     * Handle the raw scroll event from the viewport element.
+     *
+     * @param {Event} scrollEvent - The DOM scroll event.
+     */
+    onScrollEvent(scrollEvent: Event): void;
+    /**
+     * Setup component lifecycle: announce the initial window, re-ask once the
+     * loaded window changes, and cancel a pending scroll frame on unmount.
+     *
+     * @template {X extends FuroTableContext ? X : never} T, X
+     * @returns {T} For method chaining.
+     * @this {T}
+     */
+    setupComponent<T extends X extends FuroTableContext ? X : never, X>(this: T): T;
+    /**
+     * Coalesce raw scroll events into one `onScroll` per animation frame, so a
+     * burst of scroll events triggers at most one windowing pass per frame.
+     */
+    scheduleScrollFrame(): void;
+    /**
+     * Cancel a pending coalesced scroll frame, if any. Called on unmount so the
+     * frame callback cannot fire against a torn-down component.
+     *
+     * @returns {void}
+     */
+    teardownScrollFrame(): void;
+    /**
+     * Handle a scroll on the virtual viewport: store the offset and emit a
+     * range change when the visible window moves.
+     *
+     * @param {{
+     *   scrollTop: number
+     * }} params - Parameters of this method.
+     */
+    onScroll({ scrollTop, }: {
+        scrollTop: number;
+    }): void;
+    /**
+     * Emit `reach-end` once when a downward scroll brings the visible window
+     * within `endThreshold` rows of the end of the currently loaded window, and
+     * more records remain to load. Re-arms only when the loaded window grows, so
+     * a consumer appending pages is asked exactly once per page — unlike
+     * `range:change`, it never fires on upward scroll nor before the end.
+     *
+     * @returns {void}
+     */
+    emitReachEndIfNeeded(): void;
+    /**
+     * Release the `reach-end` guard once the loaded window shrank, so a refresh
+     * landing back on an already seen end can ask for its next page again.
+     *
+     * @returns {void}
+     */
+    releaseReachEndGuard(): void;
+    /**
+     * Emit `range:change` when the visible window differs from the last emitted.
+     * Virtual mode only, because a plain table has no window to move.
+     */
+    emitRangeChange(): void;
+    /**
+     * Announce the window the table renders on mount. That window can already
+     * hold unloaded rows, which no scroll event would otherwise ask to fill.
+     *
+     * @returns {void}
+     */
+    emitInitialWindow(): void;
+    /**
+     * Ask for the next page again once the loaded window changed, so a window
+     * still holding unloaded rows never waits for a scroll that may never come.
+     *
+     * @returns {void}
+     */
+    onLoadedWindowChange(): void;
+    /**
+     * Resolve the field of the column immediately after the given one. The next
+     * column absorbs the width change during a fit-mode resize.
+     *
+     * @param {{
+     *   field: string
+     * }} params - Parameters of this method.
+     * @returns {string | null}
+     */
+    resolveNextColumnField({ field, }: {
+        field: string;
+    }): string | null;
+    /**
+     * Whether a column's resize handle is shown. The last column has no neighbour
+     * to trade width with in fit mode, so it is not resizable.
+     *
+     * @param {{
+     *   columnIndex: number
+     * }} params - Parameters of this method.
+     * @returns {boolean}
+     */
+    canResizeColumn({ columnIndex, }: {
+        columnIndex: number;
+    }): boolean;
+    /**
+     * Measure the current rendered width (px) of every data column from its
+     * header cell. Pinning all widths on the first resize keeps the table's total
+     * width fixed while resizing trades width between two adjacent columns.
+     *
+     * @param {{
+     *   handle: HTMLElement
+     * }} params - Parameters of this method.
+     * @returns {Record<string, number>}
+     */
+    measureColumnWidths({ handle, }: {
+        handle: HTMLElement;
+    }): Record<string, number>;
+    /**
+     * Begin resizing a column (fit mode). On the first resize, all column widths
+     * are pinned so the table's total width stays fixed; dragging then trades
+     * width with the next column. Captures the pointer on the handle so move/end
+     * events keep firing even when the cursor leaves it.
+     *
+     * @param {{
+     *   column: FuroTableColumn
+     *   pointerEvent: PointerEvent
+     * }} params - Parameters of this method.
+     */
+    onColumnResizeStart({ column, pointerEvent, }: {
+        column: FuroTableColumn;
+        pointerEvent: PointerEvent;
+    }): void;
+    /**
+     * Trade width between the resized column and its neighbour as the pointer
+     * moves. The shared total is preserved (fit mode) and both columns are
+     * clamped to the minimum width, so the table never overflows from a resize.
+     *
+     * @param {{
+     *   pointerEvent: PointerEvent
+     * }} params - Parameters of this method.
+     */
+    onColumnResizeMove({ pointerEvent, }: {
+        pointerEvent: PointerEvent;
+    }): void;
+    /**
+     * Finish resizing a column and release the captured pointer.
+     *
+     * @param {{
+     *   pointerEvent: PointerEvent
+     * }} params - Parameters of this method.
+     */
+    onColumnResizeEnd({ pointerEvent, }: {
+        pointerEvent: PointerEvent;
+    }): void;
+}
+export type FuroTableContextParams = import("../../../contexts/BaseFuroContext.js").BaseFuroContextParams & {
+    props: Props;
+    componentContext: ComponentContext;
+    refHash: {
+        selectedRowKeysRef: import("vue").Ref<Array<string | number>>;
+        pendingSelectionRef: import("vue").Ref<PendingSelection | null>;
+        scrollTopRef: import("vue").Ref<number>;
+        columnWidthsRef: import("vue").Ref<Record<string, number>>;
+    };
+};
+/**
+ * The last selection this table emitted.
+ */
+export type PendingSelection = {
+    derivedFrom: Array<string | number>;
+    selectedRowKeys: Array<string | number>;
+};
+export type FuroTableContextFactoryParams = Omit<FuroTableContextParams, "refHash"> & {
+    refHash?: FuroTableContextParams["refHash"];
+};
+export type EmitEventName = keyof typeof FuroTableContext.EMIT_EVENT_NAME;
+export type Props = import("vue").HTMLAttributes & {
+    parcel?: FuroTableParcel | null;
+};
+/**
+ * Closed-set Furo behavior for `<FuroTable>`. JSON-serializable only.
+ */
+export type FuroTableParcel = {
+    columns?: Array<FuroTableColumn>;
+    rows?: Array<Record<string, unknown>>;
+    rowKey?: string;
+    selectable?: boolean;
+    selectedRowKeys?: Array<string | number> | null;
+    sort?: FuroTableSort | null;
+    loading?: boolean;
+    errorMessage?: string | null;
+    emptyText?: string;
+    virtual?: FuroTableVirtual | null;
+    totalRecords?: number | null;
+    rowOffset?: number;
+    resizable?: boolean;
+    compact?: boolean;
+    gridLines?: boolean;
+    rowActionsLabel?: string;
+    rowActionsWidth?: string;
+};
+/**
+ * Fixed-height virtual-scroll configuration. When set, FuroTable windows the
+ * rendered rows and emits `range:change` so the consumer can lazy-fetch the
+ * visible window into a sparse `rows` (with `rowOffset` + `totalRecords`).
+ *
+ * For infinite-append consumers, prefer the `reach-end` event over
+ * `range:change`: it fires once per loaded window when a downward scroll nears
+ * the end (within `endThreshold` rows), never on upward scroll.
+ */
+export type FuroTableVirtual = {
+    itemSize: number;
+    height: number;
+    overscan?: number;
+    endThreshold?: number;
+};
+export type FuroTableColumn = {
+    field: string;
+    label?: string;
+    sortable?: boolean;
+    align?: "start" | "center" | "end";
+    width?: string;
+};
+export type FuroTableSort = {
+    field: string;
+    direction: "asc" | "desc";
+};
+export type ComponentContext = import("vue").SetupContext<FuroTableEmitHash, FuroTableSlots>;
+export type FuroTableEmitHash = typeof FuroTableContext.EMIT_EVENT_HASH;
+export type FuroTableSlots = import("vue").SlotsType<{
+    "header-cell": {
+        column: FuroTableColumn;
+    };
+    cell: {
+        row: Record<string, unknown>;
+        column: FuroTableColumn;
+        value: unknown;
+    };
+    loading: {};
+    empty: {};
+    error: {
+        message: string | null;
+    };
+    placeholder: {
+        index: number;
+    };
+    "row-actions": {
+        row: Record<string, unknown>;
+    };
+    pagination: {};
+    footer: {
+        selection: {
+            keys: Array<string | number>;
+            count: number;
+        };
+    };
+}>;
+export type FuroTableSetup = (props: Props, componentContext: ComponentContext) => {
+    context: FuroTableContext;
+};
+import BaseFuroContext from '../../../contexts/BaseFuroContext.js';
+import FuroTableRowItemContext from './FuroTableRowItemContext.js';