ia-table 0.14.8 → 0.15.1

package/dist/index.d.ts

@@ -2,6 +2,8 @@ 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';
@@ -101,6 +103,10 @@ declare const ACTION_TYPES: {
     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";
 };
 
 declare interface ChildHeightsResult {
@@ -452,6 +458,10 @@ declare class InfiniteCache {
     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;
@@ -502,6 +512,14 @@ export declare interface RowSpanParams {
 
 export declare type SmartGridActionTypes = typeof ACTION_TYPES;
 
+export declare interface SmartGridAddChatContainerProps {
+    setShowAddChat: Dispatch<SetStateAction<boolean>>;
+    handleChatName: NonNullable<SmartGridLeftPanelConfig["handleChatName"]>;
+    selectedChannelInfo?: SmartGridChannel | null;
+    handleToast: SmartGridHandleToastFn;
+    setIsCreateNewChatOpen: Dispatch<SetStateAction<boolean>>;
+}
+
 export declare type SmartGridAggregationType = "sum" | "count" | "avg" | "min" | "max";
 
 export declare interface SmartGridAPI extends SmartGridPaginationAPI, SmartGridApiExtra {
@@ -603,6 +621,20 @@ 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 {
@@ -856,6 +888,7 @@ export declare interface SmartGridBodyCellDetailProps {
     totalRows?: number;
     totalColumns?: number;
     childKeyField: string;
+    isCommentFeatureEnabled: boolean;
 }
 
 export declare interface SmartGridBodyCellProps {
@@ -886,8 +919,8 @@ export declare interface SmartGridBodyCellProps {
 }
 
 export declare interface SmartGridButtonProps {
-    onClick: (e: MouseEvent_2<HTMLButtonElement>) => void;
-    children: ReactNode;
+    onClick?: (e: MouseEvent_2<HTMLButtonElement>) => void;
+    children?: ReactNode;
     variant?: SmartGridButtonVariant;
     size?: SmartGridButtonSize;
     iconButton?: boolean;
@@ -897,6 +930,9 @@ export declare interface SmartGridButtonProps {
     rightIcon?: ReactNode;
     buttonRef?: MutableRefObject<HTMLButtonElement> | RefObject<HTMLButtonElement>;
     simpleButton?: boolean;
+    ariaLabel?: string;
+    loading?: boolean;
+    title?: string;
 }
 
 export declare type SmartGridButtonSize = "small" | "medium" | "large";
@@ -1079,7 +1115,7 @@ export declare type SmartGridCellRenderer = {
     colDef: SmartGridColumnDefinition;
     node: SmartGridCellRendererNode;
     api: SmartGridAPI;
-    eGridCell: HTMLDivElement | null;
+    eGridCell: RefObject<HTMLDivElement | null>;
     wholeData: SmartGridRowData[] | null | undefined;
     actions: Record<string, unknown>;
     setDataValue: (colId: string, newValue: unknown) => void;
@@ -1138,6 +1174,7 @@ export declare type SmartGridCellRendererParams = {
     rightLabel?: string;
     splits?: SmartGridColumnDefinition[];
     isEnableResetButton?: boolean;
+    placeholder?: string;
 } & Record<string, unknown>;
 
 export declare interface SmartGridCellRendererRendererProps {
@@ -1175,14 +1212,412 @@ export declare interface SmartGridCellValueChangedParams {
     value: unknown;
 }
 
+export declare interface SmartGridChannel {
+    id: string | number;
+    title: string;
+    time: string;
+    unreadCount: number;
+    objectType: string;
+}
+
+/**
+ * ChatObject - Represents a chat/topic
+ * @see MDX Documentation: Data Structures > ChatObject
+ */
+export declare interface SmartGridChat {
+    id: string;
+    title: string;
+    subtitle: string;
+    user: string;
+    text: string;
+    time: string;
+    isChecked: boolean;
+    isPinned: boolean;
+    unreadCount: number;
+    messageCount: number;
+    timestamp: string;
+    createdBy?: string;
+    otherProps: {
+        object_ids: string[];
+        object_type: string;
+        topic_id: string;
+        created_by_user: string;
+        is_pinned: boolean;
+        unread_count: number;
+        message_count: number;
+        created_at: string;
+    };
+}
+
+export declare interface SmartGridChatAvatarProps {
+    src?: string;
+    name?: string;
+    size?: SmartGridAvatarSize;
+}
+
+export declare interface SmartGridChatChannelItemAvatar {
+    label?: string;
+    src?: string;
+}
+
+export declare interface SmartGridChatChannelItemProps {
+    id: string | number;
+    title?: string;
+    subtitle?: string;
+    timestamp?: string;
+    unreadCount?: number;
+    avatar?: SmartGridChatChannelItemAvatar;
+    isSelected?: boolean;
+    isMuted?: boolean;
+    onClick?: (id: string | number) => void;
+    showChannelList?: boolean;
+    showCheckbox?: boolean;
+    handleChatSelect?: (id: string | number) => void;
+    selectedChat?: (string | number)[];
+    onPinnedChatClick?: (chatId: string | number, isPinned: boolean) => Promise<boolean>;
+    handleToast?: SmartGridHandleToastFn;
+    isPinned?: boolean;
+}
+
+export declare interface SmartGridChatChannelListProps {
+    channels: SmartGridChatChannelItemProps[];
+    selectedChannelOrChatId?: string | number;
+    onChannelSelect: (channelId: string | number, channel: SmartGridChatChannelItemProps) => void;
+    showChannelList?: boolean;
+    showCheckbox?: boolean;
+    handleChatSelect?: (id: string | number) => void;
+    selectedChat?: (string | number)[];
+    onPinnedChatClick?: (chatId: string | number, isPinned: boolean) => Promise<boolean>;
+    handleToast?: SmartGridHandleToastFn;
+}
+
+export declare interface SmartGridChatConfiguration {
+    title: string;
+    description: string;
+    buttonLabel: string;
+    buttonIcon: string;
+    buttonIconPosition: "left" | "right";
+    tooltipConfig: SmartGridChatTooltipConfig;
+    messageChatConfig: SmartGridMessageChatConfig;
+    headerChatConfig: SmartGridHeaderChatConfig;
+    inputChatConfig: SmartGridInputChatConfig;
+    leftPanel: SmartGridLeftPanelConfig;
+    rightPanel: SmartGridRightPanelConfig;
+}
+
+export declare interface SmartGridChatDefaultMessageTypeProps {
+    content?: string | React.ReactNode;
+    timestamp?: string;
+    handleClickOnMoreOptions?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    priority?: SmartGridMessagePriority;
+    edited?: boolean;
+    onThreadClick?: () => void;
+    pinned?: boolean;
+    visibility?: boolean;
+    onPin?: (isPinned: boolean) => Promise<SmartGridChatMessage | boolean | undefined>;
+    isUser?: boolean;
+    isThreadIconVisible?: boolean;
+    isPinChatIconvisible?: boolean;
+    isHighlighted?: boolean;
+    highlightColor?: string | null;
+}
+
+export declare interface SmartGridChatDeletedMessageTypeProps {
+    timestamp?: string;
+    isUser?: boolean;
+}
+
+export declare interface SmartGridChatEditedMessageTypeProps {
+    content?: string | React.ReactNode;
+    timestamp?: string;
+    handleClickOnMoreOptions?: (e: React.MouseEvent<SVGSVGElement>) => void;
+    priority?: SmartGridMessagePriority;
+    edited?: boolean;
+    onThreadClick?: () => void;
+    pinned?: boolean;
+    onPin?: (isPinned: boolean) => Promise<boolean | undefined>;
+    isUser?: boolean;
+}
+
+export declare interface SmartGridChatFormData {
+    chatName?: string;
+    chatDescription?: string;
+    [key: string]: unknown;
+}
+
+export declare interface SmartGridChatHeaderActionExternalHandlers {
+    onSearchChange?: (value: string) => void;
+    onSelectAll?: (allValues: (string | number)[]) => void;
+    onClearSelection?: () => void;
+    onSelectionChange?: (newSelection: (string | number)[]) => void;
+    onParticipantsClick?: () => Promise<void>;
+    loadMenuOptions?: () => Promise<SmartGridParticipant[]>;
+    menuOptions?: SmartGridParticipant[];
+    onClose?: () => void;
+    onParticipantAdd?: (participantIds: (string | number)[], selectedRadioOption: string, chatId: string | number) => Promise<{
+        success: boolean;
+        participant: SmartGridParticipant;
+    } | null>;
+    onNotificationSettingChange?: (data: SmartGridNotificationSettings) => Promise<void | {
+        success: boolean;
+        settings: SmartGridNotificationSettings;
+    }>;
+    onSearchMessage?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    participantsList?: SmartGridParticipant[];
+    loadParticipantsAvatar?: (radioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+    handleRadioButtonChange?: (value: string) => Promise<void>;
+}
+
+export declare interface SmartGridChatHeaderActionProps {
+    enableSearch?: boolean;
+    messageSearchValue?: string;
+    handleOpenMessageSearch?: () => void;
+    handleCloseMessageSearch?: () => void;
+    handleMessageSearchChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    onParticipantsClick?: (e: React.MouseEvent<HTMLButtonElement>) => Promise<void>;
+    participants?: SmartGridParticipant[];
+    onPinnedClick?: () => void;
+    threeDotMenuOptions?: SmartGridThreeDotMenuOption[];
+    showNotificationSettings?: boolean;
+    handleNotificationSettingsClose?: () => void;
+    onThreeDotMenuClick?: () => void;
+    externalHandlers?: SmartGridChatHeaderActionExternalHandlers;
+    isLoadingOptions?: boolean;
+    isSearching?: boolean;
+    filteredMenuOptions?: SmartGridParticipant[];
+    menuSearchQuery?: string;
+    setMenuSearchQuery?: (query: string) => void;
+    renderCustomHeader?: (headerProps: Record<string, unknown>) => React.ReactNode;
+    threeDotMenuOpen?: boolean;
+    onSaveNotification?: (data: SmartGridNotificationSettings) => void;
+    selectedMenuItems?: (string | number)[];
+    setSelectedMenuItems?: React.Dispatch<React.SetStateAction<(string | number)[]>>;
+    handleThreeDotMenuClose?: () => void;
+    notificationSettings?: SmartGridNotificationSettings;
+    maxAvatars?: number;
+    selectedRadioOption?: string;
+    chatId?: string | number;
+    menuOptions?: SmartGridParticipant[];
+    externalSavingMembers?: boolean;
+    showSearch?: boolean;
+    showPinned?: boolean;
+    showParticipants?: boolean;
+    showThreeDotMenu?: boolean;
+    className?: string;
+    searchPlaceholder?: string;
+    isAddParticipantsAllowed?: boolean;
+    isLoadingParticipants?: boolean;
+    loadingError?: string | null;
+}
+
+export declare interface SmartGridChatHeaderInfoProps {
+    title?: string;
+    createdBy?: string;
+    createdAt?: string;
+    chatId?: string | number;
+}
+
+export declare interface SmartGridChatHeaderNavigationProps {
+    title?: string;
+    onBack?: () => void;
+    onSearchClick?: () => void;
+    onMenuClick?: () => void;
+    onMoreClick?: () => void;
+    showChannelList?: boolean;
+    isSearchOpen?: boolean;
+    showAddChatBtn?: boolean;
+    showSearchChat?: boolean;
+    setShowPinnedMsg?: (value: boolean) => void;
+    onThreadClick?: (messageId?: string | number, payload?: SmartGridChatMessage) => void;
+    headerConfig?: SmartGridLeftHeaderPanel;
+    handleChatName?: SmartGridLeftPanelConfig["handleChatName"];
+    filterChannelsByTitle?: (value: string) => void;
+    selectedChat?: (string | number)[];
+    selectedChannelInfo?: SmartGridChannel | null;
+    handleToast?: (isOpen: boolean, message?: string, variant?: SmartGridToastVariant) => void;
+    onDeleteTopics?: () => void;
+    isCreateNewChatOpen?: boolean;
+    setIsCreateNewChatOpen?: Dispatch<SetStateAction<boolean>>;
+}
+
+export declare interface SmartGridChatHeaderProps {
+    title: string;
+    chatId: string | number;
+    participants?: SmartGridParticipant[];
+    className?: string;
+    participantsList?: SmartGridParticipant[];
+    onSaveNotification?: (data: SmartGridNotificationSettings) => void;
+    createdBy?: string;
+    createdAt?: string;
+    chatHeaderConfig: Partial<SmartGridHeaderChatConfig> & {
+        onSearchMessage?: (searchValue: string, chatId: string | number) => Promise<SmartGridChatMessage[] | void>;
+        onSearchClear?: () => void;
+        externalSavingMembers?: boolean;
+    };
+}
+
+export declare interface SmartGridChatInputProps {
+    placeholder: string;
+    value: string;
+    onChange: (value: string) => void;
+    onSend: (payload: SmartGridChatInputSendPayload) => Promise<void>;
+    onAttach?: (file: File) => void;
+    onImageUpload?: (image: File) => void;
+    onEmojiClick?: (emoji: string) => void;
+    showFormatting?: boolean;
+    showQuickAction?: boolean;
+    quickActionLabel?: string;
+    disabled?: boolean;
+    maxLength?: number;
+    className?: string;
+    messageConfig: SmartGridMessageChatConfig & {
+        loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+        messageConfig?: SmartGridMessageConfig;
+    };
+    isEditMode?: boolean;
+    editingMessage?: SmartGridChatMessage | null;
+    onCancelEdit?: () => void;
+    chatId: string | number;
+}
+
+export declare interface SmartGridChatInputSendPayload {
+    content: string;
+    selectedPriority?: string;
+    taggedUsers?: (string | number)[];
+    [key: string]: unknown;
+}
+
+/**
+ * MessageObject - Represents a chat message
+ * @see MDX Documentation: Data Structures > MessageObject
+ */
+export declare interface SmartGridChatMessage {
+    id: string | number;
+    author?: "user" | "assistant" | "system" | string;
+    authorName?: string;
+    authorAvatar?: string;
+    content?: string;
+    timestamp?: string;
+    date?: string;
+    priority?: "low" | "medium" | "high" | "default" | "normal" | string;
+    isPinned?: boolean;
+    deleted?: boolean;
+    edited?: boolean;
+    showActions?: boolean;
+    showReplyBadge?: boolean;
+    replyText?: string | null;
+    text?: string;
+    time?: string;
+    user?: string;
+    userInitials?: string;
+    quote?: string;
+    type?: "default" | "deleted" | "edited" | string;
+    senderId?: string | number;
+    created_at?: string;
+    isRealTime?: boolean;
+    otherProps?: {
+        sender_id?: number | string;
+        created_at?: string;
+        updated_at?: string;
+        isRealTime?: boolean;
+        topic_id?: string;
+        sender_name?: string;
+        object_ids?: (string | number)[];
+        object_type?: string;
+        deleted?: boolean;
+        [key: string]: unknown;
+    };
+}
+
+export declare interface SmartGridChatMessageActionsProps {
+    messageId?: string | number;
+    onReply?: (messageId: string | number) => void;
+    onReact?: (messageId: string | number) => void;
+    onBookmark?: (messageId: string | number) => void;
+    onPin?: (messageId: string | number) => void;
+    onMore?: (messageId: string | number) => void;
+    actions?: SmartGridMessageActionKey[];
+    className?: string;
+}
+
+export declare interface SmartGridChatMessageAvatarProps {
+    authorName?: string;
+    authorAvatar?: string;
+}
+
+export declare interface SmartGridChatMessageProps {
+    messageId?: string | number;
+    author?: string;
+    authorName?: string;
+    authorAvatar?: string;
+    content?: string | React.ReactNode;
+    timestamp?: string;
+    isUser?: boolean;
+    showActions?: boolean;
+    showAvatar?: boolean;
+    isDeleted?: boolean;
+    edited?: boolean;
+    deleted?: boolean;
+    onReply?: () => void;
+    onReact?: () => void;
+    onBookmark?: () => void;
+    onPin?: (isPinned: boolean) => Promise<SmartGridChatMessage | boolean | undefined>;
+    pinned?: boolean;
+    onMore?: () => void;
+    onEdit?: () => void;
+    onMessageDelete?: (messageId: string | number) => Promise<SmartGridChatMessage | {
+        success: boolean;
+        messageId: string | number;
+    } | undefined>;
+    onRefetchMessages?: () => Promise<SmartGridChatMessage[]>;
+    type?: SmartGridChatMessageType;
+    priority?: SmartGridMessagePriority;
+    actions?: SmartGridMessageActionKey[];
+    className?: string;
+    onThreadClick?: () => void;
+    isThreadIconVisible?: boolean;
+    isPinChatIconvisible?: boolean;
+    isHighlighted?: boolean;
+    highlightColor?: string | null;
+}
+
+export declare type SmartGridChatMessageType = "default" | "deleted" | "editable";
+
+export declare interface SmartGridChatNotificationSettingsProps {
+    isOpen?: boolean;
+    onClose?: () => void;
+    isLoading?: boolean;
+    position?: {
+        top: number;
+        right: number;
+    };
+    onSaveNotification?: (data: SmartGridNotificationSettings) => void;
+    notificationSettings?: SmartGridNotificationSettings;
+}
+
+export declare interface SmartGridChatRadioOption {
+    label: string;
+    value: string;
+}
+
+export declare interface SmartGridChatTooltipConfig {
+    title: string;
+    description: string;
+}
+
 export declare interface SmartGridCheckboxProps {
     checked?: boolean;
-    onChange: (checked: boolean) => void;
-    label?: string;
+    onChange: (e: ChangeEvent<HTMLInputElement>) => 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;
@@ -1200,6 +1635,10 @@ export declare interface SmartGridCheckConfiguration {
     unCheckAll?: boolean;
 }
 
+export declare type SmartGridClickCallbackRefCurrent = {
+    onCellClick?: ((params: any) => void) | null;
+};
+
 /** Client-side datasource interface */
 declare interface SmartGridClientSideDatasource {
     getRows: (params: SmartGridGetRowsRequestParams) => void;
@@ -1266,6 +1705,209 @@ export declare interface SmartGridColumnWithGroupId extends SmartGridBaseColumnD
     groupId: string;
 }
 
+/**
+ * SmartGridComment - Represents a single comment in a thread
+ */
+export declare interface SmartGridComment {
+    id: string | number;
+    text: string;
+    author: string;
+    timestamp: string;
+    isEdited?: boolean;
+    read?: boolean;
+    isRead?: boolean;
+}
+
+/**
+ * SmartGridCommentConfiguration - Configuration options for comment features
+ */
+export declare interface SmartGridCommentConfiguration {
+    disableMarkAsRead?: boolean;
+    disableMarkAsResolved?: boolean;
+    disableDeleteThread?: boolean;
+    disableEditComment?: boolean;
+    disableDeleteComment?: boolean;
+    disableMultiCommentThread?: boolean;
+    messageIdHighlightTimer?: number;
+}
+
+/**
+ * SmartGridCommentContextRef - Context reference for comment functionality
+ * Used by smartGridContextRef in CommentWrapper
+ */
+export declare interface SmartGridCommentContextRef {
+    comments: SmartGridCommentThread;
+    popup: SmartGridCommentPopup | null;
+    handleCommentIconHover: (params: SmartGridCellRenderer) => void;
+    handleMouseEnter: () => void;
+    handleMouseLeave: () => void;
+    resolvedComments: string[];
+    getLatestUnresolvedThreadId: (cellId: string) => string | null;
+    configuration?: SmartGridCommentConfiguration;
+    colIdentifierKey?: string;
+}
+
+/**
+ * SmartGridCommentDeleteState - State for comment deletion
+ */
+export declare interface SmartGridCommentDeleteState {
+    cellId?: string;
+    data?: SmartGridCommentRowData;
+    comment?: SmartGridComment;
+}
+
+/**
+ * SmartGridCommentMenuOption - Menu option for comment actions
+ */
+export declare interface SmartGridCommentMenuOption {
+    label: string;
+    id: string;
+    icon?: React.ReactNode;
+    onClick: () => void;
+    value: string;
+}
+
+/**
+ * SmartGridCommentPanelProps - Props for CommentPanel component
+ */
+export declare interface SmartGridCommentPanelProps {
+    showCommentPanel: boolean;
+    setShowCommentPanel: () => void;
+    comments: SmartGridCommentThread;
+    onCommentItemClick: (cellId: string, comments: SmartGridComment[], messageId?: string | number | null) => void;
+    onMenuClick: (event: React.MouseEvent<HTMLButtonElement>, comment?: string | SmartGridComment | null, type?: "commentMenu" | "topMenu") => void;
+    onMarkAsReadClick?: (cellId: string | number) => Promise<void>;
+    onMarkAsResolvedClick: (cellId: string, comments: SmartGridComment[]) => Promise<void>;
+    commentProps: SmartGridCommentProps;
+    resolvedComments: string[];
+    popup: SmartGridCommentPopup | null;
+    onShowResolvedCommentsRequest?: () => Promise<void>;
+    height: string | number;
+}
+
+/**
+ * SmartGridCommentPopup - State for comment popup
+ */
+export declare interface SmartGridCommentPopup {
+    position: SmartGridCommentPopupPosition;
+    rowId?: string | number;
+    colId?: string;
+    cellId: string;
+    comment?: SmartGridComment[];
+    author?: string;
+    openedBy: "hover" | "click";
+    data?: SmartGridCommentRowData;
+    messageId?: string | number | null;
+}
+
+/**
+ * SmartGridCommentPopupPosition - Position for comment popup
+ */
+export declare interface SmartGridCommentPopupPosition {
+    top: number;
+    left: number;
+    side?: "left" | "right" | "clamped";
+}
+
+/**
+ * SmartGridCommentProps - Props passed to comment components
+ */
+export declare interface SmartGridCommentProps {
+    comments?: SmartGridCommentThread;
+    resolvedComments?: string[];
+    author?: string;
+    colIdentifierKey?: string;
+    configuration?: SmartGridCommentConfiguration;
+    commentSearchOptions?: Array<{
+        label: string;
+        value: string;
+    }>;
+    selectedCommentSearchOption?: string;
+    handleSaveComment?: (cellId: string, text: string, data: SmartGridCommentRowData, taggedUsers?: SmartGridCommentTaggedUser[]) => Promise<SmartGridCommentThread | void>;
+    handleCommentEdit?: (text: string, comment: SmartGridComment, commentId: string | number, taggedUsers?: SmartGridCommentTaggedUser[]) => Promise<SmartGridCommentThread | void>;
+    handleCommentDelete?: (commentId: string | number, comment: SmartGridComment) => Promise<SmartGridCommentThread | void>;
+    handleThreadDelete?: (cellId: string, data: SmartGridComment[]) => Promise<SmartGridCommentThread | void>;
+    handleMarkAsRead?: (cellId: string | number) => Promise<void>;
+    handleMarkAsUnread?: (cellId: string | number) => Promise<void>;
+    handleMarkAsResolved?: (cellId: string, comments: SmartGridComment[]) => Promise<string[] | void>;
+    handleFetchResolvedComments?: () => Promise<{
+        comments?: SmartGridCommentThread;
+        resolvedComments?: string[];
+    } | void>;
+    loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+}
+
+/**
+ * SmartGridCommentRowData - Row data associated with a comment
+ */
+export declare interface SmartGridCommentRowData {
+    [key: string]: unknown;
+}
+
+/**
+ * SmartGridCommentSearchOption - Search/filter option for comments
+ */
+export declare interface SmartGridCommentSearchOption {
+    label: string;
+    value: string;
+    id: string;
+}
+
+/**
+ * SmartGridCommentsPortalProps - Props for CommentsPortal component
+ */
+export declare interface SmartGridCommentsPortalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    comments?: SmartGridComment[];
+    onAddComment: (cellId: string | number, inputValue: string, taggedUsers?: SmartGridCommentTaggedUser[]) => Promise<void>;
+    cellId?: string | number;
+    position?: SmartGridCommentPopupPosition;
+    author?: string;
+    onMouseEnter?: () => void;
+    onMouseLeave?: () => void;
+    openedBy?: "hover" | "click";
+    onMenuClick: (event: React.MouseEvent<HTMLButtonElement>, comment?: string | number | SmartGridComment | null, type?: "commentMenu" | "topMenu") => void;
+    onMarkAsReadClick?: ((cellId: string | number) => Promise<void>) | null;
+    onMarkAsResolvedClick?: ((cellId: string | number, comments: SmartGridComment[]) => Promise<void>) | null;
+    editCommentText?: string;
+    isLoading?: boolean;
+    error?: string | null;
+    onClearError?: () => void;
+    currentAuthor?: string;
+    editingComment?: SmartGridComment | null;
+    setEditingComment?: React.Dispatch<React.SetStateAction<SmartGridComment | null>>;
+    onUpdateComment?: (commentId: string | number | null, newText: string) => Promise<void>;
+    loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+    resolvedComments?: string[];
+    messageId?: string | number | null;
+    configuration?: SmartGridCommentConfiguration;
+}
+
+/**
+ * SmartGridCommentTaggedUser - User tagged in a comment
+ */
+export declare interface SmartGridCommentTaggedUser {
+    id: string | number;
+    name: string;
+    avatar?: string;
+    status?: string;
+}
+
+/**
+ * SmartGridCommentThread - A collection of comments keyed by cell ID
+ */
+export declare type SmartGridCommentThread = Record<string, SmartGridComment[]>;
+
+/**
+ * SmartGridCommentWrapperProps - Props for CommentWrapper component
+ */
+export declare interface SmartGridCommentWrapperProps {
+    commentProps: SmartGridCommentProps;
+    commentPannelRef: React.MutableRefObject<((show: boolean) => void) | null>;
+    height: string | number;
+}
+
 export declare interface SmartGridContainerRect {
     top: number;
     left: number;
@@ -1280,6 +1922,18 @@ export declare interface SmartGridCopyCellValueParams {
     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;
@@ -1462,6 +2116,21 @@ export declare interface SmartGridDateRangeValue {
     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;
     headerComponentParams?: {
@@ -1562,6 +2231,86 @@ export declare interface SmartGridDragSourceData {
     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<string, unknown>;
+    secondaryButtonLabel?: string;
+    onSecondaryButtonClick?: () => void;
+    secondaryButtonProps?: Record<string, unknown>;
+    hideBackdrop?: boolean;
+    disablePortal?: boolean;
+    keepMounted?: boolean;
+}
+
+export declare type SmartGridDrawerSize = "small" | "medium" | "large";
+
+export declare interface SmartGridEditorCommands {
+    toggleBold?: () => void;
+    toggleItalic?: () => void;
+    toggleLink?: () => void;
+    toggleBulletList?: () => void;
+    toggleOrderedList?: () => void;
+    toggleStrike?: () => void;
+    toggleHighlight?: () => void;
+    toggleH1?: () => void;
+    toggleH2?: () => void;
+    toggleH3?: () => void;
+    toggleH4?: () => void;
+    toggleH5?: () => void;
+    toggleH6?: () => void;
+    insertEmoji?: (emoji: string) => void;
+    clearContent?: () => void;
+    editor?: SmartGridTipTapEditor;
+    [key: string]: (() => void) | ((emoji: string) => void) | SmartGridTipTapEditor | undefined;
+}
+
+export declare interface SmartGridEditorToolbarProps {
+    editor: SmartGridEditorCommands | null;
+    activeStates?: Record<SmartGridToolbarItemKey, boolean>;
+    enabledItems?: SmartGridToolbarItemKey[];
+    onFileSelect?: (e: ChangeEvent<HTMLInputElement>) => void;
+    onImageSelect?: (e: ChangeEvent<HTMLInputElement>) => void;
+    onEmojiSelect?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    className?: string;
+}
+
+export declare interface SmartGridEditorToolbarRef {
+    fileInput?: HTMLInputElement | null;
+    imageInput?: HTMLInputElement | null;
+}
+
+export declare interface SmartGridEmojiObject {
+    emoji: string;
+}
+
+export declare interface SmartGridEmojiPickerProps {
+    open?: boolean;
+    onClose?: () => void;
+    onEmojiClick?: (emoji: string) => void;
+    anchorEl?: HTMLElement | null;
+}
+
+export declare interface SmartGridEmptyContainerProps {
+    title?: string;
+    subTitle?: string;
+}
+
 export declare interface SmartGridEvent {
     type: string;
     api?: SmartGridAPI;
@@ -1638,6 +2387,8 @@ declare interface SmartGridFetchFunctionRef {
     current?: SmartGridFetDataParams | null;
 }
 
+export declare type SmartGridFetchMoreFn<T> = (page: number) => Promise<T[] | null | undefined>;
+
 /** Fetch response */
 declare interface SmartGridFetchResponse {
     data?: SmartGridRowData[];
@@ -1654,6 +2405,17 @@ export declare type SmartGridFetDataParams = (body: SmartGridFetchDataFunctionBo
     totalCount?: number | null;
 }>;
 
+export declare interface SmartGridFileUploaderProps {
+    file?: File | null;
+    fileUrl?: string | null;
+    isLoading?: boolean;
+    isError?: boolean;
+    errorMessage?: string;
+    onClear?: () => void;
+    onRetry?: () => void;
+    onDownload?: (url: string, fileName: string) => void;
+}
+
 export declare type SmartGridFilterMode = "value" | "condition";
 
 export declare interface SmartGridFilterModel {
@@ -1694,6 +2456,22 @@ export declare interface SmartGridFocusedCell extends SmartGridSelectedCell {
     floating: SmartGridFloatingType;
 }
 
+export declare interface SmartGridFormatActiveState {
+    bold: boolean;
+    italic: boolean;
+    link: boolean;
+    bulletList: boolean;
+    orderedList: boolean;
+    strike: boolean;
+    highlight: boolean;
+    h1: boolean;
+    h2: boolean;
+    h3: boolean;
+    h4: boolean;
+    h5: boolean;
+    h6: boolean;
+}
+
 export declare type SmartGridFrozenColumnsDetails = {
     indexes: string[];
     positions: Record<string, number>;
@@ -1770,6 +2548,14 @@ export declare interface SmartGridGlobalColumnCounts {
     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;
@@ -1785,6 +2571,44 @@ export declare interface SmartGridHeaderCellProps {
     } | null;
 }
 
+export declare interface SmartGridHeaderChatConfig {
+    participants: SmartGridParticipant[];
+    participantsList: SmartGridParticipant[];
+    headerConfig: SmartGridHeaderConfig;
+    notificationSettings: SmartGridNotificationSettings;
+    loadParticipants: (radioValue: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+    loadParticipantsAvatar: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+    loadMenuOptions: () => Promise<SmartGridParticipant[]>;
+    onParticipantsClick: (radioValue: string | number) => Promise<SmartGridParticipant[]>;
+    onParticipantAdd: (participantIds: (string | number)[], selectedRadioOption: string, chatId: string | number) => Promise<{
+        success: boolean;
+        participant: SmartGridParticipant;
+    } | null>;
+    onParticipantRemove: (participant: SmartGridParticipant) => Promise<{
+        success: boolean;
+        participant: SmartGridParticipant;
+    }>;
+    onPinnedClick: (chatId: string | number) => Promise<SmartGridChatMessage[]>;
+    onPinnedChatClick: (chatId: string | number, isPinned: boolean) => Promise<boolean>;
+    onChatClick: (chatId: string | number, channelId?: string | number | null) => Promise<void>;
+    onSearchChange: (value: string, radioValue?: string, chatId?: string | number) => Promise<SmartGridParticipant[]>;
+    onNotificationSettingChange: (settings: SmartGridNotificationSettings) => Promise<{
+        success: boolean;
+        settings: SmartGridNotificationSettings;
+    } | void>;
+}
+
+export declare interface SmartGridHeaderConfig {
+    showSearch?: boolean;
+    showParticipants?: boolean;
+    showPinned?: boolean;
+    showNotifications?: boolean;
+    selectedRadioOptionMenu?: string;
+    maxAvatars?: number;
+    radioOptions?: SmartGridChatRadioOption[];
+    searchConfig?: SmartGridSearchConfig;
+}
+
 export declare interface SmartGridHeaderMenuReturn {
     unfreezeColumn: (column: SmartGridColumnDefinition) => void;
     freezeColumn: (column: SmartGridColumnDefinition) => void;
@@ -1856,6 +2680,14 @@ export declare interface SmartGridIATableState {
     activeInstance?: HTMLElement | null;
 }
 
+export declare interface SmartGridImageUploaderProps {
+    image?: string | null;
+    isLoading?: boolean;
+    isError?: boolean;
+    handleClear?: () => void;
+    handleRetry?: () => void;
+}
+
 export declare interface SmartGridInfiniteCache {
     analytics: SmartGridCacheAnalytics;
     blockCount: number;
@@ -2014,6 +2846,25 @@ export declare interface SmartGridInfiniteScrollLoaderProps {
     colSpan: number;
 }
 
+export declare interface SmartGridInfiniteScrollOptions {
+    threshold?: number;
+    rootMargin?: string;
+    enabled?: boolean;
+    isRestoringScroll?: MutableRefObject<boolean> | null;
+}
+
+export declare interface SmartGridInfiniteScrollReturn {
+    loadMoreRef: RefObject<HTMLDivElement>;
+    isLoading: boolean;
+    hasMore: boolean;
+    error: Error | null;
+    loadMore: () => Promise<void>;
+    reset: () => void;
+    updateHasMore: (newHasMore: boolean) => void;
+    updateCurrentPage: (newPage: number) => void;
+    currentPage: number;
+}
+
 export declare interface SmartGridInitialDataUpdateParams {
     dispatch: SmartGridDispatch;
     pinnedTopRows: SmartGridRowData[];
@@ -2053,6 +2904,29 @@ export declare interface SmartGridInitialDataUpdateParams {
     splitRendererKeys?: string[];
 }
 
+export declare interface SmartGridInputChatConfig {
+    inputConfig: SmartGridInputConfig;
+    onSend: (payload: SmartGridSendPayload, chatId: string | number) => Promise<SmartGridChatMessage | {
+        success: boolean;
+        message: string;
+    }>;
+    onMessageReply: (messageId: string | number, chatId: string | number) => void;
+    onMessageBookmark: (messageId: string | number, chatId: string | number) => void;
+    onMessageMore: (messageId: string | number, chatId: string | number) => void;
+    onAttachFile: (file: File) => void;
+    onImageUpload: (image: File) => void;
+    onEmojiSelect: (emoji: string) => void;
+}
+
+export declare interface SmartGridInputConfig {
+    placeholder?: string;
+    maxLength?: number;
+    showFormatting?: boolean;
+    showEmojiPicker?: boolean;
+    showAttachments?: boolean;
+    allowedFileTypes?: string[];
+}
+
 export declare interface SmartGridInputFormatInstance {
     colDef?: {
         type?: string;
@@ -2093,6 +2967,7 @@ export declare interface SmartGridInputProps {
     onFocus?: (e: FocusEvent_2<HTMLInputElement>) => void;
     onBlur?: (e: FocusEvent_2<HTMLInputElement>) => void;
     autoFocus?: boolean;
+    rightIconClick?: () => void;
 }
 
 export declare type SmartGridInputType = "text" | "password" | "email" | "number" | "tel" | "int" | "url";
@@ -2122,6 +2997,32 @@ declare interface SmartGridLastAccessedSequence_2 {
     next: () => number;
 }
 
+export declare interface SmartGridLeftChatPanel {
+    showCheckbox?: boolean;
+}
+
+export declare interface SmartGridLeftHeaderPanel {
+    showAddChat?: boolean;
+    showCheckbox?: boolean;
+}
+
+export declare interface SmartGridLeftPanelConfig {
+    leftHeaderPanel: SmartGridLeftHeaderPanel;
+    leftChatPanel: SmartGridLeftChatPanel;
+    rightHeaderPanel: SmartGridRightHeaderPanel;
+    loadChannelsList: () => Promise<SmartGridChannel[]>;
+    loadChatList: (selectedChannelInfo: SmartGridChannel) => Promise<SmartGridChat[]>;
+    handleChatName: (formData: SmartGridChatFormData, selectedChannelId: SmartGridChannel | null) => Promise<SmartGridCreateChatResponse>;
+    deleteChat: (topicId: string | number) => Promise<{
+        success: boolean;
+        topicId: string | number;
+    }>;
+    directChatList: SmartGridChat[];
+    hasDirectChatList: boolean;
+    selectedChatId?: string | number;
+    clearDirectChatList: () => void;
+}
+
 export declare interface SmartGridMasterDetailConfig {
     enabled: boolean;
     expandedRows: (string | number)[];
@@ -2149,6 +3050,72 @@ export declare interface SmartGridMemoryAnalyticsReturn {
     updateMemoryAndAnalytices: () => void;
 }
 
+export declare interface SmartGridMentionCommand {
+    id: string;
+    label: string;
+}
+
+export declare interface SmartGridMentionConfig {
+    chatId?: string | number;
+    loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+}
+
+export declare interface SmartGridMentionEditorProps {
+    value?: string;
+    onChange?: (html: string) => void;
+    onSend?: () => void;
+    disabled?: boolean;
+    maxLength?: number;
+    placeholder?: string;
+    chatId?: string | number;
+    loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+}
+
+export declare interface SmartGridMentionEditorRef {
+    toggleBold: () => void;
+    toggleItalic: () => void;
+    toggleLink: () => void;
+    addImage: (url: string, alt?: string) => void;
+    getHTML: () => string;
+    getJSON: () => Record<string, unknown> | undefined;
+    clearContent: () => void;
+    isEmpty: () => boolean;
+    insertEmoji: (emoji: string) => void;
+    toggleStrike: () => void;
+    toggleHighlight: () => boolean | undefined;
+    toggleBulletList: () => void;
+    toggleOrderedList: () => void;
+    toggleH1: () => void;
+    toggleH2: () => void;
+    toggleH3: () => void;
+    toggleH4: () => void;
+    toggleH5: () => void;
+    toggleH6: () => void;
+    editor: Editor | null;
+}
+
+export declare interface SmartGridMentionInfo {
+    id: string | number;
+    label: string;
+    position: number;
+}
+
+export declare interface SmartGridMentionListProps {
+    items: SmartGridMentionUser[];
+    command: (item: SmartGridMentionCommand) => void;
+}
+
+export declare interface SmartGridMentionListRef {
+    onKeyDown: (props: SmartGridSuggestionRenderProps) => boolean | undefined;
+}
+
+export declare interface SmartGridMentionUser {
+    id: string | number;
+    name: string;
+    avatar?: string;
+    status?: string;
+}
+
 export declare type SmartGridMenuAlignment = "start" | "end" | "auto";
 
 export declare interface SmartGridMenuAlignments {
@@ -2160,8 +3127,12 @@ export declare interface SmartGridMenuAlignments {
 export declare interface SmartGridMenuOption {
     label: string | number;
     id: string | number;
-    onClick: (value: string | number) => void;
+    onClick?: (value: string | number) => void;
     icon?: ReactNode;
+    value?: string | number;
+    prefillText?: string;
+    name?: string;
+    avatar?: string;
     submenu?: SmartGridMenuOption[];
     submenuPosition?: SmartGridMenuPosition;
     submenuWidth?: number;
@@ -2182,6 +3153,49 @@ export declare interface SmartGridMenuOptions {
     wrapText?: boolean;
 }
 
+export declare interface SmartGridMenuOptionsHeaderCustomProps {
+    searchPlaceholder?: string;
+    selectAllLabel?: string;
+    clearButtonText?: string;
+    radioButtonProps?: Record<string, unknown>;
+    searchInputProps?: Record<string, unknown>;
+    checkboxProps?: Record<string, unknown>;
+    clearButtonProps?: Record<string, unknown>;
+}
+
+export declare interface SmartGridMenuOptionsHeaderExternalHandlers {
+    onSearchChange?: (value: string) => void;
+    onSelectAll?: (allValues: (string | number)[]) => void;
+    onClearSelection?: () => void;
+    onRadioButtonChange?: (value: string) => void;
+}
+
+export declare interface SmartGridMenuOptionsHeaderOverrideConfig {
+    radioButtonOptions?: SmartGridChatRadioOption[];
+    selectedRadioButton?: string;
+    showRadioButton?: boolean;
+    isSearchable?: boolean;
+    isSelectAllAllowed?: boolean;
+}
+
+export declare interface SmartGridMenuOptionsHeaderProps {
+    options?: SmartGridParticipant[];
+    selectedItems?: (string | number)[];
+    onSearchChange?: (value: string) => void;
+    onSelectAll?: (allValues: (string | number)[]) => void;
+    searchQuery?: string;
+    onClearSelection?: () => void;
+    onRadioButtonChange?: (value: string) => void;
+    radioButtonOptions?: SmartGridChatRadioOption[];
+    selectedRadioButton?: string;
+    showRadioButton?: boolean;
+    isSearchable?: boolean;
+    isSelectAllAllowed?: boolean;
+    customHeaderProps?: SmartGridMenuOptionsHeaderCustomProps;
+    externalHandlers?: SmartGridMenuOptionsHeaderExternalHandlers;
+    overrideConfig?: SmartGridMenuOptionsHeaderOverrideConfig;
+}
+
 export declare type SmartGridMenuPosition = "top" | "bottom" | "left" | "right";
 
 export declare interface SmartGridMenuPositionResult {
@@ -2209,13 +3223,25 @@ export declare interface SmartGridMenuPositionState {
     transformOrigin?: string;
 }
 
+export declare interface SmartGridMenuPrimaryButtonProps {
+    loading?: boolean;
+    disabled?: boolean;
+    label?: string;
+}
+
 export declare interface SmartGridMenuProps {
     options?: SmartGridMenuOption[];
-    selectedElement?: string | number;
-    iconPlacement?: "left" | "right";
-    isOpen: boolean;
+    selectedElement?: string | number | {
+        value?: string | number;
+        prefillText?: string;
+    } | null;
+    iconPlacement?: "left" | "right" | "top";
+    isOpen?: boolean;
+    open?: boolean;
     setIsOpen: (isOpen: boolean) => void;
-    menuButtonRef?: RefObject<HTMLElement>;
+    onClose?: () => void;
+    menuButtonRef?: RefObject<HTMLElement | null>;
+    anchorEl?: HTMLElement | null;
     position?: SmartGridMenuPosition;
     width?: number;
     horizontalAlign?: SmartGridMenuAlignment;
@@ -2225,8 +3251,86 @@ export declare interface SmartGridMenuProps {
     portalContainer?: HTMLElement;
     additionalButtons?: ReactNode;
     forcePosition?: boolean;
+    onClick?: (option: SmartGridMenuOption) => void;
+    menuContainerClassName?: string;
+    primaryButtonProps?: SmartGridMenuPrimaryButtonProps;
+    onPrimaryButtonClick?: () => void | Promise<void>;
+    onTertiaryButtonClick?: () => void;
+    selected?: string;
+    withActionButtons?: boolean;
+    withCheckbox?: boolean;
+    renderCustomHeader?: (headerProps: Record<string, unknown>) => ReactNode;
+    filteredOptions?: SmartGridMenuOption[];
+    searchQuery?: string;
+    onSearchChange?: (value: string) => void;
+    onSelectAll?: (allValues: (string | number)[]) => void;
+    onClearSelection?: () => void;
+    customHeaderProps?: Record<string, unknown>;
+}
+
+export declare interface SmartGridMessageAction {
+    icon: React.ReactNode | null;
+    handler?: (messageId: string | number) => void;
+    ariaLabel: string;
+}
+
+export declare type SmartGridMessageActionKey = "reply" | "bookmark" | "pin" | "more";
+
+export declare interface SmartGridMessageChatConfig {
+    realTimeMessages: SmartGridChatMessage[];
+    isWebSocketConnected: boolean;
+    currentTopicId: string | number | null;
+    isThreadIconVisible: boolean;
+    isPinChatIconVisible: boolean;
+    emptyChannelStateTitle: string;
+    emptyChannelStateSubTitle: string;
+    emptyChatStateTitle: string;
+    emptyChatStateSubTitle: string;
+    currentUserId: string | number | null;
+    selectedMessageId: string | number | null;
+    maxSearchPages: number;
+    highlightDuration: number;
+    scrollBehavior: ScrollBehavior;
+    scrollBlock: ScrollLogicalPosition;
+    highlightColor: string;
+    messageConfig: SmartGridMessageConfig;
+    onRealTimeMessageUpdate: (newMessage: SmartGridChatMessage) => void;
+    onMessageReply: (messageId: string | number, message: SmartGridChatMessage) => void;
+    onMessageBookmark: (messageId: string | number, message: SmartGridChatMessage) => void;
+    onMessagePin: (messageId: string | number, isPinned: boolean, chatId: string | number, item: SmartGridChatMessage) => Promise<SmartGridChatMessage | boolean | undefined>;
+    onMessageUpdate: (messageId: string | number, updatedData: Partial<SmartGridChatMessage>) => Promise<SmartGridChatMessage | {
+        success: boolean;
+        messageId: string | number;
+        updatedData: Partial<SmartGridChatMessage>;
+    }>;
+    onMessageDelete: (messageId: string | number) => Promise<{
+        success: boolean;
+        messageId: string | number;
+    }>;
+    onThreadClick: (messageId: string | number, message: SmartGridChatMessage) => void;
+    loadThreadMessages: (parentMessageId: string | number) => Promise<SmartGridChatMessage[]>;
+    loadPinnedMsg: () => Promise<SmartGridChatMessage[]>;
+    onSearchMessage: (value: string, chatId: string | number) => Promise<SmartGridChatMessage[]>;
+    leaveCurrentTopic: () => void;
+    markTopicAsDeleted: (topicId: string | number) => void;
+    onClearAllMessages: (chatId?: string | number) => void;
+}
+
+export declare interface SmartGridMessageConfig {
+    showActions?: boolean;
+    priorityOptions?: SmartGridPriorityOption[];
+    quickActionProps?: SmartGridQuickActionProp[];
+    isMsgFormat?: boolean;
+}
+
+export declare interface SmartGridMessageItemProps {
+    type?: SmartGridPinnedPanelType;
+    msg?: SmartGridPinnedMessageItem;
+    onMessageClick?: (messageId: string | number) => void;
 }
 
+export declare type SmartGridMessagePriority = "default" | "normal" | "low" | "medium" | "high";
+
 export declare interface SmartGridModalProps {
     open?: boolean;
     onClose: () => void;
@@ -2236,7 +3340,7 @@ export declare interface SmartGridModalProps {
     width?: string | number;
     height?: string | number;
     className?: string;
-    onPrimaryButtonClick?: () => void;
+    onPrimaryButtonClick?: () => void | Promise<void>;
     primaryButtonLabel?: string;
     onSecondaryButtonClick?: () => void;
     secondaryButtonLabel?: string;
@@ -2246,17 +3350,42 @@ export declare interface SmartGridModalProps {
     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 SmartGridNewSortModel {
     column: string | null;
     order: SmartGridSortDirection | null;
 }
 
+/**
+ * SmartGridNoCommentsProps - Props for NoComments component
+ */
+export declare interface SmartGridNoCommentsProps {
+    onAddComment?: (cellId: string | number, inputValue: string, taggedUsers?: SmartGridCommentTaggedUser[]) => void | Promise<void>;
+    cellId?: string | number;
+    position?: SmartGridCommentPopupPosition;
+    isInsidePortal?: boolean;
+    editCommentText?: string;
+    isLoading?: boolean;
+    error?: string | null;
+    onClearError?: () => void;
+    isEditFlow?: boolean;
+    onUpdateComment?: (text: string) => void;
+    setEditingComment?: React.Dispatch<React.SetStateAction<SmartGridComment | null>>;
+    loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+}
+
 export declare interface SmartGridNotification {
     message: string;
     type?: "success" | "error" | "warning" | "info";
@@ -2264,6 +3393,13 @@ export declare interface SmartGridNotification {
     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 {
@@ -2271,6 +3407,8 @@ export declare interface SmartGridOldSortModel {
     sort: SmartGridSortDirection;
 }
 
+export declare type SmartGridOnMessagePin = (messageId: string | number, pinned: boolean, chatId: string | number, item: SmartGridChatMessage) => Promise<SmartGridChatMessage | boolean | undefined>;
+
 export declare type SmartGridOnReadyParams = {
     api: SmartGridAPI;
     columnApi: SmartGridAPI;
@@ -2348,6 +3486,28 @@ export declare interface SmartGridParamsNode {
     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;
@@ -2360,6 +3520,29 @@ declare interface SmartGridPersistenceOptions {
     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;
@@ -2609,6 +3792,48 @@ export declare interface SmartGridPivotWrapperProps {
     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<HTMLDivElement>) => 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 interface SmartGridPromptButton {
     label: string;
     type: "default" | "primary" | "secondary";
@@ -2630,10 +3855,28 @@ export declare interface SmartGridPromptProps {
 
 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<HTMLInputElement>) => void;
+    onChange: (e: ChangeEvent<HTMLInputElement>, val: string | number) => void;
     orientation?: SmartGridRadioOrientation;
     disabled?: boolean;
     name?: string;
@@ -2646,7 +3889,7 @@ export declare interface SmartGridRadioOption {
     disabled?: boolean;
 }
 
-export declare type SmartGridRadioOrientation = "vertical" | "horizontal";
+export declare type SmartGridRadioOrientation = "vertical" | "horizontal" | "row";
 
 export declare type SmartGridRangeFilter = {
     column: string;
@@ -2710,12 +3953,34 @@ export declare interface SmartGridRenderHeadersProps {
     virtualizedStartCololumnIndex: MutableRefObject<number>;
 }
 
+export declare interface SmartGridReplyBadgeProps {
+    text?: string;
+    action?: string;
+    onReplyClick?: () => void;
+    onActionClick?: () => void;
+    className?: string;
+    showIcon?: boolean;
+}
+
 /** Response metadata */
 declare interface SmartGridResponseMetadata {
     totalCount?: number;
     lastRowIndexKnown?: boolean;
 }
 
+export declare interface SmartGridRightHeaderPanel {
+    showParticipants?: boolean;
+    showPinnedChat?: boolean;
+    showChatSearch?: boolean;
+    showActionBtn?: boolean;
+}
+
+export declare interface SmartGridRightPanelConfig {
+    loadMessages: (chatId: string | number, page?: number) => Promise<SmartGridChatMessage[]>;
+    loadOlderMessages: (channelId: string | number) => Promise<SmartGridChatMessage[]>;
+    messagesClearedTrigger?: number;
+}
+
 export declare interface SmartGridRowClickHandler {
     (rowData: SmartGridRowData, rowIndex: number): void;
 }
@@ -2985,6 +4250,12 @@ export declare interface SmartGridScrollSyncReturn {
     syncHorizontalScroll: (scrollLeft: number, sourceElement: HTMLElement, bodyScrollRef?: RefObject<HTMLDivElement | null> | null) => void;
 }
 
+export declare interface SmartGridSearchConfig {
+    placeholder?: string;
+    debounceMs?: number;
+    minChars?: number;
+}
+
 export declare type SmartGridSearchFunctionParams = SmartGridFilterModel[] | Record<string, SmartGridFilterModel[]>;
 
 export declare type SmartGridSearchFunctionParamsWithField = Record<string, SmartGridFilterModel>;
@@ -3072,6 +4343,11 @@ export declare interface SmartGridSelectProps {
     isEnableResetButton?: boolean;
 }
 
+export declare interface SmartGridSendPayload {
+    content: string;
+    [key: string]: unknown;
+}
+
 export declare interface SmartGridServerProps {
     totalItems: number;
     totalPages: number;
@@ -3266,6 +4542,9 @@ export declare interface SmartGridStateContext {
         deleteViewPromptText?: null | string;
     }>;
     saveViewCallbackRef: MutableRefObject<SmartGridSaveViewCallbackRefCurrent>;
+    clickCallbackRef: MutableRefObject<SmartGridClickCallbackRefCurrent>;
+    customCallback: SmartGridCustomCallbackRefCurrent;
+    contextRef: MutableRefObject<SmartGridCommentContextRef> | null;
     tableId: string;
     isSingleSelect: boolean;
     selectable: boolean;
@@ -3285,6 +4564,8 @@ export declare interface SmartGridStateContext {
     pivotPanelColumnDef: null | SmartGridColumnDefinition[];
     removeCheckConfigurationOnOperation: boolean;
     totalColumnsCount: number;
+    isCommentFeatureEnabled: boolean;
+    isChatEnabled: boolean;
     [key: string]: unknown;
 }
 
@@ -3295,6 +4576,39 @@ export declare type SmartGridStringFilter = {
     operator?: string;
 };
 
+export declare interface SmartGridSuggestion {
+    items: (params: SmartGridSuggestionItemsParams) => Promise<SmartGridMentionUser[]>;
+    render: () => SmartGridSuggestionRenderReturn;
+}
+
+export declare interface SmartGridSuggestionItemsParams {
+    query: string;
+    editor: Editor & {
+        storage: {
+            mentionConfig?: SmartGridMentionConfig;
+        };
+    };
+}
+
+export declare interface SmartGridSuggestionKeyDownProps {
+    event?: KeyboardEvent;
+}
+
+export declare interface SmartGridSuggestionRenderProps {
+    editor?: Editor;
+    clientRect?: (() => DOMRect | null) | null;
+    items?: SmartGridMentionUser[];
+    command?: (item: SmartGridMentionCommand) => void;
+    event?: KeyboardEvent;
+}
+
+export declare interface SmartGridSuggestionRenderReturn {
+    onStart: (props: SmartGridSuggestionRenderProps) => void;
+    onUpdate: (props: SmartGridSuggestionRenderProps) => void;
+    onKeyDown: (props: SmartGridSuggestionKeyDownProps) => boolean;
+    onExit: () => void;
+}
+
 export declare interface SmartGridSwitchProps {
     value: boolean;
     leftLabel?: string;
@@ -3343,6 +4657,100 @@ export declare interface SmartGridTableBodyProps {
     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<boolean>;
+    onDeleteTopics?: () => void;
+    selectedChat?: (string | number)[];
+    handleChatSelect?: (id: string | number) => void;
+    isCreateNewChatOpen?: boolean;
+    setIsCreateNewChatOpen?: Dispatch<SetStateAction<boolean>>;
+}
+
+export declare interface SmartGridTableChatRightSectionProps {
+    title: string;
+    chatId: string | number;
+    CreatedBy: string;
+    participants?: SmartGridParticipant[];
+    participantsList?: SmartGridParticipant[];
+    onParticipantsClick?: () => void;
+    messages?: SmartGridChatMessage[];
+    placeholder?: string;
+    showFormatting?: boolean;
+    maxLength?: number;
+    showParticipantsList?: boolean;
+    showPinnedChat?: boolean;
+    showSearch?: boolean;
+    showActionBtn?: boolean;
+    onMessageReply?: (messageId: string | number, chatId: string | number) => void;
+    onMessageBookmark?: (messageId: string | number, chatId: string | number) => void;
+    onMessagePin?: SmartGridOnMessagePin;
+    onMessageMore?: (messageId: string | number, chatId: string | number) => void;
+    onAttachFile?: (file: File) => void;
+    onImageUpload?: (image: File) => void;
+    onEmojiClick?: (emoji: string) => void;
+    setPinnedMessages?: React.Dispatch<React.SetStateAction<SmartGridChatMessage[]>>;
+    className?: string;
+    showDateSeparators?: boolean;
+    autoScroll?: boolean;
+    onThreadClick?: (messageId: string | number, chatId: string | number) => void;
+    messageConfig: SmartGridMessageChatConfig & {
+        loadMessages?: (chatId: string | number, page: number) => Promise<SmartGridChatMessage[] | {
+            messages: SmartGridChatMessage[];
+            noMoreData: boolean;
+        }>;
+        messagesClearedTrigger?: number;
+        loadParticipantsAvatar?: (selectedRadioOption: string, chatId: string | number) => Promise<SmartGridParticipant[]>;
+        messageConfig?: SmartGridMessageConfig;
+        highlightTrigger?: number | null;
+    };
+    inputChatConfig: SmartGridInputChatConfig & {
+        inputConfig?: SmartGridInputConfig & {
+            showQuickAction?: boolean;
+            quickActionLabel?: string;
+        };
+    };
+    chatHeaderConfig: SmartGridHeaderChatConfig;
+    handleToast: (isOpen: boolean, message: string, variant: SmartGridToastVariant) => void;
+}
+
+export declare interface SmartGridTableChatSidePanelProps {
+    isOpen: boolean;
+    handleClose: () => void;
+    chatConfiguration: SmartGridChatConfiguration;
+}
+
+export declare type SmartGridTableChatWrapper = {
+    isChatOpen: boolean;
+    handleChatClick: () => void;
+    handleChatClose: () => void;
+    chatConfiguration: SmartGridChatConfiguration;
+};
+
 export declare type SmartGridTableComponentProps = SmartGridTableProps;
 
 export declare interface SmartGridTableContentDetailsProps {
@@ -3368,6 +4776,7 @@ export declare interface SmartGridTableContentDetailsProps {
     isLeftPinnedRowsAvailable?: boolean;
     columnScrollHandlerRef?: MutableRefObject<SmartGridScrollHandler | null>;
     isScrollingSynced?: MutableRefObject<boolean>;
+    commentProps?: SmartGridCommentProps;
 }
 
 export declare interface SmartGridTableContentProps {
@@ -3425,6 +4834,15 @@ export declare interface SmartGridTableContentProps {
     downloadExcelHandler?: () => void;
     downloadCSVHandler?: () => void;
     pivotConfig?: SmartGridPivotConfig;
+    isChatEnabled?: boolean;
+    isCommentFeatureEnabled?: boolean;
+    isChatOpen?: boolean;
+    handleChatClick?: () => void;
+    handleChatClose?: () => void;
+    chatConfiguration?: SmartGridChatConfiguration;
+    ChatComponent?: (props: SmartGridTableChatWrapper) => JSX.Element;
+    CommentComponent?: FC<SmartGridCommentWrapperProps>;
+    commentProps?: SmartGridCommentProps;
 }
 
 export declare interface SmartGridTableContentRendererProps {
@@ -3659,12 +5077,45 @@ export declare interface SmartGridTableProps extends SmartGridSaveViewCallbackRe
      * 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<SmartGridCommentWrapperProps>;
+    commentProps?: SmartGridCommentProps;
 }
 
 export declare interface SmartGridTableRef {
     api: SmartGridAPI;
 }
 
+/**
+ * SmartGridThreadDeleteState - State for thread deletion
+ */
+export declare interface SmartGridThreadDeleteState {
+    cellId: string;
+    data: SmartGridComment[];
+}
+
+export declare interface SmartGridThreeDotMenuOption {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    onClick?: () => void;
+}
+
+export declare type SmartGridTipTapEditor = {
+    isActive: (name: string, attrs?: Record<string, unknown>) => boolean;
+    on: (event: string, handler: () => void) => void;
+    off: (event: string, handler: () => void) => void;
+    state: Record<string, unknown>;
+};
+
+export declare type SmartGridToastVariant = "info" | "success" | "warning" | "error";
+
 export declare interface SmartGridToggleRenderProps {
     render: (state: SmartGridToggleRenderState) => ReactNode;
 }
@@ -3675,6 +5126,16 @@ export declare interface SmartGridToggleRenderState {
     toggleMenu: () => void;
 }
 
+export declare interface SmartGridToolbarItem {
+    icon: React.FC<React.SVGProps<SVGSVGElement>>;
+    ariaLabel: string;
+    command: string;
+}
+
+export declare type SmartGridToolbarItemKey = "bold" | "italic" | "link" | "bulletList" | "orderedList" | "strike" | "highlight" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+
+export declare type SmartGridToolbarItems = Record<SmartGridToolbarItemKey, SmartGridToolbarItem>;
+
 export declare interface SmartGridTooltipButton {
     label: string;
     type: "default" | "primary" | "secondary";
@@ -3682,6 +5143,7 @@ export declare interface SmartGridTooltipButton {
 }
 
 export declare interface SmartGridTooltipConfig {
+    description?: string;
     title: string;
     targetRef: RefObject<HTMLElement>;
     varient?: SmartGridTooltipVariant;
@@ -3731,9 +5193,10 @@ export declare interface SmartGridTooltipProps extends SmartGridTooltipConfig {
     children: ReactNode;
     forceShowTooltip?: boolean;
     className?: string;
+    description?: string;
 }
 
-export declare type SmartGridTooltipVariant = "primary" | "secondary" | "tertiary";
+export declare type SmartGridTooltipVariant = "primary" | "secondary" | "tertiary" | "feature";
 
 export declare type SmartGridUpdateData = {
     data: SmartGridRowData;
@@ -3753,7 +5216,7 @@ declare interface SmartGridUpdatedPageSizeRef {
     current: number;
 }
 
-export declare interface SmartGridUpdateRefParams extends SmartGridCallbackRefCurrent, SmartGridSaveViewCallbackRefCurrent {
+export declare interface SmartGridUpdateRefParams extends SmartGridCallbackRefCurrent, SmartGridSaveViewCallbackRefCurrent, SmartGridClickCallbackRefCurrent {
     downloadExcelHandler?: () => void;
     downloadCSVHandler?: () => void;
     copyToClipboardHandler?: () => void;
@@ -3779,6 +5242,7 @@ export declare interface SmartGridUpdateRefReturn {
     exportCallbackRef: MutableRefObject<SmartGridExportCallbackRefCurrent>;
     saveViewCallbackRef: MutableRefObject<SmartGridSaveViewCallbackRefCurrent>;
     saveViewOptionsRef: MutableRefObject<SmartGridSaveViewOptionsRefCurrent>;
+    clickCallbackRef: MutableRefObject<SmartGridClickCallbackRefCurrent>;
 }
 
 export declare type SmartGridValueFormatterConfig = {