import { CSSProperties } from 'react'; import { default as default_2 } from 'react'; import { MouseEvent as MouseEvent_2 } from 'react'; import { MutableRefObject } from 'react'; import { RefObject } 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_FONT_SIZE: "SET_FONT_SIZE"; 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 SET_COLUMN_API: "SET_COLUMN_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"; readonly SET_NO_HEADER_SELECTION_CHECKBOX: "SET_NO_HEADER_SELECTION_CHECKBOX"; readonly SET_DATA_IS_TREE_DATA: "SET_DATA_IS_TREE_DATA"; readonly SET_VIRTUALIZATION_CONFIG: "SET_VIRTUALIZATION_CONFIG"; readonly SET_DISABLE_CURRENT_PAGE_RECORDS: "SET_DISABLE_CURRENT_PAGE_RECORDS"; readonly SET_FORCE_SHOW_LOADING: "SET_FORCE_SHOW_LOADING"; readonly UPDATE_ROW_DATA_WITH_REFRESH: "UPDATE_ROW_DATA_WITH_REFRESH"; }; 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; 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; blockCount: number; rowCount: number; lastRowIndexKnown: boolean; eventListeners: Record void>>; lastRequestedPage: number; analytics: SmartGridCacheAnalytics_2; rowsMaxIndex?: number; _currentRequestedPage?: number; _blockCreationQueue?: Set; constructor(params: Partial); /** * 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): 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): { success: boolean; pageNo: number; updatedRows: number; errors: string[]; }; updateBlockData(blockId: number, newData: SmartGridRowData[], notifyChanges?: boolean): { success: boolean; blockId: number; updatedRows: number; errors: string[]; }; updateWholeData(wholeData: SmartGridRowData[], pageSize: number): SmartGridUpdateDataReturnType; } export declare const PivotWrapper: React.FC; declare interface RowGroupParams { page: number; pageSize: number; groupId?: string; noDataUpdate?: boolean; } export declare type SmartGridAggregationType = "sum" | "count" | "avg" | "min" | "max"; 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 | null; getRowNodeWithIndex: (rowIndex: number) => Partial | 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) => SmartGridDisplayedRowAtIndex | null; getTableWidth: () => number; sizeColumnsToFit: () => void; setRowData: (newData: SmartGridRowData[]) => boolean | void; forEachNode: (callback: (node: SmartGridRowNode, index: number) => void | Promise) => Promise; 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[]; getCellRanges: () => SmartGridCellRange[] | null; 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; getSortModel: () => SmartGridSortModel; 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?: SmartGridColumnAPI; dispatchEvent?: (eventType: string, eventData: Record) => 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, params?: SmartGridExportParams) => void; downloadSmartGridCSV: (fileName?: string, visibleOnly?: boolean, params?: SmartGridExportParams) => void; showLoadingOverlay: () => void; hideOverlay: () => void; isSelectAllRecords: boolean; checkConfiguration: SmartGridCheckConfiguration[]; prevAction: string; } declare type SmartGridApiExtra = { [key: string]: unknown; }; 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?: { [key: string]: unknown; } & { 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; maxCharLength?: number; }; 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; 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; }; }; }; 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; /** Cache context */ declare interface SmartGridCacheContext { tableContextRef?: MutableRefObject; infiniteCache?: InfiniteCache; updateData?: (rows: SmartGridRowData[], blockId: number, metadata?: Record | undefined) => void; } declare interface SmartGridCachedBlockData { [blockId: string]: SmartGridRowData[]; } /** Cache event */ declare interface SmartGridCacheEvent { type: string; blockId?: number; source?: string; options?: Record; 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; onContentDensityChange?: ((contentDensity: SmartGridRowHeightType) => void) | null; onSortChanged?: (params: SmartGridSortParams) => void; onFilterChanged?: (params: SmartGridSearchParams) => void; } /** * Represents a cell range selection (similar to AG Grid's CellRange). * Contains the start/end rows and the columns included in the range. */ declare interface SmartGridCellRange { startRow: { rowIndex: number; rowPinned: string | null; }; endRow: { rowIndex: number; rowPinned: string | null; }; columns: SmartGridColumnDefinition[]; startColumn: SmartGridColumnDefinition; } declare type SmartGridCellRenderer = { value: unknown; data: SmartGridRowData; rowIndex: number; colIndex: number; column: SmartGridColumnDefinition; colDef: SmartGridColumnDefinition; node: SmartGridCellRendererNode; api: SmartGridAPI; eGridCell: RefObject; wholeData: SmartGridRowData[] | null | undefined; actions: Record; 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; allLeafChildren: Record[]; 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; minValue?: number; maxValue?: number; disableArrowStepping?: boolean; 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; placeholder?: string; isOnDemandDropdownOptions?: boolean; isDropdownValueLableSame?: boolean; getDropdownOptions?: (params: SmartGridDropdownOptionsParams) => Promise; } & Record; declare interface SmartGridCellValueChangedParams { colDef: SmartGridColumnDefinition; column: SmartGridColumnDefinition; data: SmartGridRowData; newValue: unknown; node: { data: SmartGridRowData; id: string | number; level: number; parent?: SmartGridUpdateData; rowIndex: number; }; value: unknown; } declare type SmartGridCheckConfigraitonSearchField = { type: string; filterType: string; filter: string; 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 interface SmartGridColumnAPI { getColumn: (colKey: string) => SmartGridColumnDefinition | null; getColumns: () => SmartGridColumnDefinition[]; getAllColumns: () => SmartGridColumnDefinition[]; getAllGridColumns: () => SmartGridColumnDefinition[]; getColumnDefs: () => SmartGridColumnDefinition[]; getAllDisplayedColumns: () => SmartGridDisplayedColumn[]; getAllDisplayedVirtualColumns: () => SmartGridDisplayedColumn[]; getDisplayedLeftColumns: () => SmartGridDisplayedColumn[]; getDisplayedRightColumns: () => SmartGridDisplayedColumn[]; getDisplayedCenterColumns: () => SmartGridDisplayedColumn[]; getColumnState: () => SmartGridColumnState[]; applyColumnState: (state: SmartGridColumnState[]) => void; resetColumnState: () => void; getColDef: (colKey: string) => SmartGridColumnDefinition | null; getColId: (column: SmartGridColumnDefinition) => string; getActualWidth: (colKey: string) => number; isPinned: (colKey: string) => SmartGridPinnedType; getDisplayNameForColumn: (colKey: string) => string | null; setColumnVisible: (colKey: string, visible: boolean) => void; setColumnsVisible: (colKeys: string[], visible: boolean) => void; isPinning: () => boolean; isPinningLeft: () => boolean; isPinningRight: () => boolean; setColumnPinned: (colKey: string, pinned: SmartGridFrozenState) => void; setColumnsPinned: (colKeys: string[], pinned: SmartGridFrozenState) => void; sizeColumnsToFit: () => void; autoSizeColumn: (colKey: string) => void; autoSizeColumns: (colKeys: string[]) => void; autoSizeAllColumns: () => void; setColumnWidth: (colKey: string, newWidth: number) => void; setColumnWidths: (columnWidths: { key: string; newWidth: number; }[]) => void; moveColumn: (colKey: string, toIndex: number) => void; moveColumns: (colKeys: string[], toIndex: number) => void; moveColumnByIndex: (fromIndex: number, toIndex: number) => void; isFilterActive: (colKey: string) => boolean; getFilterModel: () => Record; getColumnGroup: (groupId: string) => SmartGridColumnDefinition | null; getProvidedColumnGroup: (groupId: string) => SmartGridColumnDefinition | null; setColumnGroupOpened: (groupId: string, open: boolean) => void; getColumnGroupState: () => SmartGridColumnGroupState[]; setColumnGroupState: (state: SmartGridColumnGroupState[]) => void; resetColumnGroupState: () => void; getDisplayNameForColumnGroup: (groupId: string) => string | null; getAllDisplayedColumnGroups: () => SmartGridColumnDefinition[]; getLeftDisplayedColumnGroups: () => SmartGridColumnDefinition[]; getCenterDisplayedColumnGroups: () => SmartGridColumnDefinition[]; getRightDisplayedColumnGroups: () => SmartGridColumnDefinition[]; getDisplayedColBefore: (column: SmartGridColumnDefinition) => SmartGridColumnDefinition | null; getDisplayedColAfter: (column: SmartGridColumnDefinition) => SmartGridColumnDefinition | null; columnModel: { primaryColumnsMap: Record; columnDefs: SmartGridColumnDefinition[]; }; } declare type SmartGridColumnDefinition = SmartGridColumnWithField | SmartGridColumnWithGroupId | SmartGridColumnWithColId; declare interface SmartGridColumnGroupState { groupId: string; open: boolean; } 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 */ declare interface SmartGridComment { id: string | number; text: string; author: string; timestamp: string; isEdited?: boolean; read?: boolean; isRead?: boolean; } /** * SmartGridCommentConfiguration - Configuration options for comment features */ 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 */ 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; } /** * SmartGridCommentPopup - State for comment popup */ 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 */ declare interface SmartGridCommentPopupPosition { top: number; left: number; side?: "left" | "right" | "clamped"; } /** * SmartGridCommentRowData - Row data associated with a comment */ declare interface SmartGridCommentRowData { [key: string]: unknown; } /** * SmartGridCommentThread - A collection of comments keyed by cell ID */ declare type SmartGridCommentThread = Record; declare type SmartGridCustomCallbackRefCurrent = { onCellClick?: ((params: any) => void) | null; }; /** Data source context */ declare interface SmartGridDataSourceContext { infiniteCache?: InfiniteCache; tableContextRef?: MutableRefObject; updateData?: (rows: SmartGridRowData[], blockId: number, metadata?: Record | 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"; declare type SmartGridDefaultColDef = { minWidth: number; maxWidth?: number; headerComponentParams?: { innerHeaderComponent: React.FC | null; }; headerComponent?: React.FC | null; enableCellChangeFlash?: boolean; maxCharLengthInSearch?: number; }; declare type SmartGridDispatch = (action: { type: string; payload: unknown; meta?: { fromAlignedGrid?: boolean; defaultColDef?: SmartGridDefaultColDef; } | Record; }) => void; declare type SmartGridDisplayedColumn = { colDef: SmartGridColumnDefinition; colId: string; getColId: () => string; isVisible: () => boolean; isPinned: () => SmartGridPinnedType; label: string; } & SmartGridColumnDefinition; declare interface SmartGridDisplayedRowAtIndex { data: SmartGridRowData; rowIndex: number; node: SmartGridParamsNode; api: SmartGridAPI; } declare interface SmartGridDisplayedRowNode extends SmartGridRowNode { rowIndex: number; absoluteRowIndex: number; originalData: SmartGridRowData; rowHeight?: number; } declare interface SmartGridDisptach { type: string; payload?: unknown; } declare interface SmartGridDropdownOptionsParams { value: string | number | (string | number)[] | null; data: SmartGridRowData; colDef: SmartGridColumnDefinition; } 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; }; declare interface SmartGridExportCallbackRefCurrent { downloadExcelHandler?: ((e: SmartGridExportEvent) => void) | null; downloadCSVHandler?: ((e: SmartGridExportEvent) => void) | null; copyToClipboardHandler?: (() => void) | null; processCellForClipboard?: ((params: SmartGridProcessCellForClipboardParams) => string) | null; } declare interface SmartGridExportEvent extends MouseEvent_2 { processCellCallback?: (params: SmartGridProcessCellForClipboardParams) => unknown; } declare interface SmartGridExportParams { processCellCallback?: (params: SmartGridProcessCellForClipboardParams) => unknown; } /** Extended filter model with search and column filters */ declare interface SmartGridExtendedFilterModel extends SmartGridFilterModel { _search?: SmartGridFilterModel[]; _columnFilters?: Record; } declare type SmartGridFetchDataFunctionBody = { range: SmartGridRangeFilter[]; search: SmartGridStringFilter[]; sort: SmartGridSortModel[]; }; declare interface SmartGridFetchDataResponse { rowData: SmartGridRowData[]; lastRow?: number; rowCount?: number; totalCount?: number; } /** Fetch function ref type */ declare interface SmartGridFetchFunctionRef { current?: SmartGridFetDataParams | null; } /** Fetch response */ declare interface SmartGridFetchResponse { data?: SmartGridRowData[]; rowCount?: number; totalItems?: number; total?: number; lastRow?: number; lastRowIndexKnown?: boolean; } declare type SmartGridFetDataParams = (body: SmartGridFetchDataFunctionBody, page: number, context?: SmartGridDataSourceContext, pageNum?: number, options?: { pageSize: number; }) => Promise; export declare type SmartGridFilterMode = "value" | "condition"; declare interface SmartGridFilterModel { pattern: string; search_type: string; column?: string; field?: string; min_val?: number; max_val?: number; type?: string; operator?: string; value?: string; operators?: SmartGridSearchOperatorOption[]; [key: string]: unknown; } /** * 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; } declare type SmartGridFrozenColumnsDetails = { indexes: string[]; positions: Record; totalWidth: number; rightPinned: { indexes: string[]; positions: Record; totalWidth: number; }; }; declare type SmartGridFrozenState = "left" | "right" | boolean | null | undefined; declare interface SmartGridGetRowDataParams { data: SmartGridRowData; rowIndex?: number; node: SmartGridParamsNode; api: SmartGridAPI; } /** Request params for getRows */ declare interface SmartGridGetRowsRequestParams { startRow: number; endRow: number; pageSize: number; sortModel?: SmartGridSortModel; filterModel?: SmartGridExtendedFilterModel; successCallback: (rows: SmartGridRowData[], lastRow?: number, lastRowIndexKnown?: boolean) => void; failCallback: (error?: unknown) => void; context?: SmartGridDataSourceContext; request?: { startRow: number; endRow: number; sortModel?: SmartGridSortModel; filterModel?: SmartGridFilterModel; pageSize: number; groupKeys: string[]; }; } declare type SmartGridHeaderRowHeight = { maxHeight: number; maxLineCount: number; }; declare type SmartGridHeaderStyleParams = { column: SmartGridColumnDefinition; displayName: string; enableSorting: boolean; sortState: SmartGridSortModel; onSort: (field: string, direction: string) => void; isSearchable?: boolean; showSortIcon: boolean; toggleSearchModal: (e: default_2.MouseEvent) => void; hasFilters: boolean; isExpandable?: boolean; onToggle?: (field: string, isExpandable: boolean) => void; api: SmartGridAPI; availableWidth: number; wrapHeaderText: boolean; menuButtonRef: default_2.RefObject; menuToggle: (e: default_2.MouseEvent) => void; toggleAdvancedSeach: default_2.Dispatch>; }; declare interface SmartGridInfiniteCache { analytics: SmartGridCacheAnalytics; blockCount: number; blocks: Record; 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; _originalDatasource: { getRows: (params: SmartGridDataSourceParams) => void; }; _pendingRAFs: number[]; _pendingRequests: Record; 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; pageSize: number; overflowSize: number; } declare interface SmartGridInfiniteCacheReturn { cacheReady: boolean; shouldUseCacheRef: MutableRefObject; getRows: (startRow: number, endRow: number) => SmartGridRowData[]; setVisibleRange: (startRow: number, endRow: number) => void; setSortModel: (sortModel: SmartGridSortModel) => void; setFilterModel: (filterModel: SmartGridFilterModel | Record, options?: Record) => void; refreshCache: (options?: SmartGridRefreshCacheOptions) => void; setServerSideDataSource: (datasource: SmartGridServerSideDataSource, resetCache?: boolean) => SmartGridWrappedDataSource | null; setPurgeStrategy: (strategy: string) => void; setPersistence: (enabled: boolean, options?: Record) => void; clearPersistedCache: () => void; getCacheState: () => SmartGridCacheStateReturn | null; modelRef: MutableRefObject; dataSourceRef?: MutableRefObject; 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; 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, options?: Record) => void; purgeCache?: () => void; refreshCache?: () => void; refreshCachePartial?: (preserveFields: string[]) => void; resetCache?: () => void; setPurgeStrategy?: (strategy: string) => void; setCachePersistence?: (enabled: boolean, options?: Record) => void; clearPersistedCache?: () => void; getCacheState?: () => SmartGridCacheStateReturn; getCacheAnalytics?: () => SmartGridCacheAnalyticsData | null; getMemoryUsageEstimate?: () => number; resetCacheAnalytics?: () => void; datasource?: SmartGridDataSourceContext; getRow?: (index: number) => { data: SmartGridRowData; } | null; } declare type SmartGridInputType = "text" | "password" | "email" | "number" | "tel" | "int" | "url"; declare interface SmartGridInternalGetRowsParams { startRow: number; endRow: number; filterModel?: SmartGridFilterModel | null; sortModel?: SmartGridSortModel | null; request?: Record; successCallback?: (rowData: SmartGridRowData[], lastRow?: number) => void; failCallback?: () => void; noDataUpdate?: boolean; } declare interface SmartGridIsRowSelectableParams { data: SmartGridRowData; id: string; rowIndex: number; } /** Last accessed sequence generator */ declare interface SmartGridLastAccessedSequence { value: number; next: () => number; } /** Last accessed sequence generator */ declare interface SmartGridLastAccessedSequence_2 { value: number; next: () => number; } declare type SmartGridModelType = "normal" | "serverSide" | "infinite"; declare interface SmartGridNewSortModel { column: string | null; order: SmartGridSortDirection | null; } declare interface SmartGridNotification { message: string; type?: "success" | "error" | "warning" | "info"; duration?: number; timeout?: number; } declare type SmartGridNumberFormat = "full" | "thousands" | "millions" | "billions"; declare interface SmartGridOldSortModel { colId: string; sort: SmartGridSortDirection; } declare type SmartGridOnSelectionChangedParams = { api: SmartGridAPI; type: string; source: string; }; declare interface SmartGridOptions { [key: string]: unknown; } /** Page size ref */ declare interface SmartGridPageSizeRef { current: number; } /** Page size ref */ declare interface SmartGridPageSizeRef_2 { current: number; } declare interface 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; } /** Pending request with abort capability */ declare interface SmartGridPendingRequest { abort?: () => void; } /** Persistence options for cache */ declare interface SmartGridPersistenceOptions { maxPersistedBlocks: number; persistBlockData: boolean; compressionEnabled: boolean; } declare type SmartGridPinnedType = "leftPinned" | "rightPinned" | null; export declare interface SmartGridPivotAggregationOption { value: string; label: string; } declare interface SmartGridPivotConfig { PivotComponent: React.FC; savedPivotState: SmartGridPivotState | undefined; pivotPanelColumnDef: SmartGridColumnDefinition[]; enablePivotTutorial?: boolean; savedPivots?: SmartGridPivotState[]; recentlyUsedPivots?: SmartGridPivotState[]; isHidePivotSave?: boolean; pivotChildren?: React.ReactNode; handlePivotSave?: (state: SmartGridPivotSavePayload, setIsPivotOpen: React.Dispatch>) => void; handlePivotApply?: (state: SmartGridPivotState, setIsPivotOpen: React.Dispatch>) => void; pivotAggregationFunc?: SmartGridSelectOption[]; showPivotTotalsSection?: boolean; isPivotRowGrandTotal?: boolean; isPivotColumnGrandTotal?: boolean; isPivotRowSubTotal?: boolean; isPivotColumnSubTotal?: boolean; isHideFilters?: boolean; isHideValues?: boolean; } export declare interface SmartGridPivotDropZoneItem { mode: string; filterValue: string; id: string; name: string; aggregation?: SmartGridAggregationType; condition?: string; } export declare interface SmartGridPivotDropZoneProps { type: "rows" | "columns" | "values"; items: SmartGridColumnDefinition[]; defaultExpanded?: boolean; onDrop: (column: SmartGridColumnDefinition) => void; onRemoveItem: (itemId: string) => void; isDragOver?: boolean; onClearAll?: () => void; } export declare interface SmartGridPivotField { id: string; name: string; type: "dimension" | "measure"; } export declare interface SmartGridPivotFieldItemProps { column: SmartGridColumnDefinition; isDragging?: boolean; } export declare interface SmartGridPivotFieldListProps { fields: SmartGridColumnDefinition[]; } export declare interface SmartGridPivotFilterConditionOption { value: string; label: string; } export declare interface SmartGridPivotFilterConditions { number?: SmartGridPivotFilterConditionOption[]; text?: SmartGridPivotFilterConditionOption[]; } export declare interface SmartGridPivotFilterItem { id: string; name: string; value: string; mode: SmartGridFilterMode; condition?: string; } export declare interface SmartGridPivotFiltersSectionProps { items: SmartGridColumnDefinition[]; defaultExpanded?: boolean; onDrop: (column: SmartGridColumnDefinition) => void; onRemoveItem: (id: string) => void; onFilterValueChange: (id: string, value: string) => void; onFilterModeChange?: (id: string, mode: SmartGridFilterMode) => void; onFilterConditionChange?: (id: string, condition: string) => void; onClearAll?: () => void; } export declare interface SmartGridPivotFooterProps { onCancel: () => void; onSave?: () => void; onApply?: () => void; isSaveDisabled?: boolean; isApplyDisabled?: boolean; isHideSave?: boolean; cancelText?: string; saveText?: string; applyText?: string; } export declare interface SmartGridPivotHeaderProps { title: string; onClose: () => void; } export declare type SmartGridPivotMode = "saved" | "create"; export declare interface SmartGridPivotNotificationProps { message: string; defaultVisible?: boolean; onClose?: () => void; } export declare interface SmartGridPivotPanelProps { isOpen: boolean; onClose: () => void; onSave: (state: SmartGridPivotSavePayload) => void; availableFields: SmartGridColumnDefinition[]; versions?: SmartGridPivotVersion[]; selectedVersion?: SmartGridPivotVersion; onVersionChange?: (version: SmartGridPivotVersion) => void; initialState?: Partial; showNotification?: boolean; onNotificationClose?: () => void; pivotAggrValues?: SmartGridPivotAggregationOption[]; pivotFilterConditions?: SmartGridPivotFilterConditions; pivotChildren?: React.ReactNode; savedPivots?: SmartGridPivotState[]; recentlyUsedPivots?: SmartGridPivotState[]; onDeleteSavedPivot?: (pivotId: string) => void; onEditSavedPivot?: (pivot: SmartGridPivotState) => void; defaultMode?: SmartGridPivotMode; handlePivotApply?: (state: SmartGridPivotState) => void; isHidePivotSave?: boolean; showTotalsSection?: boolean; pivotAggregationFunc?: SmartGridSelectOption[]; isPivotRowGrandTotal?: boolean; isPivotColumnGrandTotal?: boolean; isPivotRowSubTotal?: boolean; isPivotColumnSubTotal?: boolean; isHideFilters?: boolean; isHideValues?: boolean; } export declare interface SmartGridPivotSavePayload extends SmartGridPivotState { isReplace?: boolean; isUpdated?: boolean; oldName?: string; } export declare interface SmartGridPivotSectionProps { title: string; type: SmartGridPivotSectionType; isExpanded: boolean; onToggleExpand: () => void; children?: React.ReactNode; } export declare interface SmartGridPivotSectionState { items: SmartGridColumnDefinition[]; } export declare type SmartGridPivotSectionType = "rows" | "columns" | "values" | "filters" | "totals"; export declare interface SmartGridPivotState { id?: string; name: string; viewType?: SmartGridPivotViewType; isDefault?: boolean; rows: SmartGridPivotSectionState; columns: SmartGridPivotSectionState; values: SmartGridPivotSectionState; filters: SmartGridPivotSectionState; totals: SmartGridPivotTotalsState; } export declare interface SmartGridPivotTotalsState { showRowGrandTotal: boolean; showColumnGrandTotal: boolean; showRowSubTotal: boolean; showColumnSubTotal: boolean; } export declare interface SmartGridPivotValueItem { id: string; name: string; aggregation: SmartGridAggregationType; } export declare interface SmartGridPivotValuesSectionProps { items: SmartGridColumnDefinition[]; defaultExpanded?: boolean; onDrop: (column: SmartGridColumnDefinition) => void; onRemoveItem: (id: string) => void; onAggregationChange: (id: string, aggregation: SmartGridAggregationType) => void; onClearAll?: () => void; pivotAggregationFunc?: SmartGridSelectOption[]; } export declare interface SmartGridPivotVersion { value: string; label: string; } export declare interface SmartGridPivotVersionSelectProps { label: string; versions: SmartGridPivotVersion[]; selectedVersion: SmartGridPivotVersion | null; onVersionChange: (version: SmartGridPivotVersion) => void; } export declare type SmartGridPivotViewType = "global" | "personal"; export declare interface SmartGridPivotWrapperProps { pivotConfig: SmartGridPivotConfig; shouldRenderTable: boolean; showSaveTableConfig: boolean; } declare type SmartGridProcessCellForClipboardParams = { value: unknown; data: SmartGridRowData; column: SmartGridColumnDefinition; columnApi: SmartGridColumnAPI; api: SmartGridAPI; node: { data: SmartGridRowData; }; colDef: SmartGridColumnDefinition; context: unknown; type: "excel" | "csv" | "copy"; accumulatedRowIndex: number; }; 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; } /** Response metadata */ declare interface SmartGridResponseMetadata { totalCount?: number; lastRowIndexKnown?: boolean; } declare interface SmartGridRowData { [key: string]: unknown; id?: string | number; isChildRow?: boolean; isChildGroup?: boolean; childIndex?: number; groupingLevel?: number; level?: number; parentRowIndex?: number; parentRowData?: SmartGridRowData; __parentPath?: string; _rowHeight?: number; _isPinnedTop?: boolean; _isPinnedBottom?: boolean; __isAggregationRow?: boolean; subTotalAggreRow?: boolean; grandTotalAggreRow?: boolean; isGrandTotalRow?: boolean; __parentId?: string | number | null; __rowSpanInfo?: SmartGridRowSpanInfo; __flattenedRowId?: string; __rowIndex?: number; __split?: { key?: string; }; } /** * 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; loadedData: Record; loading: Record; pagination: Record; cache: { metadata: Record; 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 SmartGridRowHeightType = "default" | "compact" | "comfortable"; declare type SmartGridRowInfo = { isFirst: boolean; isLast: 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 SmartGridRowSelectionRefCurrent { isRowSelectable?: (params: SmartGridIsRowSelectableParams) => boolean; hideDisabledCheckboxes?: boolean; } declare interface SmartGridRowSpanInfo { [key: string]: SmartGridRowInfo | boolean | undefined; isRowSpan?: boolean; Selection?: SmartGridRowInfo; } declare type SmartGridRowStyleParams = { api: SmartGridAPI; data: SmartGridRowData; pinned: boolean; node: { rowIndex: number; data: SmartGridRowData; api: SmartGridAPI; pinned: boolean; }; }; declare type SmartGridSavedViewsOptions = { isActive: boolean; isDefaultView: boolean; viewName: string; viewType: "personal" | "global"; }; declare interface SmartGridSaveViewCallbackRefCurrent { handleSetDefaultView?: ((view: SmartGridSavedViewsOptions) => void) | null; handleSavedViewClick?: ((view: SmartGridSavedViewsOptions) => void) | null; handleEditSaveView?: ((updatedData: SmartGridSavedViewsOptions, view: SmartGridSavedViewsOptions) => void) | null; handleSaveAndApply?: ((view: SmartGridSavedViewsOptions) => void) | null; handleDeleteViewClick?: ((view: SmartGridSavedViewsOptions) => void) | null; } declare type SmartGridSearchFunctionParams = SmartGridFilterModel[] | Record; declare type SmartGridSearchFunctionParamsWithField = Record; declare interface SmartGridSearchOperatorOption { value: string; label: string; type?: string; } declare interface SmartGridSearchParams { type: "searchChanged"; api: SmartGridAPI; searchModel: SmartGridSearchFunctionParams; } declare interface SmartGridSearchWithSearchKey { _search: SmartGridSearchFunctionParamsWithField; } declare interface SmartGridSelectedCell { colIndex: number; column: SmartGridColumnDefinition; data: SmartGridRowData; field: string; rowId: string | number; rowIndex: number; value: unknown; } declare interface SmartGridSelectOption { value: string | number; label: string; isDisabled?: boolean; } declare interface SmartGridServerSideDataSource { getRows: (params: SmartGridServerSideGetRowsParams) => { abort?: () => void; } | void; } /** Server-side datasource interface */ declare interface SmartGridServerSideDatasource { infiniteCache: InfiniteCache | undefined; _originalParams: SmartGridServerSideDataSourceParams; _loadingBlocks: Record; _pendingRequests: Record; _lastRequestParams: SmartGridGetRowsRequestParams | null; _isDestroyed: boolean; updateCacheReference: (newCache: InfiniteCache) => boolean; updateConfig: (newConfig: Partial) => 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 SmartGridSortParams { type: "sortChanged"; api: SmartGridAPI; sortModel: SmartGridSortModel[]; column: SmartGridColumnDefinition; } declare interface SmartGridStateContext { data?: SmartGridRowData[] | null; filteredData: SmartGridRowData[] | null; originalData: SmartGridRowData[] | null; previewMode: boolean; isLoading: boolean; columns: SmartGridColumnDefinition[]; columnMap: Record; 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; columnFilters: Record; expandedChildRows: Record; expandedColumnGroups: SmartGridExpandedColumnGroups; uniqueIdField: string; childKeyField: string; frozenColumns: SmartGridFrozenColumnsDetails; notification: SmartGridNotification & { show: boolean; }; columnsToAutosize: string[] | Record; prevAction: string; checkConfiguration: SmartGridCheckConfiguration[]; isSelectAllRecords: boolean; unCheckedRows: Record; 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; defaultColDef: SmartGridDefaultColDef | null; api: SmartGridAPI | null; columnApi: SmartGridColumnAPI | 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; headerRowHeightwithIndex: Record; 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 | null; hasAggregation: boolean; callBackRef: MutableRefObject; exportCallbackRef: MutableRefObject; saveViewOptionsRef: MutableRefObject<{ maxSavedViews?: null | number; deleteViewPromptText?: null | string; }>; saveViewCallbackRef: MutableRefObject; clickCallbackRef: MutableRefObject; customCallback: SmartGridCustomCallbackRefCurrent; contextRef: MutableRefObject | null; rowSelectionRef: MutableRefObject | 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; pivotPanelColumnDef: null | SmartGridColumnDefinition[]; removeCheckConfigurationOnOperation: boolean; totalColumnsCount: number; isCommentFeatureEnabled: boolean; isChatEnabled: boolean; noHeaderSelection: boolean; treeData: boolean; virtualizationConfig: SmartGridVirConfig; disableCurrentPageRecords: boolean; showForceLoading: boolean; [key: string]: unknown; } declare type SmartGridStringFilter = { column: string; pattern: string; search_type: string; operator?: string; }; declare interface SmartGridTableContextValue { state: SmartGridStateContext; tableApi: SmartGridAPI | null; dispatch: SmartGridDispatch; ACTION_TYPES: typeof ACTION_TYPES; toggleGroupExpansion: (rowId: string | number, rowIndex: number) => void; dispatchEvent: (eventType: string, eventData: Record) => void; getRowStyle?: (params: SmartGridRowStyleParams) => CSSProperties; } declare interface SmartGridTableInstance { current: HTMLElement | null; } declare interface SmartGridTableModel { getData: () => SmartGridRowData[]; api: SmartGridAPI; columnApi: SmartGridColumnAPI; appliedFontSize: "medium" | "small" | "large"; appliedNumberFormat: SmartGridNumberFormat; modelRef?: { current?: SmartGridInfiniteRowModel; }; infiniteCache: SmartGridInfiniteCacheReturn | null; getColumnDefs: () => SmartGridColumnDefinition[]; getSortModel: () => SmartGridSortModel[]; getFilterModel: () => SmartGridFilterModel; getType: () => SmartGridModelType; getRowsToDisplay: () => number; forEachNode: (callback: (node: SmartGridRowNode, index: number) => void | Promise) => Promise; getRowNode: (id: string | number) => SmartGridRowNode | null; getSelectedRows: () => SmartGridRowData[]; getPaginationModel: () => SmartGridPaginationModel; getColumnState: () => SmartGridColumnState[]; rowsToDisplay: SmartGridRowData[]; } declare type SmartGridTooltipGetterParams = { api: SmartGridAPI; colDef: SmartGridColumnDefinition; column: SmartGridColumnDefinition; data: SmartGridRowData; location: string; node: { data: SmartGridRowData; id: string; level: number; parent: SmartGridUpdateData; rowIndex: number; }; rowIndex: number; value: unknown; }; declare type SmartGridUpdateData = { data: SmartGridRowData; setData: (data: SmartGridRowData) => void; setDataValue: (field: string, value: unknown, callbackNeeded?: boolean) => void; }; declare type SmartGridUpdateDataReturnType = { success: boolean; totalRows: number; blocksUpdated: number; errors: string[]; }; /** Page size ref for server-side */ declare interface SmartGridUpdatedPageSizeRef { current: number; } declare type SmartGridValueFormatterConfig = { type?: string; symbol?: string; position?: "prefix" | "suffix"; decimals?: number; }; declare interface SmartGridValueFormatterParams { value: unknown; data: SmartGridRowData; colDef: SmartGridColumnDefinition; } declare interface SmartGridValueGetterParams { data: SmartGridRowData; node: { data: SmartGridRowData; }; colDef: SmartGridColumnDefinition; column: SmartGridColumnDefinition; api: SmartGridAPI | null; columnApi?: SmartGridColumnAPI; getValue: (field: string) => unknown; } /** Viewport range */ declare interface SmartGridViewportRange { startRow: number; endRow: number; } declare type SmartGridVirConfig = { threshold: number; }; declare interface SmartGridWrappedDataSource { _originalDatasource: SmartGridServerSideDataSource; _loadingBlocks: Record; _pendingRequests: Record void; }>; _isDestroyed: boolean; _pendingRAFs?: number[]; infiniteCache: unknown; updateCacheReference: (newCache: unknown) => void; destroy: () => void; getRows: (params: SmartGridInternalGetRowsParams) => void; } export { }