ia-table 0.12.9 → 0.13.0

package/dist/index.d.ts

@@ -1,15 +1,3514 @@
-import { ComponentType } from "react";
-import type { SmartGridTableProps } from "./components/IATable/types/table";
-
-// Export all types from the types folder
-export * from "./components/IATable/types/index";
-
-// SVG module declarations for library consumers
-declare module "*.svg" {
-  import React from "react";
-  const SVGComponent: React.FC<React.SVGProps<SVGSVGElement>>;
-  export default SVGComponent;
-}
-
-declare const IATable: ComponentType<SmartGridTableProps>;
-export default IATable;
+import { ChangeEvent } from 'react';
+import { CSSProperties } from 'react';
+import { default as default_2 } from 'react';
+import { Dispatch } from 'react';
+import { FocusEvent as FocusEvent_2 } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { Moment } from 'moment';
+import { MouseEvent as MouseEvent_2 } from 'react';
+import { MutableRefObject } from 'react';
+import { ReactNode } from 'react';
+import { Ref } from 'react';
+import { RefAttributes } from 'react';
+import { RefObject } from 'react';
+import { SetStateAction } 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 interface ChildHeightsResult {
+    childrenTotalHeight: number;
+    childCount: number;
+}
+
+export declare interface DateValidationConstraints {
+    startDate: Date | string;
+    endDate: Date | string;
+    startYear: number;
+    endYear: number;
+    disableOnlyPast?: boolean;
+    disableOnlyFuture?: boolean;
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    minDate?: Date | string;
+    maxDate?: Date | string;
+}
+
+declare const Index: ForwardRefExoticComponent<Omit<SmartGridTableProps, "ref"> & RefAttributes<SmartGridTableAPIObject | null>>;
+export default Index;
+
+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_2;
+    /**
+     * 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;
+}
+
+declare interface RowGroupParams {
+    page: number;
+    pageSize: number;
+    groupId?: string;
+    noDataUpdate?: boolean;
+}
+
+/**
+ * A specialized cache for efficiently managing row heights in virtualized tables
+ * Optimized for large datasets (9K+ rows) to improve virtualization performance
+ */
+declare class RowHeightCache {
+    private heightMap;
+    private hierarchicalLookup;
+    private prefixLookup;
+    private accumulatedHeights;
+    private totalHeight;
+    private isDirty;
+    private previousRowHeight;
+    private count;
+    private previousCount;
+    constructor();
+    setAllHeight(rowHeightMap: RowHeightMap): void;
+    setPreviousCount(newCount: number): void;
+    setHeight(rowId: string | number, height: number, rowIndex?: number | string): void;
+    getHeight(rowId: string | number, defaultHeight: number, rowIndex?: number | string): number;
+    getChildHeights(defaultHeight: number, rowIndex?: number): ChildHeightsResult;
+    buildAccumulatedHeights(data: SmartGridRowData[], defaultHeight: number, uniqueIdField: string | undefined, rowHeight: number): void;
+    findRowAtScrollPosition(scrollTop: number): number;
+    getTotalHeight(): number;
+    toObject(): RowHeightMap;
+    static fromObject(heightMap: RowHeightMap): RowHeightCache;
+}
+
+declare type RowHeightMap = Record<string | number, number>;
+
+export declare interface RowSpanParams {
+    node: {
+        rowIndex: number;
+        data: SmartGridRowData;
+        api: SmartGridAPI;
+    };
+    api: SmartGridAPI;
+    rowIndex?: number;
+    data: SmartGridRowData;
+    wholeData: SmartGridRowData[];
+}
+
+export declare type SmartGridActionTypes = typeof ACTION_TYPES;
+
+export 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 | 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;
+}
+
+export declare type SmartGridBadgeColor = "default" | "success" | "warning" | "error" | "info";
+
+export declare interface SmartGridBadgeProps {
+    label: string;
+    variant?: SmartGridBadgeVariant;
+    color?: SmartGridBadgeColor;
+    size?: SmartGridBadgeSize;
+    className?: string;
+    onClick?: (e: MouseEvent_2<HTMLDivElement>) => void;
+}
+
+export declare type SmartGridBadgeSize = "default" | "small";
+
+export declare type SmartGridBadgeVariant = "filled" | "stroke";
+
+export 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[];
+    parentField?: string | null;
+    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;
+        [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;
+    [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;
+}
+
+export declare interface SmartGridBodyCellDetailProps {
+    cellRef: RefObject<HTMLDivElement>;
+    cellClasses: string;
+    cellStyle: CSSProperties;
+    handleCellClickForSelection: (e: React.MouseEvent<HTMLDivElement>) => void;
+    handleDoubleClick: (e: React.MouseEvent<HTMLDivElement>) => void;
+    rowIndex: number;
+    rowId: string | number;
+    colIndex: number;
+    field: string;
+    isPinnedLeft: boolean;
+    isPinnedRight: boolean;
+    cellType: string;
+    isChildRow?: boolean;
+    isGrandTotalRow?: boolean;
+    isFirstColumn: boolean;
+    isFirstFrozenColumn: boolean;
+    isGroupRowExpanded: boolean;
+    isGroupingKey: boolean;
+    level: number;
+    showDragHandle: boolean;
+    showToggle: boolean;
+    isExpanded: boolean;
+    isDetailExpanded?: boolean;
+    hideToolTip: boolean;
+    contentStyle: CSSProperties;
+    shouldHideContent: boolean;
+    formattedCellValue: unknown;
+    actualValue: string | boolean | null | undefined | number | {};
+    toolTipTitle: string;
+    shouldRenderRowGroupContent: boolean;
+    groupId: string | null;
+    serverSide: boolean;
+    loadingRef?: RefObject<HTMLDivElement> | null;
+    stateRowHeight: {
+        height: number;
+        type: string;
+    };
+    virtualized?: boolean;
+    allColumnsLastRow?: SmartGridColumnDefinition[];
+    isSingleSelect?: boolean;
+    leftPinnedOnly?: boolean;
+    disableSelectAllRecords?: boolean;
+    rowData: SmartGridRowData;
+    column: SmartGridColumnDefinition;
+    showMasterDetailToggle: boolean;
+    isRowGroupEnabled: boolean;
+    updatedCellId: string | number;
+    cellValue: unknown;
+    tableApi: SmartGridAPI | null;
+    hasChildren: boolean;
+    isAggregationParentRowWithAggregatedData: boolean;
+    lazyLoadCellRenderer?: boolean;
+}
+
+export declare interface SmartGridBodyCellProps {
+    customRowStyle?: CSSProperties;
+    loadingRef?: RefObject<HTMLDivElement> | null;
+    virtualized?: boolean;
+    leftPinnedOnly?: boolean;
+    rowData: SmartGridRowData;
+    column: SmartGridColumnDefinition;
+    rowIndex: number;
+    colIndex: number;
+    onDoubleClick?: (e: React.MouseEvent<HTMLDivElement>, params: {
+        rowData: SmartGridRowData;
+        column: SmartGridColumnDefinition;
+        rowIndex: number;
+        colIndex: number;
+    }) => void;
+    hideContent?: boolean;
+    className?: string;
+    isChildRow?: boolean;
+    allColumnsLastRow?: SmartGridColumnDefinition[];
+    rowSpanInfo?: SmartGridRowSpanInfoDetails;
+    selectable?: boolean;
+    isFirstGrandTotalColumn?: boolean;
+    isGrandTotalRow?: boolean;
+    isLeftPinnedRowsAvailable?: boolean;
+    style?: CSSProperties | null;
+}
+
+export declare interface SmartGridButtonProps {
+    onClick: (e: MouseEvent_2<HTMLButtonElement>) => void;
+    children: ReactNode;
+    variant?: SmartGridButtonVariant;
+    size?: SmartGridButtonSize;
+    iconButton?: boolean;
+    className?: string;
+    disabled?: boolean;
+    leftIcon?: ReactNode;
+    rightIcon?: ReactNode;
+}
+
+export declare type SmartGridButtonSize = "small" | "medium" | "large";
+
+export declare type SmartGridButtonVariant = "primary" | "secondary" | "tertiary" | "link" | "url" | "text" | "danger";
+
+export 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;
+}
+
+export declare interface SmartGridCacheAnalyticsData {
+    hitRatio: number;
+    hits: number;
+    misses: number;
+    blockLoads: number;
+    blockEvictions: number;
+}
+
+export 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;
+};
+
+export 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;
+}
+
+export declare interface SmartGridCachedBlockData {
+    [blockId: string]: SmartGridRowData[];
+}
+
+/** Cache event */
+declare interface SmartGridCacheEvent {
+    type: string;
+    blockId?: number;
+    source?: string;
+    options?: Record<string, unknown>;
+    pageNo?: number;
+}
+
+export 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;
+}
+
+export declare interface SmartGridCacheState {
+    blockCount: number;
+    cache?: SmartGridInfiniteCache;
+    lastRowKnown: boolean;
+    rowCount: number;
+    status: string;
+}
+
+/** Cache state for debugging */
+declare interface SmartGridCacheState_2 {
+    blockCount: number;
+    rowCount: number;
+    lastRowIndexKnown: boolean;
+    blocks: SmartGridBlockStateJsonExtended[];
+    analytics: SmartGridCacheAnalytics_2;
+}
+
+export declare interface SmartGridCacheStateReturn {
+    cache: unknown;
+    rowCount: number;
+    lastRowKnown: boolean;
+    blockCount: number;
+    status: string;
+}
+
+export declare interface SmartGridCalendarDay {
+    day: number;
+    isCurrentMonth: boolean;
+}
+
+export declare interface SmartGridCalendarPosition {
+    top: number;
+    left: number;
+}
+
+export 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;
+}
+
+export 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;
+};
+
+export declare interface SmartGridCellRendererDesignIconProps {
+    cellRenderer: string;
+}
+
+export declare interface SmartGridCellRendererMappingType {
+    [key: string]: string;
+}
+
+export 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;
+};
+
+export 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[];
+} & Record<string, unknown>;
+
+export declare interface SmartGridCellRendererRendererProps {
+    isGrandTotalRow?: boolean;
+    rowData: SmartGridRowData;
+    isAggregationParentRowWithAggregatedData: boolean;
+    cellValue: unknown;
+    rowIndex: number;
+    colIndex: number;
+    column: SmartGridColumnDefinition;
+    tableApi: SmartGridAPI | null;
+    cellRef: RefObject<HTMLDivElement>;
+    hasChildren: boolean;
+    lazyLoadCellRenderer?: boolean;
+}
+
+export declare interface SmartGridCellSelectionParams {
+    tableInstance: SmartGridTableInstance;
+    callBackRef: MutableRefObject<SmartGridCallbackRefCurrent | null>;
+    api: SmartGridAPI | null;
+}
+
+export 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;
+}
+
+export declare interface SmartGridCheckboxProps {
+    checked?: boolean;
+    onChange: (checked: boolean) => void;
+    label?: string;
+    disabled?: boolean;
+    className?: string;
+}
+
+export declare interface SmartGridCheckConfiguration {
+    checkedRows?: string[];
+    unCheckedRows?: string[];
+    checkAll?: boolean;
+    searchColumns?: SmartGridFilterModel | {
+        [key: string]: SmartGridFilterModel[];
+    };
+    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;
+}
+
+export declare interface SmartGridColumnAutoSizeReturn {
+    autoSizeColumn: (column: SmartGridColumnDefinition) => void;
+    customSizeColumn: (column: SmartGridColumnDefinition) => void;
+    autoSizeAllColumns: () => void;
+}
+
+export declare type SmartGridColumnDefinition = SmartGridColumnWithField | SmartGridColumnWithGroupId | SmartGridColumnWithColId;
+
+export declare type SmartGridColumnPinnedType = "leftPinnedOnly" | "rightPinnedOnly" | "normal" | "top" | "bottom";
+
+export declare interface SmartGridColumnState {
+    colId: string;
+    hide: boolean;
+    width: number;
+    sort: SmartGridSortDirection | null;
+    filter: SmartGridFilterModel[] | null;
+}
+
+export declare interface SmartGridColumnVirtualizationParams {
+    columns: SmartGridColumnDefinition[];
+    containerWidth: number;
+    columnBuffer: number;
+    headerRows: SmartGridColumnDefinition[][];
+    virtualizationThreshold?: number;
+    globalColumnCounts: SmartGridGlobalColumnCounts;
+    pinnedType: SmartGridPinType;
+    virtualizedStartCololumnIndex: MutableRefObject<number>;
+}
+
+export declare interface SmartGridColumnVirtualizationReturn {
+    visibleColumns: SmartGridColumnDefinition[];
+    virtualizedHeaderRows: SmartGridColumnDefinition[][];
+    handleScroll: (e: React.UIEvent<HTMLElement>) => void;
+}
+
+export declare interface SmartGridColumnWithColId extends SmartGridBaseColumnDefinition {
+    field?: string;
+    groupId?: string;
+    colId: string;
+}
+
+export declare interface SmartGridColumnWithField extends SmartGridBaseColumnDefinition {
+    field: string;
+    groupId?: string;
+}
+
+export declare interface SmartGridColumnWithGroupId extends SmartGridBaseColumnDefinition {
+    field?: string;
+    groupId: string;
+}
+
+export declare interface SmartGridContainerRect {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+
+export declare type SmartGridContextRef = React.MutableRefObject<SmartGridTableContextValue | null>;
+
+export declare interface SmartGridCopyCellValueParams {
+    tableInstance: MutableRefObject<HTMLElement | null>;
+    tableApi: SmartGridAPI | null;
+}
+
+/** Data source context */
+export 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[];
+    };
+}
+
+export 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;
+}
+
+export declare interface SmartGridDataUpdateMetadata {
+    totalCount?: number;
+    [key: string]: unknown;
+}
+
+export declare interface SmartGridDateConstraints {
+    startYear?: number;
+    endYear?: number;
+    disableOnlyPast?: boolean;
+    disableOnlyFuture?: boolean;
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    minDate?: Date | string | null;
+    maxDate?: Date | string | null;
+}
+
+export declare type SmartGridDateFormat = "YYYY-MM-DD" | "DD-MM-YYYY" | "MM-DD-YYYY";
+
+export declare type SmartGridDatePickerHandler = React.MouseEvent<HTMLButtonElement> | KeyboardEvent;
+
+export declare interface SmartGridDatePickerInputProps {
+    dateString: string;
+    placeholder?: string;
+    disabled?: boolean;
+    isError?: boolean;
+    setErrorState: (hasError: boolean) => void;
+    inputContainerRef: RefObject<HTMLDivElement>;
+    selectedDate?: string;
+    isOpen?: boolean;
+    setIsOpen: (isOpen: boolean) => void;
+    displayFormat?: SmartGridDateFormat;
+    onDateStringChange?: (date: string | Moment | null) => void;
+    minDate?: Date | string | null;
+    maxDate?: Date | string | null;
+    onClear?: (e: MouseEvent_2<HTMLButtonElement>) => void;
+    readOnly?: boolean;
+    customIcon?: ReactNode;
+    hasDateError?: boolean;
+    isheadercell?: boolean | null;
+    isCellRenderer?: boolean;
+}
+
+export declare interface SmartGridDatePickerProps extends SmartGridDateConstraints {
+    value?: string;
+    onChange?: (date: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    label?: string;
+    required?: boolean;
+    withPortal?: boolean;
+    width?: string;
+    dateFormat?: SmartGridDateFormat;
+    isCellRenderer?: boolean;
+    tableApi?: SmartGridAPI | null;
+    isheadercell?: boolean | null;
+    column?: SmartGridColumnDefinition;
+    advancedSearchApplyRef?: MutableRefObject<boolean>;
+    lazyLoadCellRenderer?: boolean;
+}
+
+export declare interface SmartGridDateRangePickerCalendarProps extends SmartGridDateConstraints {
+    leftMonth: Date | Moment;
+    setLeftMonth: (month: Date | Moment) => void;
+    rightMonth: Date | Moment;
+    setRightMonth: (month: Date | Moment) => void;
+    selectedStartDate: string;
+    selectedEndDate: string;
+    tempStartDate: string | null;
+    setTempStartDate: (date: string | null) => void;
+    tempEndDate: string | null;
+    setTempEndDate: (date: string | null) => void;
+    showMonthDropdown: boolean;
+    setShowMonthDropdown: (show: boolean) => void;
+    showYearDropdown: boolean;
+    setShowYearDropdown: (show: boolean) => void;
+    activeCalendar: "left" | "right";
+    setActiveCalendar: (calendar: "left" | "right") => void;
+    monthDropdownRef: RefObject<HTMLDivElement>;
+    yearDropdownRef: RefObject<HTMLDivElement>;
+    focusedInput: "start" | "end" | "";
+    setFocusedInput: (input: "start" | "end" | "") => void;
+    isCellRenderer?: boolean;
+    tableApi?: SmartGridAPI | null | undefined;
+    setIsOpen: (isOpen: boolean) => void;
+    onChange?: (dates: SmartGridDateRangeValue) => void;
+    startDate?: string;
+    endDate?: string;
+    onDateChangeApply?: (dates: SmartGridDateRangeValue) => void;
+    hasDateError?: string;
+    setSelectedStartDate?: (date: string) => void;
+    setSelectedEndDate?: (date: string) => void;
+    error?: string;
+}
+
+export declare interface SmartGridDateRangePickerInputProps {
+    inputContainerRef: RefObject<HTMLDivElement>;
+    startDateString: string;
+    endDateString: string;
+    isDisabled?: boolean;
+    isError?: boolean | string;
+    onStartDateFocus: (e: FocusEvent_2<HTMLInputElement>) => void;
+    onEndDateFocus: (e: FocusEvent_2<HTMLInputElement>) => void;
+    displayFormat?: SmartGridDateFormat;
+    onStartDateStringChange?: (date: string | Moment | null) => void;
+    onEndDateStringChange?: (date: string | Moment | null) => void;
+    minDate?: Date | string | null;
+    maxDate?: Date | string | null;
+    readOnly?: boolean;
+    isOutsideRange?: (date: Moment) => boolean;
+    onErrorStateChange?: Dispatch<SetStateAction<string>>;
+    clearErrorsTrigger?: number;
+    onClear?: (e: MouseEvent_2<HTMLButtonElement>) => void;
+    onCalendarOpen?: () => void;
+    isCellRenderer?: boolean;
+}
+
+export declare interface SmartGridDateRangePickerProps extends SmartGridDateConstraints {
+    startDate?: string;
+    endDate?: string;
+    onChange?: (dates: SmartGridDateRangeValue) => void;
+    disabled?: boolean;
+    label?: string;
+    required?: boolean;
+    error?: string;
+    withPortal?: boolean;
+    width?: string;
+    dateFormat?: SmartGridDateFormat;
+    isCellRenderer?: boolean;
+    tableApi?: SmartGridAPI | null;
+    readOnly?: boolean;
+    isOutsideRange?: (date: Moment) => boolean;
+    lazyLoadCellRenderer?: boolean;
+}
+
+export declare interface SmartGridDateRangeValue {
+    startDate: string;
+    endDate: string;
+}
+
+export declare type SmartGridDefaultColDef = {
+    minWidth: number;
+    headerComponentParams?: {
+        innerHeaderComponent: ((params: SmartGridHeaderStyleParams) => JSX.Element | string) | null;
+    };
+    headerComponent?: ((params: SmartGridHeaderStyleParams) => JSX.Element | string) | null;
+};
+
+export declare type SmartGridDispatch = (action: {
+    type: string;
+    payload: unknown;
+    meta?: {
+        fromAlignedGrid?: boolean;
+        defaultColDef?: SmartGridDefaultColDef;
+    } | Record<string, unknown>;
+}) => void;
+
+export declare interface SmartGridDisplayedColumn {
+    colDef: SmartGridColumnDefinition;
+    colId: string;
+    getColId: () => string;
+    isVisible: () => boolean;
+    isPinned: () => SmartGridPinnedType;
+    label: string;
+}
+
+export declare interface SmartGridDisplayedRowAtIndex {
+    data: SmartGridRowData;
+    rowIndex: number;
+    node: SmartGridParamsNode;
+    api: SmartGridAPI;
+}
+
+export declare interface SmartGridDisplayedRowNode extends SmartGridRowNode {
+    rowIndex: number;
+    absoluteRowIndex: number;
+    originalData: SmartGridRowData;
+    rowHeight?: number;
+}
+
+export declare interface SmartGridDisptach {
+    type: string;
+    payload?: unknown;
+}
+
+export declare interface SmartGridDragColumnParams {
+    hasChildren: boolean;
+    index: number;
+    column: SmartGridColumnDefinition;
+    dispatch: SmartGridDispatch;
+    columns: SmartGridColumnDefinition[];
+}
+
+export declare interface SmartGridDragColumnReturn {
+    handleDragStart: (e: React.DragEvent<HTMLElement>) => void;
+    handleDragOver: (e: React.DragEvent<HTMLElement>) => void;
+    handleDragLeave: () => void;
+    handleDrop: (e: React.DragEvent<HTMLElement>) => void;
+    handleDragEnd: () => void;
+    isDragging: boolean;
+    dragOverColumn: string | null;
+}
+
+export declare interface SmartGridDragColumnSettingParams {
+    localColumns: SmartGridColumnDefinition[];
+    dispatch: SmartGridDispatch;
+}
+
+export declare interface SmartGridDragColumnSettingReturn {
+    handleDragStart: (e: React.DragEvent<HTMLElement>, column: SmartGridColumnDefinition) => void;
+    handleDragOver: (e: React.DragEvent<HTMLElement>, column: SmartGridColumnDefinition) => void;
+    handleDragLeave: () => void;
+    handleDrop: (e: React.DragEvent<HTMLElement>, targetColumn: SmartGridColumnDefinition) => void;
+    handleDragEnd: () => void;
+    draggedColumn: SmartGridColumnDefinition | null;
+    dragOverColumn: SmartGridColumnDefinition | null;
+}
+
+export declare interface SmartGridDragRowParams {
+    rowIndex: number;
+    rowData: SmartGridRowData;
+    bodyContainerRef: MutableRefObject<HTMLElement | null>;
+}
+
+export declare interface SmartGridDragRowReturn {
+    handleDragStart: (e: React.DragEvent<HTMLElement>) => void;
+    handleDragEnd: () => void;
+    handleDragOver: (e: React.DragEvent<HTMLElement>) => void;
+    handleDragLeave: () => void;
+    handleDrop: (e: React.DragEvent<HTMLElement>) => void;
+}
+
+export declare interface SmartGridDragSourceData {
+    field: string;
+    index: number;
+    order_of_display?: number;
+    path: string[];
+}
+
+export declare interface SmartGridEvent {
+    type: string;
+    api?: SmartGridAPI;
+    [key: string]: unknown;
+}
+
+export declare type SmartGridEventListener = {
+    fn: SmartGridEventListenerFn;
+    once: boolean;
+};
+
+export declare type SmartGridEventListenerFn = (event: SmartGridEvent) => void;
+
+export declare interface SmartGridExpandableCellProps {
+    rowId: string | number;
+    isExpanded: boolean;
+    rowData: SmartGridRowData;
+    column: SmartGridColumnDefinition;
+    groupId: string | null;
+    rowIndex: number;
+    showMasterDetailToggle: boolean;
+    isRowGroupEnabled: boolean;
+    updatedCellId: string | number;
+    isGroupRowExpanded: boolean;
+}
+
+export declare type SmartGridExpandedChildRows = {
+    childRowsCount: number;
+    rowId: string | number;
+    rowIndex: number;
+    children?: SmartGridRowData[];
+};
+
+export declare type SmartGridExpandedColumnGroups = {
+    isAllGroupExpanded?: boolean;
+    [key: string]: boolean | undefined;
+};
+
+export declare interface SmartGridExportCallbackRefCurrent {
+    downloadExcelHandler?: (() => void) | null;
+    downloadCSVHandler?: (() => void) | null;
+    copyToClipboardHandler?: (() => void) | null;
+}
+
+/** Extended filter model with search and column filters */
+declare interface SmartGridExtendedFilterModel extends SmartGridFilterModel {
+    _search?: SmartGridFilterModel[];
+    _columnFilters?: Record<string, unknown>;
+}
+
+export declare type SmartGridFetchDataFunctionBody = {
+    range: SmartGridRangeFilter[];
+    search: SmartGridStringFilter[];
+    sort: SmartGridSortModel[];
+};
+
+export declare interface SmartGridFetchDataParams {
+    startRow: number;
+    endRow: number;
+    filterModel?: SmartGridFilterModel | null;
+    sortModel?: SmartGridSortModel | null;
+}
+
+export 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;
+}
+
+export declare type SmartGridFetDataParams = (body: SmartGridFetchDataFunctionBody, page: number, context?: SmartGridDataSourceContext, pageNum?: number, options?: {
+    pageSize: number;
+}) => Promise<SmartGridFetchResponse & {
+    totalCount?: number | null;
+}>;
+
+export 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;
+}
+
+export declare type SmartGridFloatingType = "top" | "bottom" | null;
+
+export declare interface SmartGridFocusedCell extends SmartGridSelectedCell {
+    floating: SmartGridFloatingType;
+}
+
+export declare type SmartGridFrozenColumnsDetails = {
+    indexes: string[];
+    positions: Record<string, number>;
+    totalWidth: number;
+    rightPinned: {
+        indexes: string[];
+        positions: Record<string, number>;
+        totalWidth: number;
+    };
+};
+
+export declare type SmartGridFrozenState = "left" | "right" | boolean | null | undefined;
+
+export declare interface SmartGridGetActualValueParams {
+    column: SmartGridColumnDefinition;
+    rowData: SmartGridRowData;
+    cellValue: string | number | {
+        label?: string;
+    } | {
+        label?: string;
+    }[];
+}
+
+export declare interface SmartGridGetDatePickerDataParams {
+    cellRenderer: string;
+    actualValue: {
+        startDate?: string;
+        endDate?: string;
+    } | string | string[];
+    cellValue: {
+        startDate?: string;
+        endDate?: string;
+    } | string | string[];
+}
+
+export declare interface SmartGridGetErrorInDateTimeParams {
+    column: SmartGridColumnDefinition;
+    actualValue: string;
+}
+
+export 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[];
+    };
+}
+
+export declare interface SmartGridGlobalColumnCounts {
+    leftPinnedOnly?: number;
+    rightPinnedOnly?: number;
+    normal?: number;
+    left?: number;
+    right?: number;
+}
+
+export declare interface SmartGridHeaderCellProps {
+    column: SmartGridColumnDefinition;
+    index: number;
+    onToggle?: (field: string, isExpandable: boolean) => void;
+    isExpandable?: boolean;
+    selectable?: boolean;
+    ShowFullText?: boolean;
+    totalFinalHeight?: number | null;
+    headerHeight?: number;
+    currentRowHeight?: {
+        maxHeight: number;
+        maxLineCount: number;
+    } | null;
+}
+
+export declare interface SmartGridHeaderMenuReturn {
+    unfreezeColumn: (column: SmartGridColumnDefinition) => void;
+    freezeColumn: (column: SmartGridColumnDefinition) => void;
+    pinColumnRight: (field: string) => void;
+    unpinColumnRight: (field: string) => void;
+    autoSizeColumn: (column: SmartGridColumnDefinition) => void;
+    customSizeColumn: (column: SmartGridColumnDefinition) => void;
+}
+
+export declare type SmartGridHeaderRowHeight = {
+    maxHeight: number;
+    maxLineCount: number;
+};
+
+export declare interface SmartGridHeaderRowHeightWithIndex {
+    [key: string]: SmartGridHeaderRowHeight;
+}
+
+export declare interface SmartGridHeaderSearchProps {
+    column: SmartGridColumnDefinition;
+    showInplaceSearchInput: boolean;
+    searchValue: string;
+    setSearchValue: (value: string) => void;
+    setShowSearchModal: (value: boolean | ((prev: boolean) => boolean)) => void;
+    advancedSearchApplyRef: MutableRefObject<boolean>;
+}
+
+export 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>>;
+};
+
+export declare type SmartGridHeightComfortable = {
+    type: "comfortable";
+    height: 52;
+    padding: 32;
+};
+
+export declare type SmartGridHeightCompact = {
+    type: "compact";
+    height: 30;
+    padding: 9;
+};
+
+export declare type SmartGridHeightDefault = {
+    type: "default";
+    height: 46;
+    padding: 24;
+};
+
+export declare interface SmartGridIATableState {
+    selectedCells: Map<string, SmartGridSelectedCellState>;
+    instanceKeyHandlers: Map<string, (e: KeyboardEvent) => void>;
+    activeInstance?: HTMLElement | null;
+}
+
+export 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;
+}
+
+export 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;
+}
+
+export declare interface SmartGridInfiniteCacheOptions {
+    threshold?: number;
+    maxBlocksInCache?: number;
+    cacheOverflowSize?: number;
+    rowHeight?: number;
+    purgeStrategy?: string;
+    enablePersistence?: boolean;
+    persistenceStorageKey?: string;
+    persistenceOptions?: Record<string, unknown>;
+    uniqueIdField?: string;
+    fetchDataMethodRef?: SmartGridFetchFunctionRef;
+    apiUrl?: string | null;
+    initialFilterModel?: SmartGridFilterModel | null;
+    initialSortModel?: SmartGridSortModel | null;
+    tableId?: string;
+    force?: boolean;
+    isServerSideRef?: MutableRefObject<boolean>;
+    pageSize?: number;
+    updatedPageSizeRef?: MutableRefObject<number>;
+    enableIndexedDBCache?: boolean;
+    enableStreamingLoad?: boolean;
+    enableEnhancedWorker?: boolean;
+    binaryFormat?: boolean;
+    extremelyLargeDatasetThreshold?: number;
+    tableContextRef?: MutableRefObject<SmartGridTableContextValue | null>;
+    context?: Record<string, unknown>;
+    onDataUpdate: (rows: SmartGridRowData[], blockId: number, metadata: Record<string, unknown> | undefined) => void;
+    isPaginationMode?: boolean;
+}
+
+export declare interface SmartGridInfiniteCacheParams {
+    datasource: SmartGridInfiniteCacheDataSourceParams;
+    updatedPageSizeRef: MutableRefObject<number>;
+    pageSize: number;
+    overflowSize: number;
+}
+
+export 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[];
+}
+
+export declare interface SmartGridInfiniteRowModel {
+    infiniteCache?: SmartGridInfiniteCache;
+    setViewportRange?: (startRow: number, endRow: number) => void;
+    logCacheSummary?: () => void;
+    datasource: {
+        getWholeData: () => SmartGridRowData[];
+    };
+    [key: string]: unknown;
+}
+
+export 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;
+}
+
+export declare interface SmartGridInfiniteScrollLoaderProps {
+    isLoading: boolean;
+    colSpan: number;
+}
+
+export declare interface SmartGridInitialDataUpdateParams {
+    dispatch: SmartGridDispatch;
+    pinnedTopRows: SmartGridRowData[];
+    pinnedBottomRows: SmartGridRowData[];
+    tableInstance: MutableRefObject<HTMLElement | null>;
+    columnMap: Record<string, SmartGridColumnDefinition>;
+    uniqueIdField: string;
+    childKeyField: string;
+    enableRowSpan?: boolean;
+    rowSpanColumn?: string | string[];
+    pageSize: number;
+    serverSide: boolean;
+    rowDragManaged?: boolean;
+    infiniteScroll?: boolean;
+    initialExpandedColumnGroups?: Record<string, boolean>;
+    tableApi: SmartGridAPI | null;
+    smartGridMenuOptions?: SmartGridMenuOptions;
+    purgeClosedRowNodes?: boolean;
+    detailRendererTable?: boolean;
+    isSaveViewEnabled?: boolean;
+    isSavingViewLoading?: boolean;
+    savedViewsOptions?: unknown[];
+    rowHeight?: string;
+    tableId: string;
+    refObj: MutableRefObject<unknown>;
+    callBackRef: MutableRefObject<SmartGridCallbackRefCurrent | null>;
+    exportCallbackRef: MutableRefObject<SmartGridExportCallbackRefCurrent | null>;
+    saveViewCallbackRef: MutableRefObject<SmartGridSaveViewCallbackRefCurrent | null>;
+    saveViewOptionsRef: MutableRefObject<SmartGridSaveViewOptionsRefCurrent | null>;
+    isSingleSelect?: boolean;
+    defaultColDef?: SmartGridDefaultColDef;
+    disableSelectAllRecords?: boolean;
+    selectable?: boolean;
+    columnBufferSize?: number;
+    lazyLoadCellRenderer?: boolean;
+    hasSplitRenderer?: boolean;
+    splitRendererKeys?: string[];
+}
+
+export declare interface SmartGridInputFormatInstance {
+    colDef?: {
+        type?: string;
+        id?: string;
+        extra?: {
+            roundOffTo?: number;
+            showNullAsEmpty?: boolean;
+        };
+    };
+    data?: {
+        roundOffTo?: number;
+    };
+    isCellInFocus?: boolean;
+    isCeil?: boolean;
+    roundOffTo?: number;
+    type?: string;
+    inputType?: string;
+}
+
+export declare interface SmartGridInputProps {
+    placeholder?: string;
+    label?: string;
+    value?: string | number;
+    onChange: (e: ChangeEvent<HTMLInputElement>) => void;
+    type?: SmartGridInputType;
+    disabled?: boolean;
+    error?: string;
+    leftIcon?: ReactNode;
+    rightIcon?: ReactNode;
+    className?: string;
+    width?: string | number;
+    onClick?: (e: MouseEvent_2<HTMLInputElement>) => void;
+    isCellRenderer?: boolean;
+    inputType?: SmartGridInputValueType;
+    iconButton?: ReactNode;
+    iconButtonClassName?: string;
+    height?: string | number;
+    onFocus?: (e: FocusEvent_2<HTMLInputElement>) => void;
+    onBlur?: (e: FocusEvent_2<HTMLInputElement>) => void;
+}
+
+export declare type SmartGridInputType = "text" | "password" | "email" | "number" | "tel" | "int" | "url";
+
+export declare type SmartGridInputValueType = "text" | "str" | "int" | "float" | "decimal" | "percentage" | "dollar";
+
+export 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;
+}
+
+export declare interface SmartGridMasterDetailConfig {
+    enabled: boolean;
+    expandedRows: (string | number)[];
+    detailRenderer: React.ComponentType | null;
+    detailRowHeight: number;
+    detailPadding: number;
+    expandedRowData: SmartGridRowData[];
+    currentRowStyles?: {
+        height?: number;
+        top?: number;
+    };
+    rowIndex?: number | null;
+}
+
+export declare interface SmartGridMemoryAnalyticsParams {
+    modelRef: MutableRefObject<SmartGridInfiniteRowModelRef | null>;
+    shouldUseCache: boolean;
+}
+
+export declare interface SmartGridMemoryAnalyticsReturn {
+    memoryUsage: number;
+    analytics: SmartGridCacheAnalyticsData | null;
+    updateAnalytics: () => void;
+    resetAnalytics: () => void;
+    updateMemoryAndAnalytices: () => void;
+}
+
+export declare type SmartGridMenuAlignment = "start" | "end" | "auto";
+
+export declare interface SmartGridMenuAlignments {
+    START: "start";
+    END: "end";
+    AUTO: "auto";
+}
+
+export declare interface SmartGridMenuOption {
+    label: string | number;
+    id: string | number;
+    onClick: (value: string | number) => void;
+    icon?: ReactNode;
+    submenu?: SmartGridMenuOption[];
+    submenuPosition?: SmartGridMenuPosition;
+    submenuWidth?: number;
+    submenuIconPlacement?: "left" | "right";
+    selectedElement?: string | number;
+    useHover?: boolean;
+    noCloseOnSelect?: boolean;
+    isDisabled?: boolean;
+}
+
+export declare interface SmartGridMenuOptions {
+    withColumMenu?: boolean;
+    autoWithColumMenu?: boolean;
+    freezeColumnMenu?: boolean;
+    sortColumnMenu?: boolean;
+    collapseColumnAll?: boolean;
+    expandColumnAll?: boolean;
+    wrapText?: boolean;
+}
+
+export declare type SmartGridMenuPosition = "top" | "bottom" | "left" | "right";
+
+export declare interface SmartGridMenuPositionResult {
+    top?: number;
+    left?: number;
+    width?: number;
+    transformOrigin?: string;
+    transform?: string;
+}
+
+export declare interface SmartGridMenuPositions {
+    BOTTOM: "bottom";
+    TOP: "top";
+    LEFT: "left";
+    RIGHT: "right";
+}
+
+export declare interface SmartGridMenuPositionState {
+    top: number;
+    left: number;
+    width?: number;
+    height?: number;
+    visibility?: "visible" | "hidden";
+    transform?: string;
+    transformOrigin?: string;
+}
+
+export declare interface SmartGridMenuProps {
+    options?: SmartGridMenuOption[];
+    selectedElement?: string | number;
+    iconPlacement?: "left" | "right";
+    isOpen: boolean;
+    setIsOpen: (isOpen: boolean) => void;
+    menuButtonRef?: RefObject<HTMLElement>;
+    position?: SmartGridMenuPosition;
+    width?: number;
+    horizontalAlign?: SmartGridMenuAlignment;
+    isSubmenu?: boolean;
+    parentOptionRef?: RefObject<HTMLElement> | null;
+    skipAnimation?: boolean;
+    portalContainer?: HTMLElement;
+    additionalButtons?: ReactNode;
+    forcePosition?: boolean;
+}
+
+export declare interface SmartGridModalProps {
+    open?: boolean;
+    onClose: () => void;
+    title?: string;
+    children?: ReactNode;
+    size?: SmartGridModalSize;
+    width?: string | number;
+    height?: string | number;
+    className?: string;
+    onPrimaryButtonClick?: () => void;
+    primaryButtonLabel?: string;
+    onSecondaryButtonClick?: () => void;
+    secondaryButtonLabel?: string;
+    closeOnOutsideClick?: boolean;
+    primaryButtonVariant?: SmartGridButtonVariant;
+    primaryButtonProps?: Record<string, unknown>;
+    showCloseButton?: boolean;
+    showPrimaryButton?: boolean;
+    showSecondaryButton?: boolean;
+}
+
+export declare type SmartGridModalSize = "small" | "medium" | "large";
+
+export declare type SmartGridModelType = "normal" | "serverSide" | "infinite";
+
+export declare interface SmartGridNewSortModel {
+    column: string | null;
+    order: SmartGridSortDirection | null;
+}
+
+export declare interface SmartGridNotification {
+    message: string;
+    type?: "success" | "error" | "warning" | "info";
+    duration?: number;
+    timeout?: number;
+}
+
+export declare type SmartGridNumberFormat = "full" | "thousands" | "millions" | "billions";
+
+export declare interface SmartGridOldSortModel {
+    colId: string;
+    sort: SmartGridSortDirection;
+}
+
+export declare type SmartGridOnReadyParams = {
+    api: SmartGridAPI;
+    columnApi: SmartGridAPI;
+    type: "gridReady";
+};
+
+export declare type SmartGridOnSelectionChangedParams = {
+    api: SmartGridAPI;
+    type: string;
+    source: string;
+};
+
+export declare interface SmartGridOptions {
+    [key: string]: unknown;
+}
+
+export declare type SmartGridOutsideClickCallback = () => void;
+
+/** Page size ref */
+declare interface SmartGridPageSizeRef {
+    current: number;
+}
+
+/** Page size ref */
+declare interface SmartGridPageSizeRef_2 {
+    current: number;
+}
+
+export declare interface SmartGridPagesPerPageSectionProps {
+    label: string;
+    options: Array<{
+        label: string | number;
+        id: string | number;
+        onClick: (value: number) => void;
+    }>;
+    selectedElement: number;
+}
+
+export declare interface SmartGridPaginationModel {
+    currentPage: number;
+    pageSize: number;
+    totalPages: number;
+    totalRecords: number;
+}
+
+export declare interface SmartGridPaginationProps {
+    pagination?: boolean;
+    hidePaginationPageSizeSelector?: boolean;
+    paginationPageSizeSelector?: number[];
+}
+
+export declare interface SmartGridPaginationRelated {
+    totalItems: number;
+    totalPages: number;
+    currentPage: number;
+    isCountUnknown: boolean;
+}
+
+export 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;
+}
+
+export declare interface SmartGridPinnedRowsProps {
+    rowHeight: number;
+    selectable: boolean;
+    expandable: boolean;
+    pinnedRows: SmartGridRowData[];
+    onRowClick?: SmartGridRowClickHandler;
+    pinnedRowsRef: RefObject<HTMLDivElement | null>;
+    leftPinnedOnly: boolean;
+    rightPinnedOnly: boolean;
+    frozenColumnWidth: number;
+    isPinnedGrandTotalRow: boolean;
+    isLeftPinnedRowsAvailable: boolean;
+    handlePinnedScroll: SmartGridScrollHandler;
+    virtualizedAllVisibleColumns: SmartGridColumnDefinition[];
+    virtualizedStartCololumnIndex: MutableRefObject<number>;
+    uniqueIdField: string;
+    pinnedType: "top" | "bottom";
+    allColumnsLastRow: SmartGridColumnDefinition[];
+}
+
+export declare type SmartGridPinnedType = "leftPinned" | "rightPinned" | null;
+
+export declare type SmartGridPinType = "leftPinnedOnly" | "rightPinnedOnly" | "normal";
+
+export declare interface SmartGridPromptButton {
+    label: string;
+    type: "default" | "primary" | "secondary";
+    onClick?: () => void;
+}
+
+export declare interface SmartGridPromptProps {
+    isOpen?: boolean;
+    handleClose: (e?: MouseEvent_2) => void;
+    title: string;
+    children: ReactNode;
+    variant?: SmartGridPromptVariant;
+    onPrimaryButtonClick: (e: MouseEvent_2<HTMLButtonElement>) => void;
+    primaryButtonLabel?: string;
+    onSecondaryButtonClick?: (e: MouseEvent_2<HTMLButtonElement>) => void;
+    secondaryButtonLabel?: string;
+    primaryButtonProps?: Record<string, unknown>;
+}
+
+export declare type SmartGridPromptVariant = "info" | "success" | "warning" | "delete" | "error";
+
+export declare interface SmartGridRadioGroupProps {
+    options: SmartGridRadioOption[];
+    selectedOption: string | number;
+    onChange: (e: ChangeEvent<HTMLInputElement>) => void;
+    orientation?: SmartGridRadioOrientation;
+    disabled?: boolean;
+    name?: string;
+}
+
+export declare interface SmartGridRadioOption {
+    value: string | number;
+    label: string;
+    disabled?: boolean;
+}
+
+export declare type SmartGridRadioOrientation = "vertical" | "horizontal";
+
+export declare type SmartGridRangeFilter = {
+    column: string;
+    min_val: number;
+    max_val: number;
+    search_type: string;
+    operator?: string;
+};
+
+export declare interface SmartGridRefreshCacheOptions {
+    purge?: boolean;
+    partialRefresh?: boolean;
+    preserveFields?: string[];
+    userInitiated?: boolean;
+}
+
+export declare interface SmartGridRefreshOptions {
+    purge?: boolean;
+    resetPage?: boolean;
+    userInitiated?: boolean;
+}
+
+export declare interface SmartGridRemoveLazyLoadParams {
+    cellRef: RefObject<HTMLDivElement>;
+}
+
+export declare interface SmartGridRenderHeadersProps {
+    leftPinnedOnly: boolean;
+    rightPinnedOnly: boolean;
+    filteredColumns: SmartGridColumnDefinition[];
+    selectable: boolean;
+    virtualizedHeaderRows: SmartGridColumnDefinition[][];
+    dispatch: SmartGridDispatch;
+    headerRows: SmartGridColumnDefinition[][];
+    virtualizedColumns: SmartGridColumnDefinition[];
+    headerRowHeightwithIndex: SmartGridHeaderRowHeightWithIndex;
+    ShowFullText: boolean;
+    virtualizedStartCololumnIndex: MutableRefObject<number>;
+}
+
+/** Response metadata */
+declare interface SmartGridResponseMetadata {
+    totalCount?: number;
+    lastRowIndexKnown?: boolean;
+}
+
+export declare interface SmartGridRowClickHandler {
+    (rowData: SmartGridRowData, rowIndex: number): void;
+}
+
+export 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;
+    };
+}
+
+export declare interface SmartGridRowDragEndParams {
+    api: SmartGridAPI;
+    type: "rowDragEnd";
+    fromIndex: number;
+    toIndex: number;
+    rowData: SmartGridRowData;
+}
+
+export declare interface SmartGridRowDragStartParams {
+    api: SmartGridAPI;
+    type: "rowDragStart";
+    rowIndex: number;
+    rowData: SmartGridRowData;
+}
+
+export declare type SmartGridRowGrouOpenParams = {
+    rowId: string;
+    rowIndex: number;
+    api: SmartGridAPI;
+    isExpanded: boolean;
+};
+
+export declare type SmartGridRowGroupPaginationParams = {
+    page: number;
+    pageSize: number;
+};
+
+export declare interface SmartGridRowGroupPaginationState extends SmartGridRowGroupStatePagination {
+    page: number;
+    pageSize: number;
+    hasMore: boolean;
+}
+
+export declare interface SmartGridRowGroupParams {
+    groupId: string;
+    isRowGroupEnabled: boolean;
+    loadingRef: RefObject<HTMLDivElement | null>;
+}
+
+export declare interface SmartGridRowGroupReturn {
+    groupData: SmartGridRowData[];
+    isLoading: boolean;
+    hasMore: boolean;
+    error: string | null;
+    groupLoading: boolean;
+    loadingRef: RefObject<HTMLDivElement | null>;
+}
+
+export 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;
+};
+
+export declare type SmartGridRowGroupStateExpandedGroups = {
+    count: number;
+    fieldName: string;
+    rowIndex: number;
+    value: string;
+    [key: string]: boolean | number | string;
+};
+
+export declare type SmartGridRowGroupStatePagination = {
+    hasMore: boolean;
+    lastUpdated: number;
+    page: number;
+    pageSize: number;
+    totalItems?: number;
+    totalPages?: number;
+    error?: boolean;
+};
+
+export declare type SmartGridRowHeightMap = Record<string | number, number>;
+
+export declare interface SmartGridRowHoverEffectParams {
+    scrollContainerRef: RefObject<HTMLElement | null>;
+    tableInstance: MutableRefObject<HTMLElement | null>;
+}
+
+export declare type SmartGridRowInfo = {
+    isFirst: boolean;
+    span: number;
+    rowIds?: (string | number)[];
+};
+
+export 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;
+}
+
+export declare interface SmartGridRowRenderer {
+    firstRenderedRow: number;
+    lastRenderedRow: number;
+    setRenderedRange: (firstRow: number, lastRow: number) => void;
+}
+
+export declare interface SmartGridRowRenderProps {
+    currentPageData: SmartGridRowData[];
+    onRowClick?: SmartGridRowClickHandler;
+    selectable: boolean;
+    expandable: boolean;
+    leftPinnedOnly: boolean;
+    rightPinnedOnly: boolean;
+    virtualizedAllVisibleColumns: SmartGridColumnDefinition[];
+    bodyContainerRef: RefObject<HTMLDivElement>;
+    allColumnsLastRow: SmartGridColumnDefinition[];
+    rowHeight: number;
+    masterDetailEnabled: boolean;
+    showInfiniteLoader: boolean;
+    totalHeight: number;
+    loadedData: Record<string, SmartGridRowData[]>;
+    expandedGroups: Record<string, SmartGridRowGroupStateExpandedGroups>;
+    rowHeightMap: SmartGridRowHeightMap;
+    isLoading?: boolean;
+    shimmerRowCount?: number;
+    virtualizedStartCololumnIndex: MutableRefObject<number>;
+    columnHorizontalScrollContainerRef: RefObject<HTMLDivElement>;
+    tableApi: SmartGridAPI | null;
+    scrollContainerRef: RefObject<HTMLDivElement>;
+    rowHeightCache: RowHeightCache | null;
+    adjustTableHeightServerSide?: boolean;
+}
+
+export declare interface SmartGridRowSpanInfo {
+    [key: string]: SmartGridRowInfo | boolean | undefined;
+    isRowSpan?: boolean;
+    Selection?: SmartGridRowInfo;
+}
+
+export declare interface SmartGridRowSpanInfoDetails {
+    span?: number;
+    isFirst?: boolean;
+}
+
+export declare type SmartGridRowStyleParams = {
+    api: SmartGridAPI;
+    data: SmartGridRowData;
+    pinned: boolean;
+    node: {
+        rowIndex: number;
+        data: SmartGridRowData;
+        api: SmartGridAPI;
+        pinned: boolean;
+    };
+};
+
+export declare interface SmartGridSafeCellRendererProps {
+    renderer: React.ComponentType<SmartGridCellRendererParams> | ((params: SmartGridCellRendererParams) => JSX.Element);
+    params: SmartGridCellRendererParams;
+}
+
+export declare type SmartGridSavedViewsOptions = {
+    isActive: boolean;
+    isDefaultView: boolean;
+    viewName: string;
+    viewType: "personal" | "global";
+};
+
+export 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;
+}
+
+export declare interface SmartGridSaveViewOptionsRefCurrent {
+    maxSavedViews?: number | null;
+    deleteViewPromptText?: string | null;
+}
+
+export declare interface SmartGridScrollHandler {
+    (event: React.UIEvent<HTMLDivElement>): void;
+}
+
+export declare interface SmartGridScrollSyncParams {
+    frozenScrollContainerRef?: RefObject<HTMLDivElement | null>;
+    normalScrollContainerRef?: RefObject<HTMLDivElement | null>;
+    rightPinnedScrollContainerRef?: RefObject<HTMLDivElement | null>;
+}
+
+export declare interface SmartGridScrollSyncReturn {
+    headerScrollContainerRef: RefObject<HTMLDivElement | null>;
+    pinnedTopScrollContainerRef: RefObject<HTMLDivElement | null>;
+    pinnedBottomScrollContainerRef: RefObject<HTMLDivElement | null>;
+    createHeaderScrollHandler: (bodyScrollRef: RefObject<HTMLDivElement | null>) => (e: React.UIEvent<HTMLElement>) => void;
+    createPinnedTopScrollHandler: (bodyScrollRef: RefObject<HTMLDivElement | null>) => (e: React.UIEvent<HTMLElement>) => void;
+    createPinnedBottomScrollHandler: (bodyScrollRef: RefObject<HTMLDivElement | null>) => (e: React.UIEvent<HTMLElement>) => void;
+    createBodyScrollHandler: (bodyScrollRef: RefObject<HTMLDivElement | null>, handleColumnScroll: ((e: React.UIEvent<HTMLElement>) => void) | null) => (e: React.UIEvent<HTMLElement>) => void;
+    createNormalScrollHandler: (handleColumnScroll: ((e: React.UIEvent<HTMLElement>) => void) | null) => (e: React.UIEvent<HTMLElement>) => void;
+    handleFrozenScroll: (e: React.UIEvent<HTMLElement>) => void;
+    handleRightPinnedScroll: (e: React.UIEvent<HTMLElement>) => void;
+    syncHorizontalScroll: (scrollLeft: number, sourceElement: HTMLElement, bodyScrollRef?: RefObject<HTMLDivElement | null> | null) => void;
+}
+
+export declare type SmartGridSearchFunctionParams = SmartGridFilterModel[] | Record<string, SmartGridFilterModel[]>;
+
+export declare type SmartGridSearchFunctionParamsWithField = Record<string, SmartGridFilterModel>;
+
+export declare interface SmartGridSearchInputWithoutBorderProps {
+    inputRef?: RefObject<HTMLInputElement>;
+    onChange: (e: ChangeEvent<HTMLInputElement>) => void;
+    type?: string;
+    placeholder?: string;
+    value?: string;
+}
+
+export declare interface SmartGridSearchOperatorOption {
+    value: string;
+    label: string;
+    type?: string;
+}
+
+export declare interface SmartGridSearchWithSearchKey {
+    _search: SmartGridSearchFunctionParamsWithField;
+}
+
+export declare interface SmartGridSelectDropdownPosition {
+    top: number;
+    left: number;
+    width: number;
+}
+
+export declare interface SmartGridSelectedCell {
+    colIndex: number;
+    column: SmartGridColumnDefinition;
+    data: SmartGridRowData;
+    field: string;
+    rowId: string | number;
+    rowIndex: number;
+    value: unknown;
+}
+
+export declare interface SmartGridSelectedCellState {
+    rowIndex: number;
+    colIndex: number;
+    column: SmartGridColumnDefinition;
+    cellValue: unknown;
+    rowData: SmartGridRowData;
+    target: HTMLElement;
+    tableId: string;
+    frozenColumnsLength: number;
+    pinnedType?: SmartGridPinnedType;
+    rowId: string | number;
+    field: string;
+    tableInstanceId?: string | undefined;
+    rowAttr: string | null;
+}
+
+export declare interface SmartGridSelectOption {
+    value: string | number;
+    label: string;
+    isDisabled?: boolean;
+}
+
+export declare type SmartGridSelectOptions = Dispatch<SetStateAction<SmartGridSelectOptionsCombination>> | SmartGridSelectOptionsCombinationFunc;
+
+export declare type SmartGridSelectOptionsCombination = SmartGridSelectOption | SmartGridSelectOption[] | null;
+
+export declare type SmartGridSelectOptionsCombinationFunc = (option: SmartGridSelectOptionsCombination) => void;
+
+export declare interface SmartGridSelectProps {
+    label?: string;
+    width?: string | number;
+    selectedOptions: SmartGridSelectOptionsCombination;
+    setSelectedOptions: SmartGridSelectOptions;
+    isDisabled?: boolean;
+    isOpen?: boolean;
+    setIsOpen?: (isOpen: boolean) => void;
+    initialOptions?: SmartGridSelectOption[];
+    withPortal?: boolean;
+    className?: string;
+    isMulti?: boolean;
+    currentOptions?: SmartGridSelectOption[];
+    setCurrentOptions?: Dispatch<SetStateAction<SmartGridSelectOption[]>>;
+    onBlur?: () => void;
+    isCellRenderer?: boolean;
+    tableApi?: SmartGridAPI | null;
+    lazyLoadCellRenderer?: boolean;
+}
+
+export declare interface SmartGridServerProps {
+    totalItems: number;
+    totalPages: number;
+    currentPage: number;
+    isCountUnknown: boolean;
+    enablePaginationWhenCountUnknown?: boolean;
+    displayNextPageButton?: boolean;
+    pageSize: number;
+}
+
+export 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;
+}
+
+export declare interface SmartGridServerSideGetRowsParams {
+    request: {
+        startRow: number;
+        endRow: number;
+        filterModel?: SmartGridFilterModel | SmartGridSearchWithSearchKey | null;
+        sortModel?: SmartGridSortModel | null;
+    };
+    api: SmartGridAPI;
+    success: (response: SmartGridFetchDataResponse) => void;
+    fail: () => void;
+}
+
+export declare interface SmartGridShimmerRowProps {
+    columns?: SmartGridColumnDefinition[];
+    selectable?: boolean;
+    expandable?: boolean;
+    rowHeight?: number;
+    isShimmering?: boolean;
+    virtualizedAllVisibleColumns?: SmartGridColumnDefinition[];
+    isSingleSelect?: boolean;
+    leftPinnedOnly?: boolean;
+    disableSelectAllRecords?: boolean;
+}
+
+export declare type SmartGridSortDirection = "asc" | "desc" | "none";
+
+export declare type SmartGridSortModel = SmartGridOldSortModel | SmartGridNewSortModel | null;
+
+export declare interface SmartGridSortWithHeaderNameProps {
+    isAutoHeightColumn?: boolean;
+    sortState: SmartGridSortModel;
+    onSort: (columnId: string, direction: string) => void;
+    column: SmartGridColumnDefinition;
+    isExpandable?: boolean;
+    availableWidth: number;
+    onToggle?: (field: string, isExpandable: boolean) => void;
+    isExpandedGrouping: boolean;
+    showSortIcon?: boolean;
+    wrapHeaderText?: boolean;
+    ShowFullText?: boolean;
+    totalFinalHeight?: number | null;
+    isIntegerType?: boolean;
+    currentRowHeight?: {
+        maxHeight: number;
+        maxLineCount: number;
+    } | null;
+    innerHeaderComponent?: ((props: SmartGridHeaderStyleParams) => JSX.Element | string) | null;
+    customHeaderProps?: SmartGridHeaderStyleParams;
+}
+
+export 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>;
+    [key: string]: unknown;
+}
+
+export declare type SmartGridStringFilter = {
+    column: string;
+    pattern: string;
+    search_type: string;
+    operator?: string;
+};
+
+export declare interface SmartGridSwitchProps {
+    value: boolean;
+    leftLabel?: string;
+    rightLabel?: string;
+    disabled?: boolean;
+    onChange: (value: boolean) => void;
+}
+
+export declare interface SmartGridTableAPIObject {
+    api: SmartGridAPI;
+    tableId?: string;
+}
+
+export declare interface SmartGridTableBodyContentProps {
+    onRowClick?: SmartGridRowClickHandler;
+    expandable?: boolean;
+    paginateOriginalRowsOnly?: boolean;
+    adjustTableHeightServerSide?: boolean;
+    tableId?: string;
+    alignedGrids?: string[];
+    headerHeight?: number | string;
+    showHeader?: boolean;
+    masterDetail?: boolean;
+    height?: number | string;
+    normalScrollContainerRef: RefObject<HTMLDivElement>;
+    ShowFullText?: boolean;
+    enterPriseTableRef: RefObject<HTMLDivElement>;
+}
+
+export declare interface SmartGridTableBodyProps {
+    onRowClick?: SmartGridRowClickHandler;
+    selectable?: boolean;
+    expandable?: boolean;
+    leftPinnedOnly?: boolean;
+    rightPinnedOnly?: boolean;
+    adjustTableHeightServerSide?: boolean;
+    masterDetailEnabled?: boolean;
+    allColumnsLastRow?: SmartGridColumnDefinition[];
+    scrollContainerRef: RefObject<HTMLDivElement>;
+    virtualizedAllVisibleColumns?: SmartGridColumnDefinition[];
+    isInfiniteLoadingMoreRef: MutableRefObject<boolean>;
+    shimmerRowCount?: number;
+    virtualizedStartCololumnIndex: MutableRefObject<number>;
+    columnHorizontalScrollContainerRef: RefObject<HTMLDivElement>;
+    paginateOriginalRowsOnly?: boolean;
+}
+
+export declare type SmartGridTableComponentProps = SmartGridTableProps;
+
+export declare interface SmartGridTableContentDetailsProps {
+    frozenScrollContainerRef: RefObject<HTMLDivElement>;
+    normalScrollContainerRef: RefObject<HTMLDivElement>;
+    rightPinnedScrollContainerRef: RefObject<HTMLDivElement>;
+    columnHorizontalScrollContainerRef: RefObject<HTMLDivElement>;
+    headerRowRef: RefObject<HTMLDivElement>;
+    headerHeight?: number | string;
+    showHeader?: boolean;
+    expandable?: boolean;
+    selectable?: boolean;
+    leftPinnedOnly?: boolean;
+    rightPinnedOnly?: boolean;
+    alignedGrids?: string[];
+    masterDetail?: boolean;
+    onRowClick?: SmartGridRowClickHandler;
+    adjustTableHeightServerSide?: boolean;
+    paginateOriginalRowsOnly?: boolean;
+    tableId?: string;
+    height?: number | string;
+    ShowFullText?: boolean;
+    isLeftPinnedRowsAvailable?: boolean;
+    columnScrollHandlerRef?: MutableRefObject<SmartGridScrollHandler | null>;
+    isScrollingSynced?: MutableRefObject<boolean>;
+}
+
+export declare interface SmartGridTableContentProps {
+    showHeader?: boolean;
+    showFooter?: boolean;
+    showToolbar?: boolean;
+    showSaveTableConfig?: boolean;
+    height?: number | string;
+    headerHeight?: number | string;
+    pagination?: boolean;
+    paginateOriginalRowsOnly?: boolean;
+    tableHeader?: string | ReactNode;
+    topRightOptions?: string | ReactNode;
+    topLeftOptions?: string | ReactNode;
+    bottomLeftOptions?: string | ReactNode;
+    bottomCenterOptions?: string | ReactNode;
+    bottomRightOptions?: string | ReactNode;
+    additionalButtons?: string | ReactNode;
+    adjustTableHeightServerSide?: boolean;
+    tableId?: string | null;
+    alignedGrids?: string[];
+    masterDetail?: boolean;
+    detailCellRenderer?: React.ComponentType | null;
+    detailRowHeight?: number;
+    downloadAsExcel?: boolean;
+    downloadAsCSV?: boolean;
+    copyToClipboard?: boolean;
+    hidePaginationPageSizeSelector?: boolean;
+    paginationPageSizeSelector?: number[];
+    aboveTableComponent?: ReactNode;
+    shouldRenderTable?: boolean;
+    nestedTable?: boolean;
+    nestedTableComponent?: ReactNode | null;
+    enableNestedTableCloseButton?: boolean;
+    onCloseNestedTable?: () => void;
+    showTableSettingActionTab?: boolean;
+    showTableSettingFormatTab?: boolean;
+    hideNotification?: boolean;
+    expandable?: boolean;
+    onRowClick?: SmartGridRowClickHandler;
+    ShowFullText?: boolean;
+    detailRendererTable?: boolean;
+    showFilters?: boolean;
+    onCellClick?: () => void;
+    onPageChange?: (page: number) => void;
+    onSortChange?: (sortModel: unknown) => void;
+    onFilterChange?: (filterModel: unknown) => void;
+    totalItems?: number;
+    totalPages?: number;
+    currentPage?: number;
+    isCountUnknown?: boolean;
+    onScroll?: (event: React.UIEvent<HTMLDivElement>) => void;
+    defaultColDef?: Record<string, unknown>;
+    copyToClipboardHandler?: () => void;
+    downloadExcelHandler?: () => void;
+    downloadCSVHandler?: () => void;
+}
+
+export declare interface SmartGridTableContentRendererProps {
+    headerRows: SmartGridColumnDefinition[][];
+    visibleColumns: SmartGridColumnDefinition[];
+    leftPinnedOnly: boolean;
+    rightPinnedOnly: boolean;
+    columnHorizontalScrollContainerRef: RefObject<HTMLDivElement>;
+    pinnedType: SmartGridPinType;
+    globalColumnCounts: SmartGridGlobalColumnCounts;
+    virtualizedStartCololumnIndex: MutableRefObject<number>;
+    mainContainerClassName: string;
+    mainContainerStyles: CSSProperties;
+    tableId?: string;
+    showHeader?: boolean;
+    headerHeight?: number | string;
+    headerScrollContainerRef: RefObject<HTMLDivElement | null>;
+    handleHeaderScroll: SmartGridScrollHandler;
+    headerRowRef: RefObject<HTMLDivElement | null>;
+    totalNormalColumnWidth: number | string;
+    selectable: boolean;
+    filteredColumns: SmartGridColumnDefinition[];
+    ShowFullText?: boolean;
+    expandable: boolean;
+    onRowClick?: SmartGridRowClickHandler;
+    pinnedTopScrollContainerRef: RefObject<HTMLDivElement | null>;
+    frozenColumnWidth: number;
+    isLeftPinnedRowsAvailable?: boolean;
+    handlePinnedTopScroll: SmartGridScrollHandler;
+    handleRightPinnedScroll: SmartGridScrollHandler;
+    handleFrozenScroll: SmartGridScrollHandler;
+    createBodyScrollHandler: (columnHorizontalScrollContainerRef: RefObject<HTMLDivElement | null>, handleColumnScroll: ((e: React.UIEvent<HTMLElement>) => void) | null) => (e: React.UIEvent<HTMLElement>) => void;
+    containerStyles: CSSProperties;
+    bodyContainerClassName: string;
+    bodyScrollContainer: RefObject<HTMLDivElement | null>;
+    height?: number | string;
+    handleHorizontalNormalScroll: SmartGridScrollHandler;
+    paginateOriginalRowsOnly?: boolean;
+    adjustTableHeightServerSide?: boolean;
+    masterDetail?: boolean;
+    pinnedBottomScrollContainerRef: RefObject<HTMLDivElement | null>;
+    handlePinnedBottomScroll: SmartGridScrollHandler;
+    isInfiniteLoadingMoreRef: MutableRefObject<boolean>;
+}
+
+export declare interface SmartGridTableContextRef {
+    state?: SmartGridStateContext;
+    tableApi?: SmartGridAPI;
+}
+
+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;
+}
+
+export declare interface SmartGridTableFooterProps {
+    bottomCenterOptions?: ReactNode;
+    bottomLeftOptions?: ReactNode;
+    bottomRightOptions?: ReactNode;
+    pagination?: boolean;
+    hidePaginationPageSizeSelector?: boolean;
+    paginationPageSizeSelector?: number[];
+}
+
+export declare interface SmartGridTableHeaderProps {
+    selectable?: boolean;
+    leftPinnedOnly?: boolean;
+    rightPinnedOnly?: boolean;
+    virtualizedHeaderRows?: SmartGridColumnDefinition[][];
+    filteredColumns: SmartGridColumnDefinition[];
+    headerRows: SmartGridColumnDefinition[][];
+    virtualizedColumns: SmartGridColumnDefinition[];
+    virtualizedStartCololumnIndex: MutableRefObject<number>;
+    ShowFullText?: boolean;
+}
+
+export declare interface SmartGridTableInstance {
+    current: HTMLElement | null;
+}
+
+export 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[];
+}
+
+export declare interface SmartGridTableProps extends SmartGridSaveViewCallbackRefCurrent {
+    ref?: Ref<SmartGridTableRef>;
+    data?: SmartGridRowData[] | null;
+    columns: SmartGridColumnDefinition[];
+    uniqueIdField?: string;
+    height?: number | string;
+    childKeyField?: string;
+    defaultColDef?: SmartGridDefaultColDef;
+    pinnedTopRowData?: SmartGridRowData[] | null;
+    pinnedBottomRowData?: SmartGridRowData[] | null;
+    getRowStyle?: (params: SmartGridRowStyleParams) => CSSProperties;
+    tableHeader?: string | ReactNode;
+    topRightOptions?: string | ReactNode;
+    bottomLeftOptions?: string | ReactNode;
+    bottomCenterOptions?: string | ReactNode;
+    bottomRightOptions?: string | ReactNode;
+    topLeftOptions?: string | ReactNode;
+    headerHeight?: number | string;
+    onSelectionChanged?: (event: SmartGridOnSelectionChangedParams) => void;
+    onRowDragStart?: (event: SmartGridRowDragStartParams) => void;
+    onRowDragEnd?: (event: SmartGridRowDragEndParams) => void;
+    onCellValueChanged?: (params: SmartGridCellValueChangedParams) => void;
+    onGridReady?: (params: SmartGridOnReadyParams) => void;
+    onRowGroupOpened?: (params: SmartGridRowGrouOpenParams) => void;
+    fetchData?: (manualbody: any, page: any, context: any, pageNo: any, other: any) => Promise<any>;
+    apiUrl?: string;
+    autoFetch?: boolean;
+    cacheConfig?: {
+        threshold?: number;
+        maxBlocksInCache?: number;
+        cacheOverflowSize?: number;
+        rowHeight?: number;
+        purgeStrategy?: string;
+        enablePersistence?: boolean;
+        persistenceStorageKey?: string;
+        persistenceOptions?: any;
+        force?: boolean;
+    };
+    onScroll?: (event: any) => void;
+    showSaveTableConfig?: boolean;
+    loadTableInstance?: ({ api }: {
+        api: SmartGridAPI;
+    }) => void;
+    adjustTableHeightServerSide?: boolean;
+    largeDatasetOptions?: {
+        enableIndexedDBCache?: boolean;
+        enableStreamingLoad?: boolean;
+        enableEnhancedWorker?: boolean;
+        binaryFormat?: boolean;
+        extremelyLargeDatasetThreshold?: number;
+    };
+    gridOptions?: any;
+    tableId?: string;
+    alignedGrids?: any[];
+    masterDetail?: boolean;
+    detailCellRenderer?: any;
+    detailRowHeight?: number;
+    infiniteScroll?: boolean;
+    customTabFunction?: any;
+    getRowData?: (params: SmartGridGetRowDataParams, columnName: string) => any;
+    rowDragManaged?: boolean;
+    hidePaginationPageSizeSelector?: boolean;
+    purgeClosedRowNodes?: boolean;
+    detailRendererTable?: boolean;
+    smartGridMenuOptions?: {
+        withColumMenu?: boolean;
+        autoWithColumMenu?: boolean;
+        freezeColumnMenu?: boolean;
+        sortColumnMenu?: boolean;
+        collapseColumnAll?: boolean;
+        expandColumnAll?: boolean;
+        wrapText?: boolean;
+        [key: string]: any;
+    };
+    paginateOriginalRowsOnly?: boolean;
+    isSaveViewEnabled?: boolean;
+    isSavingViewLoading?: boolean;
+    maxSavedViews?: number;
+    deleteViewPromptText?: string;
+    savedViewsOptions?: any[];
+    rowHeight?: string;
+    additionalButtons?: string | ReactNode;
+    aboveTableComponent?: string | ReactNode;
+    shouldRenderTable?: boolean;
+    nestedTable?: boolean;
+    nestedTableComponent?: ReactNode | null;
+    enableNestedTableCloseButton?: boolean;
+    downloadAsExcel?: boolean;
+    downloadAsCSV?: boolean;
+    copyToClipboard?: boolean;
+    onCloseNestedTable?: () => void;
+    downloadExcelHandler?: () => void;
+    downloadCSVHandler?: () => void;
+    copyToClipboardHandler?: () => void;
+    ShowFullText?: boolean;
+    hideNotification?: boolean;
+    isSingleSelect?: boolean;
+    defaultPageSize?: number;
+    paginationPageSize?: number[];
+    enableRowSpan?: boolean;
+    rowSpanColumn?: string | string[];
+    showHeader?: boolean;
+    showFooter?: boolean;
+    showToolbar?: boolean;
+    selectable?: boolean;
+    defaultSort?: SmartGridSortModel;
+    actions?: Record<string, any>;
+    pagination?: boolean;
+    showTableSettingActionTab?: boolean;
+    showTableSettingFormatTab?: boolean;
+    showFilters?: boolean;
+    expandable?: boolean;
+    onCellClicked?: () => void;
+    onCellClick?: () => void;
+    onRowClicked?: () => void;
+    onRowClick?: () => void;
+    disableSelectAllRecords?: boolean;
+    columnBufferSize?: number;
+    lazyLoadCellRenderer?: boolean;
+    hasSplitRenderer?: boolean;
+    splitRendererKeys?: string[];
+    removeSelectionOnOperation?: boolean;
+}
+
+export declare interface SmartGridTableRef {
+    api: SmartGridAPI;
+}
+
+export declare interface SmartGridToggleRenderProps {
+    render: (state: SmartGridToggleRenderState) => ReactNode;
+}
+
+export declare interface SmartGridToggleRenderState {
+    isOpen: boolean;
+    setIsOpen: (isOpen: boolean) => void;
+    toggleMenu: () => void;
+}
+
+export declare interface SmartGridTooltipButton {
+    label: string;
+    type: "default" | "primary" | "secondary";
+    onClick?: () => void;
+}
+
+export declare interface SmartGridTooltipConfig {
+    title?: string;
+    varient?: SmartGridTooltipVariant;
+    orientation?: SmartGridTooltipOrientation;
+    targetRef?: RefObject<HTMLElement>;
+    illustration?: string;
+    icon?: ReactNode | null;
+    bodyText?: string;
+    btns?: SmartGridTooltipButton[] | null;
+    showPaginationAbove?: boolean | null;
+    pagination?: boolean | null;
+    justifyBodyContent?: string | null;
+}
+
+export 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;
+};
+
+export declare interface SmartGridTooltipManagerInstance {
+    tooltipElement: HTMLDivElement | null;
+    currentConfig: SmartGridTooltipConfig | null;
+    hideTimeout: ReturnType<typeof setTimeout> | null;
+    initialize: () => void;
+    show: (config: SmartGridTooltipConfig) => void;
+    hide: () => void;
+    updateContent: (config: SmartGridTooltipConfig) => void;
+    getPaginationHTML: (varient?: SmartGridTooltipVariant) => string;
+    calculatePosition: (config: SmartGridTooltipConfig) => void;
+    cleanup: () => void;
+}
+
+export declare type SmartGridTooltipOrientation = "top" | "bottom" | "left" | "right";
+
+export declare interface SmartGridTooltipProps extends SmartGridTooltipConfig {
+    children: ReactNode;
+    forceShowTooltip?: boolean;
+    className?: string;
+}
+
+export declare type SmartGridTooltipVariant = "primary" | "secondary" | "tertiary";
+
+export declare type SmartGridUpdateData = {
+    data: SmartGridRowData;
+    setData: (data: SmartGridRowData) => void;
+    setDataValue: (field: string, value: unknown, callbackNeeded?: boolean) => void;
+};
+
+export declare type SmartGridUpdateDataReturnType = {
+    success: boolean;
+    totalRows: number;
+    blocksUpdated: number;
+    errors: string[];
+};
+
+/** Page size ref for server-side */
+declare interface SmartGridUpdatedPageSizeRef {
+    current: number;
+}
+
+export declare interface SmartGridUpdateRefParams extends SmartGridCallbackRefCurrent, SmartGridSaveViewCallbackRefCurrent {
+    downloadExcelHandler?: () => void;
+    downloadCSVHandler?: () => void;
+    copyToClipboardHandler?: () => void;
+    maxSavedViews?: number;
+    deleteViewPromptText?: string;
+    onSelectionChanged?: (event: SmartGridOnSelectionChangedParams) => void;
+    onRowDragStart?: (event: SmartGridRowDragStartParams) => void;
+    onRowDragEnd?: (event: SmartGridRowDragEndParams) => void;
+    onRowClicked?: (event: unknown) => void;
+    onCellValueChanged?: (event: SmartGridCellValueChangedParams) => void;
+    onRowGroupOpened?: (event: SmartGridRowGrouOpenParams) => void;
+    customTabFunction?: (e: KeyboardEvent, column: SmartGridColumnDefinition, context: {
+        api: SmartGridAPI | null;
+    }) => void;
+    handlePageChange?: (page: number) => void;
+    handleSortChange?: (sortModel: SmartGridSortModel) => void;
+    handleFilterChange?: (filterModel: SmartGridFilterModel) => void;
+    handleSearch?: (searchValue: SmartGridSearchFunctionParams) => void;
+}
+
+export declare interface SmartGridUpdateRefReturn {
+    callBackRef: MutableRefObject<SmartGridCallbackRefCurrent>;
+    exportCallbackRef: MutableRefObject<SmartGridExportCallbackRefCurrent>;
+    saveViewCallbackRef: MutableRefObject<SmartGridSaveViewCallbackRefCurrent>;
+    saveViewOptionsRef: MutableRefObject<SmartGridSaveViewOptionsRefCurrent>;
+}
+
+export declare type SmartGridValueFormatterConfig = {
+    type?: string;
+    symbol?: string;
+    position?: "prefix" | "suffix";
+    decimals?: number;
+};
+
+export declare interface SmartGridValueFormatterParams {
+    value: unknown;
+    data: SmartGridRowData;
+    colDef: SmartGridColumnDefinition;
+}
+
+export 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;
+}
+
+export declare interface SmartGridVirtualizationParams {
+    dataLength: number;
+    threshold?: number;
+    rowHeight: number;
+    bufferSize?: number;
+    containerRef: RefObject<HTMLElement | null>;
+    scrollContainerRef?: RefObject<HTMLElement | null> | null;
+    currentPageData: SmartGridRowData[];
+    rowHeightCache?: RowHeightCache | null;
+    uniqueIdField?: string;
+    tableApi?: SmartGridAPI | null;
+}
+
+export declare interface SmartGridVirtualizationReturn {
+    updatedData: SmartGridRowData[];
+    useVirtualization: boolean;
+    visibleRange: SmartGridVisibleRangeShort;
+}
+
+export declare interface SmartGridVisibleColumnRange {
+    startCol: number;
+    endCol: number;
+}
+
+export declare interface SmartGridVisibleRange {
+    startRow: number;
+    endRow: number;
+}
+
+export declare interface SmartGridVisibleRangeShort {
+    start: number;
+    end: number;
+}
+
+export declare interface SmartGridWindowTableState {
+    _targetPage?: number;
+    _forceReload?: boolean;
+    [key: string]: unknown;
+}
+
+export 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 declare type UpdateParentDataParams = {
+    parentData: SmartGridRowData;
+    newData: Partial<SmartGridRowData>;
+    dispatch: SmartGridDispatch;
+    ACTION_TYPES: Record<string, string>;
+    uniqueIdField: string;
+    api?: SmartGridAPI;
+};
+
+export { }