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 { FC } from 'react'; import { FocusEvent as FocusEvent_2 } from 'react'; import { ForwardRefExoticComponent } from 'react'; import { Moment } from 'moment'; import { MouseEvent as MouseEvent_2 } from 'react'; import { MutableRefObject } from 'react'; import { ReactNode } from 'react'; import { Ref } from 'react'; import { RefAttributes } from 'react'; import { RefObject } from 'react'; import { SetStateAction } from 'react'; declare const ACTION_TYPES: { readonly SET_DATA: "SET_DATA"; readonly SET_FILTERED_DATA: "SET_FILTERED_DATA"; readonly SET_COLUMNS: "SET_COLUMNS"; readonly SET_SORT: "SET_SORT"; readonly SET_PAGE: "SET_PAGE"; readonly SET_PAGE_SIZE: "SET_PAGE_SIZE"; readonly SET_SELECTED_ROWS: "SET_SELECTED_ROWS"; readonly SET_COLUMN_FILTER: "SET_COLUMN_FILTER"; readonly REMOVE_COLUMN_FILTER: "REMOVE_COLUMN_FILTER"; readonly APPLY_FILTERS: "APPLY_FILTERS"; readonly TOGGLE_GROUP_EXPANSION: "TOGGLE_GROUP_EXPANSION"; readonly SET_FIELD_KEYS: "SET_FIELD_KEYS"; readonly UPDATE_ROW_DATA: "UPDATE_ROW_DATA"; readonly SELECTION_CHANGED_HANDLED: "SELECTION_CHANGED_HANDLED"; readonly FREEZE_COLUMN: "FREEZE_COLUMN"; readonly UNFREEZE_COLUMN: "UNFREEZE_COLUMN"; readonly PIN_COLUMN_RIGHT: "PIN_COLUMN_RIGHT"; readonly UNPIN_COLUMN_RIGHT: "UNPIN_COLUMN_RIGHT"; readonly SET_COLUMN_WIDTH: "SET_COLUMN_WIDTH"; readonly SET_COLUMNS_WIDTH: "SET_COLUMNS_WIDTH"; readonly SHOW_NOTIFICATION: "SHOW_NOTIFICATION"; readonly HIDE_NOTIFICATION: "HIDE_NOTIFICATION"; readonly AUTOSIZE_COLUMNS_REQUESTED: "AUTOSIZE_COLUMNS_REQUESTED"; readonly TOGGLE_FREEZE_COLUMN: "TOGGLE_FREEZE_COLUMN"; readonly REORDER_COLUMNS: "REORDER_COLUMNS"; readonly SET_PREV_ACTION: "SET_PREV_ACTION"; readonly SET_CHECK_CONFIGURATION: "SET_CHECK_CONFIGURATION"; readonly SET_IS_SELECT_ALL_RECORDS: "SET_IS_SELECT_ALL_RECORDS"; readonly BATCH_UPDATE: "BATCH_UPDATE"; readonly UPDATE_ROW_DATA_OBJECT: "UPDATE_ROW_DATA_OBJECT"; readonly TOGGLE_COLUMN_VISIBILITY: "TOGGLE_COLUMN_VISIBILITY"; readonly TOGGLE_MASTER_DETAIL: "TOGGLE_MASTER_DETAIL"; readonly SET_DETAIL_RENDERER: "SET_DETAIL_RENDERER"; readonly SET_MASTER_DETAIL_CONFIG: "SET_MASTER_DETAIL_CONFIG"; readonly ADD_EVENT_LISTENER: "ADD_EVENT_LISTENER"; readonly REMOVE_EVENT_LISTENER: "REMOVE_EVENT_LISTENER"; readonly TOGGLE_COLUMN_GROUP: "TOGGLE_COLUMN_GROUP"; readonly SET_EXPANDED_COLUMN_GROUPS: "SET_EXPANDED_COLUMN_GROUPS"; readonly ENABLE_ROW_SPAN: "ENABLE_ROW_SPAN"; readonly SET_ROW_SPAN_COLUMN: "SET_ROW_SPAN_COLUMN"; readonly MOVE_ROW: "MOVE_ROW"; readonly PREVIEW_ROW_MOVE: "PREVIEW_ROW_MOVE"; readonly RESET_ROW_PREVIEW: "RESET_ROW_PREVIEW"; readonly SET_PINNED_TOP_ROWS: "SET_PINNED_TOP_ROWS"; readonly SET_PINNED_BOTTOM_ROWS: "SET_PINNED_BOTTOM_ROWS"; readonly TOGGLE_ROW_GROUP: "TOGGLE_ROW_GROUP"; readonly LOAD_ROW_GROUP_DATA: "LOAD_ROW_GROUP_DATA"; readonly SET_ROW_GROUP_DATA: "SET_ROW_GROUP_DATA"; readonly SET_ROW_GROUP_LOADING: "SET_ROW_GROUP_LOADING"; readonly SET_ROW_GROUP_PAGINATION: "SET_ROW_GROUP_PAGINATION"; readonly CLEAR_ROW_GROUP_CACHE: "CLEAR_ROW_GROUP_CACHE"; readonly REFRESH_ROW_GROUP_DATA: "REFRESH_ROW_GROUP_DATA"; readonly SET_API: "SET_API"; readonly SET_COLUMN_MAP: "SET_COLUMN_MAP"; readonly SET_NUMBER_FORMAT: "SET_NUMBER_FORMAT"; readonly SET_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 interface ChildHeightsResult { childrenTotalHeight: number; childCount: number; } export declare interface DateValidationConstraints { startDate: Date | string; endDate: Date | string; startYear: number; endYear: number; disableOnlyPast?: boolean; disableOnlyFuture?: boolean; disablePast?: boolean; disableFuture?: boolean; minDate?: Date | string; maxDate?: Date | string; } declare const Index: ForwardRefExoticComponent & RefAttributes>; export default Index; declare class InfiniteBlock { static STATE_WAITING_TO_LOAD: string; static STATE_LOADING: string; static STATE_LOADED: string; static STATE_FAILED: string; static MAX_EMPTY_BLOCKS_TO_KEEP: number; id: number; parentCache: SmartGridInfiniteCacheInterface; parent: SmartGridInfiniteCacheInterface; params: SmartGridBlockParams; state: string; version: number; lastAccessed: number; rows: Record; 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_2; /** * Returns analytics data */ getAnalytics(): SmartGridCacheAnalytics_2 & { uptime: number; hitRatio: number; avgLoadTime: number; hitsPerSecond: number; missesPerSecond: number; blocksPurgedPerSecond: number; bytesPerSecond: number; }; /** * Resets analytics data */ resetAnalytics(): void; /** * Save cache state to persistence if enabled */ persistCacheIfEnabled(): void; /** * Restore cache from persistence */ restoreFromPersistence(): void; /** * Clear persisted cache state */ clearPersistence(): void; /** * Sets the purge strategy */ setPurgeStrategy(strategy: string): void; isBlockInCreationQueue(blockId: number): boolean; /** * Logs a summary of the current cache state * Can be called from outside to check the cache status at any time */ logCacheSummary(): { totalRows: number; rowsWithData: number; blockCount: number; blocksWithData: Array<{ blockId: number; rowCount: number; }>; }; isBlockCached(blockId: number): boolean; getBlockData(blockId: number): (SmartGridRowData | null)[] | null; getAllCachedData(): SmartGridRowData[]; updatePageData(pageNo: number, updatedData: SmartGridRowData[], notifyChanges?: boolean, options?: Record): { 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; } /** * A specialized cache for efficiently managing row heights in virtualized tables * Optimized for large datasets (9K+ rows) to improve virtualization performance */ declare class RowHeightCache { private heightMap; private hierarchicalLookup; private prefixLookup; private accumulatedHeights; private totalHeight; private isDirty; private previousRowHeight; private count; private previousCount; constructor(); setAllHeight(rowHeightMap: RowHeightMap): void; setPreviousCount(newCount: number): void; setHeight(rowId: string | number, height: number, rowIndex?: number | string): void; getHeight(rowId: string | number, defaultHeight: number, rowIndex?: number | string): number; getChildHeights(defaultHeight: number, rowIndex?: number): ChildHeightsResult; buildAccumulatedHeights(data: SmartGridRowData[], defaultHeight: number, uniqueIdField: string | undefined, rowHeight: number): void; findRowAtScrollPosition(scrollTop: number): number; getTotalHeight(): number; toObject(): RowHeightMap; static fromObject(heightMap: RowHeightMap): RowHeightCache; } declare type RowHeightMap = Record; export declare interface RowSpanParams { node: { rowIndex: number; data: SmartGridRowData; api: SmartGridAPI; }; api: SmartGridAPI; rowIndex?: number; data: SmartGridRowData; wholeData: SmartGridRowData[]; } export declare type SmartGridActionTypes = typeof ACTION_TYPES; export declare interface SmartGridAddChatContainerProps { setShowAddChat: Dispatch>; handleChatName: NonNullable; selectedChannelInfo?: SmartGridChannel | null; handleToast: SmartGridHandleToastFn; setIsCreateNewChatOpen: Dispatch>; } export declare type SmartGridAggregationType = "sum" | "count" | "avg" | "min" | "max"; export 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 | 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; } export 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; } export declare type SmartGridBadgeColor = "default" | "success" | "warning" | "error" | "info"; export declare interface SmartGridBadgeProps { label: string; variant?: SmartGridBadgeVariant; color?: SmartGridBadgeColor; size?: SmartGridBadgeSize; className?: string; onClick?: (e: MouseEvent_2) => void; } export declare type SmartGridBadgeSize = "default" | "small"; export declare type SmartGridBadgeVariant = "filled" | "stroke"; export declare interface SmartGridBaseColumnDefinition { field?: string; groupId?: string; headerName?: string; column_name?: string; label?: string; width?: number; minWidth?: number; maxWidth?: number; hide?: boolean; hidden?: boolean; pinned?: SmartGridFrozenState; is_frozen?: boolean; children?: SmartGridColumnDefinition[]; parent_id?: (string | number)[]; type?: string; cellDataType?: string; valueFormatter?: ((params: SmartGridValueFormatterParams) => string) | SmartGridValueFormatterConfig | undefined; valueGetter?: (params: SmartGridValueGetterParams) => unknown; leftTotalWidth?: number; originalWidth?: number; defaultWidth?: number; isAutoWidth?: boolean; filterable?: boolean; isSortable?: boolean; is_sortable?: boolean; resizable?: boolean; align?: "left" | "center" | "right"; cellRenderer?: string | ((params: SmartGridCellRenderer) => JSX.Element); cellRendererParams?: SmartGridCellRendererParams; cellClassName?: string; cellStyle?: { textAlign?: "left" | "center" | "right"; [key: string]: unknown; }; autoHeight?: boolean; wrapHeaderText?: boolean; editable?: boolean; is_editable?: boolean; is_disabled?: boolean; is_searchable?: boolean; isSearchable?: boolean; advanceSearchEnabled?: boolean; sortable?: boolean; rowGroup?: boolean; enableRowGroup?: boolean; rowGroupIndex?: number; aggFunc?: string; columnGroupShow?: "open" | "closed" | undefined | null; originalIndex?: number; parentColumns?: string[]; hasChildren?: boolean; hasAnyFrozenChildren?: boolean; hasAnyRightPinnedChildren?: boolean; isChildWithoutParent?: boolean; colorClass?: string; isLeaf?: boolean; isStandalone?: boolean; isWithEmptyHeaderName?: boolean; isParentWithChildEmptyHeaderName?: boolean; path?: string[]; 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; } export declare interface SmartGridBodyCellDetailProps { cellRef: RefObject; cellClasses: string; cellStyle: CSSProperties; handleCellClickForSelection: (e: React.MouseEvent) => void; handleDoubleClick: (e: React.MouseEvent) => void; rowIndex: number; rowId: string | number; colIndex: number; field: string; isPinnedLeft: boolean; isPinnedRight: boolean; cellType: string; isChildRow?: boolean; isGrandTotalRow?: boolean; isFirstColumn: boolean; isFirstFrozenColumn: boolean; isGroupRowExpanded: boolean; isGroupingKey: boolean; level: number; showDragHandle: boolean; showToggle: boolean; isExpanded: boolean; isDetailExpanded?: boolean; hideToolTip: boolean; contentStyle: CSSProperties; shouldHideContent: boolean; formattedCellValue: unknown; actualValue: string | boolean | null | undefined | number | {}; toolTipTitle: string; shouldRenderRowGroupContent: boolean; groupId: string | null; serverSide: boolean; loadingRef?: RefObject | null; stateRowHeight: { height: number; type: string; }; virtualized?: boolean; allColumnsLastRow?: SmartGridColumnDefinition[]; isSingleSelect?: boolean; leftPinnedOnly?: boolean; disableSelectAllRecords?: boolean; rowData: SmartGridRowData; column: SmartGridColumnDefinition; showMasterDetailToggle: boolean; isRowGroupEnabled: boolean; updatedCellId: string | number; cellValue: unknown; tableApi: SmartGridAPI | null; hasChildren: boolean; isAggregationParentRowWithAggregatedData: boolean; lazyLoadCellRenderer?: boolean; childKeyField: string; isCommentFeatureEnabled: boolean; } export declare interface SmartGridBodyCellProps { customRowStyle?: CSSProperties; loadingRef?: RefObject | null; virtualized?: boolean; leftPinnedOnly?: boolean; rowData: SmartGridRowData; column: SmartGridColumnDefinition; rowIndex: number; colIndex: number; onDoubleClick?: (e: React.MouseEvent, params: { rowData: SmartGridRowData; column: SmartGridColumnDefinition; rowIndex: number; colIndex: number; }) => void; hideContent?: boolean; className?: string; isChildRow?: boolean; allColumnsLastRow?: SmartGridColumnDefinition[]; rowSpanInfo?: SmartGridRowSpanInfoDetails; selectable?: boolean; isFirstGrandTotalColumn?: boolean; isGrandTotalRow?: boolean; isLeftPinnedRowsAvailable?: boolean; style?: CSSProperties | null; index: number; rowId: string | number; } export declare interface SmartGridButtonProps { onClick?: (e: MouseEvent_2) => void; children?: ReactNode; variant?: SmartGridButtonVariant; size?: SmartGridButtonSize; iconButton?: boolean; className?: string; disabled?: boolean; leftIcon?: ReactNode; rightIcon?: ReactNode; buttonRef?: MutableRefObject | RefObject; simpleButton?: boolean; ariaLabel?: string; loading?: boolean; title?: string; } export declare type SmartGridButtonSize = "small" | "medium" | "large"; export declare type SmartGridButtonVariant = "primary" | "secondary" | "tertiary" | "link" | "url" | "text" | "danger"; export declare type SmartGridCacheAnalytics = { blockEvictions: number; blockLoadTimestamps: number[]; blockLoads: number; bytesLoaded: number; cachePurges: number; cacheRefreshes: number; hits: number; lastBlockLoadTime: number; misses: number; startTime: number; totalBlockLoadTime: number; }; /** Cache analytics */ declare interface SmartGridCacheAnalytics_2 { hits: number; misses: number; blockLoads: number; blockEvictions: number; totalBlockLoadTime: number; lastBlockLoadTime: number; bytesLoaded: number; startTime: number; blockLoadTimestamps: Array<{ blockId: number; timestamp: number; loadTime: number; }>; cachePurges: number; cacheRefreshes: number; } export declare interface SmartGridCacheAnalyticsData { hitRatio: number; hits: number; misses: number; blockLoads: number; blockEvictions: number; } export declare type SmartGridCacheBlock = { endRow: number; id: number; infiniteCache: SmartGridInfiniteCache; lastAccessed: number; loadStartedAt: number; params: SmartGridCacheBlockParams; parent: SmartGridInfiniteCache | null; parentCache: SmartGridInfiniteCache | null; rowNodes: { data: SmartGridRowData; id: number; rowIndex: number; }[]; rows: unknown; startRow: number; state: string; version: number; _inactiveForPageTransition: boolean; _processingInProgress: boolean; _targetPage: number; }; export declare type SmartGridCacheBlockParams = Record; /** Cache context */ declare interface SmartGridCacheContext { tableContextRef?: MutableRefObject; infiniteCache?: InfiniteCache; updateData?: (rows: SmartGridRowData[], blockId: number, metadata?: Record | undefined) => void; } export declare interface SmartGridCachedBlockData { [blockId: string]: SmartGridRowData[]; } /** Cache event */ declare interface SmartGridCacheEvent { type: string; blockId?: number; source?: string; options?: Record; pageNo?: number; } export declare type SmartGridCacheMetadata = { lastUpdated: number; timestamp?: number; }; /** Cache params */ declare interface SmartGridCacheParams { overflowSize: number; maxBlocksInCache: number; initialRowCount: number; rowHeight: number; lastAccessedSequence: SmartGridLastAccessedSequence; uniqueIdField: string; onBlockStateChanged: SmartGridBlockStateChangedCallback | null; purgeStrategy: string; enablePersistence: boolean; persistenceStorageKey: string; persistenceOptions: SmartGridPersistenceOptions; isPaginationMode: boolean; datasource?: SmartGridClientSideDatasource | SmartGridServerSideDatasource; filterModel?: SmartGridSearchWithSearchKey; sortModel?: SmartGridSortModel; context?: SmartGridCacheContext; updatedPageSizeRef?: SmartGridPageSizeRef; viewportRange?: SmartGridViewportRange; tableId?: string; pageSize?: number; loadSequentially?: boolean; } export declare interface SmartGridCacheState { blockCount: number; cache?: SmartGridInfiniteCache; lastRowKnown: boolean; rowCount: number; status: string; } /** Cache state for debugging */ declare interface SmartGridCacheState_2 { blockCount: number; rowCount: number; lastRowIndexKnown: boolean; blocks: SmartGridBlockStateJsonExtended[]; analytics: SmartGridCacheAnalytics_2; } export declare interface SmartGridCacheStateReturn { cache: unknown; rowCount: number; lastRowKnown: boolean; blockCount: number; status: string; } export declare interface SmartGridCalendarDay { day: number; isCurrentMonth: boolean; } export declare interface SmartGridCalendarPosition { top: number; left: number; } export declare interface SmartGridCallbackRefCurrent { onSelectionChanged?: ((event: SmartGridOnSelectionChangedParams) => void) | undefined; onRowDragStart?: ((event: SmartGridRowDragStartParams) => void) | null; onRowDragEnd?: ((event: SmartGridRowDragEndParams) => void) | null; onRowClicked?: ((event: unknown) => void) | null; onCellValueChanged?: ((event: SmartGridCellValueChangedParams) => void) | null; onRowGroupOpened?: ((event: SmartGridRowGrouOpenParams) => void) | null; customTabFunction?: ((e: KeyboardEvent, column: SmartGridColumnDefinition, context: { api: SmartGridAPI | null; }) => void) | null; onPageChange?: ((page: number) => void) | null; onSortChange?: ((sortModel: SmartGridSortModel) => void) | null; onFilterChange?: ((filterModel: SmartGridFilterModel) => void) | null; onSearch?: ((searchTerm: SmartGridSearchFunctionParams) => void) | null; onContentDensityChange?: ((contentDensity: SmartGridRowHeightType) => void) | null; onSortChanged?: (params: SmartGridSortParams) => void; onFilterChanged?: (params: SmartGridSearchParams) => void; } export declare interface SmartGridCellPosition { rowIndex: number; colIndex: number; } /** * Represents a cell range selection (similar to AG Grid's CellRange). * Contains the start/end rows and the columns included in the range. */ export declare interface SmartGridCellRange { startRow: { rowIndex: number; rowPinned: string | null; }; endRow: { rowIndex: number; rowPinned: string | null; }; columns: SmartGridColumnDefinition[]; startColumn: SmartGridColumnDefinition; } export 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; }; export declare interface SmartGridCellRendererDesignIconProps { cellRenderer: string; } export declare interface SmartGridCellRendererMappingType { [key: string]: string; } export declare type SmartGridCellRendererNode = { data: SmartGridRowData; rowIndex: number; id: string | number; parent: SmartGridUpdateData & { id: string | number; level: number; setExpanded: () => void; }; setDataValue: (colId: string, newValue: unknown) => void; childrenMapped: Record; allLeafChildren: Record[]; group: boolean; level: number; childIndex: number; isSelected: () => boolean; isExpandable: () => boolean; isExpanded: () => boolean; }; export declare type SmartGridCellRendererParams = { dateFormat?: SmartGridDateFormat; startYear?: number; endYear?: number; minDate?: string; maxDate?: string; 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; export declare interface SmartGridCellRendererRendererProps { isGrandTotalRow?: boolean; rowData: SmartGridRowData; isAggregationParentRowWithAggregatedData: boolean; cellValue: unknown; rowIndex: number; colIndex: number; column: SmartGridColumnDefinition; tableApi: SmartGridAPI | null; cellRef: RefObject; hasChildren: boolean; lazyLoadCellRenderer?: boolean; } export declare interface SmartGridCellSelectionParams { tableInstance: SmartGridTableInstance; callBackRef: MutableRefObject; api: SmartGridAPI | null; } export declare interface SmartGridCellValueChangedParams { colDef: SmartGridColumnDefinition; column: SmartGridColumnDefinition; data: SmartGridRowData; newValue: unknown; node: { data: SmartGridRowData; id: string | number; level: number; parent?: SmartGridUpdateData; rowIndex: number; }; value: unknown; } export declare interface 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; 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; 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) => void; priority?: SmartGridMessagePriority; edited?: boolean; onThreadClick?: () => void; pinned?: boolean; visibility?: boolean; onPin?: (isPinned: boolean) => Promise; 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) => void; priority?: SmartGridMessagePriority; edited?: boolean; onThreadClick?: () => void; pinned?: boolean; onPin?: (isPinned: boolean) => Promise; 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; loadMenuOptions?: () => Promise; menuOptions?: SmartGridParticipant[]; onClose?: () => void; onParticipantAdd?: (participantIds: (string | number)[], selectedRadioOption: string, chatId: string | number) => Promise<{ success: boolean; participant: SmartGridParticipant; } | null>; onNotificationSettingChange?: (data: SmartGridNotificationSettings) => Promise; onSearchMessage?: (e: React.ChangeEvent) => void; participantsList?: SmartGridParticipant[]; loadParticipantsAvatar?: (radioOption: string, chatId: string | number) => Promise; handleRadioButtonChange?: (value: string) => Promise; } export declare interface SmartGridChatHeaderActionProps { enableSearch?: boolean; messageSearchValue?: string; handleOpenMessageSearch?: () => void; handleCloseMessageSearch?: () => void; handleMessageSearchChange?: (e: React.ChangeEvent) => void; onParticipantsClick?: (e: React.MouseEvent) => Promise; 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) => React.ReactNode; threeDotMenuOpen?: boolean; onSaveNotification?: (data: SmartGridNotificationSettings) => void; selectedMenuItems?: (string | number)[]; setSelectedMenuItems?: React.Dispatch>; 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>; } 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 & { onSearchMessage?: (searchValue: string, chatId: string | number) => Promise; onSearchClear?: () => void; externalSavingMembers?: boolean; }; } export declare interface SmartGridChatInputProps { placeholder: string; value: string; onChange: (value: string) => void; onSend: (payload: SmartGridChatInputSendPayload) => Promise; 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; 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; pinned?: boolean; onMore?: () => void; onEdit?: () => void; onMessageDelete?: (messageId: string | number) => Promise; onRefetchMessages?: () => Promise; 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; } export declare interface SmartGridCheckboxProps { checked?: boolean; onChange: (e: ChangeEvent) => void; label?: string | ReactNode; disabled?: boolean; className?: string; defaultChecked?: boolean; variant?: SmartGridCheckboxVariant; indeterminate?: boolean; } export declare type SmartGridCheckboxVariant = "default" | "primary" | "secondary"; export declare type SmartGridCheckConfigraitonSearchField = { type: string; filterType: string; filter: string; filterMax?: string; }; export declare interface SmartGridCheckConfiguration { checkedRows?: string[]; unCheckedRows?: string[]; checkAll?: boolean; searchColumns?: SmartGridCheckConfigraitonSearchField | { [key: string]: SmartGridCheckConfigraitonSearchField; }; unCheckAll?: boolean; } export 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; } export 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[]; }; } export declare interface SmartGridColumnAutoSizeReturn { autoSizeColumn: (column: SmartGridColumnDefinition) => void; customSizeColumn: (column: SmartGridColumnDefinition) => void; autoSizeAllColumns: () => void; } export declare type SmartGridColumnDefinition = SmartGridColumnWithField | SmartGridColumnWithGroupId | SmartGridColumnWithColId; declare interface SmartGridColumnGroupState { groupId: string; open: boolean; } export declare type SmartGridColumnPinnedType = "leftPinnedOnly" | "rightPinnedOnly" | "normal" | "top" | "bottom"; export declare interface SmartGridColumnState { colId: string; hide: boolean; width: number; sort: SmartGridSortDirection | null; filter: SmartGridFilterModel[] | null; } export declare interface SmartGridColumnVirtualizationParams { columns: SmartGridColumnDefinition[]; containerWidth: number; columnBuffer: number; headerRows: SmartGridColumnDefinition[][]; virtualizationThreshold?: number; globalColumnCounts: SmartGridGlobalColumnCounts; pinnedType: SmartGridPinType; virtualizedStartCololumnIndex: MutableRefObject; } export declare interface SmartGridColumnVirtualizationReturn { visibleColumns: SmartGridColumnDefinition[]; virtualizedHeaderRows: SmartGridColumnDefinition[][]; handleScroll: (e: React.UIEvent) => void; } export declare interface SmartGridColumnWithColId extends SmartGridBaseColumnDefinition { field?: string; groupId?: string; colId: string; } export declare interface SmartGridColumnWithField extends SmartGridBaseColumnDefinition { field: string; groupId?: string; } export declare interface SmartGridColumnWithGroupId extends SmartGridBaseColumnDefinition { field?: string; groupId: string; } /** * 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, comment?: string | SmartGridComment | null, type?: "commentMenu" | "topMenu") => void; onMarkAsReadClick?: (cellId: string | number) => Promise; onMarkAsResolvedClick: (cellId: string, comments: SmartGridComment[]) => Promise; commentProps: SmartGridCommentProps; resolvedComments: string[]; popup: SmartGridCommentPopup | null; onShowResolvedCommentsRequest?: () => Promise; 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; handleCommentEdit?: (text: string, comment: SmartGridComment, commentId: string | number, taggedUsers?: SmartGridCommentTaggedUser[]) => Promise; handleCommentDelete?: (commentId: string | number, comment: SmartGridComment) => Promise; handleThreadDelete?: (cellId: string, data: SmartGridComment[]) => Promise; handleMarkAsRead?: (cellId: string | number) => Promise; handleMarkAsUnread?: (cellId: string | number) => Promise; handleMarkAsResolved?: (cellId: string, comments: SmartGridComment[]) => Promise; handleFetchResolvedComments?: () => Promise<{ comments?: SmartGridCommentThread; resolvedComments?: string[]; } | void>; loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise; } /** * 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; cellId?: string | number; position?: SmartGridCommentPopupPosition; author?: string; onMouseEnter?: () => void; onMouseLeave?: () => void; openedBy?: "hover" | "click"; onMenuClick: (event: React.MouseEvent, comment?: string | number | SmartGridComment | null, type?: "commentMenu" | "topMenu") => void; onMarkAsReadClick?: ((cellId: string | number) => Promise) | null; onMarkAsResolvedClick?: ((cellId: string | number, comments: SmartGridComment[]) => Promise) | null; editCommentText?: string; isLoading?: boolean; error?: string | null; onClearError?: () => void; currentAuthor?: string; editingComment?: SmartGridComment | null; setEditingComment?: React.Dispatch>; onUpdateComment?: (commentId: string | number | null, newText: string) => Promise; loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise; 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; /** * SmartGridCommentWrapperProps - Props for CommentWrapper component */ export declare interface SmartGridCommentWrapperProps { commentProps: SmartGridCommentProps; commentPannelRef: React.MutableRefObject<((show: boolean) => void) | null>; height: string | number; } export declare interface SmartGridContainerRect { top: number; left: number; width: number; height: number; } export declare type SmartGridContextRef = React.MutableRefObject; export declare interface SmartGridCopyCellValueParams { tableInstance: MutableRefObject; tableApi: SmartGridAPI | null; } export declare interface SmartGridCreateChatResponse { success: boolean; chatName?: string; description?: string; selectedChannel?: SmartGridChannel; formattedChat?: SmartGridChat; } export declare type SmartGridCustomCallbackRefCurrent = { onCellClick?: ((params: any) => void) | null; }; /** Data source context */ export 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[]; }; } export declare interface SmartGridDataSourceParams { startRow: number; endRow: number; successCallback: (rows: SmartGridRowData[], lastRow?: number | null) => void; failCallback: (error: Error) => void; request: RowGroupParams & { groupKeys: unknown[]; rowGroupCols: SmartGridColumnDefinition[]; startRow: number; endRow: number; }; [key: string]: unknown; } export declare interface SmartGridDataUpdateMetadata { totalCount?: number; [key: string]: unknown; } export declare interface SmartGridDateConstraints { startYear?: number; endYear?: number; disableOnlyPast?: boolean; disableOnlyFuture?: boolean; disablePast?: boolean; disableFuture?: boolean; minDate?: Date | string | null; maxDate?: Date | string | null; } export declare type SmartGridDateFormat = "YYYY-MM-DD" | "DD-MM-YYYY" | "MM-DD-YYYY" | "YYYY/MM/DD" | "DD/MM/YYYY" | "MM/DD/YYYY"; export declare type SmartGridDatePickerHandler = React.MouseEvent | KeyboardEvent; export declare interface SmartGridDatePickerInputProps { dateString: string; placeholder?: string; disabled?: boolean; isError?: boolean; setErrorState: (hasError: boolean) => void; inputContainerRef: RefObject; selectedDate?: string; isOpen?: boolean; setIsOpen: (isOpen: boolean) => void; displayFormat?: SmartGridDateFormat; onDateStringChange?: (date: string | Moment | null) => void; minDate?: Date | string | null; maxDate?: Date | string | null; onClear?: (e: MouseEvent_2) => void; readOnly?: boolean; customIcon?: ReactNode; hasDateError?: boolean; isheadercell?: boolean | null; isCellRenderer?: boolean; } export declare interface SmartGridDatePickerProps extends SmartGridDateConstraints { value?: string; onChange?: (date: string) => void; placeholder?: string; disabled?: boolean; label?: string; required?: boolean; withPortal?: boolean; width?: string; dateFormat?: SmartGridDateFormat; isCellRenderer?: boolean; tableApi?: SmartGridAPI | null; isheadercell?: boolean | null; column?: SmartGridColumnDefinition; advancedSearchApplyRef?: MutableRefObject; lazyLoadCellRenderer?: boolean; } export declare interface SmartGridDateRangePickerCalendarProps extends SmartGridDateConstraints { leftMonth: Date | Moment; setLeftMonth: (month: Date | Moment) => void; rightMonth: Date | Moment; setRightMonth: (month: Date | Moment) => void; selectedStartDate: string; selectedEndDate: string; tempStartDate: string | null; setTempStartDate: (date: string | null) => void; tempEndDate: string | null; setTempEndDate: (date: string | null) => void; showMonthDropdown: boolean; setShowMonthDropdown: (show: boolean) => void; showYearDropdown: boolean; setShowYearDropdown: (show: boolean) => void; activeCalendar: "left" | "right"; setActiveCalendar: (calendar: "left" | "right") => void; monthDropdownRef: RefObject; yearDropdownRef: RefObject; focusedInput: "start" | "end" | ""; setFocusedInput: (input: "start" | "end" | "") => void; isCellRenderer?: boolean; tableApi?: SmartGridAPI | null | undefined; setIsOpen: (isOpen: boolean) => void; onChange?: (dates: SmartGridDateRangeValue) => void; startDate?: string; endDate?: string; onDateChangeApply?: (dates: SmartGridDateRangeValue) => void; hasDateError?: string; setSelectedStartDate?: (date: string) => void; setSelectedEndDate?: (date: string) => void; error?: string; } export declare interface SmartGridDateRangePickerInputProps { inputContainerRef: RefObject; startDateString: string; endDateString: string; isDisabled?: boolean; isError?: boolean | string; onStartDateFocus: (e: FocusEvent_2) => void; onEndDateFocus: (e: FocusEvent_2) => void; displayFormat?: SmartGridDateFormat; onStartDateStringChange?: (date: string | Moment | null) => void; onEndDateStringChange?: (date: string | Moment | null) => void; minDate?: Date | string | null; maxDate?: Date | string | null; readOnly?: boolean; isOutsideRange?: (date: Moment) => boolean; onErrorStateChange?: Dispatch>; clearErrorsTrigger?: number; onClear?: (e: MouseEvent_2) => void; onCalendarOpen?: () => void; isCellRenderer?: boolean; } export declare interface SmartGridDateRangePickerProps extends SmartGridDateConstraints { startDate?: string; endDate?: string; onChange?: (dates: SmartGridDateRangeValue) => void; disabled?: boolean; label?: string; required?: boolean; error?: string; withPortal?: boolean; width?: string; dateFormat?: SmartGridDateFormat; isCellRenderer?: boolean; tableApi?: SmartGridAPI | null; readOnly?: boolean; isOutsideRange?: (date: Moment) => boolean; lazyLoadCellRenderer?: boolean; } export declare interface SmartGridDateRangeValue { startDate: string; endDate: string; } export declare type 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; } export declare type SmartGridDefaultColDef = { minWidth: number; maxWidth?: number; headerComponentParams?: { innerHeaderComponent: React.FC | null; }; headerComponent?: React.FC | null; enableCellChangeFlash?: boolean; maxCharLengthInSearch?: number; }; export declare type SmartGridDispatch = (action: { type: string; payload: unknown; meta?: { fromAlignedGrid?: boolean; defaultColDef?: SmartGridDefaultColDef; } | Record; }) => void; export declare type SmartGridDisplayedColumn = { colDef: SmartGridColumnDefinition; colId: string; getColId: () => string; isVisible: () => boolean; isPinned: () => SmartGridPinnedType; label: string; } & SmartGridColumnDefinition; export declare interface SmartGridDisplayedRowAtIndex { data: SmartGridRowData; rowIndex: number; node: SmartGridParamsNode; api: SmartGridAPI; } export declare interface SmartGridDisplayedRowNode extends SmartGridRowNode { rowIndex: number; absoluteRowIndex: number; originalData: SmartGridRowData; rowHeight?: number; } export declare interface SmartGridDisptach { type: string; payload?: unknown; } export declare interface SmartGridDragColumnParams { hasChildren: boolean; index: number; column: SmartGridColumnDefinition; dispatch: SmartGridDispatch; columns: SmartGridColumnDefinition[]; } export declare interface SmartGridDragColumnReturn { handleDragStart: (e: React.DragEvent) => void; handleDragOver: (e: React.DragEvent) => void; handleDragLeave: () => void; handleDrop: (e: React.DragEvent) => void; handleDragEnd: () => void; isDragging: boolean; dragOverColumn: string | null; } export declare interface SmartGridDragColumnSettingParams { localColumns: SmartGridColumnDefinition[]; dispatch: SmartGridDispatch; } export declare interface SmartGridDragColumnSettingReturn { handleDragStart: (e: React.DragEvent, column: SmartGridColumnDefinition) => void; handleDragOver: (e: React.DragEvent, column: SmartGridColumnDefinition) => void; handleDragLeave: () => void; handleDrop: (e: React.DragEvent, targetColumn: SmartGridColumnDefinition) => void; handleDragEnd: () => void; draggedColumn: SmartGridColumnDefinition | null; dragOverColumn: SmartGridColumnDefinition | null; } export declare interface SmartGridDragRowParams { rowIndex: number; rowData: SmartGridRowData; bodyContainerRef: MutableRefObject; } export declare interface SmartGridDragRowReturn { handleDragStart: (e: React.DragEvent) => void; handleDragEnd: () => void; handleDragOver: (e: React.DragEvent) => void; handleDragLeave: () => void; handleDrop: (e: React.DragEvent) => void; } export declare interface SmartGridDragSourceData { field: string; index: number; order_of_display?: number; path: string[]; } export declare type SmartGridDrawerAnchor = "left" | "right" | "top" | "bottom"; export declare interface SmartGridDrawerProps { open: boolean; onClose: () => void; anchor?: SmartGridDrawerAnchor; children?: ReactNode; title?: string; size?: SmartGridDrawerSize; width?: number | string; height?: number | string; className?: string; zIndex?: number; showCloseButton?: boolean; closeOnBackdropClick?: boolean; closeOnEscape?: boolean; primaryButtonLabel?: string; onPrimaryButtonClick?: () => void; primaryButtonProps?: Record; secondaryButtonLabel?: string; onSecondaryButtonClick?: () => void; secondaryButtonProps?: Record; hideBackdrop?: boolean; disablePortal?: boolean; keepMounted?: boolean; } export declare type SmartGridDrawerSize = "small" | "medium" | "large"; export declare interface SmartGridDropdownOptionsParams { value: string | number | (string | number)[] | null; data: SmartGridRowData; colDef: SmartGridColumnDefinition; } 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; enabledItems?: SmartGridToolbarItemKey[]; onFileSelect?: (e: ChangeEvent) => void; onImageSelect?: (e: ChangeEvent) => void; onEmojiSelect?: (e: React.MouseEvent) => 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; } export declare interface SmartGridEvent { type: string; api?: SmartGridAPI; [key: string]: unknown; } export declare type SmartGridEventListener = { fn: SmartGridEventListenerFn; once: boolean; }; export declare type SmartGridEventListenerFn = (event: SmartGridEvent) => void; export declare interface SmartGridExpandableCellProps { rowId: string | number; isExpanded: boolean; rowData: SmartGridRowData; column: SmartGridColumnDefinition; groupId: string | null; rowIndex: number; showMasterDetailToggle: boolean; isRowGroupEnabled: boolean; updatedCellId: string | number; isGroupRowExpanded: boolean; childKeyField: string; } export declare type SmartGridExpandedChildRows = { childRowsCount: number; rowId: string | number; rowIndex: number; children?: SmartGridRowData[]; }; export declare type SmartGridExpandedColumnGroups = { isAllGroupExpanded?: boolean; [key: string]: boolean | undefined; }; export declare interface SmartGridExportCallbackRefCurrent { downloadExcelHandler?: ((e: SmartGridExportEvent) => void) | null; downloadCSVHandler?: ((e: SmartGridExportEvent) => void) | null; copyToClipboardHandler?: (() => void) | null; processCellForClipboard?: ((params: SmartGridProcessCellForClipboardParams) => string) | null; } export declare interface SmartGridExportEvent extends MouseEvent_2 { processCellCallback?: (params: SmartGridProcessCellForClipboardParams) => unknown; } export declare interface SmartGridExportParams { processCellCallback?: (params: SmartGridProcessCellForClipboardParams) => unknown; } /** Extended filter model with search and column filters */ declare interface SmartGridExtendedFilterModel extends SmartGridFilterModel { _search?: SmartGridFilterModel[]; _columnFilters?: Record; } export declare type SmartGridFetchDataFunctionBody = { range: SmartGridRangeFilter[]; search: SmartGridStringFilter[]; sort: SmartGridSortModel[]; }; export declare interface SmartGridFetchDataParams { startRow: number; endRow: number; filterModel?: SmartGridFilterModel | null; sortModel?: SmartGridSortModel | null; } export declare interface SmartGridFetchDataResponse { rowData: SmartGridRowData[]; lastRow?: number; rowCount?: number; totalCount?: number; } /** Fetch function ref type */ declare interface SmartGridFetchFunctionRef { current?: SmartGridFetDataParams | null; } export declare type SmartGridFetchMoreFn = (page: number) => Promise; /** Fetch response */ declare interface SmartGridFetchResponse { data?: SmartGridRowData[]; rowCount?: number; totalItems?: number; total?: number; lastRow?: number; lastRowIndexKnown?: boolean; } export declare type SmartGridFetDataParams = (body: SmartGridFetchDataFunctionBody, page: number, context?: SmartGridDataSourceContext, pageNum?: number, options?: { pageSize: number; }) => Promise; 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; } export declare type SmartGridFilterMode = "value" | "condition"; export declare interface SmartGridFilterModel { pattern: string; search_type: string; column?: string; field?: string; min_val?: number; max_val?: number; type?: string; operator?: string; value?: string; operators?: SmartGridSearchOperatorOption[]; [key: string]: unknown; } /** * Parameters for flashCells API (AG Grid compatible) */ export 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; } export declare type SmartGridFloatingType = "top" | "bottom" | null; export declare interface SmartGridFocusedCell extends SmartGridSelectedCell { floating: SmartGridFloatingType; } export declare type SmartGridFontSize = "medium" | "small" | "large"; 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; } export declare type SmartGridFrozenColumnsDetails = { indexes: string[]; positions: Record; totalWidth: number; rightPinned: { indexes: string[]; positions: Record; totalWidth: number; }; }; export declare type SmartGridFrozenState = "left" | "right" | boolean | null | undefined; export declare interface SmartGridGetActualValueParams { column: SmartGridColumnDefinition; rowData: SmartGridRowData; cellValue: string | number | { label?: string; } | { label?: string; }[]; } export declare interface SmartGridGetDatePickerDataParams { cellRenderer: string; actualValue: { startDate?: string; endDate?: string; } | string | string[]; cellValue: { startDate?: string; endDate?: string; } | string | string[]; dateFormat?: string; } export declare interface SmartGridGetErrorInDateTimeParams { column: SmartGridColumnDefinition; actualValue: string; } export declare interface SmartGridGetRowDataParams { data: SmartGridRowData; rowIndex?: number; node: SmartGridParamsNode; api: SmartGridAPI; } /** Request params for getRows */ declare interface SmartGridGetRowsRequestParams { startRow: number; endRow: number; pageSize: number; sortModel?: SmartGridSortModel; filterModel?: SmartGridExtendedFilterModel; successCallback: (rows: SmartGridRowData[], lastRow?: number, lastRowIndexKnown?: boolean) => void; failCallback: (error?: unknown) => void; context?: SmartGridDataSourceContext; request?: { startRow: number; endRow: number; sortModel?: SmartGridSortModel; filterModel?: SmartGridFilterModel; pageSize: number; groupKeys: string[]; }; } export declare interface SmartGridGlobalColumnCounts { leftPinnedOnly?: number; rightPinnedOnly?: number; normal?: number; left?: number; right?: number; } export declare type SmartGridGroupedMessageItem = (SmartGridChatMessage & { type?: "default" | "deleted" | "edited" | string; }) | SmartGridDateSeparatorItem; export declare interface SmartGridHandleToastFn { (isOpen: boolean, message?: string, variant?: SmartGridToastVariant): void; } export declare interface SmartGridHeaderCellProps { column: SmartGridColumnDefinition; index: number; onToggle?: (field: string, isExpandable: boolean) => void; isExpandable?: boolean; selectable?: boolean; ShowFullText?: boolean; totalFinalHeight?: number | null; headerHeight?: number; currentRowHeight?: { maxHeight: number; maxLineCount: number; } | null; } export declare interface SmartGridHeaderChatConfig { participants: SmartGridParticipant[]; participantsList: SmartGridParticipant[]; headerConfig: SmartGridHeaderConfig; notificationSettings: SmartGridNotificationSettings; loadParticipants: (radioValue: string, chatId: string | number) => Promise; loadParticipantsAvatar: (selectedRadioOption: string, chatId: string | number) => Promise; loadMenuOptions: () => Promise; onParticipantsClick: (radioValue: string | number) => Promise; 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; onPinnedChatClick: (chatId: string | number, isPinned: boolean) => Promise; onChatClick: (chatId: string | number, channelId?: string | number | null) => Promise; onSearchChange: (value: string, radioValue?: string, chatId?: string | number) => Promise; 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; } export declare interface SmartGridHeaderMenuReturn { unfreezeColumn: (column: SmartGridColumnDefinition) => void; freezeColumn: (column: SmartGridColumnDefinition) => void; pinColumnRight: (field: string) => void; unpinColumnRight: (field: string) => void; autoSizeColumn: (column: SmartGridColumnDefinition) => void; customSizeColumn: (column: SmartGridColumnDefinition) => void; } export declare type SmartGridHeaderRowHeight = { maxHeight: number; maxLineCount: number; }; export declare interface SmartGridHeaderRowHeightWithIndex { [key: string]: SmartGridHeaderRowHeight; } export declare interface SmartGridHeaderSearchProps { column: SmartGridColumnDefinition; showInplaceSearchInput: boolean; searchValue: string; setSearchValue: (value: string) => void; setShowSearchModal: (value: boolean | ((prev: boolean) => boolean)) => void; advancedSearchApplyRef: MutableRefObject; } export declare type SmartGridHeaderStyleParams = { column: SmartGridColumnDefinition; displayName: string; enableSorting: boolean; sortState: SmartGridSortModel; onSort: (field: string, direction: string) => void; isSearchable?: boolean; showSortIcon: boolean; toggleSearchModal: (e: default_2.MouseEvent) => 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>; }; export declare type SmartGridHeightComfortable = { type: "comfortable"; height: 52; padding: 32; }; export declare type SmartGridHeightCompact = { type: "compact"; height: 30; padding: 9; }; export declare type SmartGridHeightDefault = { type: "default"; height: 46; padding: 24; }; export declare interface SmartGridIATableState { selectedCells: Map; instanceKeyHandlers: Map void>; activeInstance?: HTMLElement | null; multiSelection?: SmartGridMultiSelectionState; } export declare interface SmartGridImageUploaderProps { image?: string | null; isLoading?: boolean; isError?: boolean; handleClear?: () => void; handleRetry?: () => void; } export 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; } export 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; } export declare interface SmartGridInfiniteCacheOptions { threshold?: number; maxBlocksInCache?: number; cacheOverflowSize?: number; rowHeight?: number; purgeStrategy?: string; enablePersistence?: boolean; persistenceStorageKey?: string; persistenceOptions?: Record; uniqueIdField?: string; fetchDataMethodRef?: SmartGridFetchFunctionRef; apiUrl?: string | null; initialFilterModel?: SmartGridFilterModel | null; initialSortModel?: SmartGridSortModel | null; tableId?: string; force?: boolean; isServerSideRef?: MutableRefObject; pageSize?: number; updatedPageSizeRef?: MutableRefObject; enableIndexedDBCache?: boolean; enableStreamingLoad?: boolean; enableEnhancedWorker?: boolean; binaryFormat?: boolean; extremelyLargeDatasetThreshold?: number; tableContextRef?: MutableRefObject; context?: Record; onDataUpdate: (rows: SmartGridRowData[], blockId: number, metadata: Record | undefined) => void; isPaginationMode?: boolean; } export declare interface SmartGridInfiniteCacheParams { datasource: SmartGridInfiniteCacheDataSourceParams; updatedPageSizeRef: MutableRefObject; pageSize: number; overflowSize: number; } export 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[]; } export declare interface SmartGridInfiniteRowModel { infiniteCache?: SmartGridInfiniteCache; setViewportRange?: (startRow: number, endRow: number) => void; logCacheSummary?: () => void; datasource: { getWholeData: () => SmartGridRowData[]; }; [key: string]: unknown; } export declare interface SmartGridInfiniteRowModelRef { infiniteCache?: SmartGridInfiniteCache; params?: { context?: unknown; filterModel?: SmartGridFilterModel | Record; 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; } export declare interface SmartGridInfiniteScrollLoaderProps { isLoading: boolean; colSpan: number; } export declare interface SmartGridInfiniteScrollOptions { threshold?: number; rootMargin?: string; enabled?: boolean; isRestoringScroll?: MutableRefObject | null; } export declare interface SmartGridInfiniteScrollReturn { loadMoreRef: RefObject; isLoading: boolean; hasMore: boolean; error: Error | null; loadMore: () => Promise; reset: () => void; updateHasMore: (newHasMore: boolean) => void; updateCurrentPage: (newPage: number) => void; currentPage: number; } export declare interface SmartGridInitialDataUpdateParams { dispatch: SmartGridDispatch; pinnedTopRows: SmartGridRowData[]; pinnedBottomRows: SmartGridRowData[]; tableInstance: MutableRefObject; columnMap: Record; uniqueIdField: string; childKeyField: string; enableRowSpan?: boolean; rowSpanColumn?: string | string[]; pageSize: number; serverSide: boolean; rowDragManaged?: boolean; infiniteScroll?: boolean; initialExpandedColumnGroups?: Record; tableApi: SmartGridAPI | null; smartGridMenuOptions?: SmartGridMenuOptions; purgeClosedRowNodes?: boolean; detailRendererTable?: boolean; isSaveViewEnabled?: boolean; isSavingViewLoading?: boolean; savedViewsOptions?: unknown[]; rowHeight?: string; tableId: string; refObj: MutableRefObject; callBackRef: MutableRefObject; exportCallbackRef: MutableRefObject; saveViewCallbackRef: MutableRefObject; saveViewOptionsRef: MutableRefObject; isSingleSelect?: boolean; defaultColDef?: SmartGridDefaultColDef; disableSelectAllRecords?: boolean; selectable?: boolean; columnBufferSize?: number; lazyLoadCellRenderer?: boolean; hasSplitRenderer?: boolean; splitRendererKeys?: string[]; } export declare interface SmartGridInputChatConfig { inputConfig: SmartGridInputConfig; onSend: (payload: SmartGridSendPayload, chatId: string | number) => Promise; 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[]; } export declare interface SmartGridInputFormatInstance { colDef?: { type?: string; id?: string; extra?: { roundOffTo?: number; showNullAsEmpty?: boolean; }; }; data?: { roundOffTo?: number; }; isCellInFocus?: boolean; isCeil?: boolean; roundOffTo?: number; type?: string; inputType?: string; } export declare interface SmartGridInputProps { placeholder?: string; label?: string; value?: string | number; onChange: (e: ChangeEvent) => void; type?: SmartGridInputType; disabled?: boolean; error?: string; leftIcon?: ReactNode; rightIcon?: ReactNode; className?: string; width?: string | number; onClick?: (e: MouseEvent_2) => void; isCellRenderer?: boolean; inputType?: SmartGridInputValueType; iconButton?: ReactNode; iconButtonClassName?: string; height?: string | number; onFocus?: (e: FocusEvent_2) => void; onBlur?: (e: FocusEvent_2) => void; autoFocus?: boolean; rightIconClick?: () => void; } export declare type SmartGridInputType = "text" | "password" | "email" | "number" | "tel" | "int" | "url"; export declare type SmartGridInputValueType = "text" | "str" | "int" | "float" | "decimal" | "percentage" | "dollar"; export declare interface SmartGridInternalGetRowsParams { startRow: number; endRow: number; filterModel?: SmartGridFilterModel | null; sortModel?: SmartGridSortModel | null; request?: Record; successCallback?: (rowData: SmartGridRowData[], lastRow?: number) => void; failCallback?: () => void; noDataUpdate?: boolean; } export 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; } 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; loadChatList: (selectedChannelInfo: SmartGridChannel) => Promise; handleChatName: (formData: SmartGridChatFormData, selectedChannelId: SmartGridChannel | null) => Promise; deleteChat: (topicId: string | number) => Promise<{ success: boolean; topicId: string | number; }>; directChatList: SmartGridChat[]; hasDirectChatList: boolean; selectedChatId?: string | number; clearDirectChatList: () => void; } export declare interface SmartGridMasterDetailConfig { enabled: boolean; expandedRows: (string | number)[]; detailRenderer: React.ComponentType | null; detailRowHeight: number; detailPadding: number; expandedRowData: SmartGridRowData[]; currentRowStyles?: { height?: number; top?: number; }; rowIndex?: number | null; } export declare interface SmartGridMemoryAnalyticsParams { modelRef: MutableRefObject; shouldUseCache: boolean; } export declare interface SmartGridMemoryAnalyticsReturn { memoryUsage: number; analytics: SmartGridCacheAnalyticsData | null; updateAnalytics: () => void; resetAnalytics: () => void; updateMemoryAndAnalytices: () => void; } export declare interface SmartGridMentionCommand { id: string; label: string; } export declare interface SmartGridMentionConfig { chatId?: string | number; loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise; } 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; } export declare interface SmartGridMentionEditorRef { toggleBold: () => void; toggleItalic: () => void; toggleLink: () => void; addImage: (url: string, alt?: string) => void; getHTML: () => string; getJSON: () => Record | 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 type SmartGridMenuAlignment = "start" | "end" | "auto"; export declare interface SmartGridMenuAlignments { START: "start"; END: "end"; AUTO: "auto"; } export declare type SmartGridMenuAnchorOrigin = "start" | "end" | "center"; export declare interface SmartGridMenuOption { label: string | number; id: string | number; onClick?: (value: string | number) => void; icon?: ReactNode; value?: string | number; prefillText?: string; name?: string; avatar?: string; submenu?: SmartGridMenuOption[]; submenuPosition?: SmartGridMenuPosition; submenuWidth?: number; submenuIconPlacement?: "left" | "right"; selectedElement?: string | number; useHover?: boolean; noCloseOnSelect?: boolean; isDisabled?: boolean; } export declare interface SmartGridMenuOptions { withColumMenu?: boolean; autoWithColumMenu?: boolean; freezeColumnMenu?: boolean; sortColumnMenu?: boolean; collapseColumnAll?: boolean; expandColumnAll?: boolean; wrapText?: boolean; } export declare interface SmartGridMenuOptionsHeaderCustomProps { searchPlaceholder?: string; selectAllLabel?: string; clearButtonText?: string; radioButtonProps?: Record; searchInputProps?: Record; checkboxProps?: Record; clearButtonProps?: Record; } 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 type SmartGridMenuPosition = "top" | "bottom" | "left" | "right"; export declare interface SmartGridMenuPositionResult { top?: number; left?: number; width?: number; transformOrigin?: string; transform?: string; } export declare interface SmartGridMenuPositions { BOTTOM: "bottom"; TOP: "top"; LEFT: "left"; RIGHT: "right"; } export declare interface SmartGridMenuPositionState { top: number; left: number; width?: number; height?: number; visibility?: "visible" | "hidden"; transform?: string; transformOrigin?: string; } export declare interface SmartGridMenuPrimaryButtonProps { loading?: boolean; disabled?: boolean; label?: string; } export declare interface SmartGridMenuProps { options?: SmartGridMenuOption[]; selectedElement?: string | number | { value?: string | number; prefillText?: string; } | null; iconPlacement?: "left" | "right" | "top"; isOpen?: boolean; open?: boolean; setIsOpen: (isOpen: boolean) => void; onClose?: () => void; menuButtonRef?: RefObject; anchorEl?: HTMLElement | null; position?: SmartGridMenuPosition; width?: number; horizontalAlign?: SmartGridMenuAlignment; isSubmenu?: boolean; parentOptionRef?: RefObject | null; skipAnimation?: boolean; portalContainer?: HTMLElement; additionalButtons?: ReactNode; forcePosition?: boolean; anchorOrigin?: SmartGridMenuAnchorOrigin; onClick?: (option: SmartGridMenuOption) => void; menuContainerClassName?: string; primaryButtonProps?: SmartGridMenuPrimaryButtonProps; onPrimaryButtonClick?: () => void | Promise; onTertiaryButtonClick?: () => void; selected?: string; withActionButtons?: boolean; withCheckbox?: boolean; renderCustomHeader?: (headerProps: Record) => ReactNode; filteredOptions?: SmartGridMenuOption[]; searchQuery?: string; onSearchChange?: (value: string) => void; onSelectAll?: (allValues: (string | number)[]) => void; onClearSelection?: () => void; customHeaderProps?: Record; } 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; onMessageUpdate: (messageId: string | number, updatedData: Partial) => Promise; }>; onMessageDelete: (messageId: string | number) => Promise<{ success: boolean; messageId: string | number; }>; onThreadClick: (messageId: string | number, message: SmartGridChatMessage) => void; loadThreadMessages: (parentMessageId: string | number) => Promise; loadPinnedMsg: () => Promise; onSearchMessage: (value: string, chatId: string | number) => Promise; 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"; export declare interface SmartGridModalProps { open?: boolean; onClose: () => void; title?: string; children?: ReactNode; size?: SmartGridModalSize; width?: string | number; height?: string | number; className?: string; onPrimaryButtonClick?: () => void | Promise; primaryButtonLabel?: string; onSecondaryButtonClick?: () => void; secondaryButtonLabel?: string; closeOnOutsideClick?: boolean; primaryButtonVariant?: SmartGridButtonVariant; primaryButtonProps?: Record; showCloseButton?: boolean; showPrimaryButton?: boolean; showSecondaryButton?: boolean; footerOptions?: ReactNode; loading?: boolean; } export declare type SmartGridModalSize = "small" | "medium" | "large"; export declare type SmartGridModelType = "normal" | "serverSide" | "infinite"; export declare interface SmartGridMoreAvatarProps { count: number; size?: SmartGridAvatarSize; } export declare interface SmartGridMultiSelectionState { anchor: SmartGridCellPosition | null; current: SmartGridCellPosition | null; selectedPositions: SmartGridCellPosition[]; } export 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; 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>; loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise; } export 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; } export declare type SmartGridNumberFormat = "full" | "thousands" | "millions" | "billions"; export declare interface SmartGridOldSortModel { colId: string; sort: SmartGridSortDirection; } export declare type SmartGridOnMessagePin = (messageId: string | number, pinned: boolean, chatId: string | number, item: SmartGridChatMessage) => Promise; export declare type SmartGridOnReadyParams = { api: SmartGridAPI; columnApi: SmartGridColumnAPI; type: "gridReady"; }; export declare type SmartGridOnSelectionChangedParams = { api: SmartGridAPI; type: string; source: string; }; export declare interface SmartGridOptions { [key: string]: unknown; } export declare type SmartGridOutsideClickCallback = () => void; /** Page size ref */ declare interface SmartGridPageSizeRef { current: number; } /** Page size ref */ declare interface SmartGridPageSizeRef_2 { current: number; } export declare interface SmartGridPagesPerPageSectionProps { label: string; options: Array<{ label: string | number; id: string | number; onClick: (value: number) => void; }>; selectedElement: number; } 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; } export declare interface SmartGridPaginationModel { currentPage: number; pageSize: number; totalPages: number; totalRecords: number; } export declare interface SmartGridPaginationProps { pagination?: boolean; hidePaginationPageSizeSelector?: boolean; paginationPageSizeSelector?: number[]; } export declare interface SmartGridPaginationRelated { totalItems: number; totalPages: number; currentPage: number; isCountUnknown: boolean; } export declare interface SmartGridParamsNode { rowIndex: number; data: SmartGridRowData; api: SmartGridAPI; } /** * 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"; export declare interface SmartGridPinnedRowsProps { rowHeight: number; selectable: boolean; expandable: boolean; pinnedRows: SmartGridRowData[]; onRowClick?: SmartGridRowClickHandler; pinnedRowsRef: RefObject; leftPinnedOnly: boolean; rightPinnedOnly: boolean; frozenColumnWidth: number; isPinnedGrandTotalRow: boolean; isLeftPinnedRowsAvailable: boolean; handlePinnedScroll: SmartGridScrollHandler; virtualizedAllVisibleColumns: SmartGridColumnDefinition[]; virtualizedStartCololumnIndex: MutableRefObject; uniqueIdField: string; pinnedType: "top" | "bottom"; allColumnsLastRow: SmartGridColumnDefinition[]; } export declare type SmartGridPinnedType = "leftPinned" | "rightPinned" | null; export declare type SmartGridPinType = "leftPinnedOnly" | "rightPinnedOnly" | "normal"; export declare interface SmartGridPivotAggregationOption { value: string; label: string; } export 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 type SmartGridPivotSaveHandler = { handlePivotSave?: (state: SmartGridPivotSavePayload, setIsPivotOpen: Dispatch>) => void; handlePivotApply?: (state: SmartGridPivotSavePayload, setIsPivotOpen: Dispatch>) => void; }; 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; } export declare type SmartGridPopoverHorizontal = "left" | "center" | "right" | number; export declare interface SmartGridPopoverOrigin { vertical: SmartGridPopoverVertical; horizontal: SmartGridPopoverHorizontal; } export declare interface SmartGridPopoverProps { open: boolean; onClose: () => void; anchorEl: HTMLElement | null; anchorOrigin?: SmartGridPopoverOrigin; transformOrigin?: SmartGridPopoverOrigin; children?: ReactNode; className?: string; disablePortal?: boolean; keepMounted?: boolean; marginThreshold?: number; elevation?: number; disableScrollLock?: boolean; disableBackdrop?: boolean; onBackdropClick?: (e: MouseEvent_2) => void; } export declare type SmartGridPopoverVertical = "top" | "center" | "bottom" | number; 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 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; }; export declare interface SmartGridPromptButton { label: string; type: "default" | "primary" | "secondary"; onClick?: () => void; } export declare interface SmartGridPromptProps { isOpen?: boolean; handleClose: (e?: MouseEvent_2) => void; title: string; children: ReactNode; variant?: SmartGridPromptVariant; onPrimaryButtonClick: (e: MouseEvent_2) => void; primaryButtonLabel?: string; onSecondaryButtonClick?: (e: MouseEvent_2) => void; secondaryButtonLabel?: string; primaryButtonProps?: Record; } export declare type SmartGridPromptVariant = "info" | "success" | "warning" | "delete" | "error"; 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; } export declare interface SmartGridRadioGroupProps { options: SmartGridRadioOption[]; selectedOption: string | number; onChange: (e: ChangeEvent, val: string | number) => void; orientation?: SmartGridRadioOrientation; disabled?: boolean; name?: string; className?: string; } export declare interface SmartGridRadioOption { value: string | number; label: string; disabled?: boolean; } export declare type SmartGridRadioOrientation = "vertical" | "horizontal" | "row"; export declare type SmartGridRangeFilter = { column: string; min_val: number; max_val: number; search_type: string; operator?: string; }; /** * Parameters for redrawRows API (AG Grid compatible) */ export declare interface SmartGridRedrawRowsParams { /** Optional list of row nodes to redraw. If not provided, all rows are redrawn */ rowNodes?: SmartGridRowNode[]; } export declare interface SmartGridRefreshCacheOptions { purge?: boolean; partialRefresh?: boolean; preserveFields?: string[]; userInitiated?: boolean; } /** * Parameters for refreshCells API (AG Grid compatible) */ export 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; } export declare interface SmartGridRefreshOptions { purge?: boolean; resetPage?: boolean; userInitiated?: boolean; resetFilters?: boolean; } export declare interface SmartGridRemoveLazyLoadParams { cellRef: RefObject; } export declare interface SmartGridRenderHeadersProps { leftPinnedOnly: boolean; rightPinnedOnly: boolean; filteredColumns: SmartGridColumnDefinition[]; selectable: boolean; virtualizedHeaderRows: SmartGridColumnDefinition[][]; dispatch: SmartGridDispatch; headerRows: SmartGridColumnDefinition[][]; virtualizedColumns: SmartGridColumnDefinition[]; headerRowHeightwithIndex: SmartGridHeaderRowHeightWithIndex; ShowFullText: boolean; virtualizedStartCololumnIndex: MutableRefObject; } 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; loadOlderMessages: (channelId: string | number) => Promise; messagesClearedTrigger?: number; } export declare interface SmartGridRowClickHandler { (rowData: SmartGridRowData, rowIndex: number): void; } export declare interface SmartGridRowData { [key: string]: unknown; id?: string | number; isChildRow?: boolean; isChildGroup?: boolean; childIndex?: number; groupingLevel?: number; level?: number; parentRowIndex?: number; parentRowData?: SmartGridRowData; __parentPath?: string; _rowHeight?: number; _isPinnedTop?: boolean; _isPinnedBottom?: boolean; __isAggregationRow?: boolean; subTotalAggreRow?: boolean; grandTotalAggreRow?: boolean; isGrandTotalRow?: boolean; __parentId?: string | number | null; __rowSpanInfo?: SmartGridRowSpanInfo; __flattenedRowId?: string; __rowIndex?: number; __split?: { key?: string; }; } /** * Transaction object for applyTransaction API (AG Grid compatible) */ export 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[]; } export declare interface SmartGridRowDragEndParams { api: SmartGridAPI; type: "rowDragEnd"; fromIndex: number; toIndex: number; rowData: SmartGridRowData; } export declare interface SmartGridRowDragStartParams { api: SmartGridAPI; type: "rowDragStart"; rowIndex: number; rowData: SmartGridRowData; } export declare type SmartGridRowGrouOpenParams = { rowId: string; rowIndex: number; api: SmartGridAPI; isExpanded: boolean; }; export declare type SmartGridRowGroupPaginationParams = { page: number; pageSize: number; }; export declare interface SmartGridRowGroupPaginationState extends SmartGridRowGroupStatePagination { page: number; pageSize: number; hasMore: boolean; } export declare interface SmartGridRowGroupParams { groupId: string; isRowGroupEnabled: boolean; loadingRef: RefObject; } export declare interface SmartGridRowGroupReturn { groupData: SmartGridRowData[]; isLoading: boolean; hasMore: boolean; error: string | null; groupLoading: boolean; loadingRef: RefObject; } export 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; }; export declare type SmartGridRowGroupStateExpandedGroups = { count: number; fieldName: string; rowIndex: number; value: string; [key: string]: boolean | number | string; }; export declare type SmartGridRowGroupStatePagination = { hasMore: boolean; lastUpdated: number; page: number; pageSize: number; totalItems?: number; totalPages?: number; error?: boolean; }; export declare type SmartGridRowHeightMap = Record; declare type SmartGridRowHeightType = "default" | "compact" | "comfortable"; export declare interface SmartGridRowHoverEffectParams { scrollContainerRef: RefObject; tableInstance: MutableRefObject; } export declare type SmartGridRowInfo = { isFirst: boolean; isLast: boolean; span: number; rowIds?: (string | number)[]; }; export declare interface SmartGridRowNode extends SmartGridUpdateData { id: string | number; childIndex?: number; selected: boolean; rowIndex?: number; absoluteRowIndex?: number; originalData?: SmartGridRowData; rowHeight?: number; setSelected: (selected: boolean, clearSelection?: boolean) => void | ((value: string | number | boolean) => void); isGroup?: () => boolean; } /** * Result of applyTransaction API (AG Grid compatible) */ export declare interface SmartGridRowNodeTransaction { /** Row nodes that were added */ add: SmartGridRowNode[]; /** Row nodes that were removed */ remove: SmartGridRowNode[]; /** Row nodes that were updated */ update: SmartGridRowNode[]; } export declare interface SmartGridRowRenderer { firstRenderedRow: number; lastRenderedRow: number; setRenderedRange: (firstRow: number, lastRow: number) => void; } export declare interface SmartGridRowRenderProps { currentPageData: SmartGridRowData[]; onRowClick?: SmartGridRowClickHandler; selectable: boolean; expandable: boolean; leftPinnedOnly: boolean; rightPinnedOnly: boolean; virtualizedAllVisibleColumns: SmartGridColumnDefinition[]; bodyContainerRef: RefObject; allColumnsLastRow: SmartGridColumnDefinition[]; rowHeight: number; masterDetailEnabled: boolean; showInfiniteLoader: boolean; totalHeight: number; loadedData: Record; expandedGroups: Record; rowHeightMap: SmartGridRowHeightMap; isLoading?: boolean; shimmerRowCount?: number; virtualizedStartCololumnIndex: MutableRefObject; tableApi: SmartGridAPI | null; scrollContainerRef: RefObject; rowHeightCache: RowHeightCache | null; adjustTableHeightServerSide?: boolean; height: string | number; childRowsCount: number; } export declare interface SmartGridRowSelectionRefCurrent { isRowSelectable?: (params: SmartGridIsRowSelectableParams) => boolean; hideDisabledCheckboxes?: boolean; } export declare interface SmartGridRowSpanInfo { [key: string]: SmartGridRowInfo | boolean | undefined; isRowSpan?: boolean; Selection?: SmartGridRowInfo; } export declare interface SmartGridRowSpanInfoDetails { span?: number; isFirst?: boolean; isLast?: boolean; } export declare type SmartGridRowStyleParams = { api: SmartGridAPI; data: SmartGridRowData; pinned: boolean; node: { rowIndex: number; data: SmartGridRowData; api: SmartGridAPI; pinned: boolean; }; }; export declare interface SmartGridSafeCellRendererProps { renderer: React.ComponentType | ((params: SmartGridCellRendererParams) => JSX.Element); params: SmartGridCellRendererParams; } export declare type SmartGridSavedViewsOptions = { isActive: boolean; isDefaultView: boolean; viewName: string; viewType: "personal" | "global"; }; export declare interface SmartGridSaveViewCallbackRefCurrent { handleSetDefaultView?: ((view: SmartGridSavedViewsOptions) => void) | null; handleSavedViewClick?: ((view: SmartGridSavedViewsOptions) => void) | null; handleEditSaveView?: ((updatedData: SmartGridSavedViewsOptions, view: SmartGridSavedViewsOptions) => void) | null; handleSaveAndApply?: ((view: SmartGridSavedViewsOptions) => void) | null; handleDeleteViewClick?: ((view: SmartGridSavedViewsOptions) => void) | null; } export declare interface SmartGridSaveViewOptionsRefCurrent { maxSavedViews?: number | null; deleteViewPromptText?: string | null; } export declare interface SmartGridScrollHandler { (event: React.UIEvent): void; } export declare interface SmartGridScrollSyncParams { frozenScrollContainerRef?: RefObject; normalScrollContainerRef?: RefObject; rightPinnedScrollContainerRef?: RefObject; } export declare interface SmartGridScrollSyncReturn { headerScrollContainerRef: RefObject; pinnedTopScrollContainerRef: RefObject; pinnedBottomScrollContainerRef: RefObject; createHeaderScrollHandler: (bodyScrollRef: RefObject) => (e: React.UIEvent) => void; createPinnedTopScrollHandler: (bodyScrollRef: RefObject) => (e: React.UIEvent) => void; createPinnedBottomScrollHandler: (bodyScrollRef: RefObject) => (e: React.UIEvent) => void; createBodyScrollHandler: (bodyScrollRef: RefObject, handleColumnScroll: ((e: React.UIEvent) => void) | null) => (e: React.UIEvent) => void; createNormalScrollHandler: (handleColumnScroll: ((e: React.UIEvent) => void) | null) => (e: React.UIEvent) => void; handleFrozenScroll: (e: React.UIEvent) => void; handleRightPinnedScroll: (e: React.UIEvent) => void; syncHorizontalScroll: (scrollLeft: number, sourceElement: HTMLElement, bodyScrollRef?: RefObject | null) => void; } export declare interface SmartGridSearchConfig { placeholder?: string; debounceMs?: number; minChars?: number; } export declare type SmartGridSearchFunctionParams = SmartGridFilterModel[] | Record; export declare type SmartGridSearchFunctionParamsWithField = Record; export declare interface SmartGridSearchInputWithoutBorderProps { inputRef?: RefObject; onChange: (e: ChangeEvent) => void; type?: string; placeholder?: string; value?: string; } export declare interface SmartGridSearchOperatorOption { value: string; label: string; type?: string; } export declare interface SmartGridSearchParams { type: "searchChanged"; api: SmartGridAPI; searchModel: SmartGridSearchFunctionParams; } export declare interface SmartGridSearchWithSearchKey { _search: SmartGridSearchFunctionParamsWithField; } export declare interface SmartGridSelectDropdownPosition { top: number; left: number; width: number; } export declare interface SmartGridSelectedCell { colIndex: number; column: SmartGridColumnDefinition; data: SmartGridRowData; field: string; rowId: string | number; rowIndex: number; value: unknown; } export declare interface SmartGridSelectedCellState { rowIndex: number; colIndex: number; column: SmartGridColumnDefinition; cellValue: unknown; rowData: SmartGridRowData; target: HTMLElement; tableId: string; frozenColumnsLength: number; pinnedType?: SmartGridPinnedType; rowId: string | number; field: string; tableInstanceId?: string | undefined; rowAttr: string | null; } export declare interface SmartGridSelectOption { value: string | number; label: string; isDisabled?: boolean; } export declare type SmartGridSelectOptions = Dispatch> | SmartGridSelectOptionsCombinationFunc; export declare type SmartGridSelectOptionsCombination = SmartGridSelectOption | SmartGridSelectOption[] | null; export declare type SmartGridSelectOptionsCombinationFunc = (option: SmartGridSelectOptionsCombination) => void; export declare interface SmartGridSelectProps { label?: string; width?: string | number; selectedOptions: SmartGridSelectOptionsCombination; setSelectedOptions: SmartGridSelectOptions; isDisabled?: boolean; isOpen?: boolean; setIsOpen?: (isOpen: boolean) => void; initialOptions?: SmartGridSelectOption[]; withPortal?: boolean; className?: string; isMulti?: boolean; currentOptions?: SmartGridSelectOption[]; setCurrentOptions?: Dispatch>; onBlur?: () => void; isCellRenderer?: boolean; tableApi?: SmartGridAPI | null; lazyLoadCellRenderer?: boolean; isEnableResetButton?: boolean; isOnDemandOptions?: boolean; getDropdownOptions?: (params: SmartGridDropdownOptionsParams) => Promise; isDropdownValueLableSame?: boolean; dropdownOptionsParams?: SmartGridDropdownOptionsParams; } export declare interface SmartGridSendPayload { content: string; [key: string]: unknown; } export declare interface SmartGridServerProps { totalItems: number; totalPages: number; currentPage: number; isCountUnknown: boolean; enablePaginationWhenCountUnknown?: boolean; displayNextPageButton?: boolean; pageSize: number; } export declare interface SmartGridServerSideDataSource { getRows: (params: SmartGridServerSideGetRowsParams) => { abort?: () => void; } | void; } /** Server-side datasource interface */ declare interface SmartGridServerSideDatasource { infiniteCache: InfiniteCache | undefined; _originalParams: SmartGridServerSideDataSourceParams; _loadingBlocks: Record; _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; } export declare interface SmartGridServerSideGetRowsParams { request: { startRow: number; endRow: number; filterModel?: SmartGridFilterModel | SmartGridSearchWithSearchKey | null; sortModel?: SmartGridSortModel | null; }; api: SmartGridAPI; success: (response: SmartGridFetchDataResponse) => void; fail: () => void; } export declare interface SmartGridShimmerRowProps { columns?: SmartGridColumnDefinition[]; selectable?: boolean; expandable?: boolean; rowHeight?: number; isShimmering?: boolean; virtualizedAllVisibleColumns?: SmartGridColumnDefinition[]; isSingleSelect?: boolean; leftPinnedOnly?: boolean; disableSelectAllRecords?: boolean; } export declare type SmartGridSortDirection = "asc" | "desc" | "none"; export declare type SmartGridSortModel = SmartGridOldSortModel | SmartGridNewSortModel | null; export declare interface SmartGridSortParams { type: "sortChanged"; api: SmartGridAPI; sortModel: SmartGridSortModel[]; column: SmartGridColumnDefinition; } export declare interface SmartGridSortWithHeaderNameProps { isAutoHeightColumn?: boolean; sortState: SmartGridSortModel; onSort: (columnId: string, direction: string) => void; column: SmartGridColumnDefinition; isExpandable?: boolean; availableWidth: number; onToggle?: (field: string, isExpandable: boolean) => void; isExpandedGrouping: boolean; showSortIcon?: boolean; wrapHeaderText?: boolean; ShowFullText?: boolean; totalFinalHeight?: number | null; isIntegerType?: boolean; currentRowHeight?: { maxHeight: number; maxLineCount: number; } | null; innerHeaderComponent?: React.FC | null; customHeaderProps?: SmartGridHeaderStyleParams; } export 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; } export declare type SmartGridStringFilter = { column: string; pattern: string; search_type: string; operator?: string; }; export declare interface SmartGridSuggestion { items: (params: SmartGridSuggestionItemsParams) => Promise; 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 SmartGridSwitchProps { value: boolean; leftLabel?: string; rightLabel?: string; disabled?: boolean; onChange: (value: boolean) => void; } export declare interface SmartGridTableAPIObject { api: SmartGridAPI; columnApi: SmartGridColumnAPI; tableId?: string; } export declare interface SmartGridTableBodyContentProps { onRowClick?: SmartGridRowClickHandler; expandable?: boolean; paginateOriginalRowsOnly?: boolean; adjustTableHeightServerSide?: boolean; tableId?: string; alignedGrids?: string[]; headerHeight?: number | string; showHeader?: boolean; masterDetail?: boolean; height: number | string; normalScrollContainerRef: RefObject; ShowFullText?: boolean; enterPriseTableRef: RefObject; } export declare interface SmartGridTableBodyProps { onRowClick?: SmartGridRowClickHandler; selectable?: boolean; expandable?: boolean; leftPinnedOnly?: boolean; rightPinnedOnly?: boolean; adjustTableHeightServerSide?: boolean; masterDetailEnabled?: boolean; allColumnsLastRow?: SmartGridColumnDefinition[]; scrollContainerRef: RefObject; virtualizedAllVisibleColumns?: SmartGridColumnDefinition[]; isInfiniteLoadingMoreRef: MutableRefObject; shimmerRowCount?: number; virtualizedStartCololumnIndex: MutableRefObject; paginateOriginalRowsOnly?: boolean; height: string | number; } 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; onDeleteTopics?: () => void; selectedChat?: (string | number)[]; handleChatSelect?: (id: string | number) => void; isCreateNewChatOpen?: boolean; setIsCreateNewChatOpen?: Dispatch>; } 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>; className?: string; showDateSeparators?: boolean; autoScroll?: boolean; onThreadClick?: (messageId: string | number, chatId: string | number) => void; messageConfig: SmartGridMessageChatConfig & { loadMessages?: (chatId: string | number, page: number) => Promise; messagesClearedTrigger?: number; loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise; 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; }; export declare type SmartGridTableComponentProps = SmartGridTableProps; export declare interface SmartGridTableContentDetailsProps { frozenScrollContainerRef: RefObject; normalScrollContainerRef: RefObject; rightPinnedScrollContainerRef: RefObject; columnHorizontalScrollContainerRef: RefObject; headerRowRef: RefObject; headerHeight?: number | string; showHeader?: boolean; expandable?: boolean; selectable?: boolean; leftPinnedOnly?: boolean; rightPinnedOnly?: boolean; alignedGrids?: string[]; masterDetail?: boolean; onRowClick?: SmartGridRowClickHandler; adjustTableHeightServerSide?: boolean; paginateOriginalRowsOnly?: boolean; tableId?: string; height: number | string; ShowFullText?: boolean; isLeftPinnedRowsAvailable?: boolean; columnScrollHandlerRef?: MutableRefObject; isScrollingSynced?: MutableRefObject; commentProps?: SmartGridCommentProps; } export declare interface SmartGridTableContentProps { showHeader?: boolean; showFooter?: boolean; showToolbar?: boolean; showSaveTableConfig?: boolean; height: number | string; headerHeight?: number | string; pagination?: boolean; paginateOriginalRowsOnly?: boolean; tableHeader?: string | ReactNode; topRightOptions?: string | ReactNode; topCenterOptions?: string | ReactNode; topLeftOptions?: string | ReactNode; bottomLeftOptions?: string | ReactNode; bottomCenterOptions?: string | ReactNode; bottomRightOptions?: string | ReactNode; additionalButtons?: string | ReactNode; adjustTableHeightServerSide?: boolean; tableId?: string | null; alignedGrids?: string[]; masterDetail?: boolean; detailCellRenderer?: React.ComponentType | null; detailRowHeight?: number; downloadAsExcel?: boolean; downloadAsCSV?: boolean; copyToClipboard?: boolean; hidePaginationPageSizeSelector?: boolean; paginationPageSizeSelector?: number[]; aboveTableComponent?: ReactNode; shouldRenderTable?: boolean; nestedTable?: boolean; nestedTableComponent?: ReactNode | null; enableNestedTableCloseButton?: boolean; onCloseNestedTable?: () => void; showTableSettingActionTab?: boolean; showTableSettingFormatTab?: boolean; hideNotification?: boolean; expandable?: boolean; onRowClick?: SmartGridRowClickHandler; ShowFullText?: boolean; detailRendererTable?: boolean; showFilters?: boolean; onCellClick?: () => void; onPageChange?: (page: number) => void; onSortChange?: (sortModel: unknown) => void; onFilterChange?: (filterModel: unknown) => void; totalItems?: number; totalPages?: number; currentPage?: number; isCountUnknown?: boolean; onScroll?: (event: React.UIEvent) => void; defaultColDef?: Record; copyToClipboardHandler?: () => void; downloadExcelHandler?: (e: SmartGridExportEvent) => void; downloadCSVHandler?: (e: SmartGridExportEvent) => void; pivotConfig?: SmartGridPivotConfig; isChatEnabled?: boolean; isCommentFeatureEnabled?: boolean; isChatOpen?: boolean; handleChatClick?: () => void; handleChatClose?: () => void; chatConfiguration?: SmartGridChatConfiguration; ChatComponent?: (props: SmartGridTableChatWrapper) => JSX.Element; CommentComponent?: FC; commentProps?: SmartGridCommentProps; tableActions?: string | ReactNode; } export declare interface SmartGridTableContentRendererProps { headerRows: SmartGridColumnDefinition[][]; visibleColumns: SmartGridColumnDefinition[]; leftPinnedOnly: boolean; rightPinnedOnly: boolean; columnHorizontalScrollContainerRef: RefObject; pinnedType: SmartGridPinType; globalColumnCounts: SmartGridGlobalColumnCounts; virtualizedStartCololumnIndex: MutableRefObject; mainContainerClassName: string; mainContainerStyles: CSSProperties; tableId?: string; showHeader?: boolean; headerHeight?: number | string; headerScrollContainerRef: RefObject; handleHeaderScroll: SmartGridScrollHandler; headerRowRef: RefObject; totalNormalColumnWidth: number | string; selectable: boolean; filteredColumns: SmartGridColumnDefinition[]; ShowFullText?: boolean; expandable: boolean; onRowClick?: SmartGridRowClickHandler; pinnedTopScrollContainerRef: RefObject; frozenColumnWidth: number; isLeftPinnedRowsAvailable?: boolean; handlePinnedTopScroll: SmartGridScrollHandler; handleRightPinnedScroll: SmartGridScrollHandler; handleFrozenScroll: SmartGridScrollHandler; createBodyScrollHandler: (columnHorizontalScrollContainerRef: RefObject, handleColumnScroll: ((e: React.UIEvent) => void) | null) => (e: React.UIEvent) => void; containerStyles: CSSProperties; bodyContainerClassName: string; bodyScrollContainer: RefObject; height: number | string; handleHorizontalNormalScroll: SmartGridScrollHandler; paginateOriginalRowsOnly?: boolean; adjustTableHeightServerSide?: boolean; masterDetail?: boolean; pinnedBottomScrollContainerRef: RefObject; handlePinnedBottomScroll: SmartGridScrollHandler; isInfiniteLoadingMoreRef: MutableRefObject; } export declare interface SmartGridTableContextRef { state?: SmartGridStateContext; tableApi?: SmartGridAPI; } declare interface SmartGridTableContextValue { state: SmartGridStateContext; tableApi: SmartGridAPI | null; dispatch: SmartGridDispatch; ACTION_TYPES: typeof ACTION_TYPES; toggleGroupExpansion: (rowId: string | number, rowIndex: number) => void; dispatchEvent: (eventType: string, eventData: Record) => void; getRowStyle?: (params: SmartGridRowStyleParams) => CSSProperties; } export declare interface SmartGridTableFooterProps { bottomCenterOptions?: ReactNode; bottomLeftOptions?: ReactNode; bottomRightOptions?: ReactNode; pagination?: boolean; hidePaginationPageSizeSelector?: boolean; paginationPageSizeSelector?: number[]; } export declare interface SmartGridTableHeaderProps { selectable?: boolean; leftPinnedOnly?: boolean; rightPinnedOnly?: boolean; virtualizedHeaderRows?: SmartGridColumnDefinition[][]; filteredColumns: SmartGridColumnDefinition[]; headerRows: SmartGridColumnDefinition[][]; virtualizedColumns: SmartGridColumnDefinition[]; virtualizedStartCololumnIndex: MutableRefObject; ShowFullText?: boolean; } export declare interface SmartGridTableInstance { current: HTMLElement | null; } export 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[]; } export declare interface SmartGridTableProps extends SmartGridSaveViewCallbackRefCurrent { ref?: Ref; data?: SmartGridRowData[] | null; columns: SmartGridColumnDefinition[]; uniqueIdField?: string; height?: number | string; childKeyField?: string; defaultColDef?: SmartGridDefaultColDef; pinnedTopRowData?: SmartGridRowData[] | null; pinnedBottomRowData?: SmartGridRowData[] | null; getRowStyle?: (params: SmartGridRowStyleParams) => CSSProperties; tableHeader?: string | ReactNode; topRightOptions?: string | ReactNode; topCenterOptions?: string | ReactNode; bottomLeftOptions?: string | ReactNode; bottomCenterOptions?: string | ReactNode; bottomRightOptions?: string | ReactNode; topLeftOptions?: string | ReactNode; headerHeight?: number | string; onSelectionChanged?: (event: SmartGridOnSelectionChangedParams) => void; onRowDragStart?: (event: SmartGridRowDragStartParams) => void; onRowDragEnd?: (event: SmartGridRowDragEndParams) => void; onCellValueChanged?: (params: SmartGridCellValueChangedParams) => void; onGridReady?: (params: SmartGridOnReadyParams) => void; onRowGroupOpened?: (params: SmartGridRowGrouOpenParams) => void; fetchData?: (manualbody: any, page: any, context: any, pageNo: any, other: any) => Promise; apiUrl?: string; autoFetch?: boolean; cacheConfig?: { threshold?: number; maxBlocksInCache?: number; cacheOverflowSize?: number; rowHeight?: number; purgeStrategy?: string; enablePersistence?: boolean; persistenceStorageKey?: string; persistenceOptions?: any; force?: boolean; }; onScroll?: (event: any) => void; showSaveTableConfig?: boolean; loadTableInstance?: (instance: SmartGridTableRef) => void; adjustTableHeightServerSide?: boolean; largeDatasetOptions?: { enableIndexedDBCache?: boolean; enableStreamingLoad?: boolean; enableEnhancedWorker?: boolean; binaryFormat?: boolean; extremelyLargeDatasetThreshold?: number; }; gridOptions?: any; tableId?: string; alignedGrids?: any[]; masterDetail?: boolean; detailCellRenderer?: any; detailRowHeight?: number; infiniteScroll?: boolean; customTabFunction?: any; getRowData?: (params: SmartGridGetRowDataParams, columnName: string) => any; rowDragManaged?: boolean; hidePaginationPageSizeSelector?: boolean; purgeClosedRowNodes?: boolean; detailRendererTable?: boolean; smartGridMenuOptions?: { withColumMenu?: boolean; autoWithColumMenu?: boolean; freezeColumnMenu?: boolean; sortColumnMenu?: boolean; collapseColumnAll?: boolean; expandColumnAll?: boolean; wrapText?: boolean; [key: string]: any; }; paginateOriginalRowsOnly?: boolean; isSaveViewEnabled?: boolean; isSavingViewLoading?: boolean; maxSavedViews?: number; deleteViewPromptText?: string; savedViewsOptions?: any[]; rowHeight?: string; additionalButtons?: string | ReactNode; aboveTableComponent?: string | ReactNode; shouldRenderTable?: boolean; nestedTable?: boolean; nestedTableComponent?: ReactNode | null; enableNestedTableCloseButton?: boolean; downloadAsExcel?: boolean; downloadAsCSV?: boolean; copyToClipboard?: boolean; onCloseNestedTable?: () => void; downloadExcelHandler?: (e: SmartGridExportEvent) => void; downloadCSVHandler?: (e: SmartGridExportEvent) => void; copyToClipboardHandler?: () => void; ShowFullText?: boolean; hideNotification?: boolean; isSingleSelect?: boolean; defaultPageSize?: number; paginationPageSize?: number[]; enableRowSpan?: boolean; rowSpanColumn?: string | string[] | null; showHeader?: boolean; showFooter?: boolean; showToolbar?: boolean; selectable?: boolean; defaultSort?: SmartGridSortModel; tableActions?: string | ReactNode; pagination?: boolean; showTableSettingActionTab?: boolean; showTableSettingFormatTab?: boolean; showFilters?: boolean; expandable?: boolean; onCellClicked?: () => void; onCellClick?: () => void; onRowClicked?: () => void; onRowClick?: () => void; disableSelectAllRecords?: boolean; columnBufferSize?: number; lazyLoadCellRenderer?: boolean; hasSplitRenderer?: boolean; splitRendererKeys?: string[]; removeSelectionOnOperation?: boolean; removeCheckConfigurationOnOperation?: boolean; pivotConfig?: SmartGridPivotConfig; /** * Controls whether the table should show loading state. * When `false` and data is null/empty, the table will show "No data available" instead of shimmer/loading. * When `true` or undefined (default), normal loading behavior applies. */ loadingData?: boolean; isChatEnabled?: boolean; isChatOpen?: boolean; handleChatClick?: () => void; handleChatClose?: () => void; chatConfiguration?: SmartGridChatConfiguration; isCommentFeatureEnabled?: boolean; ChatComponent?: (props: SmartGridTableChatWrapper) => JSX.Element; CommentComponent?: FC; commentProps?: SmartGridCommentProps; onContentDensityChange?: ((contentDensity: SmartGridRowHeightType) => void) | null; noHeaderSelection?: boolean; treeData?: boolean; virtualizationConfig?: SmartGridVirConfig; rowSelection?: SmartGridRowSelectionRefCurrent; disableCurrentPageRecords?: boolean; onSortChanged?: (params: SmartGridSortParams) => void; onFilterChanged?: (params: SmartGridSearchParams) => void; cardContainer?: boolean; skipDefaultFilter?: boolean; skipDefaultSort?: boolean; processCellForClipboard?: (params: SmartGridProcessCellForClipboardParams) => string; defaultFontSize?: SmartGridFontSize; numericFormatDefault?: SmartGridNumberFormat; } export declare interface SmartGridTableRef { api: SmartGridAPI; columnApi: SmartGridColumnAPI; } /** * 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) => boolean; on: (event: string, handler: () => void) => void; off: (event: string, handler: () => void) => void; state: Record; }; export declare type SmartGridToastVariant = "info" | "success" | "warning" | "error"; export declare interface SmartGridToggleRenderProps { render: (state: SmartGridToggleRenderState) => ReactNode; } export declare interface SmartGridToggleRenderState { isOpen: boolean; setIsOpen: (isOpen: boolean) => void; toggleMenu: () => void; } export declare interface SmartGridToolbarItem { icon: React.FC>; 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; export declare interface SmartGridTooltipButton { label: string; type: "default" | "primary" | "secondary"; onClick?: () => void; } export declare interface SmartGridTooltipConfig { description?: string; title: string; targetRef: RefObject; varient?: SmartGridTooltipVariant; orientation?: SmartGridTooltipOrientation; illustration?: string; icon?: ReactNode | null; bodyText?: string; btns?: SmartGridTooltipButton[] | null; showPaginationAbove?: boolean | null; pagination?: boolean | null; justifyBodyContent?: string | null; } export declare type SmartGridTooltipGetterParams = { api: SmartGridAPI; colDef: SmartGridColumnDefinition; column: SmartGridColumnDefinition; data: SmartGridRowData; location: string; node: { data: SmartGridRowData; id: string; level: number; parent: SmartGridUpdateData; rowIndex: number; }; rowIndex: number; value: unknown; }; export declare interface SmartGridTooltipManagerInstance { tooltipElement: HTMLDivElement | null; currentConfig: SmartGridTooltipConfig | null; hideTimeout: ReturnType | null; initialize: () => void; show: (config: SmartGridTooltipConfig) => void; hide: () => void; updateContent: (config: SmartGridTooltipConfig) => void; getPaginationHTML: (varient?: SmartGridTooltipVariant) => string; calculatePosition: (config: SmartGridTooltipConfig) => void; cleanup: () => void; } export declare type SmartGridTooltipOrientation = "top" | "bottom" | "left" | "right"; export declare interface SmartGridTooltipProps extends SmartGridTooltipConfig { children: ReactNode; forceShowTooltip?: boolean; className?: string; description?: string; } export declare type SmartGridTooltipVariant = "primary" | "secondary" | "tertiary" | "feature"; export declare type SmartGridUpdateData = { data: SmartGridRowData; setData: (data: SmartGridRowData) => void; setDataValue: (field: string, value: unknown, callbackNeeded?: boolean) => void; }; export declare type SmartGridUpdateDataReturnType = { success: boolean; totalRows: number; blocksUpdated: number; errors: string[]; }; /** Page size ref for server-side */ declare interface SmartGridUpdatedPageSizeRef { current: number; } export declare interface SmartGridUpdateRefParams extends SmartGridCallbackRefCurrent, SmartGridSaveViewCallbackRefCurrent, SmartGridClickCallbackRefCurrent { downloadExcelHandler?: (e: SmartGridExportEvent) => void; downloadCSVHandler?: (e: SmartGridExportEvent) => void; copyToClipboardHandler?: () => void; maxSavedViews?: number; deleteViewPromptText?: string; onSelectionChanged?: (event: SmartGridOnSelectionChangedParams) => void; onRowDragStart?: (event: SmartGridRowDragStartParams) => void; onRowDragEnd?: (event: SmartGridRowDragEndParams) => void; onRowClicked?: (event: unknown) => void; onCellValueChanged?: (event: SmartGridCellValueChangedParams) => void; onRowGroupOpened?: (event: SmartGridRowGrouOpenParams) => void; customTabFunction?: (e: KeyboardEvent, column: SmartGridColumnDefinition, context: { api: SmartGridAPI | null; }) => void; handlePageChange?: (page: number) => void; handleSortChange?: (sortModel: SmartGridSortModel) => void; handleFilterChange?: (filterModel: SmartGridFilterModel) => void; handleSearch?: (searchValue: SmartGridSearchFunctionParams) => void; rowSelection?: SmartGridRowSelectionRefCurrent; processCellForClipboard?: (params: SmartGridProcessCellForClipboardParams) => string; } export declare interface SmartGridUpdateRefReturn { callBackRef: MutableRefObject; exportCallbackRef: MutableRefObject; saveViewCallbackRef: MutableRefObject; saveViewOptionsRef: MutableRefObject; clickCallbackRef: MutableRefObject; rowSelectionRef: MutableRefObject; } export declare type SmartGridValueFormatterConfig = { type?: string; symbol?: string; position?: "prefix" | "suffix"; decimals?: number; }; export declare interface SmartGridValueFormatterParams { value: unknown; data: SmartGridRowData; colDef: SmartGridColumnDefinition; } export declare interface SmartGridValueGetterParams { data: SmartGridRowData; node: { data: SmartGridRowData; }; colDef: SmartGridColumnDefinition; column: SmartGridColumnDefinition; api: SmartGridAPI | null; columnApi?: SmartGridColumnAPI; getValue: (field: string) => unknown; } /** Viewport range */ declare interface SmartGridViewportRange { startRow: number; endRow: number; } export declare type SmartGridVirConfig = { threshold: number; }; export declare interface SmartGridVirtualizationParams { dataLength: number; threshold?: number; rowHeight: number; bufferSize?: number; containerRef: RefObject; scrollContainerRef?: RefObject | null; currentPageData: SmartGridRowData[]; rowHeightCache?: RowHeightCache | null; uniqueIdField?: string; tableApi?: SmartGridAPI | null; } export declare interface SmartGridVirtualizationReturn { updatedData: SmartGridRowData[]; useVirtualization: boolean; visibleRange: SmartGridVisibleRangeShort; } export declare interface SmartGridVisibleColumnRange { startCol: number; endCol: number; } export declare interface SmartGridVisibleRange { startRow: number; endRow: number; } export declare interface SmartGridVisibleRangeShort { start: number; end: number; } export declare interface SmartGridWindowTableState { _targetPage?: number; _forceReload?: boolean; [key: string]: unknown; } export declare interface SmartGridWrappedDataSource { _originalDatasource: SmartGridServerSideDataSource; _loadingBlocks: Record; _pendingRequests: Record void; }>; _isDestroyed: boolean; _pendingRAFs?: number[]; infiniteCache: unknown; updateCacheReference: (newCache: unknown) => void; destroy: () => void; getRows: (params: SmartGridInternalGetRowsParams) => void; } export declare type UpdateParentDataParams = { parentData: SmartGridRowData; newData: Partial; dispatch: SmartGridDispatch; ACTION_TYPES: Record; uniqueIdField: string; api?: SmartGridAPI; }; export { }