@lavalogic/scoria 0.36.0 → 0.37.1

package/dist/Components/Table/Types/Context/TableInitOptions.d.ts

@@ -1,6 +1,22 @@
 import type { CellCoordinates } from '../Coordinates/CellCoordinates.js';
 import type { ToolbarPosition } from '../Toolbar/ToolbarPosition.js';
+/** Allowable primary-key types for the table's `selectionExtractor`. */
 export type Primitive = string | number;
+/**
+ * Consumer-facing init options passed to `createLocalTable` / the `Table`
+ * component. All defaults match the values noted in the inline comments.
+ *
+ * - `selectionExtractor` is mandatory: it returns the unique row id (used by
+ *   row-selection, focus, and column-preset code). May return a Promise so
+ *   the id can be derived from an async source.
+ * - `getUserId` is currently mandatory (consumers pass `() => undefined` if
+ *   not applicable). Promoting it to optional with a default of `() =>
+ *   undefined` is deferred (workorder Types-Context-supporting finding 7).
+ * - `onEditCell` is invoked when a cell finishes editing. `value` is typed
+ *   `unknown` because the table does not statically know which cell shape
+ *   the edit applies to; consumers narrow it from `coords.id` at the call
+ *   site.
+ */
 export interface TableInitOptions<T extends object, Identifier extends Primitive> {
     selectionExtractor: (item: T) => Identifier | Promise<Identifier>;
     allowCopy?: boolean;

package/dist/Components/Table/Types/Context/TableSettings.d.ts

@@ -1,3 +1,15 @@
+/**
+ * User-controlled visual / behavioural settings for a table. Held in
+ * `TableContext` and exposed to the settings panel.
+ *
+ * - `isCompact` - reduces row padding for higher row density.
+ * - `singleClickEditing` - enter edit mode on single click (default is double
+ *   click).
+ * - `alternateRowColours` - zebra striping.
+ * - `changeColourOnHover` - hover highlight on body rows.
+ * - `copyWithHeaders` - copy operation includes the header row.
+ * - `commaSeparatedCopy` - copy operation uses CSV instead of TSV.
+ */
 export interface TableSettings {
     isCompact: boolean;
     singleClickEditing: boolean;
@@ -6,6 +18,14 @@ export interface TableSettings {
     copyWithHeaders: boolean;
     commaSeparatedCopy: boolean;
 }
+/**
+ * The persisted-to-localStorage projection of `TableSettings`. Every field is
+ * optional because older payloads may be missing the newer fields; the
+ * loader fills in defaults from the current `TableSettings` shape.
+ *
+ * Equivalent to `Partial<TableSettings>`; written out explicitly so the
+ * persisted shape is greppable.
+ */
 export interface SavedTableSettings {
     isCompact?: boolean;
     singleClickEditing?: boolean;

package/dist/Components/Table/Types/Context/VirtualisationState.svelte.d.ts

@@ -0,0 +1,167 @@
+import type { Row } from './Row.js';
+/**
+ * Dependency surface that `VirtualisationState` reads from the
+ * surrounding `TableContext`. Every dependency is passed as a thunk so
+ * the sub-context never holds a direct reference to the parent;
+ * reactivity threads through `$derived` exactly as it does for the
+ * other Phase 6 sub-contexts.
+ */
+export interface VirtualisationStateDeps<T extends object> {
+    /** The full, ordered list of rows currently in scope (the
+     *  `paginationRowModel.rows` array from `TableContext`). */
+    getRows: () => ReadonlyArray<Row<T>>;
+    /** Per-row height lookup. The implementation reads from the
+     *  `_columnLayout` row-height pool (Phase 7.1 Item B) - whichever
+     *  side has the tallest registered height for the row. Returning
+     *  `undefined` (or 0) means "no observation yet" and the
+     *  estimated-row-height fallback is used. */
+    getRowHeight: (rowId: string) => number | undefined;
+    /** Estimated row height used when no observed height is available
+     *  yet for a row. Defaults to 48 (the CSS `--height: 3rem` baseline).
+     *  Compact tables (`isCompact = true`) pass a smaller estimate via
+     *  this thunk so the totalHeight is in the right ballpark before
+     *  any row has been observed. */
+    getEstimatedRowHeight: () => number;
+}
+/**
+ * Phase 7.4 row virtualisation. When the current row count exceeds
+ * `_virtualisationThreshold` (default 100) only the rows currently in
+ * the viewport (plus a small overscan band above and below) are
+ * rendered; the rest of the body height is reserved by two spacer
+ * `<tr>` rows in `TableBody.svelte`. Below the threshold every row is
+ * rendered directly, matching the legacy behaviour.
+ *
+ * The state is a sibling to `_columnLayout`, `_filtering`, `_sorting`,
+ * etc. Three reasons it lives in its own sub-context rather than on
+ * `_columnLayout`:
+ *
+ *   - the threshold + overscan + scroll position are virtualisation-
+ *     specific concerns the column-layout code does not need;
+ *   - the heights map on `_columnLayout` is keyed by `(side, rowId)`
+ *     while virtualisation only ever wants the max across sides
+ *     (which determines the row's slot height);
+ *   - the `visibleRange` / `visibleRows` derived chain is read by all
+ *     three `TableBody` instances; keeping it on its own state object
+ *     means `_columnLayout` does not become a god-object again.
+ *
+ * Scroll synchronisation: the three side `<table>` elements sit inside
+ * the same `.datatable` overflow container (see `Table.svelte`), so
+ * vertical scrolling is already shared. Only ONE scroll listener is
+ * needed - it is attached in `Table.svelte` on the outer
+ * `.datatable` element and reports both `scrollTop` and
+ * `clientHeight` via `registerScrollPosition`.
+ *
+ * Stability across sort / filter / pagination: rows are keyed by
+ * `row.id` (the visible index as a string assigned by
+ * `paginationRowModel`), so `{#each visibleRows as { row } (row.id)}`
+ * remains the keying surface and Svelte's diffing stays unchanged.
+ * The `_selection._keyCache` (Phase 6.5) is keyed by `row.original`,
+ * not by index or `row.id`, so virtualisation is transparent to it.
+ */
+export declare class VirtualisationState<T extends object> {
+    private readonly _deps;
+    private readonly _virtualisationThreshold;
+    private readonly _overscan;
+    /** Latest scroll position reported by the host. 0 by default so the
+     *  first paint (before any scroll event) shows the top of the
+     *  list. */
+    private _scrollTop;
+    /** Latest viewport height reported by the host. The fallback of
+     *  600 is chosen so that virtualisation has SOMETHING to clip
+     *  against before the first measurement - the overscan band keeps
+     *  the initial paint reasonable even if the real height is
+     *  smaller. */
+    private _viewportHeight;
+    constructor(deps: VirtualisationStateDeps<T>, options?: {
+        threshold?: number;
+        overscan?: number;
+    });
+    get virtualisationThreshold(): number;
+    get overscan(): number;
+    get scrollTop(): number;
+    get viewportHeight(): number;
+    /**
+     * Returns true when the current row count is above the
+     * virtualisation threshold. Below threshold the public API still
+     * works (visibleRows returns every row, padding spacers are 0),
+     * but consumers can short-circuit DOM work that is only needed in
+     * the virtualised path by reading this flag.
+     */
+    readonly isVirtualised: boolean;
+    /**
+     * Per-row resolved height. Uses the observed height from the
+     * `_columnLayout` row-height pool when available, falling back to
+     * the estimated row height (which keeps the totalHeight stable
+     * before the first ResizeObserver tick).
+     */
+    private _resolveHeight;
+    /**
+     * Sum of all row heights. This is the height the body container
+     * must reserve so the scrollbar matches the un-virtualised height.
+     *
+     * Below threshold the value is still correct (sum of all observed
+     * row heights or fallbacks), but consumers should generally not
+     * apply it as `min-height` to the body container when below
+     * threshold - the natural row flow does the right thing.
+     */
+    readonly totalHeight: number;
+    /**
+     * Half-open `[start, end)` row-index range that should be rendered
+     * in the DOM. Below the virtualisation threshold this is the full
+     * `[0, rows.length)`. Above threshold it is the slice covering the
+     * viewport (scrollTop -> scrollTop + viewportHeight) widened by
+     * `_overscan` rows above and below.
+     *
+     * The walk over row heights is O(N) per re-derive but only fires
+     * when `_scrollTop`, `_viewportHeight`, the rows array, or any
+     * relevant row height changes; for N <= a few thousand this is
+     * well under a millisecond.
+     */
+    readonly visibleRange: {
+        start: number;
+        end: number;
+    };
+    /**
+     * The slice of rows the body should render. Each entry carries:
+     *   - `row`: the underlying `Row<T>` (for keying and cell rendering);
+     *   - `top`: the pixel offset of the row from the top of the body
+     *     container (used as the spacer-row height directly preceding
+     *     it, computed cumulatively below);
+     *   - `height`: the row's resolved height (observed or fallback).
+     *
+     * The cumulative offset of `visibleRows[0]` equals
+     * `topSpacerHeight`; the cumulative offset of `visibleRows[end-1] +
+     * its height` plus `bottomSpacerHeight` equals `totalHeight`.
+     */
+    readonly visibleRows: ReadonlyArray<{
+        row: Row<T>;
+        top: number;
+        height: number;
+    }>;
+    /**
+     * Top spacer height: sum of heights of all rows BEFORE the visible
+     * window. Rendered as an empty `<tr>` of this height in
+     * `TableBody.svelte` so the visible rows appear at their correct
+     * vertical position.
+     */
+    readonly topSpacerHeight: number;
+    /**
+     * Bottom spacer height: sum of heights of all rows AFTER the
+     * visible window. Rendered as an empty `<tr>` of this height in
+     * `TableBody.svelte` so the body reserves the full virtualised
+     * height and the scrollbar reflects the un-virtualised length.
+     */
+    readonly bottomSpacerHeight: number;
+    /**
+     * Reports the current scroll position and viewport height. Called
+     * by `Table.svelte` from a single scroll listener on the outer
+     * `.datatable` container; the three side TableBody instances all
+     * read the resulting `visibleRows` so they stay in sync without
+     * extra plumbing.
+     *
+     * The setter early-exits when neither value changed so identical
+     * back-to-back scroll events (common on macOS rubber-band) do not
+     * retrigger the derived chain.
+     */
+    readonly registerScrollPosition: (scrollTop: number, viewportHeight: number) => void;
+}

package/dist/Components/Table/Types/Context/VirtualisationState.svelte.js

@@ -0,0 +1,226 @@
+/**
+ * Phase 7.4 row virtualisation. When the current row count exceeds
+ * `_virtualisationThreshold` (default 100) only the rows currently in
+ * the viewport (plus a small overscan band above and below) are
+ * rendered; the rest of the body height is reserved by two spacer
+ * `<tr>` rows in `TableBody.svelte`. Below the threshold every row is
+ * rendered directly, matching the legacy behaviour.
+ *
+ * The state is a sibling to `_columnLayout`, `_filtering`, `_sorting`,
+ * etc. Three reasons it lives in its own sub-context rather than on
+ * `_columnLayout`:
+ *
+ *   - the threshold + overscan + scroll position are virtualisation-
+ *     specific concerns the column-layout code does not need;
+ *   - the heights map on `_columnLayout` is keyed by `(side, rowId)`
+ *     while virtualisation only ever wants the max across sides
+ *     (which determines the row's slot height);
+ *   - the `visibleRange` / `visibleRows` derived chain is read by all
+ *     three `TableBody` instances; keeping it on its own state object
+ *     means `_columnLayout` does not become a god-object again.
+ *
+ * Scroll synchronisation: the three side `<table>` elements sit inside
+ * the same `.datatable` overflow container (see `Table.svelte`), so
+ * vertical scrolling is already shared. Only ONE scroll listener is
+ * needed - it is attached in `Table.svelte` on the outer
+ * `.datatable` element and reports both `scrollTop` and
+ * `clientHeight` via `registerScrollPosition`.
+ *
+ * Stability across sort / filter / pagination: rows are keyed by
+ * `row.id` (the visible index as a string assigned by
+ * `paginationRowModel`), so `{#each visibleRows as { row } (row.id)}`
+ * remains the keying surface and Svelte's diffing stays unchanged.
+ * The `_selection._keyCache` (Phase 6.5) is keyed by `row.original`,
+ * not by index or `row.id`, so virtualisation is transparent to it.
+ */
+export class VirtualisationState {
+    _deps;
+    _virtualisationThreshold;
+    _overscan;
+    /** Latest scroll position reported by the host. 0 by default so the
+     *  first paint (before any scroll event) shows the top of the
+     *  list. */
+    _scrollTop = $state(0);
+    /** Latest viewport height reported by the host. The fallback of
+     *  600 is chosen so that virtualisation has SOMETHING to clip
+     *  against before the first measurement - the overscan band keeps
+     *  the initial paint reasonable even if the real height is
+     *  smaller. */
+    _viewportHeight = $state(600);
+    constructor(deps, options = {}) {
+        this._deps = deps;
+        this._virtualisationThreshold = options.threshold ?? 100;
+        this._overscan = options.overscan ?? 10;
+    }
+    get virtualisationThreshold() {
+        return this._virtualisationThreshold;
+    }
+    get overscan() {
+        return this._overscan;
+    }
+    get scrollTop() {
+        return this._scrollTop;
+    }
+    get viewportHeight() {
+        return this._viewportHeight;
+    }
+    /**
+     * Returns true when the current row count is above the
+     * virtualisation threshold. Below threshold the public API still
+     * works (visibleRows returns every row, padding spacers are 0),
+     * but consumers can short-circuit DOM work that is only needed in
+     * the virtualised path by reading this flag.
+     */
+    isVirtualised = $derived.by(() => this._deps.getRows().length > this._virtualisationThreshold);
+    /**
+     * Per-row resolved height. Uses the observed height from the
+     * `_columnLayout` row-height pool when available, falling back to
+     * the estimated row height (which keeps the totalHeight stable
+     * before the first ResizeObserver tick).
+     */
+    _resolveHeight(rowId) {
+        const observed = this._deps.getRowHeight(rowId);
+        if (observed && observed > 0) {
+            return observed;
+        }
+        return this._deps.getEstimatedRowHeight();
+    }
+    /**
+     * Sum of all row heights. This is the height the body container
+     * must reserve so the scrollbar matches the un-virtualised height.
+     *
+     * Below threshold the value is still correct (sum of all observed
+     * row heights or fallbacks), but consumers should generally not
+     * apply it as `min-height` to the body container when below
+     * threshold - the natural row flow does the right thing.
+     */
+    totalHeight = $derived.by(() => {
+        const rows = this._deps.getRows();
+        let total = 0;
+        for (let i = 0; i < rows.length; i++) {
+            total += this._resolveHeight(rows[i].id);
+        }
+        return total;
+    });
+    /**
+     * Half-open `[start, end)` row-index range that should be rendered
+     * in the DOM. Below the virtualisation threshold this is the full
+     * `[0, rows.length)`. Above threshold it is the slice covering the
+     * viewport (scrollTop -> scrollTop + viewportHeight) widened by
+     * `_overscan` rows above and below.
+     *
+     * The walk over row heights is O(N) per re-derive but only fires
+     * when `_scrollTop`, `_viewportHeight`, the rows array, or any
+     * relevant row height changes; for N <= a few thousand this is
+     * well under a millisecond.
+     */
+    visibleRange = $derived.by(() => {
+        const rows = this._deps.getRows();
+        if (rows.length === 0) {
+            return { start: 0, end: 0 };
+        }
+        if (rows.length <= this._virtualisationThreshold) {
+            return { start: 0, end: rows.length };
+        }
+        const top = this._scrollTop;
+        const bottom = top + this._viewportHeight;
+        let offset = 0;
+        let start = 0;
+        let end = rows.length;
+        let foundStart = false;
+        for (let i = 0; i < rows.length; i++) {
+            const h = this._resolveHeight(rows[i].id);
+            const rowTop = offset;
+            const rowBottom = offset + h;
+            if (!foundStart && rowBottom >= top) {
+                start = i;
+                foundStart = true;
+            }
+            if (foundStart && rowTop > bottom) {
+                end = i;
+                break;
+            }
+            offset += h;
+        }
+        const overscanned = {
+            start: Math.max(0, start - this._overscan),
+            end: Math.min(rows.length, end + this._overscan),
+        };
+        return overscanned;
+    });
+    /**
+     * The slice of rows the body should render. Each entry carries:
+     *   - `row`: the underlying `Row<T>` (for keying and cell rendering);
+     *   - `top`: the pixel offset of the row from the top of the body
+     *     container (used as the spacer-row height directly preceding
+     *     it, computed cumulatively below);
+     *   - `height`: the row's resolved height (observed or fallback).
+     *
+     * The cumulative offset of `visibleRows[0]` equals
+     * `topSpacerHeight`; the cumulative offset of `visibleRows[end-1] +
+     * its height` plus `bottomSpacerHeight` equals `totalHeight`.
+     */
+    visibleRows = $derived.by(() => {
+        const rows = this._deps.getRows();
+        const range = this.visibleRange;
+        const out = [];
+        let offset = 0;
+        for (let i = 0; i < range.start; i++) {
+            offset += this._resolveHeight(rows[i].id);
+        }
+        for (let i = range.start; i < range.end; i++) {
+            const h = this._resolveHeight(rows[i].id);
+            out.push({ row: rows[i], top: offset, height: h });
+            offset += h;
+        }
+        return out;
+    });
+    /**
+     * Top spacer height: sum of heights of all rows BEFORE the visible
+     * window. Rendered as an empty `<tr>` of this height in
+     * `TableBody.svelte` so the visible rows appear at their correct
+     * vertical position.
+     */
+    topSpacerHeight = $derived.by(() => {
+        const rows = this._deps.getRows();
+        const range = this.visibleRange;
+        let total = 0;
+        for (let i = 0; i < range.start; i++) {
+            total += this._resolveHeight(rows[i].id);
+        }
+        return total;
+    });
+    /**
+     * Bottom spacer height: sum of heights of all rows AFTER the
+     * visible window. Rendered as an empty `<tr>` of this height in
+     * `TableBody.svelte` so the body reserves the full virtualised
+     * height and the scrollbar reflects the un-virtualised length.
+     */
+    bottomSpacerHeight = $derived.by(() => {
+        const rows = this._deps.getRows();
+        const range = this.visibleRange;
+        let total = 0;
+        for (let i = range.end; i < rows.length; i++) {
+            total += this._resolveHeight(rows[i].id);
+        }
+        return total;
+    });
+    /**
+     * Reports the current scroll position and viewport height. Called
+     * by `Table.svelte` from a single scroll listener on the outer
+     * `.datatable` container; the three side TableBody instances all
+     * read the resulting `visibleRows` so they stay in sync without
+     * extra plumbing.
+     *
+     * The setter early-exits when neither value changed so identical
+     * back-to-back scroll events (common on macOS rubber-band) do not
+     * retrigger the derived chain.
+     */
+    registerScrollPosition = (scrollTop, viewportHeight) => {
+        if (scrollTop === this._scrollTop && viewportHeight === this._viewportHeight) {
+            return;
+        }
+        this._scrollTop = scrollTop;
+        this._viewportHeight = viewportHeight;
+    };
+}

package/dist/Components/Table/Types/Coordinates/CellCoordinates.d.ts

@@ -1,4 +1,16 @@
 import type { MemoryColumnIndex } from './ColumnIndices.js';
+/**
+ * Identifies one cell for focus, edit, and multi-selection operations.
+ *
+ * - `row` is the visible row index (post-pagination, post-sort). Currently a
+ *   bare `number`; branding to a `VisibleRowIndex` is deferred because the
+ *   change ripples through every focus call site.
+ * - `id` is the column id (a `string` rather than `keyof T` so synthetic
+ *   columns can be addressed). Many call sites cast it to `string & keyof T`
+ *   after constructing a `CellCoordinates`; tightening is deferred to the
+ *   parent `ColumnDef.id` workorder.
+ * - `column` is the memory-order index of the column (see `ColumnIndices`).
+ */
 export interface CellCoordinates {
     row: number;
     id: string;

package/dist/Components/Table/Types/Coordinates/CellCoordinatesWithoutColumn.d.ts

@@ -1,2 +1,7 @@
 import type { CellCoordinates } from './CellCoordinates.js';
+/**
+ * `CellCoordinates` minus the `column` memory-index field. Used by code
+ * paths that identify a cell by row + id only (typically column-preset
+ * lookups before the visible column array has been resolved).
+ */
 export type CellCoordinatesWithoutColumn = Omit<CellCoordinates, 'column'>;

package/dist/Components/Table/Types/Coordinates/ColumnIndices.d.ts

@@ -1,8 +1,22 @@
-/** Position of a column in the `columnDefs` array (memory order). */
+/**
+ * Position of a column in the `columnDefs` array (memory / declaration
+ * order). Stable across reorder operations: a column's memory index does not
+ * change when the user drags it. Used as the canonical identifier when
+ * persisting column-preset state.
+ *
+ * Branded so it cannot be accidentally swapped with a `VisualColumnIndex`.
+ * Note: the brand is a string-literal nominal tag rather than a
+ * `unique symbol`; the workorder marks symbol-based brands as a deferred
+ * tightening (project-wide change tracked under `Misc.ts`).
+ */
 export type MemoryColumnIndex = number & {
     readonly __brand: 'MemoryColumnIndex';
 };
-/** Position of a column in the visual display order (pinned-left → center → pinned-right). */
+/**
+ * Position of a column in the visual display order (pinned-left, then
+ * centre, then pinned-right). Mutates as the user drags columns or pins /
+ * unpins them. Used for focus-arrow navigation and the cell-render order.
+ */
 export type VisualColumnIndex = number & {
     readonly __brand: 'VisualColumnIndex';
 };

package/dist/Components/Table/Types/DataRepository/BuiltInRemoteRepository.svelte.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Built-in remote data repository used by `createTable({ rows: { kind: 'remote' } })`.
+ *
+ * Phase 1 of the new Table API: this class absorbs the URL construction,
+ * filter encoding, pagination, sort, debouncing, and page-size persistence
+ * that every consumer was previously reimplementing for itself (see the
+ * FloWMS-owned `RemoteTableDataRepository.svelte.ts` for the prior shape).
+ *
+ * The default filter-encoding strategy is `'query-string'`, which produces
+ * a flat `?filter[<id>]=<value>&page=<n>&pageSize=<m>&sort=<col>&direction=<asc|desc>`
+ * URL. Consumers whose backend expects a different shape pass a custom
+ * `filterEncoding: { encode }` function. Consumers needing complete
+ * control over the request lifecycle drop to `kind: 'custom'`, which
+ * bypasses this repository entirely.
+ *
+ * The repository extends `TableDataRepository` for its pagination-state /
+ * filter-modes / force-refresh plumbing and implements
+ * `IRemoteDataRepository<TRow>` for the surface `TableContext` consumes.
+ *
+ * @remarks
+ *
+ * Out of scope for Phase 1:
+ *
+ * - Sophisticated filter-mode encoding (`StringFilterMode.NotIn`, the
+ *   `[min, max]` tuple form for ranges, etc.). The Phase 1 default
+ *   encoder emits raw `?filter[<id>]=<JSON-encoded-value>`. Consumers
+ *   needing the rich encoding the FloWMS repo currently does should pass
+ *   a custom encoder in Phase 1 and we will lift the common encodings
+ *   into the library in Phase 2 once the audit of the consumer's actual
+ *   backend shape is complete.
+ * - The five filter callbacks (`dateFilter` / `numberFilter` / etc.).
+ *   These are local-only and not meaningful for a remote source. The
+ *   interface inherits them as optional; left undefined here.
+ */
+import type { ColumnFiltersState } from '../Filtering/ColumnFiltersState.js';
+import type { FilterMode } from '../Filtering/FilterMode.js';
+import type { IRemoteDataRepository } from './IRemoteDataRepository.js';
+import type { SortingState } from './SortingState.js';
+import { TableDataRepository } from './TableDataRepository.svelte.js';
+import type { RemoteRowSource, CustomRowSource } from '../../Types/Public/RowSource.js';
+/**
+ * Options passed to the repository's constructor. Mirrors the consumer's
+ * `RemoteRowSource<TRow>` shape minus the `kind` discriminator, with the
+ * mandatory `tableName` and `getUserId` fields added (these are passed by
+ * `createTable(...)` from the top-level options, not from `RowSource`).
+ */
+export interface BuiltInRemoteRepositoryOptions<TRow extends object> extends Omit<RemoteRowSource<TRow>, 'kind'> {
+    tableName: string;
+    getUserId: () => string | undefined;
+    /** Initial page size. Overridden by the persisted value if one exists. */
+    pageSize?: number;
+}
+export declare class BuiltInRemoteRepository<TRow extends object> extends TableDataRepository<TRow, unknown> implements IRemoteDataRepository<TRow> {
+    private readonly _options;
+    readonly paginationType: "Remote";
+    readonly filterType: "Virtual";
+    readonly manualSorting = true;
+    private _data;
+    get data(): Array<TRow>;
+    set data(v: Array<TRow>);
+    private _totalRows;
+    get totalRows(): number;
+    private set totalRows(value);
+    private _lastPage;
+    get lastPage(): number;
+    private set lastPage(value);
+    private _isLoading;
+    get isLoading(): boolean;
+    loadingMessage: string | undefined;
+    private _sorting;
+    get sorting(): SortingState;
+    set sorting(v: SortingState);
+    private _filtering;
+    get filtering(): ColumnFiltersState;
+    private _abortController;
+    private _debounceTimer;
+    private _quickFilterFocusCount;
+    constructor(_options: BuiltInRemoteRepositoryOptions<TRow>);
+    readonly setFilterMode: (id: string, mode: FilterMode) => void;
+    readonly filterBy: (id: string, value: unknown) => void;
+    readonly resetFilters: () => void;
+    readonly setPage: (page: number) => void;
+    readonly nextPage: () => void;
+    readonly prevPage: () => void;
+    readonly setPageSize: (size: number | string) => void;
+    readonly updateSorting: (next: SortingState | ((prev: SortingState) => SortingState)) => void;
+    get pageStartIndex(): number;
+    get pageEndIndexExclusive(): number;
+    /**
+     * Fetches a fresh page from the configured endpoint. Cancels any
+     * in-flight request first. The `debounced` flag (when true) coalesces
+     * rapid calls into a single trailing request after the configured
+     * debounce window.
+     */
+    readonly reload: (debounced?: boolean) => Promise<void>;
+    private scheduleReload;
+    private _reloadNow;
+    private _buildMergedFilters;
+    private _buildUrl;
+    private _buildRequestInit;
+    private _applyResponseTransform;
+}
+/**
+ * Thin adapter for `kind: 'custom'`. Delegates to a consumer-supplied
+ * `fetch` function on every page / filter / sort change. Inherits
+ * `TableDataRepository` for pagination and filter-mode plumbing.
+ */
+export declare class CustomRemoteRepository<TRow extends object> extends TableDataRepository<TRow, unknown> implements IRemoteDataRepository<TRow> {
+    private readonly _fetch;
+    readonly paginationType: "Remote";
+    readonly filterType: "Virtual";
+    readonly manualSorting = true;
+    private _data;
+    get data(): Array<TRow>;
+    set data(v: Array<TRow>);
+    private _totalRows;
+    get totalRows(): number;
+    private set totalRows(value);
+    private _lastPage;
+    get lastPage(): number;
+    private set lastPage(value);
+    private _isLoading;
+    get isLoading(): boolean;
+    loadingMessage: string | undefined;
+    private _sorting;
+    get sorting(): SortingState;
+    set sorting(v: SortingState);
+    private _filtering;
+    get filtering(): ColumnFiltersState;
+    private _abortController;
+    constructor(tableName: string, getUserId: () => string | undefined, _fetch: CustomRowSource<TRow>['fetch']);
+    readonly setFilterMode: (id: string, mode: FilterMode) => void;
+    readonly filterBy: (id: string, value: unknown) => void;
+    readonly resetFilters: () => void;
+    readonly setPage: (page: number) => void;
+    readonly nextPage: () => void;
+    readonly prevPage: () => void;
+    readonly setPageSize: (size: number | string) => void;
+    readonly updateSorting: (next: SortingState | ((prev: SortingState) => SortingState)) => void;
+    get pageStartIndex(): number;
+    get pageEndIndexExclusive(): number;
+    readonly reload: () => Promise<void>;
+}