/**
 * The **Server-Side Row Model** — the strategy that makes the grid a pure
 * rendering engine and delegates every data operation to a
 * {@link ServerSideDatasource}. In this phase it implements **page-at-a-time**
 * pagination: each state change (sort / filter / search / page) triggers a
 * debounced, abortable, race-safe, optionally-cached fetch of exactly one page,
 * whose rows are published straight into `visibleRows`.
 *
 * Responsibilities are split into focused collaborators:
 *  - {@link ServerRequestBuilder} — snapshots grid state into a typed request.
 *  - {@link ServerRequestController} — abort / latest-wins / retry.
 *  - {@link ServerSideCache} — optional LRU of responses.
 *
 * This orchestrator owns only sequencing, loading/overlay state, and lifecycle
 * events; it never sorts/filters/paginates locally.
 *
 * @packageDocumentation
 */
import type { GridContext } from '../../core/grid-context';
import type { ServerSideConfig, ServerSideDatasource } from '../../types/server-side.types';
import type { RowModelStrategy } from '../row-model-strategy';
/** Delegates all data operations to a {@link ServerSideDatasource} (pagination mode). */
export declare class ServerRowModel implements RowModelStrategy {
    private readonly ctx;
    readonly type: "server";
    private readonly builder;
    private readonly controller;
    private readonly cache;
    private datasource;
    private readonly debounceMs;
    private fetchTimer;
    private requestSeq;
    private destroyed;
    constructor(ctx: GridContext, config?: Partial<ServerSideConfig>, datasource?: ServerSideDatasource);
    /** Debounced entry point invoked on every `refresh()` — coalesces bursts into one fetch. */
    buildDisplayedRows(): void;
    /** Initial kick-off after grid initialisation. */
    start(): void;
    /** Aborts in-flight work, cancels timers, and releases the datasource. */
    destroy(): void;
    /** Replaces the datasource and immediately refetches the current view. */
    setDatasource(datasource: ServerSideDatasource | null): void;
    /**
     * Forces a refetch of the current view. When `purge` is `true` the response
     * cache is cleared first so fresh data is fetched even for a cached signature.
     */
    refresh(params?: {
        purge?: boolean;
    }): void;
    private scheduleFetch;
    private fetch;
    private applyResult;
    private publishEmpty;
    /**
     * Writes the shared loading flag. `GridCore` watches this store key and is
     * the single emitter of `LOADING_STARTED` / `LOADING_STOPPED`, so this must
     * not emit them itself — doing so would double-fire for every fetch.
     */
    private setLoading;
    private createCache;
    private toMessage;
}
//# sourceMappingURL=server-row-model.d.ts.map