rowvia 0.1.0

package/dist/types/gantt/ganttChart.d.ts

@@ -0,0 +1,122 @@
+import type { GanttTask, TeamMember } from './data';
+export type GanttUnit = 'day' | 'week' | 'biweek' | 'month' | 'bimonth' | 'quarter' | 'halfyear' | 'year';
+export type GanttTheme = 'content' | 'color';
+export declare const GANTT_UNITS: GanttUnit[];
+export declare const UNIT_LABEL: Record<GanttUnit, string>;
+export interface ChartRow {
+    id: string;
+    group: boolean;
+    expanded: boolean;
+}
+export interface GanttChartOptions {
+    members: TeamMember[];
+    rowHeight: number;
+    onSelect: (id: string | null) => void;
+    onHover: (id: string | null) => void;
+    onTaskChange: (task: GanttTask) => void;
+    onAssign: (id: string, memberId: string | null) => void;
+}
+export declare class GanttChart {
+    private options;
+    private eRoot;
+    private eHeader;
+    private eRuler;
+    private rulerCtx;
+    private eRulerTools;
+    private eStepLabel;
+    private eZoomValue;
+    private eStepMenu;
+    private eScroll;
+    private eSpacer;
+    private eCanvas;
+    private ctx;
+    private eTooltip;
+    private eTodayBadge;
+    private ePopup;
+    private tasks;
+    private tasksById;
+    private rows;
+    private selectedId;
+    private hoverId;
+    private unit;
+    private zoom;
+    private theme;
+    private epochStart;
+    private totalDays;
+    private hits;
+    private hitsByRow;
+    private drag;
+    private ghost;
+    private dirty;
+    private lastLeft;
+    private lastTop;
+    private timer;
+    private observer;
+    private resizeHandler;
+    private showChildren;
+    private milestonesOnly;
+    private locateHits;
+    constructor(container: HTMLElement, options: GanttChartOptions);
+    destroy(): void;
+    setHover(id: string | null): void;
+    setShowChildren(value: boolean): void;
+    setMilestonesOnly(value: boolean): void;
+    scrollToTask(id: string): void;
+    setTasks(tasks: GanttTask[]): void;
+    setRows(rows: ChartRow[]): void;
+    setSelected(id: string | null): void;
+    setUnit(unit: GanttUnit): void;
+    setZoom(zoom: number): void;
+    setTheme(theme: GanttTheme): void;
+    get dayWidth(): number;
+    get scrollElement(): HTMLElement;
+    /** keep the timeline aligned with the grid's vertical scroll */
+    setScrollTop(top: number): void;
+    /** ask for a repaint on the next frame tick (the page's sync loop calls this) */
+    redraw(): void;
+    private markDirty;
+    /** scroll the timeline so today sits at `fraction` of the viewport, and bring the active row into view */
+    scrollToToday(fraction?: number): void;
+    private computeDomain;
+    private dateX;
+    private xToDate;
+    private resizeCanvases;
+    private tick;
+    private onScroll;
+    private draw;
+    private drawRuler;
+    private drawBody;
+    private drawWeekends;
+    private drawGridlines;
+    private drawRowBackgrounds;
+    private drawTodayLine;
+    private todayLabelX;
+    private drawTodayLabel;
+    private drawDependencies;
+    private drawBars;
+    private drawTaskBar;
+    private drawSummaryBar;
+    private firstVisibleChildIndex;
+    private drawMilestone;
+    private pushHit;
+    private drawLocateButtons;
+    /** content-space point under the pointer */
+    private pointAt;
+    private hitAt;
+    private onCanvasMouseMove;
+    private onCanvasMouseDown;
+    private updateDrag;
+    private endDrag;
+    private onRootMouseLeave;
+    private buildRulerTools;
+    private toolButton;
+    private zoomBy;
+    private pageBy;
+    private toggleStepMenu;
+    private closeStepMenu;
+    private updateRulerTools;
+    private openAssigneePopup;
+    private closeAssigneePopup;
+    private onDocumentMouseDown;
+}
+export declare function memberColor(id: string): string;

package/dist/types/gantt/index.d.ts

@@ -0,0 +1,5 @@
+export { createGantt } from './component';
+export type { GanttApi, GanttOptions } from './component';
+export type { GanttTask, TeamMember, TaskKind, TaskStatus } from './data';
+export { GanttChart, GANTT_UNITS, UNIT_LABEL } from './ganttChart';
+export type { GanttUnit, GanttTheme } from './ganttChart';

package/dist/types/gantt/locale.d.ts

@@ -0,0 +1,10 @@
+import type { GridOptions } from '../types';
+/**
+ * Chinese UI text for the grid chrome in this demo (column menu, context menu,
+ * filter popup, tool panels, pagination, find, overlays). Keys not listed here
+ * keep the library's English defaults.
+ */
+export declare const ZH_LOCALE_TEXT: Record<string, string>;
+/** all locale keys the library ships, so the demo can assert full coverage */
+export declare const LOCALE_KEYS: string[];
+export declare function withLocale(gridOptions: GridOptions): GridOptions;

package/dist/types/grid.d.ts

@@ -0,0 +1,168 @@
+import type { Column, ColumnApi, GridApi, GridOptions, RowDataTransaction, RowNode, RowNodeTransactionResult } from './types';
+import { EventService } from './core/eventService';
+import { ColumnModel } from './core/columnModel';
+import { RowModel } from './core/clientSideRowModel';
+import { InfiniteRowModel, ServerSideRowModel, ViewportRowModel } from './core/remoteRowModels';
+import { RowRenderer } from './render/rowRenderer';
+import { HeaderView } from './render/headerView';
+import { SelectionService } from './features/selectionService';
+import { EditService } from './features/editService';
+import { FilterService } from './features/filterService';
+import { SortService } from './features/sortService';
+import { PaginationService } from './features/paginationService';
+import { PopupService } from './features/popupService';
+import { FilterGui } from './features/filterGui';
+import { SideBarService } from './features/sideBar';
+import { FindService } from './features/findService';
+import { RangeSelectionService } from './features/rangeSelection';
+import { ChartService } from './features/chartService';
+import { OverlayService } from './features/overlays';
+import { ExportService } from './features/exportService';
+import { RowGroupPanel } from './features/rowGroupPanel';
+import { UndoRedoService } from './features/undoRedoService';
+import { FormulaEditorService } from './features/formulaEditor';
+import { NotesService } from './features/notesService';
+import { RowDragService } from './features/rowDragService';
+export declare class Grid {
+    private options;
+    private eventService;
+    private columnModel;
+    private rowModel;
+    private clientSideRowModel;
+    private serverSideRowModel;
+    private infiniteRowModel;
+    private viewportRowModel;
+    private rowRenderer;
+    private headerView;
+    private selectionService;
+    private editService;
+    private filterService;
+    private sortService;
+    private paginationService;
+    private popupService;
+    private filterGui;
+    private contextMenuService;
+    private columnMenuService;
+    private statusBarService;
+    private sideBarService;
+    private findService;
+    private rangeSelectionService;
+    private chartService;
+    private overlayService;
+    private exportService;
+    private rowGroupPanel;
+    private undoRedoService;
+    private formulaEditorService;
+    private notesService;
+    private rowDragService;
+    private api;
+    private columnApi;
+    private localeText;
+    private rowNodeServices;
+    private eGridDiv;
+    private eRoot;
+    private eMain;
+    private eHeader;
+    private quickFilter;
+    private resizeObserver;
+    private destroyed;
+    private gridReadyDispatched;
+    private context;
+    constructor(eGridDiv: HTMLElement, gridOptions: GridOptions);
+    getOptions(): GridOptions;
+    /** UI strings for menus / popups / panels */
+    t(key: string): string;
+    /** localisation lookup that keeps its English fallback for unknown keys */
+    translate(key: string, fallback: string): string;
+    getContext(): any;
+    getEventService(): EventService;
+    getColumnModel(): ColumnModel;
+    getRowModel(): RowModel;
+    getRowRenderer(): RowRenderer;
+    getHeaderView(): HeaderView;
+    getSelectionService(): SelectionService;
+    getEditService(): EditService;
+    getFilterService(): FilterService;
+    getSortService(): SortService;
+    getFilterGui(): FilterGui;
+    getPaginationService(): PaginationService | null;
+    getSideBarService(): SideBarService;
+    getChartService(): ChartService;
+    getFindService(): FindService;
+    getRangeSelectionService(): RangeSelectionService;
+    getExportService(): ExportService;
+    getPopupService(): PopupService;
+    getOverlayService(): OverlayService;
+    getRowGroupPanel(): RowGroupPanel | null;
+    getUndoRedoService(): UndoRedoService;
+    getFormulaEditorService(): FormulaEditorService;
+    getNotesService(): NotesService;
+    getRowDragService(): RowDragService;
+    getServerSideRowModel(): ServerSideRowModel | null;
+    getInfiniteRowModel(): InfiniteRowModel | null;
+    getViewportRowModel(): ViewportRowModel | null;
+    /** cache column totals so `showValueAs: 'percentOfTotal'` can render */
+    private updateColumnTotalCache;
+    /** (re)generate pivot result columns from the current row data */
+    refreshPivotColumns(): void;
+    private onRemoteModelChanged;
+    isRemoteLoading(): boolean;
+    getApi(): GridApi;
+    getColumnApi(): ColumnApi;
+    getRootElement(): HTMLElement;
+    getMainElement(): HTMLElement;
+    getHeaderElement(): HTMLElement;
+    getGridDiv(): HTMLElement;
+    getColumns(): {
+        left: Column[];
+        center: Column[];
+        right: Column[];
+    };
+    getAllColumns(): Column[];
+    getColumn(key: string | Column): Column | undefined;
+    getDisplayedRowCount(): number;
+    getDisplayedRowAtIndex(index: number): RowNode | undefined;
+    getRowNode(id: string): RowNode | undefined;
+    getRowHeight(node: RowNode): number;
+    getRowClass(node: RowNode): string;
+    getRowStyle(node: RowNode): Record<string, any>;
+    isNodeSelectable(node: RowNode): boolean;
+    isCellEditable(column: Column, node: RowNode): boolean;
+    setRowData(rowData: any[], initial?: boolean): void;
+    applyTransaction(transaction: RowDataTransaction): RowNodeTransactionResult | null;
+    setCellValue(column: Column, node: RowNode, value: any, source?: string, oldValueOverride?: any): void;
+    refreshModel(step?: string): void;
+    refreshCells(params?: {
+        rowNodes?: RowNode[];
+        columns?: Array<string | Column>;
+        force?: boolean;
+        flash?: boolean;
+    }): void;
+    setQuickFilter(text: string): void;
+    getQuickFilter(): string;
+    setRowNodePinned(node: RowNode, pinned: 'top' | 'bottom' | null): void;
+    /** open the find bar (Ctrl+F) */
+    openFind(): void;
+    closeFind(): void;
+    private onCellClicked;
+    private onCellMouseDown;
+    private onRowClicked;
+    private onRowDoubleClicked;
+    private onCellContextMenu;
+    private onRowGroupClicked;
+    private onHeaderCheckboxChanged;
+    private updateHeaderCheckboxes;
+    private onViewportKeyDown;
+    private onColumnResized;
+    private onColumnMoved;
+    private onColumnsChanged;
+    private onModelUpdated;
+    onGridSizeChanged(): void;
+    private onWindowResize;
+    /** outside clicks (or clicks on the grid chrome) commit the edit and drop focus */
+    private onDocumentMouseDown;
+    private renderDetailRow;
+    private dispatchGridReady;
+    updateGridOptions(options: Partial<GridOptions>): void;
+    destroy(): void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,28 @@
+import { Grid } from './grid';
+import type { GridOptions, GridApi, ColumnApi } from './types';
+import { CELL_RENDERERS, CELL_EDITORS } from './render/cellRenderers';
+import { createSparklineSvg } from './render/cellRenderers';
+import { formatNumberCommas } from './core/utils';
+export { Grid };
+export type { GridOptions, ColDef, GridApi, ColumnApi, RowNode, Column, ColumnState, SortModelItem, FilterModelItem, CellRange, CellRendererParams, ValueFormatterParams, ValueGetterParams, CellClassParams, ICellRenderer, ICellEditor, AggFunc, ExportParams, RowDataTransaction, SideBarDef, StatusPanelDef, } from './types';
+/**
+ * Create a grid inside the given element. Mirrors ag-grid's createGrid().
+ */
+export declare function createGrid(eGridDiv: HTMLElement, gridOptions: GridOptions): {
+    api: GridApi;
+    columnApi: ColumnApi;
+    grid: Grid;
+};
+/** Register custom cell renderers / editors (ag-grid module-style registry). */
+export declare function registerRenderer(name: string, factory: (params: any) => any): void;
+export declare function registerEditor(name: string, factory: (params: any) => any): void;
+export { CELL_RENDERERS, CELL_EDITORS, createSparklineSvg, formatNumberCommas };
+export { computeStickyGroupRows } from './render/stickyGroupRows';
+export { DEFAULT_LOCALE_TEXT } from './core/localeText';
+export { evaluateFormula, isFormula, tokenize, parse, FORMULA_FUNCTIONS, registerFormulaFunction } from './core/formulaEngine';
+export type { FormulaContext, FormulaValue } from './core/formulaEngine';
+export default Grid;
+export * from './gantt';
+export * from './personnel';
+export { createDetailDialog } from './components/detailDialog';
+export type { DetailDialogContent } from './components/detailDialog';

package/dist/types/personnel/component.d.ts

@@ -0,0 +1,20 @@
+import type { ScheduleItem, SchedulePerson } from './model';
+export interface PersonnelScheduleOptions {
+    people: SchedulePerson[];
+    items: ScheduleItem[];
+    today?: string;
+    title?: string;
+    workItemLabel?: string;
+    /** Use distinct keys to isolate saved views by application or workspace. */
+    viewStorageKey?: string;
+    onItemChange?: (item: ScheduleItem) => void;
+    onItemOpen?: (item: ScheduleItem) => void;
+}
+export interface PersonnelScheduleApi {
+    setData(people: SchedulePerson[], items: ScheduleItem[]): void;
+    getItems(): ScheduleItem[];
+    updateItem(id: string, changes: Partial<Omit<ScheduleItem, 'id'>>): void;
+    setPeople(ids: string[]): void;
+    destroy(): void;
+}
+export declare function createPersonnelSchedule(container: HTMLElement, options: PersonnelScheduleOptions): PersonnelScheduleApi;

package/dist/types/personnel/index.d.ts

@@ -0,0 +1,3 @@
+export { createPersonnelSchedule } from './component';
+export type { PersonnelScheduleApi, PersonnelScheduleOptions } from './component';
+export type { SchedulePerson, ScheduleItem } from './model';

package/dist/types/personnel/model.d.ts

@@ -0,0 +1,31 @@
+export interface SchedulePerson {
+    id: string;
+    name: string;
+    color?: string;
+}
+export interface ScheduleItem {
+    id: string;
+    personId: string;
+    name: string;
+    status: string;
+    node: string;
+    estimate: number;
+    start: string | null;
+    end: string | null;
+    color?: string;
+    parentId?: string;
+}
+export declare const dateNumber: (key: string) => number;
+export declare const dateKey: (n: number) => string;
+export declare const isScheduled: (item: ScheduleItem) => boolean;
+export declare function validateSchedule(people: SchedulePerson[], items: ScheduleItem[]): void;
+/** Interval packing keeps overlapping assignments on separate lanes. */
+export declare function scheduleLanes(items: ScheduleItem[], expanded?: boolean): Array<{
+    item: ScheduleItem;
+    lane: number;
+}>;
+export declare function scheduleStats(items: ScheduleItem[]): {
+    scheduled: number;
+    unscheduled: number;
+    estimate: number;
+};

package/dist/types/render/cellRenderers.d.ts

@@ -0,0 +1,30 @@
+import type { ICellEditor, ICellRenderer } from '../types';
+export declare function createSparklineSvg(values: number[] | Array<{
+    value: number;
+}>, width: number, height: number, options?: {
+    type?: 'line' | 'area' | 'bar';
+    direction?: 'horizontal' | 'vertical';
+    fill?: boolean;
+    tooltip?: {
+        enabled?: boolean;
+    };
+    axis?: {
+        type?: 'number' | 'category';
+        strokeWidth?: number;
+    };
+    pointsOfInterest?: {
+        show?: boolean;
+    };
+}): SVGElement;
+export declare const CELL_RENDERERS: Record<string, (params: any) => ICellRenderer | HTMLElement>;
+export declare function formatGroupValue(value: any): string;
+export declare const CELL_EDITORS: Record<string, (params: any) => ICellEditor>;
+export declare const ICON_CARET_RIGHT = "<svg viewBox=\"0 0 16 16\" width=\"14\" height=\"14\" fill=\"currentColor\"><path d=\"M6 4l4 4-4 4V4z\"/></svg>";
+export declare const ICON_CARET_DOWN = "<svg viewBox=\"0 0 16 16\" width=\"14\" height=\"14\" fill=\"currentColor\"><path d=\"M4 6l4 4 4-4H4z\"/></svg>";
+export declare const ICON_DRAG = "<svg viewBox=\"0 0 16 16\" width=\"14\" height=\"14\" fill=\"currentColor\"><circle cx=\"5\" cy=\"3\" r=\"1.4\"/><circle cx=\"11\" cy=\"3\" r=\"1.4\"/><circle cx=\"5\" cy=\"8\" r=\"1.4\"/><circle cx=\"11\" cy=\"8\" r=\"1.4\"/><circle cx=\"5\" cy=\"13\" r=\"1.4\"/><circle cx=\"11\" cy=\"13\" r=\"1.4\"/></svg>";
+export declare const ICON_MENU = "<svg viewBox=\"0 0 16 16\" width=\"14\" height=\"14\" fill=\"currentColor\"><circle cx=\"3\" cy=\"8\" r=\"1.4\"/><circle cx=\"8\" cy=\"8\" r=\"1.4\"/><circle cx=\"13\" cy=\"8\" r=\"1.4\"/></svg>";
+export declare const ICON_FILTER = "<svg viewBox=\"0 0 16 16\" width=\"14\" height=\"14\" fill=\"currentColor\"><path d=\"M1 2h14l-5.2 6v5.3L6.2 15V8L1 2z\"/></svg>";
+export declare const ICON_SORT_ASC = "<svg viewBox=\"0 0 16 16\" width=\"12\" height=\"12\" fill=\"currentColor\"><path d=\"M8 3l4.5 7h-9L8 3z\"/></svg>";
+export declare const ICON_SORT_DESC = "<svg viewBox=\"0 0 16 16\" width=\"12\" height=\"12\" fill=\"currentColor\"><path d=\"M8 13L3.5 6h9L8 13z\"/></svg>";
+export declare const ICON_ARROW_DOWN = "<svg viewBox=\"0 0 16 16\" width=\"12\" height=\"12\" fill=\"currentColor\"><path d=\"M8 12L3 5h10L8 12z\"/></svg>";
+export declare const ICON_CHECK = "<svg viewBox=\"0 0 16 16\" width=\"12\" height=\"12\" fill=\"currentColor\"><path d=\"M6 11.2L2.8 8l-1 1L6 13.2 14.6 4.6l-1-1L6 11.2z\"/></svg>";

package/dist/types/render/headerView.d.ts

@@ -0,0 +1,64 @@
+import type { Column, GridOptions } from '../types';
+import { EventService } from '../core/eventService';
+export interface HeaderContext {
+    options: GridOptions;
+    /** UI text lookup (localeText) */
+    t: (key: string) => string;
+    /** lazy accessors — the api does not exist yet when the header is created */
+    getApi?: () => any;
+    getFilterModel?: (colId: string) => any;
+    onFilterModelChange?: (column: Column, model: any) => void;
+    eventService: EventService;
+    getColumns: () => {
+        left: Column[];
+        center: Column[];
+        right: Column[];
+    };
+    getColumnModel: () => any;
+    getSortState: () => {
+        sortColumns: Column[];
+    };
+    onSortRequested: (column: Column, event: MouseEvent, multiSort: boolean) => void;
+    onColumnResized: (column: Column, width: number, finished: boolean) => void;
+    onColumnMoved: (fromColId: string, toColId: string | null) => void;
+    onColumnMenuClicked: (column: Column, eButton: HTMLElement) => void;
+    onFilterOpened: (column: Column, eButton: HTMLElement) => void;
+    isFilterActive: (column: Column) => boolean;
+    getQuickFilterText: () => string;
+    onFloatingFilterChanged: (column: Column, value: string) => void;
+    onHeaderCheckboxChanged: (column: Column, checked: boolean) => void;
+    onColumnPinnedRequested: (column: Column) => void;
+    isColumnMenuSuppressed: (column: Column) => boolean;
+    headerHeight: number;
+}
+export declare class HeaderView {
+    private ctx;
+    private eHeader;
+    private ePinnedLeftHeader;
+    private ePinnedRightHeader;
+    private eHeaderViewport;
+    private eHeaderContainer;
+    private eHeaderRow;
+    private eFloatingFiltersRow;
+    private eGroupRows;
+    private headerCells;
+    private customHeaderComponents;
+    private resizeState;
+    private dragState;
+    private lastWidths;
+    constructor(eHeader: HTMLElement, ctx: HeaderContext);
+    refresh(): void;
+    /** render spanning column-group header rows (one row per group depth) */
+    private renderGroupRows;
+    private renderSection;
+    private createHeaderCell;
+    private createFloatingFilter;
+    private updateSortIndicator;
+    /** update sort/filter visuals without rebuilding the DOM */
+    updateIndicators(): void;
+    private headerColumnIndex;
+    private layoutPositions;
+    setScrollLeft(left: number): void;
+    getHeaderCell(column: Column): HTMLElement | undefined;
+    getHeaderRow(): HTMLElement;
+}

package/dist/types/render/rowRenderer.d.ts

@@ -0,0 +1,190 @@
+import type { Column, GridOptions, RowNode } from '../types';
+import type { RowModel } from '../core/clientSideRowModel';
+import type { EventService } from '../core/eventService';
+import { escapeHtml } from '../core/utils';
+export interface RowRendererContext {
+    options: GridOptions;
+    eventService: EventService;
+    rowModel: RowModel;
+    getColumns: () => {
+        left: Column[];
+        center: Column[];
+        right: Column[];
+    };
+    getRowHeight: (node: RowNode) => number;
+    isNodeSelected: (node: RowNode) => boolean;
+    isRowSelectable: (node: RowNode) => boolean;
+    getRowClass: (node: RowNode) => string;
+    getRowStyle: (node: RowNode) => Record<string, any>;
+    onCellClicked: (params: any) => void;
+    onCellDoubleClicked: (params: any) => void;
+    onCellMouseDown: (params: any) => void;
+    onCellContextMenu: (params: any) => void;
+    onRowClicked: (params: any) => void;
+    onRowDoubleClicked: (params: any) => void;
+    onRowGroupClicked?: (node: RowNode) => void;
+    onViewportKeyDown: (event: KeyboardEvent) => void;
+    onViewportScroll?: () => void;
+    getCellText: (column: Column, node: RowNode) => string;
+    renderDetailRow?: (node: RowNode, eRow: HTMLElement) => {
+        eDetail: HTMLElement;
+        height: number;
+    } | null;
+    rowDragEnabled: () => boolean;
+    onRowDragStart?: (node: RowNode, eGui: HTMLElement, event: MouseEvent) => void;
+    getNote?: (rowNodeId: string, colId: string, colDefNote: any, params: any) => string | undefined;
+    onNoteClick?: (rowNodeId: string, colId: string, anchor: HTMLElement) => void;
+    rowNumberOffset?: () => number;
+}
+export declare class RowRenderer {
+    private ctx;
+    private eRoot;
+    private eHeader;
+    private eBody;
+    private ePinnedLeft;
+    private ePinnedRight;
+    private ePinnedLeftInner;
+    private ePinnedRightInner;
+    private eViewport;
+    private eContainer;
+    private eFloatingTop;
+    private eFloatingBottom;
+    private eFloatingTopLeft;
+    private eFloatingTopRight;
+    private eFloatingBottomLeft;
+    private eFloatingBottomRight;
+    private eStickyTop;
+    private eStickyLeft;
+    private eStickyCenter;
+    private eStickyRight;
+    private eRangeOverlay;
+    private rowComps;
+    private stickyComps;
+    private hoveredRowId;
+    private rowOffsets;
+    private rowInfos;
+    private totalHeight;
+    private lastScrollTop;
+    private lastRange;
+    private firstRendered;
+    private heightVersion;
+    constructor(eRoot: HTMLElement, eHeader: HTMLElement, ctx: RowRendererContext);
+    /**
+     * Forward wheel gestures from the non-scrollable sections (pinned column
+     * areas, sticky rows, floating rows, header) to the scrolling viewport.
+     */
+    private onSectionWheel;
+    private onBodyMouseOver;
+    private onBodyMouseLeave;
+    private setRowHovered;
+    getViewport(): HTMLElement;
+    getBody(): HTMLElement;
+    getContainer(): HTMLElement;
+    getRowComps(): Map<string, RowComp>;
+    setRangeOverlay(eOverlay: HTMLElement | null): void;
+    getHeaderElement(): HTMLElement;
+    /** recompute row offsets (variable heights) */
+    private recomputeOffsets;
+    /** level and group flag of the row at the given index */
+    private rowInfoAt;
+    private hasVariableHeights;
+    private getFixedRowHeight;
+    private getRowHeightForIndex;
+    /** full refresh: rows were added/removed/reordered */
+    refreshRows(): void;
+    /** called when heights may have changed (e.g. detail auto height) */
+    invalidateRowHeights(): void;
+    redrawAllRows(): void;
+    private renderPinnedRows;
+    /** refresh cell values for given rows (or all rendered) */
+    refreshCells(params?: {
+        rowNodes?: RowNode[];
+        columns?: Array<string | Column>;
+        force?: boolean;
+        flash?: boolean;
+    }): void;
+    flashCells(params: {
+        rowNodes?: RowNode[];
+        columns?: Array<string | Column>;
+    }): void;
+    redrawRows(params?: {
+        rowNodes?: RowNode[];
+    }): void;
+    private rowCompKey;
+    private findRowIndex;
+    private onScroll;
+    /** keep the pinned column sections aligned with the vertical scroll position */
+    private syncPinnedScroll;
+    /**
+     * The centre slice of the sticky rows scrolls horizontally with the columns.
+     * The translation is applied to the rows inside the slice, not to the slice
+     * itself: moving the slice would shift its clipping window over the pinned
+     * column area and hide the cells there.
+     */
+    private syncStickyHorizontal;
+    getVerticalScrollTop(): number;
+    setVerticalScrollTop(top: number): void;
+    getHorizontalScrollLeft(): number;
+    setHorizontalScrollLeft(left: number): void;
+    /**
+     * Re-renders the group rows that stick to the top of the viewport. A group
+     * row sticks when it has scrolled past the top while one of its own rows is
+     * still visible; the stick rows are the ancestor chain of the first visible
+     * row, stacked shallowest-first. Returns the set of node ids now shown in the
+     * sticky overlay so the caller can skip their normal row comps.
+     */
+    private syncStickyGroupRows;
+    renderVisibleRows(force?: boolean): void;
+    private findIndexAtPixel;
+    /** scroll so that the given row index is visible */
+    ensureIndexVisible(index: number, position?: 'top' | 'bottom' | 'middle'): void;
+    getFirstVisibleRowIndex(): number;
+    getLastVisibleRowIndex(): number;
+    ensureColumnVisible(column: Column, position?: 'start' | 'end' | 'middle'): void;
+    /** pixel x of a cell for a given column and row index */
+    getCellPosition(rowIndex: number, column: Column): {
+        top: number;
+        left: number;
+        height: number;
+        width: number;
+    };
+    getRowOffsets(): number[];
+    getTotalHeight(): number;
+    private findCellFromEvent;
+    private getRowIndexForNode;
+    private onClick;
+    private onDoubleClick;
+    private onMouseDown;
+    private onContextMenu;
+    destroy(): void;
+}
+declare class RowComp {
+    private ctx;
+    private node;
+    private rowHeight;
+    private heightVersion;
+    private eLeft;
+    private eCenter;
+    private eRight;
+    private cellComps;
+    private pinned;
+    constructor(ctx: RowRendererContext, node: RowNode, leftColumns: Column[], centerColumns: Column[], rightColumns: Column[], rowHeight: number, heightVersion: number);
+    isPinned(): boolean;
+    /** marks the row as a sticky group row (rendered in the sticky overlay) */
+    setSticky(sticky: boolean): void;
+    /** hover highlight spans every section of the row */
+    setHovered(hovered: boolean): void;
+    getNode(): RowNode;
+    private createRowElement;
+    private cellColumnIndex;
+    private createCell;
+    private updateCellContent;
+    refreshCells(columns?: Column[], force?: boolean, flash?: boolean): void;
+    appendTo(leftContainer: HTMLElement, centerContainer: HTMLElement, rightContainer: HTMLElement): void;
+    ensureVisibleCells(): void;
+    setTop(top: number): void;
+    getCenterElement(): HTMLElement | null;
+    getCellElements(): HTMLElement[];
+    destroy(): void;
+}
+export { escapeHtml };