ia-table 0.14.7 → 0.15.0

package/dist/chat.d.ts

@@ -0,0 +1,3373 @@
+import { ChangeEvent } from 'react';
+import { CSSProperties } from 'react';
+import { default as default_2 } from 'react';
+import { Dispatch } from 'react';
+import { Editor } from '@tiptap/react';
+import { JSX as JSX_2 } from 'react/jsx-runtime';
+import { MutableRefObject } 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";
+    readonly SET_REMOVE_CHECK_CONFIGURATION_ON_OPERATION: "SET_REMOVE_CHECK_CONFIGURATION_ON_OPERATION";
+    readonly SET_TOTAL_COLUMNS_COUNT: "SET_TOTAL_COLUMNS_COUNT";
+    readonly SET_ALL_CHILD_ROWS_EXPANDED: "SET_ALL_CHILD_ROWS_EXPANDED";
+    readonly EXPAND_ROW_WITH_NESTED_CHILDREN: "EXPAND_ROW_WITH_NESTED_CHILDREN";
+    readonly SET_CUSTOM_CALLBACKS: "SET_CUSTOM_CALLBACKS";
+    readonly SET_COMMENT_CONTEXT_REF: "SET_COMMENT_CONTEXT_REF";
+    readonly SET_CHAT_ENABLED: "SET_CHAT_ENABLED";
+    readonly SET_COMMENT_ENABLED: "SET_COMMENT_ENABLED";
+};
+
+export declare const CommentWrapper: React.FC<SmartGridCommentWrapperProps>;
+
+declare class InfiniteBlock {
+    static STATE_WAITING_TO_LOAD: string;
+    static STATE_LOADING: string;
+    static STATE_LOADED: string;
+    static STATE_FAILED: string;
+    static MAX_EMPTY_BLOCKS_TO_KEEP: number;
+    id: number;
+    parentCache: SmartGridInfiniteCacheInterface;
+    parent: SmartGridInfiniteCacheInterface;
+    params: SmartGridBlockParams;
+    state: string;
+    version: number;
+    lastAccessed: number;
+    rows: Record<number, SmartGridRowData>;
+    infiniteCache: SmartGridInfiniteCacheInterface;
+    startRow: number;
+    endRow: number;
+    rowNodes: SmartGridBlockRowNode[];
+    loadStartedAt?: number;
+    _targetPage?: number;
+    _responseMetadata?: SmartGridResponseMetadata;
+    _processingInProgress?: boolean;
+    _actualRowCount?: number;
+    _inactiveForPageTransition?: boolean;
+    constructor(id: number, parentCache: SmartGridInfiniteCacheInterface, params: SmartGridBlockParams);
+    /**
+     * Create empty row nodes
+     */
+    createRowNodes(): void;
+    /**
+     * Gets the block ID
+     */
+    getId(): number;
+    /**
+     * Gets the current state of the block
+     */
+    getState(): string;
+    /**
+     * Gets the start row index of this block
+     */
+    getStartRow(): number;
+    /**
+     * Gets the end row index of this block
+     */
+    getEndRow(): number;
+    /**
+     * Gets the current version of this block
+     * Used to ignore responses from outdated requests
+     */
+    getVersion(): number;
+    /**
+     * Gets the last time this block was accessed
+     * Used for LRU cache management
+     */
+    getLastAccessed(): number;
+    /**
+     * Gets a row node at the specified index
+     * Updates the last accessed time for LRU cache management
+     */
+    getRow(rowIndex: number, dontTouchLastAccessed?: boolean): SmartGridBlockRowNode | null;
+    /**
+     * Load data from datasource
+     */
+    loadFromDatasource(): void;
+    /**
+     * Process the response from the server
+     */
+    processServerResponse(rows: SmartGridRowData[], lastRow?: number, lastRowIndexKnown?: boolean): void;
+    /**
+     * Initialize block from server response
+     */
+    initBlockFromServerResponse(rows: SmartGridRowData[]): void;
+    /**
+     * Sets data and ID for a row node
+     */
+    setDataAndId(rowNode: SmartGridBlockRowNode, data: SmartGridRowData, rowIndex: number): void;
+    /**
+     * Set state to waiting to load
+     */
+    setStateWaitingToLoad(): void;
+    /**
+     * Iterates through each row node
+     */
+    forEachNode(callback: (rowNode: SmartGridBlockRowNode, index: number) => void): void;
+    /**
+     * Returns block state as JSON for debugging
+     */
+    getBlockStateJson(): SmartGridBlockStateJson;
+    /**
+     * Clean up row nodes before the block is destroyed
+     */
+    destroyRowNodes(): void;
+    /**
+     * Determines the index of the last row that has data
+     */
+    getLastRow(): number;
+    isBlockBeyondEndOfScope(): boolean;
+    getRowNode(rowIndex: number): SmartGridBlockRowNode | null;
+    pageLoaded(version: number): void;
+    loadFailed(version?: number): void;
+    getRowNodes(): SmartGridBlockRowNode[];
+    /**
+     * Gets the number of rows in this block that have data
+     */
+    getRowCount(): number;
+}
+
+declare class InfiniteCache {
+    static PURGE_STRATEGY_LRU: string;
+    static PURGE_STRATEGY_FURTHEST_FROM_VIEWPORT: string;
+    static PURGE_STRATEGY_MEMORY_OPTIMIZED: string;
+    params: SmartGridCacheParams;
+    blocks: Record<number, InfiniteBlock>;
+    blockCount: number;
+    rowCount: number;
+    lastRowIndexKnown: boolean;
+    eventListeners: Record<string, Array<(event: SmartGridCacheEvent) => void>>;
+    lastRequestedPage: number;
+    analytics: SmartGridCacheAnalytics_2;
+    rowsMaxIndex?: number;
+    _currentRequestedPage?: number;
+    _blockCreationQueue?: Set<number>;
+    constructor(params: Partial<SmartGridCacheParams>);
+    /**
+     * Gets a row at a specific index, creating blocks as needed
+     */
+    getRow(rowIndex: number, dontCreateBlock?: boolean): SmartGridBlockRowNode | undefined;
+    /**
+     * Creates a new block to manage a range of rows
+     */
+    createBlock(blockId: number): InfiniteBlock;
+    /**
+     * Get row indexes for a specific block
+     */
+    getRowIndexesForBlock(blockId: number): number[];
+    /**
+     * Notify about block state changes
+     */
+    notifyBlockStateChanged(blockId: number, state: string, rowIndexes: number[]): void;
+    /**
+     * Gets a block by ID
+     */
+    getBlock(blockId: number): InfiniteBlock | undefined;
+    /**
+     * Gets the current row count
+     */
+    getRowCount(): number;
+    /**
+     * Checks if total row count is known or virtual
+     */
+    isLastRowIndexKnown(): boolean;
+    /**
+     * Sets the row count and updates lastRowIndexKnown flag
+     */
+    setRowCount(rowCount: number, lastRowIndexKnown?: boolean): void;
+    /**
+     * Count the total number of rows with data across all blocks in the cache
+     */
+    getTotalCachedRowCount(): {
+        totalRows: number;
+        rowsWithData: number;
+        blockCount: number;
+        blocksWithData: Array<{
+            blockId: number;
+            rowCount: number;
+        }>;
+    };
+    /**
+     * Callback for when a block finishes loading
+     */
+    pageLoaded(block: InfiniteBlock, lastRow?: number): void;
+    /**
+     * Print all cached data from all blocks
+     * Shows a complete snapshot of what's actually in the cache
+     */
+    printAllCachedData(): void;
+    /**
+     * Check and update row count based on loaded block data
+     */
+    checkRowCount(block: InfiniteBlock, lastRow: number | boolean | null): void;
+    /**
+     * Gets all blocks in the cache, sorted by ID
+     */
+    getBlocksInOrder(): InfiniteBlock[];
+    /**
+     * Removes expired blocks from the cache using configured strategy
+     */
+    purgeBlocksIfNeeded(blockToExclude: InfiniteBlock): void;
+    /**
+     * Sorts blocks based on the specified strategy
+     */
+    sortBlocksByStrategy(blocks: InfiniteBlock[], strategy: string): InfiniteBlock[];
+    /**
+     * Compares two blocks based on the specified strategy
+     * Returns a negative number if a should be removed before b
+     */
+    compareBlocksByStrategy(a: InfiniteBlock, b: InfiniteBlock, strategy: string): number;
+    /**
+     * Sort blocks by distance from viewport (for furthest-from-viewport strategy)
+     */
+    sortBlocksByDistanceFromViewport(blocks: InfiniteBlock[]): void;
+    /**
+     * Sort blocks using the memory-optimized strategy
+     * This uses a combined heuristic considering:
+     * 1. Block access recency
+     * 2. Distance from viewport
+     * 3. Block data size (if available)
+     */
+    sortBlocksByMemoryOptimized(blocks: InfiniteBlock[]): void;
+    /**
+     * Checks if a block is currently in the visible viewport
+     */
+    isBlockCurrentlyDisplayed(block: InfiniteBlock): boolean;
+    /**
+     * Removes a block from the cache and destroys it
+     */
+    removeBlockFromCache(blockToRemove: InfiniteBlock): void;
+    /**
+     * Gets all row nodes in a range (used for selection)
+     */
+    getRowNodesInRange(firstIndex: number, lastIndex: number): SmartGridBlockRowNode[];
+    /**
+     * Iterates over all row nodes in the cache
+     */
+    forEachNodeDeep(callback: (rowNode: SmartGridBlockRowNode, index: number) => void): void;
+    /**
+     * Purges the entire cache
+     */
+    purgeCache(options?: Record<string, unknown>): void;
+    /**
+     * Refreshes the cache without purging it completely
+     */
+    refreshCache(): void;
+    /**
+     * Refreshes the cache partially, preserving specified fields
+     */
+    refreshCachePartial(preserveFields?: string[]): void;
+    /**
+     * Sets view port range
+     */
+    setViewportRange(startRow: number, endRow: number): void;
+    /**
+     * Returns all data from all blocks as a flattened array
+     */
+    /**
+     * Ensures blocks are loaded for the specified range
+     */
+    ensureBlocksLoadedForRange(startRow: number, endRow: number): void;
+    /**
+     * Adds an event listener
+     */
+    addEventListener(type: string, listener: (event: SmartGridCacheEvent) => void): void;
+    /**
+     * Removes an event listener
+     */
+    removeEventListener(type: string, listener: (event: SmartGridCacheEvent) => void): void;
+    /**
+     * Dispatches an event to all listeners
+     */
+    dispatchEvent(event: SmartGridCacheEvent): void;
+    /**
+     * Returns cache state for debugging
+     */
+    getCacheState(): SmartGridCacheState;
+    /**
+     * Returns analytics data
+     */
+    getAnalytics(): SmartGridCacheAnalytics_2 & {
+        uptime: number;
+        hitRatio: number;
+        avgLoadTime: number;
+        hitsPerSecond: number;
+        missesPerSecond: number;
+        blocksPurgedPerSecond: number;
+        bytesPerSecond: number;
+    };
+    /**
+     * Resets analytics data
+     */
+    resetAnalytics(): void;
+    /**
+     * Save cache state to persistence if enabled
+     */
+    persistCacheIfEnabled(): void;
+    /**
+     * Restore cache from persistence
+     */
+    restoreFromPersistence(): void;
+    /**
+     * Clear persisted cache state
+     */
+    clearPersistence(): void;
+    /**
+     * Sets the purge strategy
+     */
+    setPurgeStrategy(strategy: string): void;
+    isBlockInCreationQueue(blockId: number): boolean;
+    /**
+     * Logs a summary of the current cache state
+     * Can be called from outside to check the cache status at any time
+     */
+    logCacheSummary(): {
+        totalRows: number;
+        rowsWithData: number;
+        blockCount: number;
+        blocksWithData: Array<{
+            blockId: number;
+            rowCount: number;
+        }>;
+    };
+    isBlockCached(blockId: number): boolean;
+    getBlockData(blockId: number): (SmartGridRowData | null)[] | null;
+    getAllCachedData(): SmartGridRowData[];
+    updatePageData(pageNo: number, updatedData: SmartGridRowData[], notifyChanges?: boolean, options?: Record<string, unknown>): {
+        success: boolean;
+        pageNo: number;
+        updatedRows: number;
+        errors: string[];
+    };
+    updateBlockData(blockId: number, newData: SmartGridRowData[], notifyChanges?: boolean): {
+        success: boolean;
+        blockId: number;
+        updatedRows: number;
+        errors: string[];
+    };
+    updateWholeData(wholeData: SmartGridRowData[], pageSize: number): SmartGridUpdateDataReturnType;
+}
+
+export declare function isChatMessage(item: SmartGridGroupedMessageItem): item is SmartGridChatMessage;
+
+export declare function isDateSeparator(item: SmartGridGroupedMessageItem): item is SmartGridDateSeparatorItem;
+
+declare interface RowGroupParams {
+    page: number;
+    pageSize: number;
+    groupId?: string;
+    noDataUpdate?: boolean;
+}
+
+export declare interface SmartGridAddChatContainerProps {
+    setShowAddChat: Dispatch<SetStateAction<boolean>>;
+    handleChatName: NonNullable<SmartGridLeftPanelConfig["handleChatName"]>;
+    selectedChannelInfo?: SmartGridChannel | null;
+    handleToast: SmartGridHandleToastFn;
+    setIsCreateNewChatOpen: Dispatch<SetStateAction<boolean>>;
+}
+
+declare interface SmartGridAPI extends SmartGridPaginationAPI, SmartGridApiExtra {
+    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[];
+    getSelectedRowsID: () => (string | number)[];
+    setSelectedRows: (rowIds: (string | number)[]) => void;
+    clearSelection: () => void;
+    selectAll: () => void;
+    getCache: () => SmartGridInfiniteCache | null;
+    getCacheState: () => SmartGridCacheState_2 | null;
+    getInfiniteCacheInstance: () => SmartGridInfiniteCache | null;
+    refreshServerSideStore: (options?: SmartGridRefreshOptions) => void;
+    getCachedBlockData: () => SmartGridCachedBlockData;
+    logCacheSummary: () => void | null;
+    getCachedRowById: (id: string | number) => SmartGridRowData | null;
+    getRowNode: (key: string | number) => Partial<SmartGridRowNode> | null;
+    setVisibleRange: (startRow: number, endRow: number) => void;
+    refreshCache: (options?: SmartGridRefreshOptions) => boolean;
+    deselectAll: () => void;
+    getRenderedNodes: () => SmartGridDisplayedRowNode[];
+    gridOptionsWrapper: {
+        gridOptions: SmartGridOptions;
+    };
+    getDisplayedRowAtIndex: (index: number, wholeData?: SmartGridRowData[], api?: Partial<SmartGridAPI>) => SmartGridDisplayedRowAtIndex | null;
+    getTableWidth: () => number;
+    sizeColumnsToFit: () => void;
+    setRowData: (newData: SmartGridRowData[]) => boolean | void;
+    forEachNode: (callback: (node: SmartGridRowNode, index: number) => void | Promise<void>) => Promise<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[];
+    refreshCells: (params?: SmartGridRefreshCellsParams) => void;
+    flashCells: (params?: SmartGridFlashCellsParams) => void;
+    redrawRows: (params?: SmartGridRedrawRowsParams) => void;
+    applyTransaction: (transaction: SmartGridRowDataTransaction) => SmartGridRowNodeTransaction;
+    getSelectedNodes: () => SmartGridRowNode[];
+    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) => SmartGridWrappedDataSource | null;
+    updateSmartGridTableData: (wholeData: SmartGridRowData[]) => void;
+    downloadSmartGridExcel: (fileName?: string, visibleOnly?: boolean) => void;
+    downloadSmartGridCSV: (fileName?: string, visibleOnly?: boolean) => void;
+}
+
+declare type SmartGridApiExtra = {
+    [key: string]: unknown;
+};
+
+export declare interface SmartGridAvatarGroupProps {
+    avatars?: SmartGridAvatarUser[];
+    maxAvatars?: number;
+    size?: SmartGridAvatarSize;
+}
+
+export declare type SmartGridAvatarSize = "sm" | "md" | "lg";
+
+export declare interface SmartGridAvatarUser {
+    id?: string | number;
+    url?: string;
+    label?: string;
+}
+
+declare interface SmartGridBaseColumnDefinition {
+    field?: string;
+    groupId?: string;
+    headerName?: string;
+    column_name?: string;
+    label?: string;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    hide?: boolean;
+    hidden?: boolean;
+    pinned?: SmartGridFrozenState;
+    is_frozen?: boolean;
+    children?: SmartGridColumnDefinition[];
+    parent_id?: (string | number)[];
+    type?: string;
+    cellDataType?: string;
+    valueFormatter?: ((params: SmartGridValueFormatterParams) => string) | SmartGridValueFormatterConfig | undefined;
+    valueGetter?: (params: SmartGridValueGetterParams) => unknown;
+    leftTotalWidth?: number;
+    originalWidth?: number;
+    defaultWidth?: number;
+    isAutoWidth?: boolean;
+    filterable?: boolean;
+    isSortable?: boolean;
+    is_sortable?: boolean;
+    resizable?: boolean;
+    align?: "left" | "center" | "right";
+    cellRenderer?: string | ((params: SmartGridCellRenderer) => JSX.Element);
+    cellRendererParams?: SmartGridCellRendererParams;
+    cellClassName?: string;
+    cellStyle?: {
+        textAlign?: "left" | "center" | "right";
+        [key: string]: unknown;
+    };
+    autoHeight?: boolean;
+    wrapHeaderText?: boolean;
+    editable?: boolean;
+    is_editable?: boolean;
+    is_disabled?: boolean;
+    is_searchable?: boolean;
+    isSearchable?: boolean;
+    advanceSearchEnabled?: boolean;
+    sortable?: boolean;
+    rowGroup?: boolean;
+    enableRowGroup?: boolean;
+    rowGroupIndex?: number;
+    aggFunc?: string;
+    columnGroupShow?: "open" | "closed" | undefined | null;
+    originalIndex?: number;
+    parentColumns?: string[];
+    hasChildren?: boolean;
+    hasAnyFrozenChildren?: boolean;
+    hasAnyRightPinnedChildren?: boolean;
+    isChildWithoutParent?: boolean;
+    colorClass?: string;
+    isLeaf?: boolean;
+    isStandalone?: boolean;
+    isWithEmptyHeaderName?: boolean;
+    isParentWithChildEmptyHeaderName?: boolean;
+    path?: string[];
+    pathIdentifier?: string;
+    parentField?: string | null;
+    value?: string | number;
+    dimension_type?: string;
+    originalFields?: string[];
+    colId?: string;
+    colSpan?: number;
+    rowSpan?: number;
+    comparator?: (valueA: unknown, valueB: unknown, nodeA: SmartGridRowData, nodeB: SmartGridRowData, sortModel: SmartGridSortModel | SmartGridSortModel[]) => number;
+    headerTooltip?: string;
+    filter?: string | boolean;
+    filterParams?: {
+        filterOptions?: string[];
+        textCustomComparator?: (filter: string, value: unknown, filterText: string) => boolean;
+        numberCustomComparator?: (filter: number, value: unknown) => boolean;
+        dateCustomComparator?: (filterLocalDateAtMidnight: Date, cellValue: string) => number;
+        comparator?: (filterValue: unknown, cellValue: unknown) => boolean;
+        [key: string]: unknown;
+    };
+    order_of_display?: number;
+    is_hidden?: boolean;
+    formatter?: string | null;
+    accessor?: string;
+    id?: string;
+    required?: boolean;
+    sub_headers?: SmartGridColumnDefinition[];
+    extra?: {
+        width?: number;
+        is_grouping_key?: boolean;
+        is_disabled?: boolean;
+        isDisabled?: boolean;
+        columnGroupShow?: "open" | "closed";
+        is_multi?: boolean;
+        options_column?: string;
+        aggregation_func?: SmartGridSelectOption[];
+        enableCommaSeparated?: boolean;
+        [key: string]: unknown;
+    };
+    headerComponent?: default_2.FC<SmartGridHeaderStyleParams>;
+    headerStyle?: (params: SmartGridHeaderStyleParams) => CSSProperties;
+    tooltipValueGetter?: (params: SmartGridTooltipGetterParams) => string;
+    cellRendererLazyType?: string;
+    originalPath?: string[] | null;
+    isReorderedColumn?: boolean | null;
+    processCellForClipboard?: (params: SmartGridCellRendererParams) => string;
+    pivotAggregation?: "sum" | "count" | "avg" | "min" | "max";
+    pivotFilterValue?: string;
+    pivotFilterMode?: "value" | "condition";
+    pivotFilterCondition?: string;
+    [key: string]: unknown;
+}
+
+/** Block context */
+declare interface SmartGridBlockContext {
+    updateData?: (rows: SmartGridRowData[], blockId: number, metadata?: SmartGridResponseMetadata) => void;
+    tableContextRef?: {
+        current?: {
+            state?: {
+                expandedChildRows?: Record<string, {
+                    childRowsCount: number;
+                }>;
+            };
+        };
+    };
+    infiniteCache?: SmartGridInfiniteCacheInterface;
+    [key: string]: unknown;
+}
+
+/** Datasource interface */
+declare interface SmartGridBlockDatasource {
+    getRows: (params: SmartGridDatasourceGetRowsParams) => void;
+}
+
+/** Block params */
+declare interface SmartGridBlockParams {
+    updatedPageSizeRef: SmartGridPageSizeRef_2;
+    pageSize?: number;
+    lastAccessedSequence: SmartGridLastAccessedSequence_2;
+    datasource?: SmartGridBlockDatasource;
+    sortModel?: SmartGridSortModel;
+    filterModel?: SmartGridFilterModel;
+    context?: SmartGridBlockContext;
+    loadSequentially?: boolean;
+    _directPaginationRequest?: boolean;
+    isPaginationMode?: boolean;
+    _targetPage?: number;
+    tableId: string;
+}
+
+/** Row node in a block */
+declare interface SmartGridBlockRowNode {
+    id: number;
+    data: SmartGridRowData | null;
+    rowIndex: number;
+    rowHeight?: number;
+    rowTop?: number;
+}
+
+/** Block state change callback */
+declare type SmartGridBlockStateChangedCallback = (blockId: number, state: string, rowIndexes: number[]) => void;
+
+/** Block state JSON */
+declare interface SmartGridBlockStateJson {
+    id: number;
+    state: string;
+    startRow: number;
+    endRow: number;
+    version: number;
+    lastAccessed: number;
+}
+
+/** Block state JSON from getBlockStateJson */
+declare interface SmartGridBlockStateJsonExtended {
+    id: number;
+    state: string;
+    startRow: number;
+    endRow: number;
+    version: number;
+    lastAccessed: number;
+}
+
+declare type SmartGridCacheAnalytics = {
+    blockEvictions: number;
+    blockLoadTimestamps: number[];
+    blockLoads: number;
+    bytesLoaded: number;
+    cachePurges: number;
+    cacheRefreshes: number;
+    hits: number;
+    lastBlockLoadTime: number;
+    misses: number;
+    startTime: number;
+    totalBlockLoadTime: number;
+};
+
+/** Cache analytics */
+declare interface SmartGridCacheAnalytics_2 {
+    hits: number;
+    misses: number;
+    blockLoads: number;
+    blockEvictions: number;
+    totalBlockLoadTime: number;
+    lastBlockLoadTime: number;
+    bytesLoaded: number;
+    startTime: number;
+    blockLoadTimestamps: Array<{
+        blockId: number;
+        timestamp: number;
+        loadTime: number;
+    }>;
+    cachePurges: number;
+    cacheRefreshes: number;
+}
+
+declare interface SmartGridCacheAnalyticsData {
+    hitRatio: number;
+    hits: number;
+    misses: number;
+    blockLoads: number;
+    blockEvictions: number;
+}
+
+declare type SmartGridCacheBlock = {
+    endRow: number;
+    id: number;
+    infiniteCache: SmartGridInfiniteCache;
+    lastAccessed: number;
+    loadStartedAt: number;
+    params: SmartGridCacheBlockParams;
+    parent: SmartGridInfiniteCache | null;
+    parentCache: SmartGridInfiniteCache | null;
+    rowNodes: {
+        data: SmartGridRowData;
+        id: number;
+        rowIndex: number;
+    }[];
+    rows: unknown;
+    startRow: number;
+    state: string;
+    version: number;
+    _inactiveForPageTransition: boolean;
+    _processingInProgress: boolean;
+    _targetPage: number;
+};
+
+declare type SmartGridCacheBlockParams = Record<string, unknown>;
+
+/** Cache context */
+declare interface SmartGridCacheContext {
+    tableContextRef?: MutableRefObject<SmartGridTableContextValue | null>;
+    infiniteCache?: InfiniteCache;
+    updateData?: (rows: SmartGridRowData[], blockId: number, metadata?: Record<string, unknown> | undefined) => void;
+}
+
+declare interface SmartGridCachedBlockData {
+    [blockId: string]: SmartGridRowData[];
+}
+
+/** Cache event */
+declare interface SmartGridCacheEvent {
+    type: string;
+    blockId?: number;
+    source?: string;
+    options?: Record<string, unknown>;
+    pageNo?: number;
+}
+
+declare type SmartGridCacheMetadata = {
+    lastUpdated: number;
+    timestamp?: number;
+};
+
+/** Cache params */
+declare interface SmartGridCacheParams {
+    overflowSize: number;
+    maxBlocksInCache: number;
+    initialRowCount: number;
+    rowHeight: number;
+    lastAccessedSequence: SmartGridLastAccessedSequence;
+    uniqueIdField: string;
+    onBlockStateChanged: SmartGridBlockStateChangedCallback | null;
+    purgeStrategy: string;
+    enablePersistence: boolean;
+    persistenceStorageKey: string;
+    persistenceOptions: SmartGridPersistenceOptions;
+    isPaginationMode: boolean;
+    datasource?: SmartGridClientSideDatasource | SmartGridServerSideDatasource;
+    filterModel?: SmartGridSearchWithSearchKey;
+    sortModel?: SmartGridSortModel;
+    context?: SmartGridCacheContext;
+    updatedPageSizeRef?: SmartGridPageSizeRef;
+    viewportRange?: SmartGridViewportRange;
+    tableId?: string;
+    pageSize?: number;
+    loadSequentially?: boolean;
+}
+
+/** Cache state for debugging */
+declare interface SmartGridCacheState {
+    blockCount: number;
+    rowCount: number;
+    lastRowIndexKnown: boolean;
+    blocks: SmartGridBlockStateJsonExtended[];
+    analytics: SmartGridCacheAnalytics_2;
+}
+
+declare interface SmartGridCacheState_2 {
+    blockCount: number;
+    cache?: SmartGridInfiniteCache;
+    lastRowKnown: boolean;
+    rowCount: number;
+    status: string;
+}
+
+declare interface SmartGridCacheStateReturn {
+    cache: unknown;
+    rowCount: number;
+    lastRowKnown: boolean;
+    blockCount: number;
+    status: string;
+}
+
+declare interface SmartGridCallbackRefCurrent {
+    onSelectionChanged?: ((event: SmartGridOnSelectionChangedParams) => void) | undefined;
+    onRowDragStart?: ((event: SmartGridRowDragStartParams) => void) | null;
+    onRowDragEnd?: ((event: SmartGridRowDragEndParams) => void) | null;
+    onRowClicked?: ((event: unknown) => void) | null;
+    onCellValueChanged?: ((event: SmartGridCellValueChangedParams) => void) | null;
+    onRowGroupOpened?: ((event: SmartGridRowGrouOpenParams) => void) | null;
+    customTabFunction?: ((e: KeyboardEvent, column: SmartGridColumnDefinition, context: {
+        api: SmartGridAPI | null;
+    }) => void) | null;
+    onPageChange?: ((page: number) => void) | null;
+    onSortChange?: ((sortModel: SmartGridSortModel) => void) | null;
+    onFilterChange?: ((filterModel: SmartGridFilterModel) => void) | null;
+    onSearch?: ((searchTerm: SmartGridSearchFunctionParams) => void) | null;
+}
+
+declare type SmartGridCellRenderer = {
+    value: unknown;
+    data: SmartGridRowData;
+    rowIndex: number;
+    colIndex: number;
+    column: SmartGridColumnDefinition;
+    colDef: SmartGridColumnDefinition;
+    node: SmartGridCellRendererNode;
+    api: SmartGridAPI;
+    eGridCell: RefObject<HTMLDivElement | null>;
+    wholeData: SmartGridRowData[] | null | undefined;
+    actions: Record<string, unknown>;
+    setDataValue: (colId: string, newValue: unknown) => void;
+    isCellLockable?: boolean;
+};
+
+declare type SmartGridCellRendererNode = {
+    data: SmartGridRowData;
+    rowIndex: number;
+    id: string | number;
+    parent: SmartGridUpdateData & {
+        id: string | number;
+        level: number;
+        setExpanded: () => void;
+    };
+    setDataValue: (colId: string, newValue: unknown) => void;
+    childrenMapped: Record<string, string>;
+    allLeafChildren: Record<string, string>[];
+    group: boolean;
+    level: number;
+    childIndex: number;
+    isSelected: () => boolean;
+    isExpandable: () => boolean;
+    isExpanded: () => boolean;
+};
+
+declare type SmartGridCellRendererParams = {
+    dateFormat?: SmartGridDateFormat;
+    startYear?: number;
+    endYear?: number;
+    minDate?: string;
+    maxDate?: string;
+    options?: Array<{
+        label: string;
+        value: string | number;
+    }>;
+    isMultiSelect?: boolean;
+    type?: SmartGridInputType;
+    disabled?: boolean;
+    disableOnlyPast?: boolean;
+    disableOnlyFuture?: boolean;
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    startDate?: string | Date;
+    endDate?: string | Date;
+    inputType?: SmartGridInputType;
+    leftLabel?: string;
+    rightLabel?: string;
+    splits?: SmartGridColumnDefinition[];
+    isEnableResetButton?: boolean;
+} & Record<string, unknown>;
+
+declare interface SmartGridCellValueChangedParams {
+    colDef: SmartGridColumnDefinition;
+    column: SmartGridColumnDefinition;
+    data: SmartGridRowData;
+    newValue: unknown;
+    node: {
+        data: SmartGridRowData;
+        id: string | number;
+        level: number;
+        parent?: SmartGridUpdateData;
+        rowIndex: number;
+    };
+    value: unknown;
+}
+
+export declare interface SmartGridChannel {
+    id: string | number;
+    title: string;
+    time: string;
+    unreadCount: number;
+    objectType: string;
+}
+
+/**
+ * ChatObject - Represents a chat/topic
+ * @see MDX Documentation: Data Structures > ChatObject
+ */
+export declare interface SmartGridChat {
+    id: string;
+    title: string;
+    subtitle: string;
+    user: string;
+    text: string;
+    time: string;
+    isChecked: boolean;
+    isPinned: boolean;
+    unreadCount: number;
+    messageCount: number;
+    timestamp: string;
+    createdBy?: string;
+    otherProps: {
+        object_ids: string[];
+        object_type: string;
+        topic_id: string;
+        created_by_user: string;
+        is_pinned: boolean;
+        unread_count: number;
+        message_count: number;
+        created_at: string;
+    };
+}
+
+export declare interface SmartGridChatAvatarProps {
+    src?: string;
+    name?: string;
+    size?: SmartGridAvatarSize;
+}
+
+export declare interface SmartGridChatChannelItemAvatar {
+    label?: string;
+    src?: string;
+}
+
+export declare interface SmartGridChatChannelItemProps {
+    id: string | number;
+    title?: string;
+    subtitle?: string;
+    timestamp?: string;
+    unreadCount?: number;
+    avatar?: SmartGridChatChannelItemAvatar;
+    isSelected?: boolean;
+    isMuted?: boolean;
+    onClick?: (id: string | number) => void;
+    showChannelList?: boolean;
+    showCheckbox?: boolean;
+    handleChatSelect?: (id: string | number) => void;
+    selectedChat?: (string | number)[];
+    onPinnedChatClick?: (chatId: string | number, isPinned: boolean) => Promise<boolean>;
+    handleToast?: SmartGridHandleToastFn;
+    isPinned?: boolean;
+}
+
+export declare interface SmartGridChatChannelListProps {
+    channels: SmartGridChatChannelItemProps[];
+    selectedChannelOrChatId?: string | number;
+    onChannelSelect: (channelId: string | number, channel: SmartGridChatChannelItemProps) => void;
+    showChannelList?: boolean;
+    showCheckbox?: boolean;
+    handleChatSelect?: (id: string | number) => void;
+    selectedChat?: (string | number)[];
+    onPinnedChatClick?: (chatId: string | number, isPinned: boolean) => Promise<boolean>;
+    handleToast?: SmartGridHandleToastFn;
+}
+
+export declare interface SmartGridChatConfiguration {
+    title: string;
+    description: string;
+    buttonLabel: string;
+    buttonIcon: string;
+    buttonIconPosition: "left" | "right";
+    tooltipConfig: SmartGridChatTooltipConfig;
+    messageChatConfig: SmartGridMessageChatConfig;
+    headerChatConfig: SmartGridHeaderChatConfig;
+    inputChatConfig: SmartGridInputChatConfig;
+    leftPanel: SmartGridLeftPanelConfig;
+    rightPanel: SmartGridRightPanelConfig;
+}
+
+export declare interface SmartGridChatDefaultMessageTypeProps {
+    content?: string | React.ReactNode;
+    timestamp?: string;
+    handleClickOnMoreOptions?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    priority?: SmartGridMessagePriority;
+    edited?: boolean;
+    onThreadClick?: () => void;
+    pinned?: boolean;
+    visibility?: boolean;
+    onPin?: (isPinned: boolean) => Promise<SmartGridChatMessage | boolean | undefined>;
+    isUser?: boolean;
+    isThreadIconVisible?: boolean;
+    isPinChatIconvisible?: boolean;
+    isHighlighted?: boolean;
+    highlightColor?: string | null;
+}
+
+export declare interface SmartGridChatDeletedMessageTypeProps {
+    timestamp?: string;
+    isUser?: boolean;
+}
+
+export declare interface SmartGridChatEditedMessageTypeProps {
+    content?: string | React.ReactNode;
+    timestamp?: string;
+    handleClickOnMoreOptions?: (e: React.MouseEvent<SVGSVGElement>) => void;
+    priority?: SmartGridMessagePriority;
+    edited?: boolean;
+    onThreadClick?: () => void;
+    pinned?: boolean;
+    onPin?: (isPinned: boolean) => Promise<boolean | undefined>;
+    isUser?: boolean;
+}
+
+export declare interface SmartGridChatFormData {
+    chatName?: string;
+    chatDescription?: string;
+    [key: string]: unknown;
+}
+
+export declare interface SmartGridChatHeaderActionExternalHandlers {
+    onSearchChange?: (value: string) => void;
+    onSelectAll?: (allValues: (string | number)[]) => void;
+    onClearSelection?: () => void;
+    onSelectionChange?: (newSelection: (string | number)[]) => void;
+    onParticipantsClick?: () => Promise<void>;
+    loadMenuOptions?: () => Promise<SmartGridParticipant[]>;
+    menuOptions?: SmartGridParticipant[];
+    onClose?: () => void;
+    onParticipantAdd?: (participantIds: (string | number)[], selectedRadioOption: string, chatId: string | number) => Promise<{
+        success: boolean;
+        participant: SmartGridParticipant;
+    } | null>;
+    onNotificationSettingChange?: (data: SmartGridNotificationSettings) => Promise<void | {
+        success: boolean;
+        settings: SmartGridNotificationSettings;
+    }>;
+    onSearchMessage?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    participantsList?: SmartGridParticipant[];
+    loadParticipantsAvatar?: (radioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+    handleRadioButtonChange?: (value: string) => Promise<void>;
+}
+
+export declare interface SmartGridChatHeaderActionProps {
+    enableSearch?: boolean;
+    messageSearchValue?: string;
+    handleOpenMessageSearch?: () => void;
+    handleCloseMessageSearch?: () => void;
+    handleMessageSearchChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    onParticipantsClick?: (e: React.MouseEvent<HTMLButtonElement>) => Promise<void>;
+    participants?: SmartGridParticipant[];
+    onPinnedClick?: () => void;
+    threeDotMenuOptions?: SmartGridThreeDotMenuOption[];
+    showNotificationSettings?: boolean;
+    handleNotificationSettingsClose?: () => void;
+    onThreeDotMenuClick?: () => void;
+    externalHandlers?: SmartGridChatHeaderActionExternalHandlers;
+    isLoadingOptions?: boolean;
+    isSearching?: boolean;
+    filteredMenuOptions?: SmartGridParticipant[];
+    menuSearchQuery?: string;
+    setMenuSearchQuery?: (query: string) => void;
+    renderCustomHeader?: (headerProps: Record<string, unknown>) => React.ReactNode;
+    threeDotMenuOpen?: boolean;
+    onSaveNotification?: (data: SmartGridNotificationSettings) => void;
+    selectedMenuItems?: (string | number)[];
+    setSelectedMenuItems?: React.Dispatch<React.SetStateAction<(string | number)[]>>;
+    handleThreeDotMenuClose?: () => void;
+    notificationSettings?: SmartGridNotificationSettings;
+    maxAvatars?: number;
+    selectedRadioOption?: string;
+    chatId?: string | number;
+    menuOptions?: SmartGridParticipant[];
+    externalSavingMembers?: boolean;
+    showSearch?: boolean;
+    showPinned?: boolean;
+    showParticipants?: boolean;
+    showThreeDotMenu?: boolean;
+    className?: string;
+    searchPlaceholder?: string;
+    isAddParticipantsAllowed?: boolean;
+    isLoadingParticipants?: boolean;
+    loadingError?: string | null;
+}
+
+export declare interface SmartGridChatHeaderInfoProps {
+    title?: string;
+    createdBy?: string;
+    createdAt?: string;
+    chatId?: string | number;
+}
+
+export declare interface SmartGridChatHeaderNavigationProps {
+    title?: string;
+    onBack?: () => void;
+    onSearchClick?: () => void;
+    onMenuClick?: () => void;
+    onMoreClick?: () => void;
+    showChannelList?: boolean;
+    isSearchOpen?: boolean;
+    showAddChatBtn?: boolean;
+    showSearchChat?: boolean;
+    setShowPinnedMsg?: (value: boolean) => void;
+    onThreadClick?: (messageId?: string | number, payload?: SmartGridChatMessage) => void;
+    headerConfig?: SmartGridLeftHeaderPanel;
+    handleChatName?: SmartGridLeftPanelConfig["handleChatName"];
+    filterChannelsByTitle?: (value: string) => void;
+    selectedChat?: (string | number)[];
+    selectedChannelInfo?: SmartGridChannel | null;
+    handleToast?: (isOpen: boolean, message?: string, variant?: SmartGridToastVariant) => void;
+    onDeleteTopics?: () => void;
+    isCreateNewChatOpen?: boolean;
+    setIsCreateNewChatOpen?: Dispatch<SetStateAction<boolean>>;
+}
+
+export declare interface SmartGridChatHeaderProps {
+    title: string;
+    chatId: string | number;
+    participants?: SmartGridParticipant[];
+    className?: string;
+    participantsList?: SmartGridParticipant[];
+    onSaveNotification?: (data: SmartGridNotificationSettings) => void;
+    createdBy?: string;
+    createdAt?: string;
+    chatHeaderConfig: Partial<SmartGridHeaderChatConfig> & {
+        onSearchMessage?: (searchValue: string, chatId: string | number) => Promise<SmartGridChatMessage[] | void>;
+        onSearchClear?: () => void;
+        externalSavingMembers?: boolean;
+    };
+}
+
+export declare interface SmartGridChatInputProps {
+    placeholder: string;
+    value: string;
+    onChange: (value: string) => void;
+    onSend: (payload: SmartGridChatInputSendPayload) => Promise<void>;
+    onAttach?: (file: File) => void;
+    onImageUpload?: (image: File) => void;
+    onEmojiClick?: (emoji: string) => void;
+    showFormatting?: boolean;
+    showQuickAction?: boolean;
+    quickActionLabel?: string;
+    disabled?: boolean;
+    maxLength?: number;
+    className?: string;
+    messageConfig: SmartGridMessageChatConfig & {
+        loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+        messageConfig?: SmartGridMessageConfig;
+    };
+    isEditMode?: boolean;
+    editingMessage?: SmartGridChatMessage | null;
+    onCancelEdit?: () => void;
+    chatId: string | number;
+}
+
+export declare interface SmartGridChatInputSendPayload {
+    content: string;
+    selectedPriority?: string;
+    taggedUsers?: (string | number)[];
+    [key: string]: unknown;
+}
+
+/**
+ * MessageObject - Represents a chat message
+ * @see MDX Documentation: Data Structures > MessageObject
+ */
+export declare interface SmartGridChatMessage {
+    id: string | number;
+    author?: "user" | "assistant" | "system" | string;
+    authorName?: string;
+    authorAvatar?: string;
+    content?: string;
+    timestamp?: string;
+    date?: string;
+    priority?: "low" | "medium" | "high" | "default" | "normal" | string;
+    isPinned?: boolean;
+    deleted?: boolean;
+    edited?: boolean;
+    showActions?: boolean;
+    showReplyBadge?: boolean;
+    replyText?: string | null;
+    text?: string;
+    time?: string;
+    user?: string;
+    userInitials?: string;
+    quote?: string;
+    type?: "default" | "deleted" | "edited" | string;
+    senderId?: string | number;
+    created_at?: string;
+    isRealTime?: boolean;
+    otherProps?: {
+        sender_id?: number | string;
+        created_at?: string;
+        updated_at?: string;
+        isRealTime?: boolean;
+        topic_id?: string;
+        sender_name?: string;
+        object_ids?: (string | number)[];
+        object_type?: string;
+        deleted?: boolean;
+        [key: string]: unknown;
+    };
+}
+
+export declare interface SmartGridChatMessageActionsProps {
+    messageId?: string | number;
+    onReply?: (messageId: string | number) => void;
+    onReact?: (messageId: string | number) => void;
+    onBookmark?: (messageId: string | number) => void;
+    onPin?: (messageId: string | number) => void;
+    onMore?: (messageId: string | number) => void;
+    actions?: SmartGridMessageActionKey[];
+    className?: string;
+}
+
+export declare interface SmartGridChatMessageAvatarProps {
+    authorName?: string;
+    authorAvatar?: string;
+}
+
+export declare interface SmartGridChatMessageProps {
+    messageId?: string | number;
+    author?: string;
+    authorName?: string;
+    authorAvatar?: string;
+    content?: string | React.ReactNode;
+    timestamp?: string;
+    isUser?: boolean;
+    showActions?: boolean;
+    showAvatar?: boolean;
+    isDeleted?: boolean;
+    edited?: boolean;
+    deleted?: boolean;
+    onReply?: () => void;
+    onReact?: () => void;
+    onBookmark?: () => void;
+    onPin?: (isPinned: boolean) => Promise<SmartGridChatMessage | boolean | undefined>;
+    pinned?: boolean;
+    onMore?: () => void;
+    onEdit?: () => void;
+    onMessageDelete?: (messageId: string | number) => Promise<SmartGridChatMessage | {
+        success: boolean;
+        messageId: string | number;
+    } | undefined>;
+    onRefetchMessages?: () => Promise<SmartGridChatMessage[]>;
+    type?: SmartGridChatMessageType;
+    priority?: SmartGridMessagePriority;
+    actions?: SmartGridMessageActionKey[];
+    className?: string;
+    onThreadClick?: () => void;
+    isThreadIconVisible?: boolean;
+    isPinChatIconvisible?: boolean;
+    isHighlighted?: boolean;
+    highlightColor?: string | null;
+}
+
+export declare type SmartGridChatMessageType = "default" | "deleted" | "editable";
+
+export declare interface SmartGridChatNotificationSettingsProps {
+    isOpen?: boolean;
+    onClose?: () => void;
+    isLoading?: boolean;
+    position?: {
+        top: number;
+        right: number;
+    };
+    onSaveNotification?: (data: SmartGridNotificationSettings) => void;
+    notificationSettings?: SmartGridNotificationSettings;
+}
+
+export declare interface SmartGridChatRadioOption {
+    label: string;
+    value: string;
+}
+
+export declare interface SmartGridChatTooltipConfig {
+    title: string;
+    description: string;
+}
+
+declare type SmartGridCheckConfigraitonSearchField = {
+    type: string;
+    filterType: string;
+    filter: string;
+    filterMax?: string;
+};
+
+declare interface SmartGridCheckConfiguration {
+    checkedRows?: string[];
+    unCheckedRows?: string[];
+    checkAll?: boolean;
+    searchColumns?: SmartGridCheckConfigraitonSearchField | {
+        [key: string]: SmartGridCheckConfigraitonSearchField;
+    };
+    unCheckAll?: boolean;
+}
+
+declare type SmartGridClickCallbackRefCurrent = {
+    onCellClick?: ((params: any) => void) | null;
+};
+
+/** Client-side datasource interface */
+declare interface SmartGridClientSideDatasource {
+    getRows: (params: SmartGridGetRowsRequestParams) => void;
+    destroy?: () => void;
+    _isWrapped?: boolean;
+    _cleanup?: () => void;
+    updateData?: (state: SmartGridStateContext, newData: SmartGridRowData[]) => void;
+    getWholeData?: () => SmartGridRowData[];
+    updateCacheReference?: (newCache: InfiniteCache) => boolean;
+    _cacheInjected?: boolean;
+    infiniteCache?: InfiniteCache;
+    context?: SmartGridDataSourceContext;
+    updateWholeData: (wholeData: SmartGridRowData[]) => void;
+}
+
+declare type SmartGridColumnDefinition = SmartGridColumnWithField | SmartGridColumnWithGroupId | SmartGridColumnWithColId;
+
+declare interface SmartGridColumnState {
+    colId: string;
+    hide: boolean;
+    width: number;
+    sort: SmartGridSortDirection | null;
+    filter: SmartGridFilterModel[] | null;
+}
+
+declare interface SmartGridColumnWithColId extends SmartGridBaseColumnDefinition {
+    field?: string;
+    groupId?: string;
+    colId: string;
+}
+
+declare interface SmartGridColumnWithField extends SmartGridBaseColumnDefinition {
+    field: string;
+    groupId?: string;
+}
+
+declare interface SmartGridColumnWithGroupId extends SmartGridBaseColumnDefinition {
+    field?: string;
+    groupId: string;
+}
+
+/**
+ * SmartGridComment - Represents a single comment in a thread
+ */
+export declare interface SmartGridComment {
+    id: string | number;
+    text: string;
+    author: string;
+    timestamp: string;
+    isEdited?: boolean;
+    read?: boolean;
+    isRead?: boolean;
+}
+
+/**
+ * SmartGridCommentConfiguration - Configuration options for comment features
+ */
+export declare interface SmartGridCommentConfiguration {
+    disableMarkAsRead?: boolean;
+    disableMarkAsResolved?: boolean;
+    disableDeleteThread?: boolean;
+    disableEditComment?: boolean;
+    disableDeleteComment?: boolean;
+    disableMultiCommentThread?: boolean;
+    messageIdHighlightTimer?: number;
+}
+
+/**
+ * SmartGridCommentContextRef - Context reference for comment functionality
+ * Used by smartGridContextRef in CommentWrapper
+ */
+export declare interface SmartGridCommentContextRef {
+    comments: SmartGridCommentThread;
+    popup: SmartGridCommentPopup | null;
+    handleCommentIconHover: (params: SmartGridCellRenderer) => void;
+    handleMouseEnter: () => void;
+    handleMouseLeave: () => void;
+    resolvedComments: string[];
+    getLatestUnresolvedThreadId: (cellId: string) => string | null;
+    configuration?: SmartGridCommentConfiguration;
+    colIdentifierKey?: string;
+}
+
+/**
+ * SmartGridCommentDeleteState - State for comment deletion
+ */
+export declare interface SmartGridCommentDeleteState {
+    cellId?: string;
+    data?: SmartGridCommentRowData;
+    comment?: SmartGridComment;
+}
+
+/**
+ * SmartGridCommentMenuOption - Menu option for comment actions
+ */
+export declare interface SmartGridCommentMenuOption {
+    label: string;
+    id: string;
+    icon?: React.ReactNode;
+    onClick: () => void;
+    value: string;
+}
+
+/**
+ * SmartGridCommentPanelProps - Props for CommentPanel component
+ */
+export declare interface SmartGridCommentPanelProps {
+    showCommentPanel: boolean;
+    setShowCommentPanel: () => void;
+    comments: SmartGridCommentThread;
+    onCommentItemClick: (cellId: string, comments: SmartGridComment[], messageId?: string | number | null) => void;
+    onMenuClick: (event: React.MouseEvent<HTMLButtonElement>, comment?: string | SmartGridComment | null, type?: "commentMenu" | "topMenu") => void;
+    onMarkAsReadClick?: (cellId: string | number) => Promise<void>;
+    onMarkAsResolvedClick: (cellId: string, comments: SmartGridComment[]) => Promise<void>;
+    commentProps: SmartGridCommentProps;
+    resolvedComments: string[];
+    popup: SmartGridCommentPopup | null;
+    onShowResolvedCommentsRequest?: () => Promise<void>;
+    height: string | number;
+}
+
+/**
+ * SmartGridCommentPopup - State for comment popup
+ */
+export declare interface SmartGridCommentPopup {
+    position: SmartGridCommentPopupPosition;
+    rowId?: string | number;
+    colId?: string;
+    cellId: string;
+    comment?: SmartGridComment[];
+    author?: string;
+    openedBy: "hover" | "click";
+    data?: SmartGridCommentRowData;
+    messageId?: string | number | null;
+}
+
+/**
+ * SmartGridCommentPopupPosition - Position for comment popup
+ */
+export declare interface SmartGridCommentPopupPosition {
+    top: number;
+    left: number;
+    side?: "left" | "right" | "clamped";
+}
+
+/**
+ * SmartGridCommentProps - Props passed to comment components
+ */
+export declare interface SmartGridCommentProps {
+    comments?: SmartGridCommentThread;
+    resolvedComments?: string[];
+    author?: string;
+    colIdentifierKey?: string;
+    configuration?: SmartGridCommentConfiguration;
+    commentSearchOptions?: Array<{
+        label: string;
+        value: string;
+    }>;
+    selectedCommentSearchOption?: string;
+    handleSaveComment?: (cellId: string, text: string, data: SmartGridCommentRowData, taggedUsers?: SmartGridCommentTaggedUser[]) => Promise<SmartGridCommentThread | void>;
+    handleCommentEdit?: (text: string, comment: SmartGridComment, commentId: string | number, taggedUsers?: SmartGridCommentTaggedUser[]) => Promise<SmartGridCommentThread | void>;
+    handleCommentDelete?: (commentId: string | number, comment: SmartGridComment) => Promise<SmartGridCommentThread | void>;
+    handleThreadDelete?: (cellId: string, data: SmartGridComment[]) => Promise<SmartGridCommentThread | void>;
+    handleMarkAsRead?: (cellId: string | number) => Promise<void>;
+    handleMarkAsUnread?: (cellId: string | number) => Promise<void>;
+    handleMarkAsResolved?: (cellId: string, comments: SmartGridComment[]) => Promise<string[] | void>;
+    handleFetchResolvedComments?: () => Promise<{
+        comments?: SmartGridCommentThread;
+        resolvedComments?: string[];
+    } | void>;
+    loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+}
+
+/**
+ * SmartGridCommentRowData - Row data associated with a comment
+ */
+export declare interface SmartGridCommentRowData {
+    [key: string]: unknown;
+}
+
+/**
+ * SmartGridCommentSearchOption - Search/filter option for comments
+ */
+export declare interface SmartGridCommentSearchOption {
+    label: string;
+    value: string;
+    id: string;
+}
+
+/**
+ * SmartGridCommentsPortalProps - Props for CommentsPortal component
+ */
+export declare interface SmartGridCommentsPortalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    comments?: SmartGridComment[];
+    onAddComment: (cellId: string | number, inputValue: string, taggedUsers?: SmartGridCommentTaggedUser[]) => Promise<void>;
+    cellId?: string | number;
+    position?: SmartGridCommentPopupPosition;
+    author?: string;
+    onMouseEnter?: () => void;
+    onMouseLeave?: () => void;
+    openedBy?: "hover" | "click";
+    onMenuClick: (event: React.MouseEvent<HTMLButtonElement>, comment?: string | number | SmartGridComment | null, type?: "commentMenu" | "topMenu") => void;
+    onMarkAsReadClick?: ((cellId: string | number) => Promise<void>) | null;
+    onMarkAsResolvedClick?: ((cellId: string | number, comments: SmartGridComment[]) => Promise<void>) | null;
+    editCommentText?: string;
+    isLoading?: boolean;
+    error?: string | null;
+    onClearError?: () => void;
+    currentAuthor?: string;
+    editingComment?: SmartGridComment | null;
+    setEditingComment?: React.Dispatch<React.SetStateAction<SmartGridComment | null>>;
+    onUpdateComment?: (commentId: string | number | null, newText: string) => Promise<void>;
+    loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+    resolvedComments?: string[];
+    messageId?: string | number | null;
+    configuration?: SmartGridCommentConfiguration;
+}
+
+/**
+ * SmartGridCommentTaggedUser - User tagged in a comment
+ */
+export declare interface SmartGridCommentTaggedUser {
+    id: string | number;
+    name: string;
+    avatar?: string;
+    status?: string;
+}
+
+/**
+ * SmartGridCommentThread - A collection of comments keyed by cell ID
+ */
+export declare type SmartGridCommentThread = Record<string, SmartGridComment[]>;
+
+/**
+ * SmartGridCommentWrapperProps - Props for CommentWrapper component
+ */
+export declare interface SmartGridCommentWrapperProps {
+    commentProps: SmartGridCommentProps;
+    commentPannelRef: React.MutableRefObject<((show: boolean) => void) | null>;
+    height: string | number;
+}
+
+export declare interface SmartGridCreateChatResponse {
+    success: boolean;
+    chatName?: string;
+    description?: string;
+    selectedChannel?: SmartGridChannel;
+    formattedChat?: SmartGridChat;
+}
+
+declare type SmartGridCustomCallbackRefCurrent = {
+    onCellClick?: ((params: any) => void) | null;
+};
+
+/** Data source context */
+declare interface SmartGridDataSourceContext {
+    infiniteCache?: InfiniteCache;
+    tableContextRef?: MutableRefObject<SmartGridTableContextValue | null>;
+    updateData?: (rows: SmartGridRowData[], blockId: number, metadata?: Record<string, unknown> | undefined) => void;
+    getWholeData?: () => SmartGridRowData[];
+    [key: string]: unknown;
+}
+
+/** Datasource getRows params */
+declare interface SmartGridDatasourceGetRowsParams {
+    startRow: number;
+    endRow: number;
+    sortModel?: SmartGridSortModel;
+    filterModel?: SmartGridFilterModel;
+    pageSize: number;
+    successCallback: (rows: SmartGridRowData[], lastRow?: number, lastRowIndexKnown?: boolean) => void;
+    failCallback: (error?: unknown) => void;
+    context?: SmartGridBlockContext;
+    request?: {
+        startRow: number;
+        endRow: number;
+        sortModel?: SmartGridSortModel;
+        filterModel?: SmartGridFilterModel;
+        pageSize: number;
+        groupKeys: string[];
+    };
+}
+
+declare interface SmartGridDataSourceParams {
+    startRow: number;
+    endRow: number;
+    successCallback: (rows: SmartGridRowData[], lastRow?: number | null) => void;
+    failCallback: (error: Error) => void;
+    request: RowGroupParams & {
+        groupKeys: unknown[];
+        rowGroupCols: SmartGridColumnDefinition[];
+        startRow: number;
+        endRow: number;
+    };
+    [key: string]: unknown;
+}
+
+declare type SmartGridDateFormat = "YYYY-MM-DD" | "DD-MM-YYYY" | "MM-DD-YYYY" | "YYYY/MM/DD" | "DD/MM/YYYY" | "MM/DD/YYYY";
+
+export declare type SmartGridDateSeparatorFormat = "relative" | "absolute" | "short" | "long";
+
+export declare interface SmartGridDateSeparatorItem {
+    type: "date-separator";
+    id: string;
+    date: Date;
+    pinned?: boolean;
+}
+
+export declare interface SmartGridDateSeparatorProps {
+    date?: Date | string;
+    className?: string;
+    format?: SmartGridDateSeparatorFormat;
+}
+
+declare type SmartGridDefaultColDef = {
+    minWidth: number;
+    headerComponentParams?: {
+        innerHeaderComponent: React.FC<SmartGridHeaderStyleParams> | null;
+    };
+    headerComponent?: React.FC<SmartGridHeaderStyleParams> | null;
+    enableCellChangeFlash?: boolean;
+};
+
+declare type SmartGridDispatch = (action: {
+    type: string;
+    payload: unknown;
+    meta?: {
+        fromAlignedGrid?: boolean;
+        defaultColDef?: SmartGridDefaultColDef;
+    } | Record<string, unknown>;
+}) => void;
+
+declare interface SmartGridDisplayedColumn {
+    colDef: SmartGridColumnDefinition;
+    colId: string;
+    getColId: () => string;
+    isVisible: () => boolean;
+    isPinned: () => SmartGridPinnedType;
+    label: string;
+}
+
+declare interface SmartGridDisplayedRowAtIndex {
+    data: SmartGridRowData;
+    rowIndex: number;
+    node: SmartGridParamsNode;
+    api: SmartGridAPI;
+}
+
+declare interface SmartGridDisplayedRowNode extends SmartGridRowNode {
+    rowIndex: number;
+    absoluteRowIndex: number;
+    originalData: SmartGridRowData;
+    rowHeight?: number;
+}
+
+declare interface SmartGridDisptach {
+    type: string;
+    payload?: unknown;
+}
+
+export declare interface SmartGridEditorCommands {
+    toggleBold?: () => void;
+    toggleItalic?: () => void;
+    toggleLink?: () => void;
+    toggleBulletList?: () => void;
+    toggleOrderedList?: () => void;
+    toggleStrike?: () => void;
+    toggleHighlight?: () => void;
+    toggleH1?: () => void;
+    toggleH2?: () => void;
+    toggleH3?: () => void;
+    toggleH4?: () => void;
+    toggleH5?: () => void;
+    toggleH6?: () => void;
+    insertEmoji?: (emoji: string) => void;
+    clearContent?: () => void;
+    editor?: SmartGridTipTapEditor;
+    [key: string]: (() => void) | ((emoji: string) => void) | SmartGridTipTapEditor | undefined;
+}
+
+export declare interface SmartGridEditorToolbarProps {
+    editor: SmartGridEditorCommands | null;
+    activeStates?: Record<SmartGridToolbarItemKey, boolean>;
+    enabledItems?: SmartGridToolbarItemKey[];
+    onFileSelect?: (e: ChangeEvent<HTMLInputElement>) => void;
+    onImageSelect?: (e: ChangeEvent<HTMLInputElement>) => void;
+    onEmojiSelect?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    className?: string;
+}
+
+export declare interface SmartGridEditorToolbarRef {
+    fileInput?: HTMLInputElement | null;
+    imageInput?: HTMLInputElement | null;
+}
+
+export declare interface SmartGridEmojiObject {
+    emoji: string;
+}
+
+export declare interface SmartGridEmojiPickerProps {
+    open?: boolean;
+    onClose?: () => void;
+    onEmojiClick?: (emoji: string) => void;
+    anchorEl?: HTMLElement | null;
+}
+
+export declare interface SmartGridEmptyContainerProps {
+    title?: string;
+    subTitle?: string;
+}
+
+declare interface SmartGridEvent {
+    type: string;
+    api?: SmartGridAPI;
+    [key: string]: unknown;
+}
+
+declare type SmartGridEventListener = {
+    fn: SmartGridEventListenerFn;
+    once: boolean;
+};
+
+declare type SmartGridEventListenerFn = (event: SmartGridEvent) => void;
+
+declare type SmartGridExpandedChildRows = {
+    childRowsCount: number;
+    rowId: string | number;
+    rowIndex: number;
+    children?: SmartGridRowData[];
+};
+
+declare type SmartGridExpandedColumnGroups = {
+    isAllGroupExpanded?: boolean;
+    [key: string]: boolean | undefined;
+};
+
+/** Extended filter model with search and column filters */
+declare interface SmartGridExtendedFilterModel extends SmartGridFilterModel {
+    _search?: SmartGridFilterModel[];
+    _columnFilters?: Record<string, unknown>;
+}
+
+declare type SmartGridFetchDataFunctionBody = {
+    range: SmartGridRangeFilter[];
+    search: SmartGridStringFilter[];
+    sort: SmartGridSortModel[];
+};
+
+declare interface SmartGridFetchDataResponse {
+    rowData: SmartGridRowData[];
+    lastRow?: number;
+    rowCount?: number;
+    totalCount?: number;
+}
+
+/** Fetch function ref type */
+declare interface SmartGridFetchFunctionRef {
+    current?: SmartGridFetDataParams | null;
+}
+
+export declare type SmartGridFetchMoreFn<T> = (page: number) => Promise<T[] | null | undefined>;
+
+/** Fetch response */
+declare interface SmartGridFetchResponse {
+    data?: SmartGridRowData[];
+    rowCount?: number;
+    totalItems?: number;
+    total?: number;
+    lastRow?: number;
+    lastRowIndexKnown?: boolean;
+}
+
+declare type SmartGridFetDataParams = (body: SmartGridFetchDataFunctionBody, page: number, context?: SmartGridDataSourceContext, pageNum?: number, options?: {
+    pageSize: number;
+}) => Promise<SmartGridFetchResponse & {
+    totalCount?: number | null;
+}>;
+
+export declare interface SmartGridFileUploaderProps {
+    file?: File | null;
+    fileUrl?: string | null;
+    isLoading?: boolean;
+    isError?: boolean;
+    errorMessage?: string;
+    onClear?: () => void;
+    onRetry?: () => void;
+    onDownload?: (url: string, fileName: string) => void;
+}
+
+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;
+}
+
+/**
+ * Parameters for flashCells API (AG Grid compatible)
+ */
+declare interface SmartGridFlashCellsParams {
+    /** Optional list of row nodes to flash. If not provided with columns, nothing flashes. */
+    rowNodes?: SmartGridRowNode[];
+    /** Optional list of column IDs to flash. If not provided with rowNodes, nothing flashes. */
+    columns?: string[];
+    /** Duration of the flash in milliseconds. Default: 500 */
+    flashDuration?: number;
+    /** Duration of the fade animation in milliseconds. Default: 500 */
+    fadeDuration?: number;
+    /** Custom CSS class to apply during flash */
+    flashCssClass?: string;
+    /** Custom CSS class to apply during fade */
+    fadeCssClass?: string;
+}
+
+declare type SmartGridFloatingType = "top" | "bottom" | null;
+
+declare interface SmartGridFocusedCell extends SmartGridSelectedCell {
+    floating: SmartGridFloatingType;
+}
+
+export declare interface SmartGridFormatActiveState {
+    bold: boolean;
+    italic: boolean;
+    link: boolean;
+    bulletList: boolean;
+    orderedList: boolean;
+    strike: boolean;
+    highlight: boolean;
+    h1: boolean;
+    h2: boolean;
+    h3: boolean;
+    h4: boolean;
+    h5: boolean;
+    h6: boolean;
+}
+
+declare type SmartGridFrozenColumnsDetails = {
+    indexes: string[];
+    positions: Record<string, number>;
+    totalWidth: number;
+    rightPinned: {
+        indexes: string[];
+        positions: Record<string, number>;
+        totalWidth: number;
+    };
+};
+
+declare type SmartGridFrozenState = "left" | "right" | boolean | null | undefined;
+
+declare interface SmartGridGetRowDataParams {
+    data: SmartGridRowData;
+    rowIndex?: number;
+    node: SmartGridParamsNode;
+    api: SmartGridAPI;
+}
+
+/** Request params for getRows */
+declare interface SmartGridGetRowsRequestParams {
+    startRow: number;
+    endRow: number;
+    pageSize: number;
+    sortModel?: SmartGridSortModel;
+    filterModel?: SmartGridExtendedFilterModel;
+    successCallback: (rows: SmartGridRowData[], lastRow?: number, lastRowIndexKnown?: boolean) => void;
+    failCallback: (error?: unknown) => void;
+    context?: SmartGridDataSourceContext;
+    request?: {
+        startRow: number;
+        endRow: number;
+        sortModel?: SmartGridSortModel;
+        filterModel?: SmartGridFilterModel;
+        pageSize: number;
+        groupKeys: string[];
+    };
+}
+
+export declare type SmartGridGroupedMessageItem = (SmartGridChatMessage & {
+    type?: "default" | "deleted" | "edited" | string;
+}) | SmartGridDateSeparatorItem;
+
+export declare interface SmartGridHandleToastFn {
+    (isOpen: boolean, message?: string, variant?: SmartGridToastVariant): void;
+}
+
+export declare interface SmartGridHeaderChatConfig {
+    participants: SmartGridParticipant[];
+    participantsList: SmartGridParticipant[];
+    headerConfig: SmartGridHeaderConfig;
+    notificationSettings: SmartGridNotificationSettings;
+    loadParticipants: (radioValue: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+    loadParticipantsAvatar: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+    loadMenuOptions: () => Promise<SmartGridParticipant[]>;
+    onParticipantsClick: (radioValue: string | number) => Promise<SmartGridParticipant[]>;
+    onParticipantAdd: (participantIds: (string | number)[], selectedRadioOption: string, chatId: string | number) => Promise<{
+        success: boolean;
+        participant: SmartGridParticipant;
+    } | null>;
+    onParticipantRemove: (participant: SmartGridParticipant) => Promise<{
+        success: boolean;
+        participant: SmartGridParticipant;
+    }>;
+    onPinnedClick: (chatId: string | number) => Promise<SmartGridChatMessage[]>;
+    onPinnedChatClick: (chatId: string | number, isPinned: boolean) => Promise<boolean>;
+    onChatClick: (chatId: string | number, channelId?: string | number | null) => Promise<void>;
+    onSearchChange: (value: string, radioValue?: string, chatId?: string | number) => Promise<SmartGridParticipant[]>;
+    onNotificationSettingChange: (settings: SmartGridNotificationSettings) => Promise<{
+        success: boolean;
+        settings: SmartGridNotificationSettings;
+    } | void>;
+}
+
+export declare interface SmartGridHeaderConfig {
+    showSearch?: boolean;
+    showParticipants?: boolean;
+    showPinned?: boolean;
+    showNotifications?: boolean;
+    selectedRadioOptionMenu?: string;
+    maxAvatars?: number;
+    radioOptions?: SmartGridChatRadioOption[];
+    searchConfig?: SmartGridSearchConfig;
+}
+
+declare type SmartGridHeaderRowHeight = {
+    maxHeight: number;
+    maxLineCount: number;
+};
+
+declare type SmartGridHeaderStyleParams = {
+    column: SmartGridColumnDefinition;
+    displayName: string;
+    enableSorting: boolean;
+    sortState: SmartGridSortModel;
+    onSort: (field: string, direction: string) => void;
+    isSearchable?: boolean;
+    showSortIcon: boolean;
+    toggleSearchModal: (e: default_2.MouseEvent<HTMLElement>) => void;
+    hasFilters: boolean;
+    isExpandable?: boolean;
+    onToggle?: (field: string, isExpandable: boolean) => void;
+    api: SmartGridAPI;
+    availableWidth: number;
+    wrapHeaderText: boolean;
+    menuButtonRef: default_2.RefObject<HTMLDivElement>;
+    menuToggle: (e: default_2.MouseEvent<HTMLElement>) => void;
+    toggleAdvancedSeach: default_2.Dispatch<default_2.SetStateAction<boolean>>;
+};
+
+export declare interface SmartGridImageUploaderProps {
+    image?: string | null;
+    isLoading?: boolean;
+    isError?: boolean;
+    handleClear?: () => void;
+    handleRetry?: () => void;
+}
+
+declare interface SmartGridInfiniteCache {
+    analytics: SmartGridCacheAnalytics;
+    blockCount: number;
+    blocks: Record<number, SmartGridCacheBlock>;
+    eventListeners: Record<"cacheUpdated", Function[]>;
+    lastRequestedPage: number;
+    lastRowIndexKnown: boolean;
+    params: SmartGridInfiniteCacheParams;
+    rowCount: number;
+    _currentRequestedPage: number;
+    getAllCachedData: () => SmartGridRowData[];
+    updatePageData?: (page: number, data: SmartGridRowData[], replace: boolean, options?: {
+        isRefreshData?: boolean;
+    }) => void;
+    purgeCache?: (options?: {
+        isRefreshData?: boolean;
+    }) => void;
+    getTotalCachedRowCount?: () => number;
+    printAllCachedData?: () => void;
+    setViewportRange?: (start: number, end: number) => void;
+    updateWholeData: (wholeData: SmartGridRowData[], pageSize?: number) => void;
+    getBlockData: (blockId: number) => (SmartGridRowData | null)[] | null;
+}
+
+declare type SmartGridInfiniteCacheDataSourceParams = {
+    getWholeData: () => SmartGridRowData[];
+    updateData?: (state: SmartGridStateContext, data: SmartGridRowData[], rowId?: string, rowIndex?: number) => void;
+    _cacheInjected: boolean;
+    _isDestroyed: boolean;
+    _loadingBlocks: Record<string, unknown>;
+    _originalDatasource: {
+        getRows: (params: SmartGridDataSourceParams) => void;
+    };
+    _pendingRAFs: number[];
+    _pendingRequests: Record<string, unknown>;
+    infiniteCache: SmartGridInfiniteCache;
+    destroy: () => void;
+    getRows: (params: SmartGridDataSourceParams) => void;
+    updateCacheReference: (cache: SmartGridInfiniteCache) => void;
+    updateWholeData: (wholeData: SmartGridRowData[], pageSize?: number) => void;
+};
+
+/** Infinite cache interface (forward declaration) */
+declare interface SmartGridInfiniteCacheInterface {
+    rowsMaxIndex?: number;
+    _currentRequestedPage?: number;
+    isLastRowIndexKnown: () => boolean;
+    getRowCount: () => number;
+    pageLoaded: (block: InfiniteBlock, lastRow?: number) => void;
+    getBlock: (blockId: number) => InfiniteBlock | undefined;
+    isBlockInCreationQueue: (blockId: number) => boolean;
+    createBlock: (blockId: number) => InfiniteBlock;
+    setRowCount?: (count: number, lastRowIndexKnown: boolean) => void;
+}
+
+declare interface SmartGridInfiniteCacheParams {
+    datasource: SmartGridInfiniteCacheDataSourceParams;
+    updatedPageSizeRef: MutableRefObject<number>;
+    pageSize: number;
+    overflowSize: number;
+}
+
+declare interface SmartGridInfiniteCacheReturn {
+    cacheReady: boolean;
+    shouldUseCacheRef: MutableRefObject<boolean>;
+    getRows: (startRow: number, endRow: number) => SmartGridRowData[];
+    setVisibleRange: (startRow: number, endRow: number) => void;
+    setSortModel: (sortModel: SmartGridSortModel) => void;
+    setFilterModel: (filterModel: SmartGridFilterModel | Record<string, unknown>, options?: Record<string, unknown>) => void;
+    refreshCache: (options?: SmartGridRefreshCacheOptions) => void;
+    setServerSideDataSource: (datasource: SmartGridServerSideDataSource, resetCache?: boolean) => SmartGridWrappedDataSource | null;
+    setPurgeStrategy: (strategy: string) => void;
+    setPersistence: (enabled: boolean, options?: Record<string, unknown>) => void;
+    clearPersistedCache: () => void;
+    getCacheState: () => SmartGridCacheStateReturn | null;
+    modelRef: MutableRefObject<SmartGridInfiniteRowModelRef | null>;
+    dataSourceRef?: MutableRefObject<SmartGridWrappedDataSource | null>;
+    setVisibleData?: (data: SmartGridRowData[]) => void;
+    getAllCachedData?: () => SmartGridRowData[];
+}
+
+declare interface SmartGridInfiniteRowModel {
+    infiniteCache?: SmartGridInfiniteCache;
+    setViewportRange?: (startRow: number, endRow: number) => void;
+    logCacheSummary?: () => void;
+    datasource: {
+        getWholeData: () => SmartGridRowData[];
+    };
+    [key: string]: unknown;
+}
+
+declare interface SmartGridInfiniteRowModelRef {
+    infiniteCache?: SmartGridInfiniteCache;
+    params?: {
+        context?: unknown;
+        filterModel?: SmartGridFilterModel | Record<string, unknown>;
+        sortModel?: SmartGridSortModel | null;
+        [key: string]: unknown;
+    };
+    setViewportRange?: (startRow: number, endRow: number) => void;
+    logCacheSummary?: () => void;
+    setDatasource?: (datasource: unknown, preserveCache?: boolean) => void;
+    setSortModel?: (sortModel: SmartGridSortModel) => void;
+    setFilterModel?: (filterModel: SmartGridFilterModel | {
+        _search: SmartGridSearchFunctionParams;
+    } | Record<string, unknown>, options?: Record<string, unknown>) => void;
+    purgeCache?: () => void;
+    refreshCache?: () => void;
+    refreshCachePartial?: (preserveFields: string[]) => void;
+    resetCache?: () => void;
+    setPurgeStrategy?: (strategy: string) => void;
+    setCachePersistence?: (enabled: boolean, options?: Record<string, unknown>) => void;
+    clearPersistedCache?: () => void;
+    getCacheState?: () => SmartGridCacheStateReturn;
+    getCacheAnalytics?: () => SmartGridCacheAnalyticsData | null;
+    getMemoryUsageEstimate?: () => number;
+    resetCacheAnalytics?: () => void;
+    datasource?: SmartGridDataSourceContext;
+    getRow?: (index: number) => {
+        data: SmartGridRowData;
+    } | null;
+}
+
+export declare interface SmartGridInfiniteScrollOptions {
+    threshold?: number;
+    rootMargin?: string;
+    enabled?: boolean;
+    isRestoringScroll?: MutableRefObject<boolean> | null;
+}
+
+export declare interface SmartGridInfiniteScrollReturn {
+    loadMoreRef: RefObject<HTMLDivElement>;
+    isLoading: boolean;
+    hasMore: boolean;
+    error: Error | null;
+    loadMore: () => Promise<void>;
+    reset: () => void;
+    updateHasMore: (newHasMore: boolean) => void;
+    updateCurrentPage: (newPage: number) => void;
+    currentPage: number;
+}
+
+export declare interface SmartGridInputChatConfig {
+    inputConfig: SmartGridInputConfig;
+    onSend: (payload: SmartGridSendPayload, chatId: string | number) => Promise<SmartGridChatMessage | {
+        success: boolean;
+        message: string;
+    }>;
+    onMessageReply: (messageId: string | number, chatId: string | number) => void;
+    onMessageBookmark: (messageId: string | number, chatId: string | number) => void;
+    onMessageMore: (messageId: string | number, chatId: string | number) => void;
+    onAttachFile: (file: File) => void;
+    onImageUpload: (image: File) => void;
+    onEmojiSelect: (emoji: string) => void;
+}
+
+export declare interface SmartGridInputConfig {
+    placeholder?: string;
+    maxLength?: number;
+    showFormatting?: boolean;
+    showEmojiPicker?: boolean;
+    showAttachments?: boolean;
+    allowedFileTypes?: string[];
+}
+
+declare type SmartGridInputType = "text" | "password" | "email" | "number" | "tel" | "int" | "url";
+
+declare interface SmartGridInternalGetRowsParams {
+    startRow: number;
+    endRow: number;
+    filterModel?: SmartGridFilterModel | null;
+    sortModel?: SmartGridSortModel | null;
+    request?: Record<string, unknown>;
+    successCallback?: (rowData: SmartGridRowData[], lastRow?: number) => void;
+    failCallback?: () => void;
+    noDataUpdate?: boolean;
+}
+
+/** Last accessed sequence generator */
+declare interface SmartGridLastAccessedSequence {
+    value: number;
+    next: () => number;
+}
+
+/** Last accessed sequence generator */
+declare interface SmartGridLastAccessedSequence_2 {
+    value: number;
+    next: () => number;
+}
+
+export declare interface SmartGridLeftChatPanel {
+    showCheckbox?: boolean;
+}
+
+export declare interface SmartGridLeftHeaderPanel {
+    showAddChat?: boolean;
+    showCheckbox?: boolean;
+}
+
+export declare interface SmartGridLeftPanelConfig {
+    leftHeaderPanel: SmartGridLeftHeaderPanel;
+    leftChatPanel: SmartGridLeftChatPanel;
+    rightHeaderPanel: SmartGridRightHeaderPanel;
+    loadChannelsList: () => Promise<SmartGridChannel[]>;
+    loadChatList: (selectedChannelInfo: SmartGridChannel) => Promise<SmartGridChat[]>;
+    handleChatName: (formData: SmartGridChatFormData, selectedChannelId: SmartGridChannel | null) => Promise<SmartGridCreateChatResponse>;
+    deleteChat: (topicId: string | number) => Promise<{
+        success: boolean;
+        topicId: string | number;
+    }>;
+    directChatList: SmartGridChat[];
+    hasDirectChatList: boolean;
+    selectedChatId?: string | number;
+    clearDirectChatList: () => void;
+}
+
+export declare interface SmartGridMentionCommand {
+    id: string;
+    label: string;
+}
+
+export declare interface SmartGridMentionConfig {
+    chatId?: string | number;
+    loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+}
+
+export declare interface SmartGridMentionEditorProps {
+    value?: string;
+    onChange?: (html: string) => void;
+    onSend?: () => void;
+    disabled?: boolean;
+    maxLength?: number;
+    placeholder?: string;
+    chatId?: string | number;
+    loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+}
+
+export declare interface SmartGridMentionEditorRef {
+    toggleBold: () => void;
+    toggleItalic: () => void;
+    toggleLink: () => void;
+    addImage: (url: string, alt?: string) => void;
+    getHTML: () => string;
+    getJSON: () => Record<string, unknown> | undefined;
+    clearContent: () => void;
+    isEmpty: () => boolean;
+    insertEmoji: (emoji: string) => void;
+    toggleStrike: () => void;
+    toggleHighlight: () => boolean | undefined;
+    toggleBulletList: () => void;
+    toggleOrderedList: () => void;
+    toggleH1: () => void;
+    toggleH2: () => void;
+    toggleH3: () => void;
+    toggleH4: () => void;
+    toggleH5: () => void;
+    toggleH6: () => void;
+    editor: Editor | null;
+}
+
+export declare interface SmartGridMentionInfo {
+    id: string | number;
+    label: string;
+    position: number;
+}
+
+export declare interface SmartGridMentionListProps {
+    items: SmartGridMentionUser[];
+    command: (item: SmartGridMentionCommand) => void;
+}
+
+export declare interface SmartGridMentionListRef {
+    onKeyDown: (props: SmartGridSuggestionRenderProps) => boolean | undefined;
+}
+
+export declare interface SmartGridMentionUser {
+    id: string | number;
+    name: string;
+    avatar?: string;
+    status?: string;
+}
+
+export declare interface SmartGridMenuOptionsHeaderCustomProps {
+    searchPlaceholder?: string;
+    selectAllLabel?: string;
+    clearButtonText?: string;
+    radioButtonProps?: Record<string, unknown>;
+    searchInputProps?: Record<string, unknown>;
+    checkboxProps?: Record<string, unknown>;
+    clearButtonProps?: Record<string, unknown>;
+}
+
+export declare interface SmartGridMenuOptionsHeaderExternalHandlers {
+    onSearchChange?: (value: string) => void;
+    onSelectAll?: (allValues: (string | number)[]) => void;
+    onClearSelection?: () => void;
+    onRadioButtonChange?: (value: string) => void;
+}
+
+export declare interface SmartGridMenuOptionsHeaderOverrideConfig {
+    radioButtonOptions?: SmartGridChatRadioOption[];
+    selectedRadioButton?: string;
+    showRadioButton?: boolean;
+    isSearchable?: boolean;
+    isSelectAllAllowed?: boolean;
+}
+
+export declare interface SmartGridMenuOptionsHeaderProps {
+    options?: SmartGridParticipant[];
+    selectedItems?: (string | number)[];
+    onSearchChange?: (value: string) => void;
+    onSelectAll?: (allValues: (string | number)[]) => void;
+    searchQuery?: string;
+    onClearSelection?: () => void;
+    onRadioButtonChange?: (value: string) => void;
+    radioButtonOptions?: SmartGridChatRadioOption[];
+    selectedRadioButton?: string;
+    showRadioButton?: boolean;
+    isSearchable?: boolean;
+    isSelectAllAllowed?: boolean;
+    customHeaderProps?: SmartGridMenuOptionsHeaderCustomProps;
+    externalHandlers?: SmartGridMenuOptionsHeaderExternalHandlers;
+    overrideConfig?: SmartGridMenuOptionsHeaderOverrideConfig;
+}
+
+export declare interface SmartGridMessageAction {
+    icon: React.ReactNode | null;
+    handler?: (messageId: string | number) => void;
+    ariaLabel: string;
+}
+
+export declare type SmartGridMessageActionKey = "reply" | "bookmark" | "pin" | "more";
+
+export declare interface SmartGridMessageChatConfig {
+    realTimeMessages: SmartGridChatMessage[];
+    isWebSocketConnected: boolean;
+    currentTopicId: string | number | null;
+    isThreadIconVisible: boolean;
+    isPinChatIconVisible: boolean;
+    emptyChannelStateTitle: string;
+    emptyChannelStateSubTitle: string;
+    emptyChatStateTitle: string;
+    emptyChatStateSubTitle: string;
+    currentUserId: string | number | null;
+    selectedMessageId: string | number | null;
+    maxSearchPages: number;
+    highlightDuration: number;
+    scrollBehavior: ScrollBehavior;
+    scrollBlock: ScrollLogicalPosition;
+    highlightColor: string;
+    messageConfig: SmartGridMessageConfig;
+    onRealTimeMessageUpdate: (newMessage: SmartGridChatMessage) => void;
+    onMessageReply: (messageId: string | number, message: SmartGridChatMessage) => void;
+    onMessageBookmark: (messageId: string | number, message: SmartGridChatMessage) => void;
+    onMessagePin: (messageId: string | number, isPinned: boolean, chatId: string | number, item: SmartGridChatMessage) => Promise<SmartGridChatMessage | boolean | undefined>;
+    onMessageUpdate: (messageId: string | number, updatedData: Partial<SmartGridChatMessage>) => Promise<SmartGridChatMessage | {
+        success: boolean;
+        messageId: string | number;
+        updatedData: Partial<SmartGridChatMessage>;
+    }>;
+    onMessageDelete: (messageId: string | number) => Promise<{
+        success: boolean;
+        messageId: string | number;
+    }>;
+    onThreadClick: (messageId: string | number, message: SmartGridChatMessage) => void;
+    loadThreadMessages: (parentMessageId: string | number) => Promise<SmartGridChatMessage[]>;
+    loadPinnedMsg: () => Promise<SmartGridChatMessage[]>;
+    onSearchMessage: (value: string, chatId: string | number) => Promise<SmartGridChatMessage[]>;
+    leaveCurrentTopic: () => void;
+    markTopicAsDeleted: (topicId: string | number) => void;
+    onClearAllMessages: (chatId?: string | number) => void;
+}
+
+export declare interface SmartGridMessageConfig {
+    showActions?: boolean;
+    priorityOptions?: SmartGridPriorityOption[];
+    quickActionProps?: SmartGridQuickActionProp[];
+    isMsgFormat?: boolean;
+}
+
+export declare interface SmartGridMessageItemProps {
+    type?: SmartGridPinnedPanelType;
+    msg?: SmartGridPinnedMessageItem;
+    onMessageClick?: (messageId: string | number) => void;
+}
+
+export declare type SmartGridMessagePriority = "default" | "normal" | "low" | "medium" | "high";
+
+declare type SmartGridModelType = "normal" | "serverSide" | "infinite";
+
+export declare interface SmartGridMoreAvatarProps {
+    count: number;
+    size?: SmartGridAvatarSize;
+}
+
+declare interface SmartGridNewSortModel {
+    column: string | null;
+    order: SmartGridSortDirection | null;
+}
+
+/**
+ * SmartGridNoCommentsProps - Props for NoComments component
+ */
+export declare interface SmartGridNoCommentsProps {
+    onAddComment?: (cellId: string | number, inputValue: string, taggedUsers?: SmartGridCommentTaggedUser[]) => void | Promise<void>;
+    cellId?: string | number;
+    position?: SmartGridCommentPopupPosition;
+    isInsidePortal?: boolean;
+    editCommentText?: string;
+    isLoading?: boolean;
+    error?: string | null;
+    onClearError?: () => void;
+    isEditFlow?: boolean;
+    onUpdateComment?: (text: string) => void;
+    setEditingComment?: React.Dispatch<React.SetStateAction<SmartGridComment | null>>;
+    loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+}
+
+declare interface SmartGridNotification {
+    message: string;
+    type?: "success" | "error" | "warning" | "info";
+    duration?: number;
+    timeout?: number;
+}
+
+export declare interface SmartGridNotificationSettings {
+    notificationSetting?: string;
+    includeChannelMentions?: boolean;
+    muteChannel?: boolean;
+    channelName?: string;
+}
+
+declare type SmartGridNumberFormat = "full" | "thousands" | "millions" | "billions";
+
+declare interface SmartGridOldSortModel {
+    colId: string;
+    sort: SmartGridSortDirection;
+}
+
+export declare type SmartGridOnMessagePin = (messageId: string | number, pinned: boolean, chatId: string | number, item: SmartGridChatMessage) => Promise<SmartGridChatMessage | boolean | undefined>;
+
+declare type SmartGridOnSelectionChangedParams = {
+    api: SmartGridAPI;
+    type: string;
+    source: string;
+};
+
+declare interface SmartGridOptions {
+    [key: string]: unknown;
+}
+
+/** Page size ref */
+declare interface SmartGridPageSizeRef {
+    current: number;
+}
+
+/** Page size ref */
+declare interface SmartGridPageSizeRef_2 {
+    current: number;
+}
+
+declare interface SmartGridPaginationAPI {
+    paginationGetPageSize: () => number;
+    paginationGetRowCount: () => number;
+    paginationGetCurrentPage: () => number;
+    paginationGetTotalPages: () => number;
+    paginationGoToPage: (pageNumber: number) => void;
+    paginationGoToFirstPage: () => void;
+    paginationGoToLastPage: () => void;
+    paginationGoToNextPage: () => void;
+    paginationGoToPreviousPage: () => void;
+    paginationIsLastPageFound: () => boolean;
+}
+
+declare interface SmartGridPaginationModel {
+    currentPage: number;
+    pageSize: number;
+    totalPages: number;
+    totalRecords: number;
+}
+
+declare interface SmartGridParamsNode {
+    rowIndex: number;
+    data: SmartGridRowData;
+    api: SmartGridAPI;
+}
+
+/**
+ * ParticipantObject - Represents a chat participant
+ * @see MDX Documentation: Data Structures > ParticipantObject
+ */
+export declare interface SmartGridParticipant {
+    id: string | number;
+    label: string;
+    value: string | number;
+    name?: string;
+    role?: string;
+    url?: string;
+    status?: "online" | "offline";
+    isPinned?: boolean;
+    avatar?: string;
+    otherProps?: {
+        user_name: string;
+        user_code: string | number;
+        email: string;
+        user_image?: string;
+    };
+}
+
+/** 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 SmartGridPinnedMessageItem {
+    id?: string | number;
+    userInitials?: string;
+    src?: string;
+    senderName?: string;
+    timestamp?: string;
+    content?: string | React.ReactNode;
+    quote?: string | React.ReactNode;
+    edited?: boolean;
+    type?: string;
+    deleted?: boolean;
+}
+
+export declare interface SmartGridPinnedPanelProps {
+    type?: SmartGridPinnedPanelType;
+    messages?: SmartGridPinnedMessageItem[];
+    onClose?: () => void;
+    onMessageClick?: (messageId: string | number) => void;
+    handleToast?: SmartGridHandleToastFn;
+}
+
+export declare type SmartGridPinnedPanelType = "pinned" | "thread";
+
+declare type SmartGridPinnedType = "leftPinned" | "rightPinned" | null;
+
+export declare interface SmartGridPriorityMenuOption {
+    id?: string;
+    label?: string;
+    value?: string;
+    icon?: React.ReactNode;
+    onClick?: (data: SmartGridPriorityMenuOption) => void;
+}
+
+export declare interface SmartGridPriorityOption {
+    id: string | number;
+    value: string;
+    label: string | number;
+    icon?: React.ReactNode;
+    onClick?: (value: string | number) => void;
+}
+
+export declare interface SmartGridQuickActionOption {
+    id?: string;
+    label?: string;
+    value?: string;
+    icon?: React.ReactNode;
+    onClick?: (data: SmartGridQuickActionOption) => void;
+    prefillText?: string;
+}
+
+export declare interface SmartGridQuickActionProp {
+    id: string | number;
+    value: string;
+    label: string | number;
+    prefillText?: string;
+    icon?: React.ReactNode;
+    onClick?: (value: string | number) => void;
+}
+
+declare type SmartGridRangeFilter = {
+    column: string;
+    min_val: number;
+    max_val: number;
+    search_type: string;
+    operator?: string;
+};
+
+/**
+ * Parameters for redrawRows API (AG Grid compatible)
+ */
+declare interface SmartGridRedrawRowsParams {
+    /** Optional list of row nodes to redraw. If not provided, all rows are redrawn */
+    rowNodes?: SmartGridRowNode[];
+}
+
+declare interface SmartGridRefreshCacheOptions {
+    purge?: boolean;
+    partialRefresh?: boolean;
+    preserveFields?: string[];
+    userInitiated?: boolean;
+}
+
+/**
+ * Parameters for refreshCells API (AG Grid compatible)
+ */
+declare interface SmartGridRefreshCellsParams {
+    /** Optional list of row nodes to refresh. If not provided, all rows are refreshed. */
+    rowNodes?: SmartGridRowNode[];
+    /** Optional list of column IDs to refresh. If not provided, all columns are refreshed. */
+    columns?: string[];
+    /** If true, forces refresh even if the cell value hasn't changed. Default: false */
+    force?: boolean;
+    /** If true, suppresses the flash animation. Default: false */
+    suppressFlash?: boolean;
+}
+
+declare interface SmartGridRefreshOptions {
+    purge?: boolean;
+    resetPage?: boolean;
+    userInitiated?: boolean;
+    resetFilters?: boolean;
+}
+
+export declare interface SmartGridReplyBadgeProps {
+    text?: string;
+    action?: string;
+    onReplyClick?: () => void;
+    onActionClick?: () => void;
+    className?: string;
+    showIcon?: boolean;
+}
+
+/** Response metadata */
+declare interface SmartGridResponseMetadata {
+    totalCount?: number;
+    lastRowIndexKnown?: boolean;
+}
+
+export declare interface SmartGridRightHeaderPanel {
+    showParticipants?: boolean;
+    showPinnedChat?: boolean;
+    showChatSearch?: boolean;
+    showActionBtn?: boolean;
+}
+
+export declare interface SmartGridRightPanelConfig {
+    loadMessages: (chatId: string | number, page?: number) => Promise<SmartGridChatMessage[]>;
+    loadOlderMessages: (channelId: string | number) => Promise<SmartGridChatMessage[]>;
+    messagesClearedTrigger?: number;
+}
+
+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;
+    };
+}
+
+/**
+ * Transaction object for applyTransaction API (AG Grid compatible)
+ */
+declare interface SmartGridRowDataTransaction {
+    /** Rows to add */
+    add?: SmartGridRowData[];
+    /** Index position to add rows at. If not provided, rows are added at the end */
+    addIndex?: number;
+    /** Rows to remove. Only the row ID field is required */
+    remove?: SmartGridRowData[];
+    /** Rows to update. The row ID field is used to match rows */
+    update?: SmartGridRowData[];
+}
+
+declare interface SmartGridRowDragEndParams {
+    api: SmartGridAPI;
+    type: "rowDragEnd";
+    fromIndex: number;
+    toIndex: number;
+    rowData: SmartGridRowData;
+}
+
+declare interface SmartGridRowDragStartParams {
+    api: SmartGridAPI;
+    type: "rowDragStart";
+    rowIndex: number;
+    rowData: SmartGridRowData;
+}
+
+declare type SmartGridRowGrouOpenParams = {
+    rowId: string;
+    rowIndex: number;
+    api: SmartGridAPI;
+    isExpanded: boolean;
+};
+
+declare type SmartGridRowGroupState = {
+    expandedGroups: Record<string, SmartGridRowGroupStateExpandedGroups>;
+    loadedData: Record<string, SmartGridRowData[]>;
+    loading: Record<string, boolean>;
+    pagination: Record<string, SmartGridRowGroupStatePagination>;
+    cache: {
+        metadata: Record<string, SmartGridCacheMetadata>;
+        expirationTime: number;
+    };
+    api: SmartGridAPI | null;
+    isLoadingSomething: boolean;
+    isAllRowExpanded: boolean;
+    isManuallyChanged: boolean;
+};
+
+declare type SmartGridRowGroupStateExpandedGroups = {
+    count: number;
+    fieldName: string;
+    rowIndex: number;
+    value: string;
+    [key: string]: boolean | number | string;
+};
+
+declare type SmartGridRowGroupStatePagination = {
+    hasMore: boolean;
+    lastUpdated: number;
+    page: number;
+    pageSize: number;
+    totalItems?: number;
+    totalPages?: number;
+    error?: boolean;
+};
+
+declare type SmartGridRowInfo = {
+    isFirst: boolean;
+    span: number;
+    rowIds?: (string | number)[];
+};
+
+declare interface SmartGridRowNode extends SmartGridUpdateData {
+    id: string | number;
+    childIndex?: number;
+    selected: boolean;
+    rowIndex?: number;
+    absoluteRowIndex?: number;
+    originalData?: SmartGridRowData;
+    rowHeight?: number;
+    setSelected: (selected: boolean, clearSelection?: boolean) => void | ((value: string | number | boolean) => void);
+    isGroup?: () => boolean;
+}
+
+/**
+ * Result of applyTransaction API (AG Grid compatible)
+ */
+declare interface SmartGridRowNodeTransaction {
+    /** Row nodes that were added */
+    add: SmartGridRowNode[];
+    /** Row nodes that were removed */
+    remove: SmartGridRowNode[];
+    /** Row nodes that were updated */
+    update: SmartGridRowNode[];
+}
+
+declare interface SmartGridRowSpanInfo {
+    [key: string]: SmartGridRowInfo | boolean | undefined;
+    isRowSpan?: boolean;
+    Selection?: SmartGridRowInfo;
+}
+
+declare type SmartGridRowStyleParams = {
+    api: SmartGridAPI;
+    data: SmartGridRowData;
+    pinned: boolean;
+    node: {
+        rowIndex: number;
+        data: SmartGridRowData;
+        api: SmartGridAPI;
+        pinned: boolean;
+    };
+};
+
+declare type SmartGridSavedViewsOptions = {
+    isActive: boolean;
+    isDefaultView: boolean;
+    viewName: string;
+    viewType: "personal" | "global";
+};
+
+declare interface SmartGridSaveViewCallbackRefCurrent {
+    handleSetDefaultView?: ((view: SmartGridSavedViewsOptions) => void) | null;
+    handleSavedViewClick?: ((view: SmartGridSavedViewsOptions) => void) | null;
+    handleEditSaveView?: ((updatedData: SmartGridSavedViewsOptions, view: SmartGridSavedViewsOptions) => void) | null;
+    handleSaveAndApply?: ((view: SmartGridSavedViewsOptions) => void) | null;
+    handleDeleteViewClick?: ((view: SmartGridSavedViewsOptions) => void) | null;
+}
+
+export declare interface SmartGridSearchConfig {
+    placeholder?: string;
+    debounceMs?: number;
+    minChars?: number;
+}
+
+declare type SmartGridSearchFunctionParams = SmartGridFilterModel[] | Record<string, SmartGridFilterModel[]>;
+
+declare type SmartGridSearchFunctionParamsWithField = Record<string, SmartGridFilterModel>;
+
+declare interface SmartGridSearchOperatorOption {
+    value: string;
+    label: string;
+    type?: string;
+}
+
+declare interface SmartGridSearchWithSearchKey {
+    _search: SmartGridSearchFunctionParamsWithField;
+}
+
+declare interface SmartGridSelectedCell {
+    colIndex: number;
+    column: SmartGridColumnDefinition;
+    data: SmartGridRowData;
+    field: string;
+    rowId: string | number;
+    rowIndex: number;
+    value: unknown;
+}
+
+declare interface SmartGridSelectOption {
+    value: string | number;
+    label: string;
+    isDisabled?: boolean;
+}
+
+export declare interface SmartGridSendPayload {
+    content: string;
+    [key: string]: unknown;
+}
+
+declare interface SmartGridServerSideDataSource {
+    getRows: (params: SmartGridServerSideGetRowsParams) => {
+        abort?: () => void;
+    } | void;
+}
+
+/** Server-side datasource interface */
+declare interface SmartGridServerSideDatasource {
+    infiniteCache: InfiniteCache | undefined;
+    _originalParams: SmartGridServerSideDataSourceParams;
+    _loadingBlocks: Record<number, boolean>;
+    _pendingRequests: Record<string, SmartGridPendingRequest>;
+    _lastRequestParams: SmartGridGetRowsRequestParams | null;
+    _isDestroyed: boolean;
+    updateCacheReference: (newCache: InfiniteCache) => boolean;
+    updateConfig: (newConfig: Partial<SmartGridServerSideDataSourceParams>) => SmartGridServerSideDatasource;
+    destroy: () => void;
+    resetLoadState: () => void;
+    getRows: (requestParams: SmartGridGetRowsRequestParams) => void;
+    _cacheInjected?: boolean;
+    _isWrapped?: boolean;
+    context?: SmartGridDataSourceContext;
+}
+
+/** Server-side datasource params */
+declare interface SmartGridServerSideDataSourceParams {
+    fetchFunc?: SmartGridFetchFunctionRef;
+    apiUrl?: string;
+    sortModel: SmartGridSortModel;
+    filterModel: SmartGridSearchWithSearchKey | null;
+    infiniteCache: InfiniteCache | null;
+    context: SmartGridDataSourceContext;
+    pageSize: number;
+    resetState?: boolean;
+    updatedPageSizeRef?: SmartGridUpdatedPageSizeRef;
+}
+
+declare interface SmartGridServerSideGetRowsParams {
+    request: {
+        startRow: number;
+        endRow: number;
+        filterModel?: SmartGridFilterModel | SmartGridSearchWithSearchKey | null;
+        sortModel?: SmartGridSortModel | null;
+    };
+    api: SmartGridAPI;
+    success: (response: SmartGridFetchDataResponse) => void;
+    fail: () => void;
+}
+
+declare type SmartGridSortDirection = "asc" | "desc" | "none";
+
+declare type SmartGridSortModel = SmartGridOldSortModel | SmartGridNewSortModel | null;
+
+declare interface SmartGridStateContext {
+    data?: SmartGridRowData[] | null;
+    filteredData: SmartGridRowData[] | null;
+    originalData: SmartGridRowData[] | null;
+    previewMode: boolean;
+    isLoading: boolean;
+    columns: SmartGridColumnDefinition[];
+    columnMap: Record<string, SmartGridColumnDefinition>;
+    sortState: SmartGridSortModel;
+    pagination: {
+        currentPage: number;
+        pageSize: number;
+        totalPages: number | null;
+        isCountUnknown: boolean;
+        totalItems: number;
+        currentLoadedPage: number;
+        allTotalPages: number;
+        page: number;
+    };
+    selectedRows: (string | number)[];
+    selectedRowsObject: Record<string, boolean>;
+    columnFilters: Record<string, SmartGridFilterModel[]>;
+    expandedChildRows: Record<string, SmartGridExpandedChildRows>;
+    expandedColumnGroups: SmartGridExpandedColumnGroups;
+    uniqueIdField: string;
+    childKeyField: string;
+    frozenColumns: SmartGridFrozenColumnsDetails;
+    notification: SmartGridNotification & {
+        show: boolean;
+    };
+    columnsToAutosize: string[] | Record<string, boolean>;
+    prevAction: string;
+    checkConfiguration: SmartGridCheckConfiguration[];
+    isSelectAllRecords: boolean;
+    unCheckedRows: Record<string, boolean>;
+    isSelectionChanged: boolean;
+    masterDetail: {
+        enabled: boolean;
+        expandedRows: (string | number)[];
+        detailRenderer: null | Function;
+        detailRowHeight: number;
+        detailPadding: number;
+        expandedRowData: SmartGridRowData | SmartGridRowData[] | null;
+        currentRowStyles?: {
+            height?: number;
+            top?: number;
+        };
+        rowIndex?: number | null;
+    };
+    eventListeners: Record<string, SmartGridEventListener[]>;
+    defaultColDef: SmartGridDefaultColDef | null;
+    api: SmartGridAPI | null;
+    actions: {};
+    serverSide: boolean;
+    enableRowSpan: boolean;
+    rowSpanColumn: string | string[] | null;
+    rowDragManaged: boolean;
+    format: {
+        fontSize: "medium" | "small" | "large";
+        numberFormat: SmartGridNumberFormat;
+    };
+    pinnedTopRows: SmartGridRowData[];
+    pinnedBottomRows: SmartGridRowData[];
+    rowGroupState: SmartGridRowGroupState;
+    tableInstance: MutableRefObject<HTMLElement | null>;
+    headerRowHeightwithIndex: Record<string, SmartGridHeaderRowHeight>;
+    infiniteScroll: boolean;
+    smartGridMenuOptions: {
+        withColumMenu?: boolean;
+        autoWithColumMenu?: boolean;
+        freezeColumnMenu?: boolean;
+        sortColumnMenu?: boolean;
+        collapseColumnAll?: boolean;
+        expandColumnAll?: boolean;
+        wrapText?: boolean;
+    };
+    purgeClosedRowNodes: boolean;
+    detailRendererTable: boolean;
+    isSaveViewEnabled: boolean;
+    rowHeight: {
+        type: "default" | "compact" | "comfortable";
+        height: number;
+        padding: number;
+    };
+    aggregationTotalRow: Record<number, 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>;
+    clickCallbackRef: MutableRefObject<SmartGridClickCallbackRefCurrent>;
+    customCallback: SmartGridCustomCallbackRefCurrent;
+    contextRef: MutableRefObject<SmartGridCommentContextRef> | null;
+    tableId: string;
+    isSingleSelect: boolean;
+    selectable: boolean;
+    disableSelectAllRecords: boolean;
+    columnBufferSize?: number;
+    lazyLoadCellRenderer?: boolean;
+    hasSplitRenderer?: boolean;
+    splitRendererKeys?: string[] | null;
+    originalFromIndex?: number | null;
+    lastToIndex?: number | null;
+    hasExpandedChildren?: boolean;
+    isDraggingDownward?: boolean;
+    saveViewCallbacks?: {
+        isSavingViewLoading?: boolean;
+        savedViewsOptions?: SmartGridSavedViewsOptions[];
+    } & Record<string, unknown>;
+    pivotPanelColumnDef: null | SmartGridColumnDefinition[];
+    removeCheckConfigurationOnOperation: boolean;
+    totalColumnsCount: number;
+    isCommentFeatureEnabled: boolean;
+    isChatEnabled: boolean;
+    [key: string]: unknown;
+}
+
+declare type SmartGridStringFilter = {
+    column: string;
+    pattern: string;
+    search_type: string;
+    operator?: string;
+};
+
+export declare interface SmartGridSuggestion {
+    items: (params: SmartGridSuggestionItemsParams) => Promise<SmartGridMentionUser[]>;
+    render: () => SmartGridSuggestionRenderReturn;
+}
+
+export declare interface SmartGridSuggestionItemsParams {
+    query: string;
+    editor: Editor & {
+        storage: {
+            mentionConfig?: SmartGridMentionConfig;
+        };
+    };
+}
+
+export declare interface SmartGridSuggestionKeyDownProps {
+    event?: KeyboardEvent;
+}
+
+export declare interface SmartGridSuggestionRenderProps {
+    editor?: Editor;
+    clientRect?: (() => DOMRect | null) | null;
+    items?: SmartGridMentionUser[];
+    command?: (item: SmartGridMentionCommand) => void;
+    event?: KeyboardEvent;
+}
+
+export declare interface SmartGridSuggestionRenderReturn {
+    onStart: (props: SmartGridSuggestionRenderProps) => void;
+    onUpdate: (props: SmartGridSuggestionRenderProps) => void;
+    onKeyDown: (props: SmartGridSuggestionKeyDownProps) => boolean;
+    onExit: () => void;
+}
+
+export declare interface SmartGridTableChatChannelHeaderConfig extends SmartGridLeftHeaderPanel {
+    showSearch?: boolean;
+    leftChatPanel?: SmartGridLeftHeaderPanel;
+}
+
+export declare interface SmartGridTableChatChannelHeaderProps {
+    title?: string;
+    channels?: SmartGridChatChannelItemProps[];
+    selectedChannelOrChatId?: string | number;
+    onBack?: () => void;
+    onChannelSelect?: (channelId: string | number, channel: SmartGridChatChannelItemProps) => void;
+    onMenuClick?: () => void;
+    onSearchClick?: () => void;
+    onMoreClick?: () => void;
+    showChannelList?: boolean;
+    setShowPinnedMsg?: (value: boolean) => void;
+    onThreadClick?: (messageId?: string | number, payload?: SmartGridChatMessage) => void;
+    isSearchOpen?: boolean;
+    headerConfig?: SmartGridTableChatChannelHeaderConfig;
+    showAddChatBtn?: boolean;
+    showCheckbox?: boolean;
+    handleChatName?: SmartGridLeftPanelConfig["handleChatName"];
+    filterChannelsByTitle?: (value: string) => void;
+    loadingChannels?: boolean;
+    selectedChannelInfo?: SmartGridChannel | null;
+    handleToast?: SmartGridHandleToastFn;
+    onPinnedChatClick?: (chatId: string | number, isPinned: boolean) => Promise<boolean>;
+    onDeleteTopics?: () => void;
+    selectedChat?: (string | number)[];
+    handleChatSelect?: (id: string | number) => void;
+    isCreateNewChatOpen?: boolean;
+    setIsCreateNewChatOpen?: Dispatch<SetStateAction<boolean>>;
+}
+
+export declare interface SmartGridTableChatRightSectionProps {
+    title: string;
+    chatId: string | number;
+    CreatedBy: string;
+    participants?: SmartGridParticipant[];
+    participantsList?: SmartGridParticipant[];
+    onParticipantsClick?: () => void;
+    messages?: SmartGridChatMessage[];
+    placeholder?: string;
+    showFormatting?: boolean;
+    maxLength?: number;
+    showParticipantsList?: boolean;
+    showPinnedChat?: boolean;
+    showSearch?: boolean;
+    showActionBtn?: boolean;
+    onMessageReply?: (messageId: string | number, chatId: string | number) => void;
+    onMessageBookmark?: (messageId: string | number, chatId: string | number) => void;
+    onMessagePin?: SmartGridOnMessagePin;
+    onMessageMore?: (messageId: string | number, chatId: string | number) => void;
+    onAttachFile?: (file: File) => void;
+    onImageUpload?: (image: File) => void;
+    onEmojiClick?: (emoji: string) => void;
+    setPinnedMessages?: React.Dispatch<React.SetStateAction<SmartGridChatMessage[]>>;
+    className?: string;
+    showDateSeparators?: boolean;
+    autoScroll?: boolean;
+    onThreadClick?: (messageId: string | number, chatId: string | number) => void;
+    messageConfig: SmartGridMessageChatConfig & {
+        loadMessages?: (chatId: string | number, page: number) => Promise<SmartGridChatMessage[] | {
+            messages: SmartGridChatMessage[];
+            noMoreData: boolean;
+        }>;
+        messagesClearedTrigger?: number;
+        loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+        messageConfig?: SmartGridMessageConfig;
+        highlightTrigger?: number | null;
+    };
+    inputChatConfig: SmartGridInputChatConfig & {
+        inputConfig?: SmartGridInputConfig & {
+            showQuickAction?: boolean;
+            quickActionLabel?: string;
+        };
+    };
+    chatHeaderConfig: SmartGridHeaderChatConfig;
+    handleToast: (isOpen: boolean, message: string, variant: SmartGridToastVariant) => void;
+}
+
+export declare interface SmartGridTableChatSidePanelProps {
+    isOpen: boolean;
+    handleClose: () => void;
+    chatConfiguration: SmartGridChatConfiguration;
+}
+
+export declare type SmartGridTableChatWrapper = {
+    isChatOpen: boolean;
+    handleChatClick: () => void;
+    handleChatClose: () => void;
+    chatConfiguration: SmartGridChatConfiguration;
+};
+
+declare interface SmartGridTableContextValue {
+    state: SmartGridStateContext;
+    tableApi: SmartGridAPI | null;
+    dispatch: SmartGridDispatch;
+    ACTION_TYPES: typeof ACTION_TYPES;
+    toggleGroupExpansion: (rowId: string | number, rowIndex: number) => void;
+    dispatchEvent: (eventType: string, eventData: Record<string, unknown>) => void;
+    getRowStyle?: (params: SmartGridRowStyleParams) => CSSProperties;
+}
+
+declare interface SmartGridTableInstance {
+    current: HTMLElement | null;
+}
+
+declare interface SmartGridTableModel {
+    getData: () => SmartGridRowData[];
+    modelRef?: {
+        current?: SmartGridInfiniteRowModel;
+    };
+    infiniteCache: SmartGridInfiniteCacheReturn | null;
+    getColumnDefs: () => SmartGridColumnDefinition[];
+    getSortModel: () => SmartGridSortModel[];
+    getFilterModel: () => SmartGridFilterModel;
+    getType: () => SmartGridModelType;
+    getRowsToDisplay: () => number;
+    forEachNode: (callback: (node: SmartGridRowNode, index: number) => void | Promise<void>) => Promise<void>;
+    getRowNode: (id: string | number) => SmartGridRowNode | null;
+    getSelectedRows: () => SmartGridRowData[];
+    getPaginationModel: () => SmartGridPaginationModel;
+    getColumnState: () => SmartGridColumnState[];
+    rowsToDisplay: SmartGridRowData[];
+}
+
+/**
+ * SmartGridThreadDeleteState - State for thread deletion
+ */
+export declare interface SmartGridThreadDeleteState {
+    cellId: string;
+    data: SmartGridComment[];
+}
+
+export declare interface SmartGridThreeDotMenuOption {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    onClick?: () => void;
+}
+
+export declare type SmartGridTipTapEditor = {
+    isActive: (name: string, attrs?: Record<string, unknown>) => boolean;
+    on: (event: string, handler: () => void) => void;
+    off: (event: string, handler: () => void) => void;
+    state: Record<string, unknown>;
+};
+
+export declare type SmartGridToastVariant = "info" | "success" | "warning" | "error";
+
+export declare interface SmartGridToolbarItem {
+    icon: React.FC<React.SVGProps<SVGSVGElement>>;
+    ariaLabel: string;
+    command: string;
+}
+
+export declare type SmartGridToolbarItemKey = "bold" | "italic" | "link" | "bulletList" | "orderedList" | "strike" | "highlight" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+
+export declare type SmartGridToolbarItems = Record<SmartGridToolbarItemKey, SmartGridToolbarItem>;
+
+declare type SmartGridTooltipGetterParams = {
+    api: SmartGridAPI;
+    colDef: SmartGridColumnDefinition;
+    column: SmartGridColumnDefinition;
+    data: SmartGridRowData;
+    location: string;
+    node: {
+        data: SmartGridRowData;
+        id: string;
+        level: number;
+        parent: SmartGridUpdateData;
+        rowIndex: number;
+    };
+    rowIndex: number;
+    value: unknown;
+};
+
+declare type SmartGridUpdateData = {
+    data: SmartGridRowData;
+    setData: (data: SmartGridRowData) => void;
+    setDataValue: (field: string, value: unknown, callbackNeeded?: boolean) => void;
+};
+
+declare type SmartGridUpdateDataReturnType = {
+    success: boolean;
+    totalRows: number;
+    blocksUpdated: number;
+    errors: string[];
+};
+
+/** Page size ref for server-side */
+declare interface SmartGridUpdatedPageSizeRef {
+    current: number;
+}
+
+declare type SmartGridValueFormatterConfig = {
+    type?: string;
+    symbol?: string;
+    position?: "prefix" | "suffix";
+    decimals?: number;
+};
+
+declare interface SmartGridValueFormatterParams {
+    value: unknown;
+    data: SmartGridRowData;
+    colDef: SmartGridColumnDefinition;
+}
+
+declare interface SmartGridValueGetterParams {
+    data: SmartGridRowData;
+    node: {
+        data: SmartGridRowData;
+    };
+    colDef: SmartGridColumnDefinition;
+    column: SmartGridColumnDefinition;
+    api: SmartGridAPI | null;
+    columnApi?: SmartGridAPI;
+    getValue: (field: string) => unknown;
+}
+
+/** Viewport range */
+declare interface SmartGridViewportRange {
+    startRow: number;
+    endRow: number;
+}
+
+declare interface SmartGridWrappedDataSource {
+    _originalDatasource: SmartGridServerSideDataSource;
+    _loadingBlocks: Record<number, boolean>;
+    _pendingRequests: Record<number, {
+        abort?: () => void;
+    }>;
+    _isDestroyed: boolean;
+    _pendingRAFs?: number[];
+    infiniteCache: unknown;
+    updateCacheReference: (newCache: unknown) => void;
+    destroy: () => void;
+    getRows: (params: SmartGridInternalGetRowsParams) => void;
+}
+
+export declare const TableChatWrapper: ({ isChatOpen, handleChatClick, handleChatClose, chatConfiguration, }: SmartGridTableChatWrapper) => JSX_2.Element;
+
+export { }