ia-table 0.13.2 → 0.14.0

package/dist/pivot.d.ts

@@ -0,0 +1,2153 @@
+import { CSSProperties } from 'react';
+import { default as default_2 } from 'react';
+import { MutableRefObject } from 'react';
+
+declare const ACTION_TYPES: {
+    readonly SET_DATA: "SET_DATA";
+    readonly SET_FILTERED_DATA: "SET_FILTERED_DATA";
+    readonly SET_COLUMNS: "SET_COLUMNS";
+    readonly SET_SORT: "SET_SORT";
+    readonly SET_PAGE: "SET_PAGE";
+    readonly SET_PAGE_SIZE: "SET_PAGE_SIZE";
+    readonly SET_SELECTED_ROWS: "SET_SELECTED_ROWS";
+    readonly SET_COLUMN_FILTER: "SET_COLUMN_FILTER";
+    readonly REMOVE_COLUMN_FILTER: "REMOVE_COLUMN_FILTER";
+    readonly APPLY_FILTERS: "APPLY_FILTERS";
+    readonly TOGGLE_GROUP_EXPANSION: "TOGGLE_GROUP_EXPANSION";
+    readonly SET_FIELD_KEYS: "SET_FIELD_KEYS";
+    readonly UPDATE_ROW_DATA: "UPDATE_ROW_DATA";
+    readonly SELECTION_CHANGED_HANDLED: "SELECTION_CHANGED_HANDLED";
+    readonly FREEZE_COLUMN: "FREEZE_COLUMN";
+    readonly UNFREEZE_COLUMN: "UNFREEZE_COLUMN";
+    readonly PIN_COLUMN_RIGHT: "PIN_COLUMN_RIGHT";
+    readonly UNPIN_COLUMN_RIGHT: "UNPIN_COLUMN_RIGHT";
+    readonly SET_COLUMN_WIDTH: "SET_COLUMN_WIDTH";
+    readonly SET_COLUMNS_WIDTH: "SET_COLUMNS_WIDTH";
+    readonly SHOW_NOTIFICATION: "SHOW_NOTIFICATION";
+    readonly HIDE_NOTIFICATION: "HIDE_NOTIFICATION";
+    readonly AUTOSIZE_COLUMNS_REQUESTED: "AUTOSIZE_COLUMNS_REQUESTED";
+    readonly TOGGLE_FREEZE_COLUMN: "TOGGLE_FREEZE_COLUMN";
+    readonly REORDER_COLUMNS: "REORDER_COLUMNS";
+    readonly SET_PREV_ACTION: "SET_PREV_ACTION";
+    readonly SET_CHECK_CONFIGURATION: "SET_CHECK_CONFIGURATION";
+    readonly SET_IS_SELECT_ALL_RECORDS: "SET_IS_SELECT_ALL_RECORDS";
+    readonly BATCH_UPDATE: "BATCH_UPDATE";
+    readonly UPDATE_ROW_DATA_OBJECT: "UPDATE_ROW_DATA_OBJECT";
+    readonly TOGGLE_COLUMN_VISIBILITY: "TOGGLE_COLUMN_VISIBILITY";
+    readonly TOGGLE_MASTER_DETAIL: "TOGGLE_MASTER_DETAIL";
+    readonly SET_DETAIL_RENDERER: "SET_DETAIL_RENDERER";
+    readonly SET_MASTER_DETAIL_CONFIG: "SET_MASTER_DETAIL_CONFIG";
+    readonly ADD_EVENT_LISTENER: "ADD_EVENT_LISTENER";
+    readonly REMOVE_EVENT_LISTENER: "REMOVE_EVENT_LISTENER";
+    readonly TOGGLE_COLUMN_GROUP: "TOGGLE_COLUMN_GROUP";
+    readonly SET_EXPANDED_COLUMN_GROUPS: "SET_EXPANDED_COLUMN_GROUPS";
+    readonly ENABLE_ROW_SPAN: "ENABLE_ROW_SPAN";
+    readonly SET_ROW_SPAN_COLUMN: "SET_ROW_SPAN_COLUMN";
+    readonly MOVE_ROW: "MOVE_ROW";
+    readonly PREVIEW_ROW_MOVE: "PREVIEW_ROW_MOVE";
+    readonly RESET_ROW_PREVIEW: "RESET_ROW_PREVIEW";
+    readonly SET_PINNED_TOP_ROWS: "SET_PINNED_TOP_ROWS";
+    readonly SET_PINNED_BOTTOM_ROWS: "SET_PINNED_BOTTOM_ROWS";
+    readonly TOGGLE_ROW_GROUP: "TOGGLE_ROW_GROUP";
+    readonly LOAD_ROW_GROUP_DATA: "LOAD_ROW_GROUP_DATA";
+    readonly SET_ROW_GROUP_DATA: "SET_ROW_GROUP_DATA";
+    readonly SET_ROW_GROUP_LOADING: "SET_ROW_GROUP_LOADING";
+    readonly SET_ROW_GROUP_PAGINATION: "SET_ROW_GROUP_PAGINATION";
+    readonly CLEAR_ROW_GROUP_CACHE: "CLEAR_ROW_GROUP_CACHE";
+    readonly REFRESH_ROW_GROUP_DATA: "REFRESH_ROW_GROUP_DATA";
+    readonly SET_API: "SET_API";
+    readonly SET_COLUMN_MAP: "SET_COLUMN_MAP";
+    readonly SET_NUMBER_FORMAT: "SET_NUMBER_FORMAT";
+    readonly SET_HEADER_ROW_HEIGHT: "SET_HEADER_ROW_HEIGHT";
+    readonly CLEANUP_TABLE_RESOURCES: "CLEANUP_TABLE_RESOURCES";
+    readonly ADD_TABLE_INSTANCE: "ADD_TABLE_INSTANCE";
+    readonly ROW_DRAG_MANAGED: "ROW_DRAG_MANAGED";
+    readonly INFINITE_SCROLL: "INFINITE_SCROLL";
+    readonly SET_INITIAL_EXPANDED_COLUMN_GROUPS: "SET_INITIAL_EXPANDED_COLUMN_GROUPS";
+    readonly SET_SERVER_SIDE: "SET_SERVER_SIDE";
+    readonly SET_TABLE_API: "SET_TABLE_API";
+    readonly EXPAND_COLLAPSE_ALL_COLUMNS: "EXPAND_COLLAPSE_ALL_COLUMNS";
+    readonly SET_SMART_GRID_MENU_OPTIONS: "SET_SMART_GRID_MENU_OPTIONS";
+    readonly ROW_GROUP_CACHE_ENABLE: "ROW_GROUP_CACHE_ENABLE";
+    readonly DETAIL_RENDERER_TABLE: "DETAIL_RENDERER_TABLE";
+    readonly IS_SAVE_VIEW_ENABLED: "IS_SAVE_VIEW_ENABLED";
+    readonly SAVE_VIEW_CALLBACKS: "SAVE_VIEW_CALLBACKS";
+    readonly SET_ROW_HEIGHT: "SET_ROW_HEIGHT";
+    readonly EXPAND_COLLAPSE_ALL_ROWS: "EXPAND_COLLAPSE_ALL_ROWS";
+    readonly SET_LOADING: "SET_LOADING";
+    readonly SET_REFS: "SET_REFS";
+    readonly SET_TABLE_ID: "SET_TABLE_ID";
+    readonly SET_IS_SINGLE_SELECT: "SET_IS_SINGLE_SELECT";
+    readonly SET_DEFAULT_COL_DEF: "SET_DEFAULT_COL_DEF";
+    readonly SET_SELECTABLE: "SET_SELECTABLE";
+    readonly SET_DISABLE_SELECT_ALL_RECORDS_OPTION: "SET_DISABLE_SELECT_ALL_RECORDS_OPTION";
+    readonly SET_COLUMN_BUFFER_SIZE: "SET_COLUMN_BUFFER_SIZE";
+    readonly SET_LAZY_LOAD_CELL_RENDERER: "SET_LAZY_LOAD_CELL_RENDERER";
+    readonly SET_HAS_SPLIT_RENDERER: "SET_HAS_SPLIT_RENDERER";
+    readonly SET_HAS_SPLIT_RENDERER_KEYS: "SET_HAS_SPLIT_RENDERER_KEYS";
+    readonly SET_REMOVE_SELECTION_ON_OPERATION: "SET_REMOVE_SELECTION_ON_OPERATION";
+};
+
+declare class InfiniteBlock {
+    static STATE_WAITING_TO_LOAD: string;
+    static STATE_LOADING: string;
+    static STATE_LOADED: string;
+    static STATE_FAILED: string;
+    static MAX_EMPTY_BLOCKS_TO_KEEP: number;
+    id: number;
+    parentCache: SmartGridInfiniteCacheInterface;
+    parent: SmartGridInfiniteCacheInterface;
+    params: SmartGridBlockParams;
+    state: string;
+    version: number;
+    lastAccessed: number;
+    rows: Record<number, SmartGridRowData>;
+    infiniteCache: SmartGridInfiniteCacheInterface;
+    startRow: number;
+    endRow: number;
+    rowNodes: SmartGridBlockRowNode[];
+    loadStartedAt?: number;
+    _targetPage?: number;
+    _responseMetadata?: SmartGridResponseMetadata;
+    _processingInProgress?: boolean;
+    _actualRowCount?: number;
+    _inactiveForPageTransition?: boolean;
+    constructor(id: number, parentCache: SmartGridInfiniteCacheInterface, params: SmartGridBlockParams);
+    /**
+     * Create empty row nodes
+     */
+    createRowNodes(): void;
+    /**
+     * Gets the block ID
+     */
+    getId(): number;
+    /**
+     * Gets the current state of the block
+     */
+    getState(): string;
+    /**
+     * Gets the start row index of this block
+     */
+    getStartRow(): number;
+    /**
+     * Gets the end row index of this block
+     */
+    getEndRow(): number;
+    /**
+     * Gets the current version of this block
+     * Used to ignore responses from outdated requests
+     */
+    getVersion(): number;
+    /**
+     * Gets the last time this block was accessed
+     * Used for LRU cache management
+     */
+    getLastAccessed(): number;
+    /**
+     * Gets a row node at the specified index
+     * Updates the last accessed time for LRU cache management
+     */
+    getRow(rowIndex: number, dontTouchLastAccessed?: boolean): SmartGridBlockRowNode | null;
+    /**
+     * Load data from datasource
+     */
+    loadFromDatasource(): void;
+    /**
+     * Process the response from the server
+     */
+    processServerResponse(rows: SmartGridRowData[], lastRow?: number, lastRowIndexKnown?: boolean): void;
+    /**
+     * Initialize block from server response
+     */
+    initBlockFromServerResponse(rows: SmartGridRowData[]): void;
+    /**
+     * Sets data and ID for a row node
+     */
+    setDataAndId(rowNode: SmartGridBlockRowNode, data: SmartGridRowData, rowIndex: number): void;
+    /**
+     * Set state to waiting to load
+     */
+    setStateWaitingToLoad(): void;
+    /**
+     * Iterates through each row node
+     */
+    forEachNode(callback: (rowNode: SmartGridBlockRowNode, index: number) => void): void;
+    /**
+     * Returns block state as JSON for debugging
+     */
+    getBlockStateJson(): SmartGridBlockStateJson;
+    /**
+     * Clean up row nodes before the block is destroyed
+     */
+    destroyRowNodes(): void;
+    /**
+     * Determines the index of the last row that has data
+     */
+    getLastRow(): number;
+    isBlockBeyondEndOfScope(): boolean;
+    getRowNode(rowIndex: number): SmartGridBlockRowNode | null;
+    pageLoaded(version: number): void;
+    loadFailed(version?: number): void;
+    getRowNodes(): SmartGridBlockRowNode[];
+    /**
+     * Gets the number of rows in this block that have data
+     */
+    getRowCount(): number;
+}
+
+declare class InfiniteCache {
+    static PURGE_STRATEGY_LRU: string;
+    static PURGE_STRATEGY_FURTHEST_FROM_VIEWPORT: string;
+    static PURGE_STRATEGY_MEMORY_OPTIMIZED: string;
+    params: SmartGridCacheParams;
+    blocks: Record<number, InfiniteBlock>;
+    blockCount: number;
+    rowCount: number;
+    lastRowIndexKnown: boolean;
+    eventListeners: Record<string, Array<(event: SmartGridCacheEvent) => void>>;
+    lastRequestedPage: number;
+    analytics: SmartGridCacheAnalytics_2;
+    rowsMaxIndex?: number;
+    _currentRequestedPage?: number;
+    _blockCreationQueue?: Set<number>;
+    constructor(params: Partial<SmartGridCacheParams>);
+    /**
+     * Gets a row at a specific index, creating blocks as needed
+     */
+    getRow(rowIndex: number, dontCreateBlock?: boolean): SmartGridBlockRowNode | undefined;
+    /**
+     * Creates a new block to manage a range of rows
+     */
+    createBlock(blockId: number): InfiniteBlock;
+    /**
+     * Get row indexes for a specific block
+     */
+    getRowIndexesForBlock(blockId: number): number[];
+    /**
+     * Notify about block state changes
+     */
+    notifyBlockStateChanged(blockId: number, state: string, rowIndexes: number[]): void;
+    /**
+     * Gets a block by ID
+     */
+    getBlock(blockId: number): InfiniteBlock | undefined;
+    /**
+     * Gets the current row count
+     */
+    getRowCount(): number;
+    /**
+     * Checks if total row count is known or virtual
+     */
+    isLastRowIndexKnown(): boolean;
+    /**
+     * Sets the row count and updates lastRowIndexKnown flag
+     */
+    setRowCount(rowCount: number, lastRowIndexKnown?: boolean): void;
+    /**
+     * Count the total number of rows with data across all blocks in the cache
+     */
+    getTotalCachedRowCount(): {
+        totalRows: number;
+        rowsWithData: number;
+        blockCount: number;
+        blocksWithData: Array<{
+            blockId: number;
+            rowCount: number;
+        }>;
+    };
+    /**
+     * Callback for when a block finishes loading
+     */
+    pageLoaded(block: InfiniteBlock, lastRow?: number): void;
+    /**
+     * Print all cached data from all blocks
+     * Shows a complete snapshot of what's actually in the cache
+     */
+    printAllCachedData(): void;
+    /**
+     * Check and update row count based on loaded block data
+     */
+    checkRowCount(block: InfiniteBlock, lastRow: number | boolean | null): void;
+    /**
+     * Gets all blocks in the cache, sorted by ID
+     */
+    getBlocksInOrder(): InfiniteBlock[];
+    /**
+     * Removes expired blocks from the cache using configured strategy
+     */
+    purgeBlocksIfNeeded(blockToExclude: InfiniteBlock): void;
+    /**
+     * Sorts blocks based on the specified strategy
+     */
+    sortBlocksByStrategy(blocks: InfiniteBlock[], strategy: string): InfiniteBlock[];
+    /**
+     * Compares two blocks based on the specified strategy
+     * Returns a negative number if a should be removed before b
+     */
+    compareBlocksByStrategy(a: InfiniteBlock, b: InfiniteBlock, strategy: string): number;
+    /**
+     * Sort blocks by distance from viewport (for furthest-from-viewport strategy)
+     */
+    sortBlocksByDistanceFromViewport(blocks: InfiniteBlock[]): void;
+    /**
+     * Sort blocks using the memory-optimized strategy
+     * This uses a combined heuristic considering:
+     * 1. Block access recency
+     * 2. Distance from viewport
+     * 3. Block data size (if available)
+     */
+    sortBlocksByMemoryOptimized(blocks: InfiniteBlock[]): void;
+    /**
+     * Checks if a block is currently in the visible viewport
+     */
+    isBlockCurrentlyDisplayed(block: InfiniteBlock): boolean;
+    /**
+     * Removes a block from the cache and destroys it
+     */
+    removeBlockFromCache(blockToRemove: InfiniteBlock): void;
+    /**
+     * Gets all row nodes in a range (used for selection)
+     */
+    getRowNodesInRange(firstIndex: number, lastIndex: number): SmartGridBlockRowNode[];
+    /**
+     * Iterates over all row nodes in the cache
+     */
+    forEachNodeDeep(callback: (rowNode: SmartGridBlockRowNode, index: number) => void): void;
+    /**
+     * Purges the entire cache
+     */
+    purgeCache(options?: Record<string, unknown>): void;
+    /**
+     * Refreshes the cache without purging it completely
+     */
+    refreshCache(): void;
+    /**
+     * Refreshes the cache partially, preserving specified fields
+     */
+    refreshCachePartial(preserveFields?: string[]): void;
+    /**
+     * Sets view port range
+     */
+    setViewportRange(startRow: number, endRow: number): void;
+    /**
+     * Returns all data from all blocks as a flattened array
+     */
+    /**
+     * Ensures blocks are loaded for the specified range
+     */
+    ensureBlocksLoadedForRange(startRow: number, endRow: number): void;
+    /**
+     * Adds an event listener
+     */
+    addEventListener(type: string, listener: (event: SmartGridCacheEvent) => void): void;
+    /**
+     * Removes an event listener
+     */
+    removeEventListener(type: string, listener: (event: SmartGridCacheEvent) => void): void;
+    /**
+     * Dispatches an event to all listeners
+     */
+    dispatchEvent(event: SmartGridCacheEvent): void;
+    /**
+     * Returns cache state for debugging
+     */
+    getCacheState(): SmartGridCacheState;
+    /**
+     * Returns analytics data
+     */
+    getAnalytics(): SmartGridCacheAnalytics_2 & {
+        uptime: number;
+        hitRatio: number;
+        avgLoadTime: number;
+        hitsPerSecond: number;
+        missesPerSecond: number;
+        blocksPurgedPerSecond: number;
+        bytesPerSecond: number;
+    };
+    /**
+     * Resets analytics data
+     */
+    resetAnalytics(): void;
+    /**
+     * Save cache state to persistence if enabled
+     */
+    persistCacheIfEnabled(): void;
+    /**
+     * Restore cache from persistence
+     */
+    restoreFromPersistence(): void;
+    /**
+     * Clear persisted cache state
+     */
+    clearPersistence(): void;
+    /**
+     * Sets the purge strategy
+     */
+    setPurgeStrategy(strategy: string): void;
+    isBlockInCreationQueue(blockId: number): boolean;
+    /**
+     * Logs a summary of the current cache state
+     * Can be called from outside to check the cache status at any time
+     */
+    logCacheSummary(): {
+        totalRows: number;
+        rowsWithData: number;
+        blockCount: number;
+        blocksWithData: Array<{
+            blockId: number;
+            rowCount: number;
+        }>;
+    };
+    isBlockCached(blockId: number): boolean;
+    getBlockData(blockId: number): (SmartGridRowData | null)[] | null;
+    getAllCachedData(): SmartGridRowData[];
+    updatePageData(pageNo: number, updatedData: SmartGridRowData[], notifyChanges?: boolean, options?: Record<string, unknown>): {
+        success: boolean;
+        pageNo: number;
+        updatedRows: number;
+        errors: string[];
+    };
+    updateBlockData(blockId: number, newData: SmartGridRowData[], notifyChanges?: boolean): {
+        success: boolean;
+        blockId: number;
+        updatedRows: number;
+        errors: string[];
+    };
+    updateWholeData(wholeData: SmartGridRowData[], pageSize: number): SmartGridUpdateDataReturnType;
+}
+
+export declare const PivotWrapper: React.FC<SmartGridPivotWrapperProps>;
+
+declare interface RowGroupParams {
+    page: number;
+    pageSize: number;
+    groupId?: string;
+    noDataUpdate?: boolean;
+}
+
+export declare type SmartGridAggregationType = "sum" | "count" | "avg" | "min" | "max";
+
+declare interface SmartGridAPI {
+    getInfiniteRowModel: () => SmartGridInfiniteRowModel | null;
+    getInfiniteCache: () => SmartGridInfiniteCache | null;
+    getModel: () => SmartGridTableModel;
+    onCellValueChanged: (params: SmartGridCellValueChangedParams) => void;
+    getPrevAction: () => string;
+    setPrevAction: (value: string) => void;
+    getCheckConfiguration: () => SmartGridCheckConfiguration[];
+    setCheckConfiguration: (config: SmartGridCheckConfiguration[]) => void;
+    addToCheckConfiguration: (item: SmartGridCheckConfiguration) => void;
+    getIsSelectAllRecords: () => boolean;
+    setIsSelectAllRecords: (value: boolean) => void;
+    getSelectedRows: () => SmartGridRowData[];
+    setSelectedRows: (rowIds: (string | number)[]) => void;
+    clearSelection: () => void;
+    selectAll: () => void;
+    refreshCells: () => void;
+    getCache: () => SmartGridInfiniteCache | null;
+    getCacheState: () => SmartGridCacheState_2 | null;
+    getInfiniteCacheInstance: () => SmartGridInfiniteCache | null;
+    refreshServerSideStore: (options?: SmartGridRefreshOptions) => void;
+    getCachedBlockData: () => SmartGridCachedBlockData;
+    logCacheSummary: () => void | null;
+    getCachedRowById: (id: string | number) => SmartGridRowData | null;
+    getRowNode: (key: string | number) => Partial<SmartGridRowNode> | null;
+    setVisibleRange: (startRow: number, endRow: number) => void;
+    refreshCache: (options?: SmartGridRefreshOptions) => boolean;
+    deselectAll: () => void;
+    getRenderedNodes: () => SmartGridDisplayedRowNode[];
+    gridOptionsWrapper: {
+        gridOptions: SmartGridOptions;
+    };
+    getDisplayedRowAtIndex: (index: number, wholeData?: SmartGridRowData[], api?: Partial<SmartGridAPI>) => SmartGridDisplayedRowAtIndex | null;
+    getTableWidth: () => number;
+    sizeColumnsToFit: () => void;
+    setRowData: (newData: SmartGridRowData[]) => boolean | void;
+    forEachNode: (callback: (node: SmartGridRowNode, index: number) => void) => void;
+    getColumnDefs: () => SmartGridColumnDefinition[];
+    getAllColumns: () => SmartGridColumnDefinition[];
+    setColumnDefs: (newColumns: SmartGridColumnDefinition) => void;
+    addEventListener: (event: string, listener: Function, once?: boolean) => void;
+    removeEventListener: (event: string, listener: Function) => void;
+    getPinnedTopRow: () => SmartGridRowData[] | null;
+    setPinnedTopRowData: (rows: SmartGridRowData[]) => void;
+    getPinnedBottomRow: () => SmartGridRowData[] | null;
+    setPinnedBottomRowData: (rows: SmartGridRowData[]) => void;
+    getRowData: (params: SmartGridGetRowDataParams, columnName: string) => string | number | boolean;
+    tableId: string;
+    getFocusedCell: () => SmartGridFocusedCell | null;
+    getSelectedCells: () => SmartGridSelectedCell[];
+    getAllDisplayedColumns: () => SmartGridDisplayedColumn[];
+    getDisplayedRowCount: () => number;
+    setFocusedCell: (rowIndex: number, colKey: SmartGridColumnDefinition | string | number) => boolean;
+    ensureColumnVisible: (colKey: SmartGridColumnDefinition | string | number) => boolean;
+    getColumnByField: (fieldName: string) => SmartGridColumnDefinition | null;
+    getTableInstance: () => SmartGridTableInstance | undefined;
+    getFilterModel: () => SmartGridFilterModel | Record<string, SmartGridFilterModel[]>;
+    setFilterModel: (field: string, rules: SmartGridFilterModel) => void;
+    getTableDispatcher: () => (action: SmartGridDisptach) => void;
+    getTableStateContext: () => SmartGridStateContext;
+    showNotification: (notification: SmartGridNotification) => void;
+    hideNotification: () => void;
+    applySearch: () => void;
+    getCurrentPageData: () => SmartGridRowData[];
+    getWholeTableData: () => SmartGridRowData[];
+    flashCells: () => void;
+    redrawRows: () => void;
+    refreshClientSideRowModel: () => void;
+    resetRecentSearchChanges: () => void;
+    onFilterChanged: () => void;
+    onRowDataChanged?: (params: any) => void;
+    getRowGroupState?: () => SmartGridRowGroupState;
+    setRowGroupLoading?: (groupId: string, isLoading: boolean) => void;
+    setRowGroupPagination?: (groupId: string, pagination: SmartGridRowGroupStatePagination) => void;
+    setRowGroupData?: (groupId: string, data: SmartGridRowData[], append?: boolean) => void;
+    rowRenderer?: {
+        firstRenderedRow: number;
+        lastRenderedRow: number;
+        setRenderedRange: (start: number, end: number) => void;
+    };
+    columnApi?: SmartGridAPI;
+    dispatchEvent?: (eventType: string, eventData: Record<string, unknown>) => void;
+    toggleRowGroup?: (groupId: string, rowIndex: number, { fieldName, value }: {
+        fieldName: string;
+        value: unknown;
+    }) => void;
+    setServerSideDataSource: (dataSource: SmartGridServerSideDataSource, resetCache?: boolean) => void;
+    updateSmartGridTableData: (wholeData: SmartGridRowData[]) => void;
+    downloadSmartGridExcel: (fileName?: string, visibleOnly?: boolean) => void;
+    downloadSmartGridCSV: (fileName?: string, visibleOnly?: boolean) => void;
+}
+
+declare interface SmartGridBaseColumnDefinition {
+    field?: string;
+    groupId?: string;
+    headerName?: string;
+    column_name?: string;
+    label?: string;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    hide?: boolean;
+    hidden?: boolean;
+    pinned?: SmartGridFrozenState;
+    is_frozen?: boolean;
+    children?: SmartGridColumnDefinition[];
+    parent_id?: (string | number)[];
+    type?: string;
+    cellDataType?: string;
+    valueFormatter?: ((params: SmartGridValueFormatterParams) => string) | SmartGridValueFormatterConfig | undefined;
+    valueGetter?: (params: SmartGridValueGetterParams) => unknown;
+    leftTotalWidth?: number;
+    originalWidth?: number;
+    defaultWidth?: number;
+    isAutoWidth?: boolean;
+    filterable?: boolean;
+    isSortable?: boolean;
+    is_sortable?: boolean;
+    resizable?: boolean;
+    align?: "left" | "center" | "right";
+    cellRenderer?: string | ((params: SmartGridCellRenderer) => JSX.Element);
+    cellRendererParams?: SmartGridCellRendererParams;
+    cellClassName?: string;
+    cellStyle?: {
+        textAlign?: "left" | "center" | "right";
+        [key: string]: unknown;
+    };
+    autoHeight?: boolean;
+    wrapHeaderText?: boolean;
+    editable?: boolean;
+    is_editable?: boolean;
+    is_disabled?: boolean;
+    is_searchable?: boolean;
+    isSearchable?: boolean;
+    advanceSearchEnabled?: boolean;
+    sortable?: boolean;
+    rowGroup?: boolean;
+    enableRowGroup?: boolean;
+    rowGroupIndex?: number;
+    aggFunc?: string;
+    columnGroupShow?: "open" | "closed" | undefined | null;
+    originalIndex?: number;
+    parentColumns?: string[];
+    hasChildren?: boolean;
+    hasAnyFrozenChildren?: boolean;
+    hasAnyRightPinnedChildren?: boolean;
+    isChildWithoutParent?: boolean;
+    colorClass?: string;
+    isLeaf?: boolean;
+    isStandalone?: boolean;
+    isWithEmptyHeaderName?: boolean;
+    isParentWithChildEmptyHeaderName?: boolean;
+    path?: string[];
+    pathIdentifier?: string;
+    parentField?: string | null;
+    value?: string | number;
+    dimension_type?: string;
+    originalFields?: string[];
+    colId?: string;
+    colSpan?: number;
+    rowSpan?: number;
+    comparator?: (valueA: unknown, valueB: unknown, nodeA: SmartGridRowData, nodeB: SmartGridRowData, sortModel: SmartGridSortModel | SmartGridSortModel[]) => number;
+    headerTooltip?: string;
+    filter?: string | boolean;
+    filterParams?: {
+        filterOptions?: string[];
+        textCustomComparator?: (filter: string, value: unknown, filterText: string) => boolean;
+        numberCustomComparator?: (filter: number, value: unknown) => boolean;
+        dateCustomComparator?: (filterLocalDateAtMidnight: Date, cellValue: string) => number;
+        comparator?: (filterValue: unknown, cellValue: unknown) => boolean;
+        [key: string]: unknown;
+    };
+    order_of_display?: number;
+    is_hidden?: boolean;
+    formatter?: string | null;
+    accessor?: string;
+    id?: string;
+    required?: boolean;
+    sub_headers?: SmartGridColumnDefinition[];
+    extra?: {
+        width?: number;
+        is_grouping_key?: boolean;
+        is_disabled?: boolean;
+        isDisabled?: boolean;
+        columnGroupShow?: "open" | "closed";
+        is_multi?: boolean;
+        options_column?: string;
+        aggregation_func?: SmartGridSelectOption[];
+        [key: string]: unknown;
+    };
+    headerComponent?: default_2.FC<SmartGridHeaderStyleParams>;
+    headerStyle?: (params: SmartGridHeaderStyleParams) => CSSProperties;
+    tooltipValueGetter?: (params: SmartGridTooltipGetterParams) => string;
+    cellRendererLazyType?: string;
+    originalPath?: string[] | null;
+    isReorderedColumn?: boolean | null;
+    processCellForClipboard?: (params: SmartGridCellRendererParams) => string;
+    pivotAggregation?: "sum" | "count" | "avg" | "min" | "max";
+    pivotFilterValue?: string;
+    pivotFilterMode?: "value" | "condition";
+    pivotFilterCondition?: string;
+    [key: string]: unknown;
+}
+
+/** Block context */
+declare interface SmartGridBlockContext {
+    updateData?: (rows: SmartGridRowData[], blockId: number, metadata?: SmartGridResponseMetadata) => void;
+    tableContextRef?: {
+        current?: {
+            state?: {
+                expandedChildRows?: Record<string, {
+                    childRowsCount: number;
+                }>;
+            };
+        };
+    };
+    infiniteCache?: SmartGridInfiniteCacheInterface;
+    [key: string]: unknown;
+}
+
+/** Datasource interface */
+declare interface SmartGridBlockDatasource {
+    getRows: (params: SmartGridDatasourceGetRowsParams) => void;
+}
+
+/** Block params */
+declare interface SmartGridBlockParams {
+    updatedPageSizeRef: SmartGridPageSizeRef_2;
+    pageSize?: number;
+    lastAccessedSequence: SmartGridLastAccessedSequence_2;
+    datasource?: SmartGridBlockDatasource;
+    sortModel?: SmartGridSortModel;
+    filterModel?: SmartGridFilterModel;
+    context?: SmartGridBlockContext;
+    loadSequentially?: boolean;
+    _directPaginationRequest?: boolean;
+    isPaginationMode?: boolean;
+    _targetPage?: number;
+    tableId: string;
+}
+
+/** Row node in a block */
+declare interface SmartGridBlockRowNode {
+    id: number;
+    data: SmartGridRowData | null;
+    rowIndex: number;
+    rowHeight?: number;
+    rowTop?: number;
+}
+
+/** Block state change callback */
+declare type SmartGridBlockStateChangedCallback = (blockId: number, state: string, rowIndexes: number[]) => void;
+
+/** Block state JSON */
+declare interface SmartGridBlockStateJson {
+    id: number;
+    state: string;
+    startRow: number;
+    endRow: number;
+    version: number;
+    lastAccessed: number;
+}
+
+/** Block state JSON from getBlockStateJson */
+declare interface SmartGridBlockStateJsonExtended {
+    id: number;
+    state: string;
+    startRow: number;
+    endRow: number;
+    version: number;
+    lastAccessed: number;
+}
+
+declare type SmartGridCacheAnalytics = {
+    blockEvictions: number;
+    blockLoadTimestamps: number[];
+    blockLoads: number;
+    bytesLoaded: number;
+    cachePurges: number;
+    cacheRefreshes: number;
+    hits: number;
+    lastBlockLoadTime: number;
+    misses: number;
+    startTime: number;
+    totalBlockLoadTime: number;
+};
+
+/** Cache analytics */
+declare interface SmartGridCacheAnalytics_2 {
+    hits: number;
+    misses: number;
+    blockLoads: number;
+    blockEvictions: number;
+    totalBlockLoadTime: number;
+    lastBlockLoadTime: number;
+    bytesLoaded: number;
+    startTime: number;
+    blockLoadTimestamps: Array<{
+        blockId: number;
+        timestamp: number;
+        loadTime: number;
+    }>;
+    cachePurges: number;
+    cacheRefreshes: number;
+}
+
+declare interface SmartGridCacheAnalyticsData {
+    hitRatio: number;
+    hits: number;
+    misses: number;
+    blockLoads: number;
+    blockEvictions: number;
+}
+
+declare type SmartGridCacheBlock = {
+    endRow: number;
+    id: number;
+    infiniteCache: SmartGridInfiniteCache;
+    lastAccessed: number;
+    loadStartedAt: number;
+    params: SmartGridCacheBlockParams;
+    parent: SmartGridInfiniteCache | null;
+    parentCache: SmartGridInfiniteCache | null;
+    rowNodes: {
+        data: SmartGridRowData;
+        id: number;
+        rowIndex: number;
+    }[];
+    rows: unknown;
+    startRow: number;
+    state: string;
+    version: number;
+    _inactiveForPageTransition: boolean;
+    _processingInProgress: boolean;
+    _targetPage: number;
+};
+
+declare type SmartGridCacheBlockParams = Record<string, unknown>;
+
+/** Cache context */
+declare interface SmartGridCacheContext {
+    tableContextRef?: MutableRefObject<SmartGridTableContextValue | null>;
+    infiniteCache?: InfiniteCache;
+    updateData?: (rows: SmartGridRowData[], blockId: number, metadata?: Record<string, unknown> | undefined) => void;
+}
+
+declare interface SmartGridCachedBlockData {
+    [blockId: string]: SmartGridRowData[];
+}
+
+/** Cache event */
+declare interface SmartGridCacheEvent {
+    type: string;
+    blockId?: number;
+    source?: string;
+    options?: Record<string, unknown>;
+    pageNo?: number;
+}
+
+declare type SmartGridCacheMetadata = {
+    lastUpdated: number;
+    timestamp?: number;
+};
+
+/** Cache params */
+declare interface SmartGridCacheParams {
+    overflowSize: number;
+    maxBlocksInCache: number;
+    initialRowCount: number;
+    rowHeight: number;
+    lastAccessedSequence: SmartGridLastAccessedSequence;
+    uniqueIdField: string;
+    onBlockStateChanged: SmartGridBlockStateChangedCallback | null;
+    purgeStrategy: string;
+    enablePersistence: boolean;
+    persistenceStorageKey: string;
+    persistenceOptions: SmartGridPersistenceOptions;
+    isPaginationMode: boolean;
+    datasource?: SmartGridClientSideDatasource | SmartGridServerSideDatasource;
+    filterModel?: SmartGridSearchWithSearchKey;
+    sortModel?: SmartGridSortModel;
+    context?: SmartGridCacheContext;
+    updatedPageSizeRef?: SmartGridPageSizeRef;
+    viewportRange?: SmartGridViewportRange;
+    tableId?: string;
+    pageSize?: number;
+    loadSequentially?: boolean;
+}
+
+/** Cache state for debugging */
+declare interface SmartGridCacheState {
+    blockCount: number;
+    rowCount: number;
+    lastRowIndexKnown: boolean;
+    blocks: SmartGridBlockStateJsonExtended[];
+    analytics: SmartGridCacheAnalytics_2;
+}
+
+declare interface SmartGridCacheState_2 {
+    blockCount: number;
+    cache?: SmartGridInfiniteCache;
+    lastRowKnown: boolean;
+    rowCount: number;
+    status: string;
+}
+
+declare interface SmartGridCacheStateReturn {
+    cache: unknown;
+    rowCount: number;
+    lastRowKnown: boolean;
+    blockCount: number;
+    status: string;
+}
+
+declare interface SmartGridCallbackRefCurrent {
+    onSelectionChanged?: ((event: SmartGridOnSelectionChangedParams) => void) | undefined;
+    onRowDragStart?: ((event: SmartGridRowDragStartParams) => void) | null;
+    onRowDragEnd?: ((event: SmartGridRowDragEndParams) => void) | null;
+    onRowClicked?: ((event: unknown) => void) | null;
+    onCellValueChanged?: ((event: SmartGridCellValueChangedParams) => void) | null;
+    onRowGroupOpened?: ((event: SmartGridRowGrouOpenParams) => void) | null;
+    customTabFunction?: ((e: KeyboardEvent, column: SmartGridColumnDefinition, context: {
+        api: SmartGridAPI | null;
+    }) => void) | null;
+    onPageChange?: ((page: number) => void) | null;
+    onSortChange?: ((sortModel: SmartGridSortModel) => void) | null;
+    onFilterChange?: ((filterModel: SmartGridFilterModel) => void) | null;
+    onSearch?: ((searchTerm: SmartGridSearchFunctionParams) => void) | null;
+}
+
+declare type SmartGridCellRenderer = {
+    value: unknown;
+    data: SmartGridRowData;
+    rowIndex: number;
+    colIndex: number;
+    column: SmartGridColumnDefinition;
+    colDef: SmartGridColumnDefinition;
+    node: SmartGridCellRendererNode;
+    api: SmartGridAPI;
+    eGridCell: HTMLDivElement | null;
+    wholeData: SmartGridRowData[] | null | undefined;
+    actions: Record<string, unknown>;
+    setDataValue: (colId: string, newValue: unknown) => void;
+    isCellLockable?: boolean;
+};
+
+declare type SmartGridCellRendererNode = {
+    data: SmartGridRowData;
+    rowIndex: number;
+    id: string | number;
+    parent: SmartGridUpdateData & {
+        id: string | number;
+        level: number;
+        setExpanded: () => void;
+    };
+    setDataValue: (colId: string, newValue: unknown) => void;
+    childrenMapped: Record<string, string>;
+    allLeafChildren: Record<string, string>[];
+    group: boolean;
+    level: number;
+    childIndex: number;
+    isSelected: () => boolean;
+    isExpandable: () => boolean;
+    isExpanded: () => boolean;
+};
+
+declare type SmartGridCellRendererParams = {
+    dateFormat?: SmartGridDateFormat;
+    startYear?: number;
+    endYear?: number;
+    minDate?: string;
+    maxDate?: string;
+    options?: Array<{
+        label: string;
+        value: string | number;
+    }>;
+    isMultiSelect?: boolean;
+    type?: SmartGridInputType;
+    disabled?: boolean;
+    disableOnlyPast?: boolean;
+    disableOnlyFuture?: boolean;
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    startDate?: string | Date;
+    endDate?: string | Date;
+    inputType?: SmartGridInputType;
+    leftLabel?: string;
+    rightLabel?: string;
+    splits?: SmartGridColumnDefinition[];
+    isEnableResetButton?: boolean;
+} & Record<string, unknown>;
+
+declare interface SmartGridCellValueChangedParams {
+    colDef: SmartGridColumnDefinition;
+    column: SmartGridColumnDefinition;
+    data: SmartGridRowData;
+    newValue: unknown;
+    node: {
+        data: SmartGridRowData;
+        id: string | number;
+        level: number;
+        parent?: SmartGridUpdateData;
+        rowIndex: number;
+    };
+    value: unknown;
+}
+
+declare type SmartGridCheckConfigraitonSearchField = {
+    type: string;
+    filterType: string;
+    filter: string;
+};
+
+declare interface SmartGridCheckConfiguration {
+    checkedRows?: string[];
+    unCheckedRows?: string[];
+    checkAll?: boolean;
+    searchColumns?: SmartGridCheckConfigraitonSearchField | {
+        [key: string]: SmartGridCheckConfigraitonSearchField;
+    };
+    unCheckAll?: boolean;
+}
+
+/** Client-side datasource interface */
+declare interface SmartGridClientSideDatasource {
+    getRows: (params: SmartGridGetRowsRequestParams) => void;
+    destroy?: () => void;
+    _isWrapped?: boolean;
+    _cleanup?: () => void;
+    updateData?: (state: SmartGridStateContext, newData: SmartGridRowData[]) => void;
+    getWholeData?: () => SmartGridRowData[];
+    updateCacheReference?: (newCache: InfiniteCache) => boolean;
+    _cacheInjected?: boolean;
+    infiniteCache?: InfiniteCache;
+    context?: SmartGridDataSourceContext;
+    updateWholeData: (wholeData: SmartGridRowData[]) => void;
+}
+
+declare type SmartGridColumnDefinition = SmartGridColumnWithField | SmartGridColumnWithGroupId | SmartGridColumnWithColId;
+
+declare interface SmartGridColumnState {
+    colId: string;
+    hide: boolean;
+    width: number;
+    sort: SmartGridSortDirection | null;
+    filter: SmartGridFilterModel[] | null;
+}
+
+declare interface SmartGridColumnWithColId extends SmartGridBaseColumnDefinition {
+    field?: string;
+    groupId?: string;
+    colId: string;
+}
+
+declare interface SmartGridColumnWithField extends SmartGridBaseColumnDefinition {
+    field: string;
+    groupId?: string;
+}
+
+declare interface SmartGridColumnWithGroupId extends SmartGridBaseColumnDefinition {
+    field?: string;
+    groupId: string;
+}
+
+/** Data source context */
+declare interface SmartGridDataSourceContext {
+    infiniteCache?: InfiniteCache;
+    tableContextRef?: MutableRefObject<SmartGridTableContextValue | null>;
+    updateData?: (rows: SmartGridRowData[], blockId: number, metadata?: Record<string, unknown> | undefined) => void;
+    getWholeData?: () => SmartGridRowData[];
+    [key: string]: unknown;
+}
+
+/** Datasource getRows params */
+declare interface SmartGridDatasourceGetRowsParams {
+    startRow: number;
+    endRow: number;
+    sortModel?: SmartGridSortModel;
+    filterModel?: SmartGridFilterModel;
+    pageSize: number;
+    successCallback: (rows: SmartGridRowData[], lastRow?: number, lastRowIndexKnown?: boolean) => void;
+    failCallback: (error?: unknown) => void;
+    context?: SmartGridBlockContext;
+    request?: {
+        startRow: number;
+        endRow: number;
+        sortModel?: SmartGridSortModel;
+        filterModel?: SmartGridFilterModel;
+        pageSize: number;
+        groupKeys: string[];
+    };
+}
+
+declare interface SmartGridDataSourceParams {
+    startRow: number;
+    endRow: number;
+    successCallback: (rows: SmartGridRowData[], lastRow?: number | null) => void;
+    failCallback: (error: Error) => void;
+    request: RowGroupParams & {
+        groupKeys: unknown[];
+        rowGroupCols: SmartGridColumnDefinition[];
+        startRow: number;
+        endRow: number;
+    };
+    [key: string]: unknown;
+}
+
+declare type SmartGridDateFormat = "YYYY-MM-DD" | "DD-MM-YYYY" | "MM-DD-YYYY";
+
+declare type SmartGridDefaultColDef = {
+    minWidth: number;
+    headerComponentParams?: {
+        innerHeaderComponent: React.FC<SmartGridHeaderStyleParams> | null;
+    };
+    headerComponent?: React.FC<SmartGridHeaderStyleParams> | null;
+};
+
+declare type SmartGridDispatch = (action: {
+    type: string;
+    payload: unknown;
+    meta?: {
+        fromAlignedGrid?: boolean;
+        defaultColDef?: SmartGridDefaultColDef;
+    } | Record<string, unknown>;
+}) => void;
+
+declare interface SmartGridDisplayedColumn {
+    colDef: SmartGridColumnDefinition;
+    colId: string;
+    getColId: () => string;
+    isVisible: () => boolean;
+    isPinned: () => SmartGridPinnedType;
+    label: string;
+}
+
+declare interface SmartGridDisplayedRowAtIndex {
+    data: SmartGridRowData;
+    rowIndex: number;
+    node: SmartGridParamsNode;
+    api: SmartGridAPI;
+}
+
+declare interface SmartGridDisplayedRowNode extends SmartGridRowNode {
+    rowIndex: number;
+    absoluteRowIndex: number;
+    originalData: SmartGridRowData;
+    rowHeight?: number;
+}
+
+declare interface SmartGridDisptach {
+    type: string;
+    payload?: unknown;
+}
+
+declare interface SmartGridEvent {
+    type: string;
+    api?: SmartGridAPI;
+    [key: string]: unknown;
+}
+
+declare type SmartGridEventListener = {
+    fn: SmartGridEventListenerFn;
+    once: boolean;
+};
+
+declare type SmartGridEventListenerFn = (event: SmartGridEvent) => void;
+
+declare type SmartGridExpandedChildRows = {
+    childRowsCount: number;
+    rowId: string | number;
+    rowIndex: number;
+    children?: SmartGridRowData[];
+};
+
+declare type SmartGridExpandedColumnGroups = {
+    isAllGroupExpanded?: boolean;
+    [key: string]: boolean | undefined;
+};
+
+/** Extended filter model with search and column filters */
+declare interface SmartGridExtendedFilterModel extends SmartGridFilterModel {
+    _search?: SmartGridFilterModel[];
+    _columnFilters?: Record<string, unknown>;
+}
+
+declare type SmartGridFetchDataFunctionBody = {
+    range: SmartGridRangeFilter[];
+    search: SmartGridStringFilter[];
+    sort: SmartGridSortModel[];
+};
+
+declare interface SmartGridFetchDataResponse {
+    rowData: SmartGridRowData[];
+    lastRow?: number;
+    rowCount?: number;
+    totalCount?: number;
+}
+
+/** Fetch function ref type */
+declare interface SmartGridFetchFunctionRef {
+    current?: SmartGridFetDataParams | null;
+}
+
+/** Fetch response */
+declare interface SmartGridFetchResponse {
+    data?: SmartGridRowData[];
+    rowCount?: number;
+    totalItems?: number;
+    total?: number;
+    lastRow?: number;
+    lastRowIndexKnown?: boolean;
+}
+
+declare type SmartGridFetDataParams = (body: SmartGridFetchDataFunctionBody, page: number, context?: SmartGridDataSourceContext, pageNum?: number, options?: {
+    pageSize: number;
+}) => Promise<SmartGridFetchResponse & {
+    totalCount?: number | null;
+}>;
+
+export declare type SmartGridFilterMode = "value" | "condition";
+
+declare interface SmartGridFilterModel {
+    pattern: string;
+    search_type: string;
+    column?: string;
+    field?: string;
+    min_val?: number;
+    max_val?: number;
+    type?: string;
+    operator?: string;
+    value?: string;
+    operators?: SmartGridSearchOperatorOption[];
+    [key: string]: unknown;
+}
+
+declare type SmartGridFloatingType = "top" | "bottom" | null;
+
+declare interface SmartGridFocusedCell extends SmartGridSelectedCell {
+    floating: SmartGridFloatingType;
+}
+
+declare type SmartGridFrozenColumnsDetails = {
+    indexes: string[];
+    positions: Record<string, number>;
+    totalWidth: number;
+    rightPinned: {
+        indexes: string[];
+        positions: Record<string, number>;
+        totalWidth: number;
+    };
+};
+
+declare type SmartGridFrozenState = "left" | "right" | boolean | null | undefined;
+
+declare interface SmartGridGetRowDataParams {
+    data: SmartGridRowData;
+    rowIndex?: number;
+    node: SmartGridParamsNode;
+    api: SmartGridAPI;
+}
+
+/** Request params for getRows */
+declare interface SmartGridGetRowsRequestParams {
+    startRow: number;
+    endRow: number;
+    pageSize: number;
+    sortModel?: SmartGridSortModel;
+    filterModel?: SmartGridExtendedFilterModel;
+    successCallback: (rows: SmartGridRowData[], lastRow?: number, lastRowIndexKnown?: boolean) => void;
+    failCallback: (error?: unknown) => void;
+    context?: SmartGridDataSourceContext;
+    request?: {
+        startRow: number;
+        endRow: number;
+        sortModel?: SmartGridSortModel;
+        filterModel?: SmartGridFilterModel;
+        pageSize: number;
+        groupKeys: string[];
+    };
+}
+
+declare type SmartGridHeaderRowHeight = {
+    maxHeight: number;
+    maxLineCount: number;
+};
+
+declare type SmartGridHeaderStyleParams = {
+    column: SmartGridColumnDefinition;
+    displayName: string;
+    enableSorting: boolean;
+    sortState: SmartGridSortModel;
+    onSort: (field: string, direction: string) => void;
+    isSearchable?: boolean;
+    showSortIcon: boolean;
+    toggleSearchModal: (e: default_2.MouseEvent<HTMLElement>) => void;
+    hasFilters: boolean;
+    isExpandable?: boolean;
+    onToggle?: (field: string, isExpandable: boolean) => void;
+    api: SmartGridAPI;
+    availableWidth: number;
+    wrapHeaderText: boolean;
+    menuButtonRef: default_2.RefObject<HTMLDivElement>;
+    menuToggle: (e: default_2.MouseEvent<HTMLElement>) => void;
+    toggleAdvancedSeach: default_2.Dispatch<default_2.SetStateAction<boolean>>;
+};
+
+declare interface SmartGridInfiniteCache {
+    analytics: SmartGridCacheAnalytics;
+    blockCount: number;
+    blocks: Record<number, SmartGridCacheBlock>;
+    eventListeners: Record<"cacheUpdated", Function[]>;
+    lastRequestedPage: number;
+    lastRowIndexKnown: boolean;
+    params: SmartGridInfiniteCacheParams;
+    rowCount: number;
+    _currentRequestedPage: number;
+    getAllCachedData: () => SmartGridRowData[];
+    updatePageData?: (page: number, data: SmartGridRowData[], replace: boolean, options?: {
+        isRefreshData?: boolean;
+    }) => void;
+    purgeCache?: (options?: {
+        isRefreshData?: boolean;
+    }) => void;
+    getTotalCachedRowCount?: () => number;
+    printAllCachedData?: () => void;
+    setViewportRange?: (start: number, end: number) => void;
+    updateWholeData: (wholeData: SmartGridRowData[], pageSize?: number) => void;
+    getBlockData: (blockId: number) => (SmartGridRowData | null)[] | null;
+}
+
+declare type SmartGridInfiniteCacheDataSourceParams = {
+    getWholeData: () => SmartGridRowData[];
+    updateData?: (state: SmartGridStateContext, data: SmartGridRowData[], rowId?: string, rowIndex?: number) => void;
+    _cacheInjected: boolean;
+    _isDestroyed: boolean;
+    _loadingBlocks: Record<string, unknown>;
+    _originalDatasource: {
+        getRows: (params: SmartGridDataSourceParams) => void;
+    };
+    _pendingRAFs: number[];
+    _pendingRequests: Record<string, unknown>;
+    infiniteCache: SmartGridInfiniteCache;
+    destroy: () => void;
+    getRows: (params: SmartGridDataSourceParams) => void;
+    updateCacheReference: (cache: SmartGridInfiniteCache) => void;
+    updateWholeData: (wholeData: SmartGridRowData[], pageSize?: number) => void;
+};
+
+/** Infinite cache interface (forward declaration) */
+declare interface SmartGridInfiniteCacheInterface {
+    rowsMaxIndex?: number;
+    _currentRequestedPage?: number;
+    isLastRowIndexKnown: () => boolean;
+    getRowCount: () => number;
+    pageLoaded: (block: InfiniteBlock, lastRow?: number) => void;
+    getBlock: (blockId: number) => InfiniteBlock | undefined;
+    isBlockInCreationQueue: (blockId: number) => boolean;
+    createBlock: (blockId: number) => InfiniteBlock;
+    setRowCount?: (count: number, lastRowIndexKnown: boolean) => void;
+}
+
+declare interface SmartGridInfiniteCacheParams {
+    datasource: SmartGridInfiniteCacheDataSourceParams;
+    updatedPageSizeRef: MutableRefObject<number>;
+    pageSize: number;
+    overflowSize: number;
+}
+
+declare interface SmartGridInfiniteCacheReturn {
+    cacheReady: boolean;
+    shouldUseCacheRef: MutableRefObject<boolean>;
+    getRows: (startRow: number, endRow: number) => SmartGridRowData[];
+    setVisibleRange: (startRow: number, endRow: number) => void;
+    setSortModel: (sortModel: SmartGridSortModel) => void;
+    setFilterModel: (filterModel: SmartGridFilterModel | Record<string, unknown>, options?: Record<string, unknown>) => void;
+    refreshCache: (options?: SmartGridRefreshCacheOptions) => void;
+    setServerSideDataSource: (datasource: SmartGridServerSideDataSource, resetCache?: boolean) => SmartGridWrappedDataSource | null;
+    setPurgeStrategy: (strategy: string) => void;
+    setPersistence: (enabled: boolean, options?: Record<string, unknown>) => void;
+    clearPersistedCache: () => void;
+    getCacheState: () => SmartGridCacheStateReturn | null;
+    modelRef: MutableRefObject<SmartGridInfiniteRowModelRef | null>;
+    dataSourceRef?: MutableRefObject<SmartGridWrappedDataSource | null>;
+    setVisibleData?: (data: SmartGridRowData[]) => void;
+    getAllCachedData?: () => SmartGridRowData[];
+}
+
+declare interface SmartGridInfiniteRowModel {
+    infiniteCache?: SmartGridInfiniteCache;
+    setViewportRange?: (startRow: number, endRow: number) => void;
+    logCacheSummary?: () => void;
+    datasource: {
+        getWholeData: () => SmartGridRowData[];
+    };
+    [key: string]: unknown;
+}
+
+declare interface SmartGridInfiniteRowModelRef {
+    infiniteCache?: SmartGridInfiniteCache;
+    params?: {
+        context?: unknown;
+        filterModel?: SmartGridFilterModel | Record<string, unknown>;
+        sortModel?: SmartGridSortModel | null;
+        [key: string]: unknown;
+    };
+    setViewportRange?: (startRow: number, endRow: number) => void;
+    logCacheSummary?: () => void;
+    setDatasource?: (datasource: unknown, preserveCache?: boolean) => void;
+    setSortModel?: (sortModel: SmartGridSortModel) => void;
+    setFilterModel?: (filterModel: SmartGridFilterModel | {
+        _search: SmartGridSearchFunctionParams;
+    } | Record<string, unknown>, options?: Record<string, unknown>) => void;
+    purgeCache?: () => void;
+    refreshCache?: () => void;
+    refreshCachePartial?: (preserveFields: string[]) => void;
+    resetCache?: () => void;
+    setPurgeStrategy?: (strategy: string) => void;
+    setCachePersistence?: (enabled: boolean, options?: Record<string, unknown>) => void;
+    clearPersistedCache?: () => void;
+    getCacheState?: () => SmartGridCacheStateReturn;
+    getCacheAnalytics?: () => SmartGridCacheAnalyticsData | null;
+    getMemoryUsageEstimate?: () => number;
+    resetCacheAnalytics?: () => void;
+    datasource?: SmartGridDataSourceContext;
+    getRow?: (index: number) => {
+        data: SmartGridRowData;
+    } | null;
+}
+
+declare type SmartGridInputType = "text" | "password" | "email" | "number" | "tel" | "int" | "url";
+
+declare interface SmartGridInternalGetRowsParams {
+    startRow: number;
+    endRow: number;
+    filterModel?: SmartGridFilterModel | null;
+    sortModel?: SmartGridSortModel | null;
+    request?: Record<string, unknown>;
+    successCallback?: (rowData: SmartGridRowData[], lastRow?: number) => void;
+    failCallback?: () => void;
+    noDataUpdate?: boolean;
+}
+
+/** Last accessed sequence generator */
+declare interface SmartGridLastAccessedSequence {
+    value: number;
+    next: () => number;
+}
+
+/** Last accessed sequence generator */
+declare interface SmartGridLastAccessedSequence_2 {
+    value: number;
+    next: () => number;
+}
+
+declare type SmartGridModelType = "normal" | "serverSide" | "infinite";
+
+declare interface SmartGridNewSortModel {
+    column: string | null;
+    order: SmartGridSortDirection | null;
+}
+
+declare interface SmartGridNotification {
+    message: string;
+    type?: "success" | "error" | "warning" | "info";
+    duration?: number;
+    timeout?: number;
+}
+
+declare type SmartGridNumberFormat = "full" | "thousands" | "millions" | "billions";
+
+declare interface SmartGridOldSortModel {
+    colId: string;
+    sort: SmartGridSortDirection;
+}
+
+declare type SmartGridOnSelectionChangedParams = {
+    api: SmartGridAPI;
+    type: string;
+    source: string;
+};
+
+declare interface SmartGridOptions {
+    [key: string]: unknown;
+}
+
+/** Page size ref */
+declare interface SmartGridPageSizeRef {
+    current: number;
+}
+
+/** Page size ref */
+declare interface SmartGridPageSizeRef_2 {
+    current: number;
+}
+
+declare interface SmartGridPaginationModel {
+    currentPage: number;
+    pageSize: number;
+    totalPages: number;
+    totalRecords: number;
+}
+
+declare interface SmartGridParamsNode {
+    rowIndex: number;
+    data: SmartGridRowData;
+    api: SmartGridAPI;
+}
+
+/** Pending request with abort capability */
+declare interface SmartGridPendingRequest {
+    abort?: () => void;
+}
+
+/** Persistence options for cache */
+declare interface SmartGridPersistenceOptions {
+    maxPersistedBlocks: number;
+    persistBlockData: boolean;
+    compressionEnabled: boolean;
+}
+
+declare type SmartGridPinnedType = "leftPinned" | "rightPinned" | null;
+
+export declare interface SmartGridPivotAggregationOption {
+    value: string;
+    label: string;
+}
+
+declare interface SmartGridPivotConfig {
+    PivotComponent: React.FC<SmartGridPivotWrapperProps>;
+    savedPivotState: SmartGridPivotState | undefined;
+    pivotPanelColumnDef: SmartGridColumnDefinition[];
+    enablePivotTutorial?: boolean;
+    savedPivots?: SmartGridPivotState[];
+    recentlyUsedPivots?: SmartGridPivotState[];
+    isHidePivotSave?: boolean;
+    pivotChildren?: React.ReactNode;
+    handlePivotSave?: (state: SmartGridPivotSavePayload, setIsPivotOpen: React.Dispatch<React.SetStateAction<boolean>>) => void;
+    handlePivotApply?: (state: SmartGridPivotState, setIsPivotOpen: React.Dispatch<React.SetStateAction<boolean>>) => void;
+    pivotAggregationFunc?: SmartGridSelectOption[];
+    showPivotTotalsSection?: boolean;
+    isPivotRowGrandTotal?: boolean;
+    isPivotColumnGrandTotal?: boolean;
+    isPivotRowSubTotal?: boolean;
+    isPivotColumnSubTotal?: boolean;
+    isHideFilters?: boolean;
+    isHideValues?: boolean;
+}
+
+export declare interface SmartGridPivotDropZoneItem {
+    mode: string;
+    filterValue: string;
+    id: string;
+    name: string;
+    aggregation?: SmartGridAggregationType;
+    condition?: string;
+}
+
+export declare interface SmartGridPivotDropZoneProps {
+    type: "rows" | "columns" | "values";
+    items: SmartGridColumnDefinition[];
+    defaultExpanded?: boolean;
+    onDrop: (column: SmartGridColumnDefinition) => void;
+    onRemoveItem: (itemId: string) => void;
+    isDragOver?: boolean;
+    onClearAll?: () => void;
+}
+
+export declare interface SmartGridPivotField {
+    id: string;
+    name: string;
+    type: "dimension" | "measure";
+}
+
+export declare interface SmartGridPivotFieldItemProps {
+    column: SmartGridColumnDefinition;
+    isDragging?: boolean;
+}
+
+export declare interface SmartGridPivotFieldListProps {
+    fields: SmartGridColumnDefinition[];
+}
+
+export declare interface SmartGridPivotFilterConditionOption {
+    value: string;
+    label: string;
+}
+
+export declare interface SmartGridPivotFilterConditions {
+    number?: SmartGridPivotFilterConditionOption[];
+    text?: SmartGridPivotFilterConditionOption[];
+}
+
+export declare interface SmartGridPivotFilterItem {
+    id: string;
+    name: string;
+    value: string;
+    mode: SmartGridFilterMode;
+    condition?: string;
+}
+
+export declare interface SmartGridPivotFiltersSectionProps {
+    items: SmartGridColumnDefinition[];
+    defaultExpanded?: boolean;
+    onDrop: (column: SmartGridColumnDefinition) => void;
+    onRemoveItem: (id: string) => void;
+    onFilterValueChange: (id: string, value: string) => void;
+    onFilterModeChange?: (id: string, mode: SmartGridFilterMode) => void;
+    onFilterConditionChange?: (id: string, condition: string) => void;
+    onClearAll?: () => void;
+}
+
+export declare interface SmartGridPivotFooterProps {
+    onCancel: () => void;
+    onSave?: () => void;
+    onApply?: () => void;
+    isSaveDisabled?: boolean;
+    isApplyDisabled?: boolean;
+    isHideSave?: boolean;
+    cancelText?: string;
+    saveText?: string;
+    applyText?: string;
+}
+
+export declare interface SmartGridPivotHeaderProps {
+    title: string;
+    onClose: () => void;
+}
+
+export declare type SmartGridPivotMode = "saved" | "create";
+
+export declare interface SmartGridPivotNotificationProps {
+    message: string;
+    defaultVisible?: boolean;
+    onClose?: () => void;
+}
+
+export declare interface SmartGridPivotPanelProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSave: (state: SmartGridPivotSavePayload) => void;
+    availableFields: SmartGridColumnDefinition[];
+    versions?: SmartGridPivotVersion[];
+    selectedVersion?: SmartGridPivotVersion;
+    onVersionChange?: (version: SmartGridPivotVersion) => void;
+    initialState?: Partial<SmartGridPivotState>;
+    showNotification?: boolean;
+    onNotificationClose?: () => void;
+    pivotAggrValues?: SmartGridPivotAggregationOption[];
+    pivotFilterConditions?: SmartGridPivotFilterConditions;
+    pivotChildren?: React.ReactNode;
+    savedPivots?: SmartGridPivotState[];
+    recentlyUsedPivots?: SmartGridPivotState[];
+    onDeleteSavedPivot?: (pivotId: string) => void;
+    onEditSavedPivot?: (pivot: SmartGridPivotState) => void;
+    defaultMode?: SmartGridPivotMode;
+    handlePivotApply?: (state: SmartGridPivotState) => void;
+    isHidePivotSave?: boolean;
+    showTotalsSection?: boolean;
+    pivotAggregationFunc?: SmartGridSelectOption[];
+    isPivotRowGrandTotal?: boolean;
+    isPivotColumnGrandTotal?: boolean;
+    isPivotRowSubTotal?: boolean;
+    isPivotColumnSubTotal?: boolean;
+    isHideFilters?: boolean;
+    isHideValues?: boolean;
+}
+
+export declare interface SmartGridPivotSavePayload extends SmartGridPivotState {
+    isReplace?: boolean;
+    isUpdated?: boolean;
+    oldName?: string;
+}
+
+export declare interface SmartGridPivotSectionProps {
+    title: string;
+    type: SmartGridPivotSectionType;
+    isExpanded: boolean;
+    onToggleExpand: () => void;
+    children?: React.ReactNode;
+}
+
+export declare interface SmartGridPivotSectionState {
+    items: SmartGridColumnDefinition[];
+}
+
+export declare type SmartGridPivotSectionType = "rows" | "columns" | "values" | "filters" | "totals";
+
+export declare interface SmartGridPivotState {
+    id?: string;
+    name: string;
+    viewType?: SmartGridPivotViewType;
+    isDefault?: boolean;
+    rows: SmartGridPivotSectionState;
+    columns: SmartGridPivotSectionState;
+    values: SmartGridPivotSectionState;
+    filters: SmartGridPivotSectionState;
+    totals: SmartGridPivotTotalsState;
+}
+
+export declare interface SmartGridPivotTotalsState {
+    showRowGrandTotal: boolean;
+    showColumnGrandTotal: boolean;
+    showRowSubTotal: boolean;
+    showColumnSubTotal: boolean;
+}
+
+export declare interface SmartGridPivotValueItem {
+    id: string;
+    name: string;
+    aggregation: SmartGridAggregationType;
+}
+
+export declare interface SmartGridPivotValuesSectionProps {
+    items: SmartGridColumnDefinition[];
+    defaultExpanded?: boolean;
+    onDrop: (column: SmartGridColumnDefinition) => void;
+    onRemoveItem: (id: string) => void;
+    onAggregationChange: (id: string, aggregation: SmartGridAggregationType) => void;
+    onClearAll?: () => void;
+    pivotAggregationFunc?: SmartGridSelectOption[];
+}
+
+export declare interface SmartGridPivotVersion {
+    value: string;
+    label: string;
+}
+
+export declare interface SmartGridPivotVersionSelectProps {
+    label: string;
+    versions: SmartGridPivotVersion[];
+    selectedVersion: SmartGridPivotVersion | null;
+    onVersionChange: (version: SmartGridPivotVersion) => void;
+}
+
+export declare type SmartGridPivotViewType = "global" | "personal";
+
+export declare interface SmartGridPivotWrapperProps {
+    pivotConfig: SmartGridPivotConfig;
+    shouldRenderTable: boolean;
+    showSaveTableConfig: boolean;
+}
+
+declare type SmartGridRangeFilter = {
+    column: string;
+    min_val: number;
+    max_val: number;
+    search_type: string;
+    operator?: string;
+};
+
+declare interface SmartGridRefreshCacheOptions {
+    purge?: boolean;
+    partialRefresh?: boolean;
+    preserveFields?: string[];
+    userInitiated?: boolean;
+}
+
+declare interface SmartGridRefreshOptions {
+    purge?: boolean;
+    resetPage?: boolean;
+    userInitiated?: boolean;
+    resetFilters?: boolean;
+}
+
+/** Response metadata */
+declare interface SmartGridResponseMetadata {
+    totalCount?: number;
+    lastRowIndexKnown?: boolean;
+}
+
+declare interface SmartGridRowData {
+    [key: string]: unknown;
+    id?: string | number;
+    isChildRow?: boolean;
+    isChildGroup?: boolean;
+    childIndex?: number;
+    groupingLevel?: number;
+    level?: number;
+    parentRowIndex?: number;
+    parentRowData?: SmartGridRowData;
+    __parentPath?: string;
+    _rowHeight?: number;
+    _isPinnedTop?: boolean;
+    _isPinnedBottom?: boolean;
+    __isAggregationRow?: boolean;
+    subTotalAggreRow?: boolean;
+    grandTotalAggreRow?: boolean;
+    isGrandTotalRow?: boolean;
+    __parentId?: string | number | null;
+    __rowSpanInfo?: SmartGridRowSpanInfo;
+    __flattenedRowId?: string;
+    __rowIndex?: number;
+    __split?: {
+        key?: string;
+    };
+}
+
+declare interface SmartGridRowDragEndParams {
+    api: SmartGridAPI;
+    type: "rowDragEnd";
+    fromIndex: number;
+    toIndex: number;
+    rowData: SmartGridRowData;
+}
+
+declare interface SmartGridRowDragStartParams {
+    api: SmartGridAPI;
+    type: "rowDragStart";
+    rowIndex: number;
+    rowData: SmartGridRowData;
+}
+
+declare type SmartGridRowGrouOpenParams = {
+    rowId: string;
+    rowIndex: number;
+    api: SmartGridAPI;
+    isExpanded: boolean;
+};
+
+declare type SmartGridRowGroupState = {
+    expandedGroups: Record<string, SmartGridRowGroupStateExpandedGroups>;
+    loadedData: Record<string, SmartGridRowData[]>;
+    loading: Record<string, boolean>;
+    pagination: Record<string, SmartGridRowGroupStatePagination>;
+    cache: {
+        metadata: Record<string, SmartGridCacheMetadata>;
+        expirationTime: number;
+    };
+    api: SmartGridAPI | null;
+    isLoadingSomething: boolean;
+    isAllRowExpanded: boolean;
+    isManuallyChanged: boolean;
+};
+
+declare type SmartGridRowGroupStateExpandedGroups = {
+    count: number;
+    fieldName: string;
+    rowIndex: number;
+    value: string;
+    [key: string]: boolean | number | string;
+};
+
+declare type SmartGridRowGroupStatePagination = {
+    hasMore: boolean;
+    lastUpdated: number;
+    page: number;
+    pageSize: number;
+    totalItems?: number;
+    totalPages?: number;
+    error?: boolean;
+};
+
+declare type SmartGridRowInfo = {
+    isFirst: boolean;
+    span: number;
+    rowIds?: (string | number)[];
+};
+
+declare interface SmartGridRowNode extends SmartGridUpdateData {
+    id: string | number;
+    childIndex?: number;
+    selected: boolean;
+    rowIndex?: number;
+    absoluteRowIndex?: number;
+    originalData?: SmartGridRowData;
+    rowHeight?: number;
+    setSelected: (selected: boolean, clearSelection?: boolean) => void | ((value: string | number | boolean) => void);
+    isGroup?: () => boolean;
+}
+
+declare interface SmartGridRowSpanInfo {
+    [key: string]: SmartGridRowInfo | boolean | undefined;
+    isRowSpan?: boolean;
+    Selection?: SmartGridRowInfo;
+}
+
+declare type SmartGridRowStyleParams = {
+    api: SmartGridAPI;
+    data: SmartGridRowData;
+    pinned: boolean;
+    node: {
+        rowIndex: number;
+        data: SmartGridRowData;
+        api: SmartGridAPI;
+        pinned: boolean;
+    };
+};
+
+declare type SmartGridSavedViewsOptions = {
+    isActive: boolean;
+    isDefaultView: boolean;
+    viewName: string;
+    viewType: "personal" | "global";
+};
+
+declare interface SmartGridSaveViewCallbackRefCurrent {
+    handleSetDefaultView?: ((view: SmartGridSavedViewsOptions) => void) | null;
+    handleSavedViewClick?: ((view: SmartGridSavedViewsOptions) => void) | null;
+    handleEditSaveView?: ((updatedData: SmartGridSavedViewsOptions, view: SmartGridSavedViewsOptions) => void) | null;
+    handleSaveAndApply?: ((view: SmartGridSavedViewsOptions) => void) | null;
+    handleDeleteViewClick?: ((view: SmartGridSavedViewsOptions) => void) | null;
+}
+
+declare type SmartGridSearchFunctionParams = SmartGridFilterModel[] | Record<string, SmartGridFilterModel[]>;
+
+declare type SmartGridSearchFunctionParamsWithField = Record<string, SmartGridFilterModel>;
+
+declare interface SmartGridSearchOperatorOption {
+    value: string;
+    label: string;
+    type?: string;
+}
+
+declare interface SmartGridSearchWithSearchKey {
+    _search: SmartGridSearchFunctionParamsWithField;
+}
+
+declare interface SmartGridSelectedCell {
+    colIndex: number;
+    column: SmartGridColumnDefinition;
+    data: SmartGridRowData;
+    field: string;
+    rowId: string | number;
+    rowIndex: number;
+    value: unknown;
+}
+
+declare interface SmartGridSelectOption {
+    value: string | number;
+    label: string;
+    isDisabled?: boolean;
+}
+
+declare interface SmartGridServerSideDataSource {
+    getRows: (params: SmartGridServerSideGetRowsParams) => {
+        abort?: () => void;
+    } | void;
+}
+
+/** Server-side datasource interface */
+declare interface SmartGridServerSideDatasource {
+    infiniteCache: InfiniteCache | undefined;
+    _originalParams: SmartGridServerSideDataSourceParams;
+    _loadingBlocks: Record<number, boolean>;
+    _pendingRequests: Record<string, SmartGridPendingRequest>;
+    _lastRequestParams: SmartGridGetRowsRequestParams | null;
+    _isDestroyed: boolean;
+    updateCacheReference: (newCache: InfiniteCache) => boolean;
+    updateConfig: (newConfig: Partial<SmartGridServerSideDataSourceParams>) => SmartGridServerSideDatasource;
+    destroy: () => void;
+    resetLoadState: () => void;
+    getRows: (requestParams: SmartGridGetRowsRequestParams) => void;
+    _cacheInjected?: boolean;
+    _isWrapped?: boolean;
+    context?: SmartGridDataSourceContext;
+}
+
+/** Server-side datasource params */
+declare interface SmartGridServerSideDataSourceParams {
+    fetchFunc?: SmartGridFetchFunctionRef;
+    apiUrl?: string;
+    sortModel: SmartGridSortModel;
+    filterModel: SmartGridSearchWithSearchKey | null;
+    infiniteCache: InfiniteCache | null;
+    context: SmartGridDataSourceContext;
+    pageSize: number;
+    resetState?: boolean;
+    updatedPageSizeRef?: SmartGridUpdatedPageSizeRef;
+}
+
+declare interface SmartGridServerSideGetRowsParams {
+    request: {
+        startRow: number;
+        endRow: number;
+        filterModel?: SmartGridFilterModel | SmartGridSearchWithSearchKey | null;
+        sortModel?: SmartGridSortModel | null;
+    };
+    api: SmartGridAPI;
+    success: (response: SmartGridFetchDataResponse) => void;
+    fail: () => void;
+}
+
+declare type SmartGridSortDirection = "asc" | "desc" | "none";
+
+declare type SmartGridSortModel = SmartGridOldSortModel | SmartGridNewSortModel | null;
+
+declare interface SmartGridStateContext {
+    data?: SmartGridRowData[] | null;
+    filteredData: SmartGridRowData[] | null;
+    originalData: SmartGridRowData[] | null;
+    previewMode: boolean;
+    isLoading: boolean;
+    columns: SmartGridColumnDefinition[];
+    columnMap: Record<string, SmartGridColumnDefinition>;
+    sortState: SmartGridSortModel;
+    pagination: {
+        currentPage: number;
+        pageSize: number;
+        totalPages: number | null;
+        isCountUnknown: boolean;
+        totalItems: number;
+        currentLoadedPage: number;
+        allTotalPages: number;
+        page: number;
+    };
+    selectedRows: (string | number)[];
+    selectedRowsObject: Record<string, boolean>;
+    columnFilters: Record<string, SmartGridFilterModel[]>;
+    expandedChildRows: Record<string, SmartGridExpandedChildRows>;
+    expandedColumnGroups: SmartGridExpandedColumnGroups;
+    uniqueIdField: string;
+    childKeyField: string;
+    frozenColumns: SmartGridFrozenColumnsDetails;
+    notification: SmartGridNotification & {
+        show: boolean;
+    };
+    columnsToAutosize: string[] | Record<string, boolean>;
+    prevAction: string;
+    checkConfiguration: SmartGridCheckConfiguration[];
+    isSelectAllRecords: boolean;
+    unCheckedRows: Record<string, boolean>;
+    isSelectionChanged: boolean;
+    masterDetail: {
+        enabled: boolean;
+        expandedRows: (string | number)[];
+        detailRenderer: null | Function;
+        detailRowHeight: number;
+        detailPadding: number;
+        expandedRowData: SmartGridRowData | SmartGridRowData[] | null;
+        currentRowStyles?: {
+            height?: number;
+            top?: number;
+        };
+        rowIndex?: number | null;
+    };
+    eventListeners: Record<string, SmartGridEventListener[]>;
+    defaultColDef: SmartGridDefaultColDef | null;
+    api: SmartGridAPI | null;
+    actions: {};
+    serverSide: boolean;
+    enableRowSpan: boolean;
+    rowSpanColumn: string | string[] | null;
+    rowDragManaged: boolean;
+    format: {
+        fontSize: "medium" | "small" | "large";
+        numberFormat: SmartGridNumberFormat;
+    };
+    pinnedTopRows: SmartGridRowData[];
+    pinnedBottomRows: SmartGridRowData[];
+    rowGroupState: SmartGridRowGroupState;
+    tableInstance: MutableRefObject<HTMLElement | null>;
+    headerRowHeightwithIndex: Record<string, SmartGridHeaderRowHeight>;
+    infiniteScroll: boolean;
+    smartGridMenuOptions: {
+        withColumMenu?: boolean;
+        autoWithColumMenu?: boolean;
+        freezeColumnMenu?: boolean;
+        sortColumnMenu?: boolean;
+        collapseColumnAll?: boolean;
+        expandColumnAll?: boolean;
+        wrapText?: boolean;
+    };
+    purgeClosedRowNodes: boolean;
+    detailRendererTable: boolean;
+    isSaveViewEnabled: boolean;
+    rowHeight: {
+        type: "default" | "compact" | "comfortable";
+        height: number;
+        padding: number;
+    };
+    aggregationTotalRow: SmartGridRowData | null;
+    hasAggregation: boolean;
+    callBackRef: MutableRefObject<SmartGridCallbackRefCurrent | null>;
+    exportCallbackRef: MutableRefObject<{
+        downloadExcelHandler?: null | Function;
+        downloadCSVHandler?: null | Function;
+        copyToClipboardHandler?: null | Function;
+    }>;
+    saveViewOptionsRef: MutableRefObject<{
+        maxSavedViews?: null | number;
+        deleteViewPromptText?: null | string;
+    }>;
+    saveViewCallbackRef: MutableRefObject<SmartGridSaveViewCallbackRefCurrent>;
+    tableId: string;
+    isSingleSelect: boolean;
+    selectable: boolean;
+    disableSelectAllRecords: boolean;
+    columnBufferSize?: number;
+    lazyLoadCellRenderer?: boolean;
+    hasSplitRenderer?: boolean;
+    splitRendererKeys?: string[] | null;
+    originalFromIndex?: number | null;
+    lastToIndex?: number | null;
+    hasExpandedChildren?: boolean;
+    isDraggingDownward?: boolean;
+    saveViewCallbacks?: {
+        isSavingViewLoading?: boolean;
+        savedViewsOptions?: SmartGridSavedViewsOptions[];
+    } & Record<string, unknown>;
+    pivotPanelColumnDef: null | SmartGridColumnDefinition[];
+    [key: string]: unknown;
+}
+
+declare type SmartGridStringFilter = {
+    column: string;
+    pattern: string;
+    search_type: string;
+    operator?: string;
+};
+
+declare interface SmartGridTableContextValue {
+    state: SmartGridStateContext;
+    tableApi: SmartGridAPI | null;
+    dispatch: SmartGridDispatch;
+    ACTION_TYPES: typeof ACTION_TYPES;
+    toggleGroupExpansion: (rowId: string | number, rowIndex: number) => void;
+    dispatchEvent: (eventType: string, eventData: Record<string, unknown>) => void;
+    getRowStyle?: (params: SmartGridRowStyleParams) => CSSProperties;
+}
+
+declare interface SmartGridTableInstance {
+    current: HTMLElement | null;
+}
+
+declare interface SmartGridTableModel {
+    getData: () => SmartGridRowData[];
+    modelRef?: {
+        current?: SmartGridInfiniteRowModel;
+    };
+    infiniteCache: SmartGridInfiniteCacheReturn | null;
+    getColumnDefs: () => SmartGridColumnDefinition[];
+    getSortModel: () => SmartGridSortModel[];
+    getFilterModel: () => SmartGridFilterModel;
+    getType: () => SmartGridModelType;
+    getRowsToDisplay: () => number;
+    forEachNode: (callback: (node: SmartGridRowNode, index: number) => void) => void;
+    getRowNode: (id: string | number) => SmartGridRowNode | null;
+    getSelectedRows: () => SmartGridRowData[];
+    getPaginationModel: () => SmartGridPaginationModel;
+    getColumnState: () => SmartGridColumnState[];
+    rowsToDisplay: SmartGridRowData[];
+}
+
+declare type SmartGridTooltipGetterParams = {
+    api: SmartGridAPI;
+    colDef: SmartGridColumnDefinition;
+    column: SmartGridColumnDefinition;
+    data: SmartGridRowData;
+    location: string;
+    node: {
+        data: SmartGridRowData;
+        id: string;
+        level: number;
+        parent: SmartGridUpdateData;
+        rowIndex: number;
+    };
+    rowIndex: number;
+    value: unknown;
+};
+
+declare type SmartGridUpdateData = {
+    data: SmartGridRowData;
+    setData: (data: SmartGridRowData) => void;
+    setDataValue: (field: string, value: unknown, callbackNeeded?: boolean) => void;
+};
+
+declare type SmartGridUpdateDataReturnType = {
+    success: boolean;
+    totalRows: number;
+    blocksUpdated: number;
+    errors: string[];
+};
+
+/** Page size ref for server-side */
+declare interface SmartGridUpdatedPageSizeRef {
+    current: number;
+}
+
+declare type SmartGridValueFormatterConfig = {
+    type?: string;
+    symbol?: string;
+    position?: "prefix" | "suffix";
+    decimals?: number;
+};
+
+declare interface SmartGridValueFormatterParams {
+    value: unknown;
+    data: SmartGridRowData;
+    colDef: SmartGridColumnDefinition;
+}
+
+declare interface SmartGridValueGetterParams {
+    data: SmartGridRowData;
+    node: {
+        data: SmartGridRowData;
+    };
+    colDef: SmartGridColumnDefinition;
+    column: SmartGridColumnDefinition;
+    api: SmartGridAPI | null;
+    columnApi?: SmartGridAPI;
+    getValue: (field: string) => unknown;
+}
+
+/** Viewport range */
+declare interface SmartGridViewportRange {
+    startRow: number;
+    endRow: number;
+}
+
+declare interface SmartGridWrappedDataSource {
+    _originalDatasource: SmartGridServerSideDataSource;
+    _loadingBlocks: Record<number, boolean>;
+    _pendingRequests: Record<number, {
+        abort?: () => void;
+    }>;
+    _isDestroyed: boolean;
+    _pendingRAFs?: number[];
+    infiniteCache: unknown;
+    updateCacheReference: (newCache: unknown) => void;
+    destroy: () => void;
+    getRows: (params: SmartGridInternalGetRowsParams) => void;
+}
+
+export { }