@sendbird/uikit-react 3.7.0 → 3.8.0

package/types/modules/App/index.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="react" />
+import { SendbirdProviderProps } from '../../lib/Sendbird';
+import './index.scss';
+import { AppLayoutProps } from './types';
+interface AppProps {
+    appId: SendbirdProviderProps['appId'];
+    userId: SendbirdProviderProps['userId'];
+    accessToken?: SendbirdProviderProps['accessToken'];
+    customApiHost?: SendbirdProviderProps['customApiHost'];
+    customWebSocketHost?: SendbirdProviderProps['customWebSocketHost'];
+    breakpoint?: SendbirdProviderProps['breakpoint'];
+    theme?: SendbirdProviderProps['theme'];
+    userListQuery?: SendbirdProviderProps['userListQuery'];
+    nickname?: SendbirdProviderProps['nickname'];
+    profileUrl?: SendbirdProviderProps['profileUrl'];
+    dateLocale?: SendbirdProviderProps['dateLocale'];
+    config?: SendbirdProviderProps['config'];
+    isReactionEnabled?: SendbirdProviderProps['isReactionEnabled'];
+    isMentionEnabled?: SendbirdProviderProps['isMentionEnabled'];
+    isVoiceMessageEnabled?: SendbirdProviderProps['isVoiceMessageEnabled'];
+    voiceRecord?: SendbirdProviderProps['voiceRecord'];
+    replyType?: SendbirdProviderProps['replyType'];
+    isMultipleFilesMessageEnabled?: SendbirdProviderProps['isMultipleFilesMessageEnabled'];
+    colorSet?: SendbirdProviderProps['colorSet'];
+    stringSet?: SendbirdProviderProps['stringSet'];
+    allowProfileEdit?: SendbirdProviderProps['allowProfileEdit'];
+    disableUserProfile?: SendbirdProviderProps['disableUserProfile'];
+    disableMarkAsDelivered?: SendbirdProviderProps['disableMarkAsDelivered'];
+    renderUserProfile?: SendbirdProviderProps['renderUserProfile'];
+    showSearchIcon?: SendbirdProviderProps['showSearchIcon'];
+    imageCompression?: SendbirdProviderProps['imageCompression'];
+    isTypingIndicatorEnabledOnChannelList?: SendbirdProviderProps['isTypingIndicatorEnabledOnChannelList'];
+    isMessageReceiptStatusEnabledOnChannelList?: SendbirdProviderProps['isMessageReceiptStatusEnabledOnChannelList'];
+    uikitOptions?: SendbirdProviderProps['uikitOptions'];
+    isUserIdUsedForNickname?: SendbirdProviderProps['isUserIdUsedForNickname'];
+    sdkInitParams?: SendbirdProviderProps['sdkInitParams'];
+    customExtensionParams?: SendbirdProviderProps['customExtensionParams'];
+    eventHandlers?: SendbirdProviderProps['eventHandlers'];
+    isMessageGroupingEnabled?: AppLayoutProps['isMessageGroupingEnabled'];
+    disableAutoSelect?: AppLayoutProps['disableAutoSelect'];
+    onProfileEditSuccess?: AppLayoutProps['onProfileEditSuccess'];
+}
+export default function App(props: AppProps): JSX.Element;
+export {};

package/types/modules/App/types.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="react" />
+import type { User } from '@sendbird/chat';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import type { Locale } from 'date-fns';
+import { ReplyType, UserListQuery, RenderUserProfileProps, SendBirdProviderConfig } from '../../types';
+import { CustomExtensionParams, SBUEventHandlers, SendbirdChatInitParams } from '../../lib/types';
+import { SendableMessageType } from '../../utils';
+export interface AppLayoutProps {
+    isReactionEnabled?: boolean;
+    replyType?: 'NONE' | 'QUOTE_REPLY' | 'THREAD';
+    isMessageGroupingEnabled?: boolean;
+    isMultipleFilesMessageEnabled?: boolean;
+    allowProfileEdit?: boolean;
+    showSearchIcon?: boolean;
+    onProfileEditSuccess?(user: User): void;
+    disableAutoSelect?: boolean;
+    currentChannel?: GroupChannel;
+    setCurrentChannel: React.Dispatch<GroupChannel | null>;
+}
+interface SubLayoutCommonProps {
+    highlightedMessage?: number | null;
+    setHighlightedMessage: React.Dispatch<number | null>;
+    startingPoint?: number | null;
+    setStartingPoint: React.Dispatch<number | null>;
+    threadTargetMessage: SendableMessageType | null;
+    setThreadTargetMessage: React.Dispatch<SendableMessageType>;
+}
+export interface MobileLayoutProps extends AppLayoutProps, SubLayoutCommonProps {
+}
+export interface DesktopLayoutProps extends AppLayoutProps, SubLayoutCommonProps {
+    showSettings: boolean;
+    setShowSettings: React.Dispatch<boolean>;
+    showSearch: boolean;
+    setShowSearch: React.Dispatch<boolean>;
+    showThread: boolean;
+    setShowThread: React.Dispatch<boolean>;
+}
+export default interface AppProps {
+    appId: string;
+    userId: string;
+    accessToken?: string;
+    customApiHost?: string;
+    customWebSocketHost?: string;
+    theme?: 'light' | 'dark';
+    userListQuery?(): UserListQuery;
+    nickname?: string;
+    profileUrl?: string;
+    dateLocale?: Locale;
+    allowProfileEdit?: boolean;
+    disableUserProfile?: boolean;
+    showSearchIcon?: boolean;
+    renderUserProfile?: (props: RenderUserProfileProps) => React.ReactElement;
+    onProfileEditSuccess?(user: User): void;
+    config?: SendBirdProviderConfig;
+    isReactionEnabled?: boolean;
+    isMessageGroupingEnabled?: boolean;
+    stringSet?: Record<string, string>;
+    colorSet?: Record<string, string>;
+    imageCompression?: {
+        compressionRate?: number;
+        resizingWidth?: number | string;
+        resizingHeight?: number | string;
+    };
+    replyType?: ReplyType;
+    disableAutoSelect?: boolean;
+    isTypingIndicatorEnabledOnChannelList?: boolean;
+    isMessageReceiptStatusEnabledOnChannelList?: boolean;
+    sdkInitParams?: SendbirdChatInitParams;
+    customExtensionParams?: CustomExtensionParams;
+    eventHandlers?: SBUEventHandlers;
+}
+export {};

package/types/modules/Channel/components/ChannelHeader/index.d.ts

@@ -0,0 +1,7 @@
+import './channel-header.scss';
+import React from 'react';
+interface ChannelHeaderProps {
+    className?: string;
+}
+declare const ChannelHeader: React.FC<ChannelHeaderProps>;
+export default ChannelHeader;

package/types/modules/Channel/components/ChannelHeader/utils.d.ts

@@ -0,0 +1,4 @@
+import type { GroupChannel } from '@sendbird/chat/groupChannel';
+export declare const getChannelTitle: (channel: GroupChannel, currentUserId: string, stringSet: {
+    [label: string]: string;
+}) => string;

package/types/modules/Channel/components/ChannelUI/index.d.ts

@@ -0,0 +1,19 @@
+import './channel-ui.scss';
+import React from 'react';
+import { RenderCustomSeparatorProps, RenderMessageProps } from '../../../../types';
+export interface ChannelUIProps {
+    isLoading?: boolean;
+    renderPlaceholderLoader?: () => React.ReactElement;
+    renderPlaceholderInvalid?: () => React.ReactElement;
+    renderPlaceholderEmpty?: () => React.ReactElement;
+    renderChannelHeader?: () => React.ReactElement;
+    renderMessage?: (props: RenderMessageProps) => React.ReactElement;
+    renderMessageInput?: () => React.ReactElement;
+    renderFileUploadIcon?: () => React.ReactElement;
+    renderVoiceMessageIcon?: () => React.ReactElement;
+    renderSendMessageIcon?: () => React.ReactElement;
+    renderTypingIndicator?: () => React.ReactElement;
+    renderCustomSeparator?: (props: RenderCustomSeparatorProps) => React.ReactElement;
+}
+declare const ChannelUI: React.FC<ChannelUIProps>;
+export default ChannelUI;

package/types/modules/Channel/components/FileViewer/index.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { FileMessage } from '@sendbird/chat/message';
+import './file-viewer.scss';
+type FileViewerUIProps = {
+    profileUrl: string;
+    nickname: string;
+    name: string;
+    type: string;
+    url: string;
+    isByMe: boolean;
+    onCancel: () => void;
+    onDelete: () => void;
+    disableDelete: boolean;
+};
+export declare const FileViewerComponent: React.FC<FileViewerUIProps>;
+type FileViewerProps = {
+    onCancel: () => void;
+    message: FileMessage;
+};
+declare const FileViewer: React.FC<FileViewerProps>;
+export default FileViewer;

package/types/modules/Channel/components/FrozenNotification/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import './frozen-notification.scss';
+interface FrozenNotificationProps {
+    className?: string;
+}
+declare const FrozenNotification: ({ className, }: FrozenNotificationProps) => React.ReactElement;
+export default FrozenNotification;

package/types/modules/Channel/components/Message/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { EveryMessage, RenderCustomSeparatorProps, RenderMessageProps } from '../../../../types';
+type MessageUIProps = {
+    message: EveryMessage;
+    hasSeparator?: boolean;
+    chainTop?: boolean;
+    chainBottom?: boolean;
+    handleScroll?: (isBottomMessageAffected?: boolean) => void;
+    renderMessage?: (props: RenderMessageProps) => React.ReactElement;
+    renderCustomSeparator?: (props: RenderCustomSeparatorProps) => React.ReactElement;
+    renderEditInput?: () => React.ReactElement;
+    renderMessageContent?: () => React.ReactElement;
+};
+declare const Message: ({ message, hasSeparator, chainTop, chainBottom, handleScroll, renderCustomSeparator, renderEditInput, renderMessage, renderMessageContent, }: MessageUIProps) => React.ReactElement;
+export default Message;

package/types/modules/Channel/components/MessageInput/VoiceMessageInputWrapper.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import './voice-message-wrapper.scss';
+export interface VoiceMessageInputWrapperProps {
+    channel?: GroupChannel;
+    onCancelClick?: () => void;
+    onSubmitClick?: (file: File, duration: number) => void;
+}
+export declare const VoiceMessageInputWrapper: ({ channel, onCancelClick, onSubmitClick, }: VoiceMessageInputWrapperProps) => React.ReactElement;
+export default VoiceMessageInputWrapper;

package/types/modules/Channel/components/MessageInput/index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import './message-input.scss';
+export type MessageInputWrapperProps = {
+    value?: string;
+    disabled?: boolean;
+    renderFileUploadIcon?: () => React.ReactElement;
+    renderVoiceMessageIcon?: () => React.ReactElement;
+    renderSendMessageIcon?: () => React.ReactElement;
+};
+declare const _default: React.ForwardRefExoticComponent<MessageInputWrapperProps & React.RefAttributes<any>>;
+export default _default;

package/types/modules/Channel/components/MessageInput/useHandleUploadFiles.d.ts

@@ -0,0 +1,19 @@
+import { Logger } from '../../../../lib/SendbirdState';
+import { SendMFMFunctionType } from '../../context/hooks/useSendMultipleFilesMessage';
+import { SendableMessageType } from '../../../../utils';
+import { SendFileMessageFunctionType } from '../../../Thread/context/hooks/useSendFileMessage';
+/**
+ * The handleUploadFiles is a function sending a FileMessage and MultipleFilesMessage
+ * by the received FileList from the ChangeEvent of MessageInput component.
+ */
+interface useHandleUploadFilesDynamicProps {
+    sendFileMessage: SendFileMessageFunctionType;
+    sendMultipleFilesMessage: SendMFMFunctionType;
+    quoteMessage?: SendableMessageType;
+}
+interface useHandleUploadFilesStaticProps {
+    logger: Logger;
+}
+export type HandleUploadFunctionType = (files: File[]) => void;
+export declare const useHandleUploadFiles: ({ sendFileMessage, sendMultipleFilesMessage, quoteMessage, }: useHandleUploadFilesDynamicProps, { logger, }: useHandleUploadFilesStaticProps) => Array<HandleUploadFunctionType>;
+export {};

package/types/modules/Channel/components/MessageList/getMessagePartsInfo.d.ts

@@ -0,0 +1,20 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { CoreMessageType } from '../../../../utils';
+export interface GetMessagePartsInfoProps {
+    allMessages: Array<CoreMessageType>;
+    isMessageGroupingEnabled: boolean;
+    currentIndex: number;
+    currentMessage: CoreMessageType;
+    currentChannel: GroupChannel;
+    replyType: string;
+}
+interface OutPuts {
+    chainTop: boolean;
+    chainBottom: boolean;
+    hasSeparator: boolean;
+}
+/**
+ * exported, should be backward compatible
+ */
+export declare const getMessagePartsInfo: ({ allMessages, isMessageGroupingEnabled, currentIndex, currentMessage, currentChannel, replyType, }: GetMessagePartsInfoProps) => OutPuts;
+export {};

package/types/modules/Channel/components/MessageList/hooks/useScrollBehavior.d.ts

@@ -0,0 +1 @@
+export declare function useScrollBehavior(): any;

package/types/modules/Channel/components/MessageList/hooks/useSetScrollToBottom.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export declare function useSetScrollToBottom({ loading, }: {
+    loading: boolean;
+}): ({
+    scrollBottom: number;
+    scrollToBottomHandler: (e: React.UIEvent<HTMLDivElement, UIEvent>) => void;
+});

package/types/modules/Channel/components/MessageList/index.d.ts

@@ -0,0 +1,12 @@
+import './message-list.scss';
+import React from 'react';
+import { RenderCustomSeparatorProps, RenderMessageProps } from '../../../../types';
+export interface MessageListProps {
+    className?: string;
+    renderMessage?: (props: RenderMessageProps) => React.ReactElement;
+    renderPlaceholderEmpty?: () => React.ReactElement;
+    renderCustomSeparator?: (props: RenderCustomSeparatorProps) => React.ReactElement;
+    renderPlaceholderLoader?: () => React.ReactElement;
+}
+declare const MessageList: React.FC<MessageListProps>;
+export default MessageList;

package/types/modules/Channel/components/RemoveMessageModal.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { EveryMessage } from '../../../types';
+export interface RemoveMessageProps {
+    onSubmit?: () => void;
+    onCancel: () => void;
+    message: EveryMessage;
+}
+declare const RemoveMessage: React.FC<RemoveMessageProps>;
+export default RemoveMessage;

package/types/modules/Channel/components/SuggestedMentionList/SuggestedUserMentionItem.d.ts

@@ -0,0 +1,21 @@
+import React, { MutableRefObject } from 'react';
+import type { Member } from '@sendbird/chat/groupChannel';
+import type { User } from '@sendbird/chat';
+type MentionItemUIEvent = {
+    event: any;
+    member: Member;
+    itemRef: MutableRefObject<HTMLElement>;
+};
+interface SuggestedUserMentionItemProps {
+    member: User | Member;
+    isFocused?: boolean;
+    parentScrollRef?: React.RefObject<HTMLDivElement>;
+    onClick?: (props: MentionItemUIEvent) => void;
+    onMouseOver?: (props: MentionItemUIEvent) => void;
+    onMouseMove?: (props: MentionItemUIEvent) => void;
+    renderUserMentionItem?: (props: {
+        user: User | Member;
+    }) => JSX.Element;
+}
+declare function SuggestedUserMentionItem(props: SuggestedUserMentionItemProps): JSX.Element;
+export default SuggestedUserMentionItem;

package/types/modules/Channel/components/SuggestedMentionList/index.d.ts

@@ -0,0 +1,20 @@
+import './index.scss';
+import React from 'react';
+import type { User } from '@sendbird/chat';
+export interface SuggestedMentionListProps {
+    className?: string;
+    targetNickname: string;
+    memberListQuery?: Record<string, string>;
+    onUserItemClick?: (member: User) => void;
+    onFocusItemChange?: (member: User) => void;
+    onFetchUsers?: (users: Array<User>) => void;
+    renderUserMentionItem?: (props: {
+        user: User;
+    }) => JSX.Element;
+    ableAddMention: boolean;
+    maxMentionCount?: number;
+    maxSuggestionCount?: number;
+    inputEvent?: React.KeyboardEvent<HTMLDivElement>;
+}
+declare function SuggestedMentionList(props: SuggestedMentionListProps): JSX.Element;
+export default SuggestedMentionList;

package/types/modules/Channel/components/SuggestedReplies/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import './index.scss';
+interface Props {
+    replyOptions: string[];
+    onSendMessage: ({ message }: {
+        message: string;
+    }) => void;
+}
+declare const SuggestedReplies: ({ replyOptions, onSendMessage }: Props) => JSX.Element;
+export default SuggestedReplies;

package/types/modules/Channel/components/TypingIndicator.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { Member } from '@sendbird/chat/groupChannel';
+export interface TypingIndicatorTextProps {
+    members: Member[];
+}
+export declare const TypingIndicatorText: ({ members }: TypingIndicatorTextProps) => JSX.Element;
+declare const TypingIndicator: React.FC;
+export default TypingIndicator;

package/types/modules/Channel/components/UnreadCount/index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import './unread-count.scss';
+export interface UnreadCountProps {
+    className?: string;
+    count: number | undefined;
+    onClick(): void;
+    lastReadAt?: Date | null;
+    /** @deprecated Please use `lastReadAt` instead * */
+    time?: string;
+}
+declare const UnreadCount: React.FC<UnreadCountProps>;
+export default UnreadCount;

package/types/modules/Channel/context/ChannelProvider.d.ts

@@ -0,0 +1,129 @@
+import React from 'react';
+import type { GroupChannel } from '@sendbird/chat/groupChannel';
+import type { BaseMessage, FileMessage, FileMessageCreateParams, MultipleFilesMessageCreateParams, UserMessage, UserMessageCreateParams, UserMessageUpdateParams } from '@sendbird/chat/message';
+import type { EmojiContainer, SendbirdError, User } from '@sendbird/chat';
+import { ReplyType, RenderUserProfileProps, Nullable } from '../../../types';
+import { CoreMessageType, SendableMessageType } from '../../../utils';
+import { ThreadReplySelectType } from './const';
+import * as channelActions from './dux/actionTypes';
+import { ChannelActionTypes } from './dux/actionTypes';
+import { MultipleFilesMessage } from '@sendbird/chat/message';
+export type MessageListParams = {
+    replyType?: string;
+    messageType?: string;
+    prevResultSize?: number;
+    nextResultSize?: number;
+    reverse?: boolean;
+    isInclusive?: boolean;
+    includeMetaArray?: boolean;
+    includeReactions?: boolean;
+    includeThreadInfo?: boolean;
+    includeParentMessageInfo?: boolean;
+    showSubchannelMessagesOnly?: boolean;
+    customTypes?: Array<string>;
+    senderUserIds?: Array<string>;
+};
+export type ChannelQueries = {
+    messageListParams?: MessageListParams;
+};
+export type ChannelContextProps = {
+    children?: React.ReactElement;
+    channelUrl: string;
+    isReactionEnabled?: boolean;
+    isMessageGroupingEnabled?: boolean;
+    isMultipleFilesMessageEnabled?: boolean;
+    showSearchIcon?: boolean;
+    animatedMessage?: number | null;
+    highlightedMessage?: number | null;
+    startingPoint?: number | null;
+    onBeforeSendUserMessage?(text: string, quotedMessage?: SendableMessageType): UserMessageCreateParams;
+    onBeforeSendFileMessage?(file: File, quotedMessage?: SendableMessageType): FileMessageCreateParams;
+    onBeforeUpdateUserMessage?(text: string): UserMessageUpdateParams;
+    onBeforeSendVoiceMessage?: (file: File, quotedMessage?: SendableMessageType) => FileMessageCreateParams;
+    onBeforeSendMultipleFilesMessage?: (files: Array<File>, quotedMessage?: SendableMessageType) => MultipleFilesMessageCreateParams;
+    onChatHeaderActionClick?(event: React.MouseEvent<HTMLElement>): void;
+    onSearchClick?(): void;
+    onBackClick?(): void;
+    replyType?: ReplyType;
+    threadReplySelectType?: ThreadReplySelectType;
+    queries?: ChannelQueries;
+    renderUserProfile?: (props: RenderUserProfileProps) => React.ReactElement;
+    filterMessageList?(messages: BaseMessage): boolean;
+    disableUserProfile?: boolean;
+    disableMarkAsRead?: boolean;
+    onReplyInThread?: (props: {
+        message: SendableMessageType;
+    }) => void;
+    onQuoteMessageClick?: (props: {
+        message: SendableMessageType;
+    }) => void;
+    onMessageAnimated?: () => void;
+    onMessageHighlighted?: () => void;
+    scrollBehavior?: 'smooth' | 'auto';
+    reconnectOnIdle?: boolean;
+};
+interface MessageStoreInterface {
+    allMessages: CoreMessageType[];
+    localMessages: CoreMessageType[];
+    loading: boolean;
+    initialized: boolean;
+    /** @deprecated Please use `unreadSinceDate` instead * */
+    unreadSince: string;
+    unreadSinceDate: Date | null;
+    isInvalid: boolean;
+    currentGroupChannel: Nullable<GroupChannel>;
+    hasMorePrev: boolean;
+    oldestMessageTimeStamp: number;
+    hasMoreNext: boolean;
+    latestMessageTimeStamp: number;
+    emojiContainer: EmojiContainer;
+    readStatus: any;
+}
+interface SendMessageParams {
+    message: string;
+    quoteMessage?: SendableMessageType;
+    mentionedUsers?: User[];
+    mentionTemplate?: string;
+}
+interface UpdateMessageParams {
+    messageId: number;
+    message: string;
+    mentionedUsers?: User[];
+    mentionTemplate?: string;
+}
+interface ChannelProviderInterface extends ChannelContextProps, MessageStoreInterface {
+    scrollToMessage?(createdAt: number, messageId: number): void;
+    isScrolled?: boolean;
+    setIsScrolled?: React.Dispatch<React.SetStateAction<boolean>>;
+    messageActionTypes: typeof channelActions;
+    messagesDispatcher: React.Dispatch<ChannelActionTypes>;
+    quoteMessage: SendableMessageType | null;
+    setQuoteMessage: React.Dispatch<React.SetStateAction<SendableMessageType | null>>;
+    initialTimeStamp: number;
+    setInitialTimeStamp: React.Dispatch<React.SetStateAction<number>>;
+    animatedMessageId: number;
+    highLightedMessageId: number;
+    nicknamesMap: Map<string, string>;
+    emojiAllMap: any;
+    onScrollCallback: () => void;
+    onScrollDownCallback: any;
+    scrollRef: React.MutableRefObject<HTMLDivElement>;
+    setAnimatedMessageId: React.Dispatch<React.SetStateAction<number>>;
+    setHighLightedMessageId: React.Dispatch<React.SetStateAction<number>>;
+    messageInputRef: React.MutableRefObject<HTMLInputElement>;
+    deleteMessage(message: CoreMessageType): Promise<CoreMessageType>;
+    updateMessage(props: UpdateMessageParams, callback?: (err: SendbirdError, message: UserMessage) => void): void;
+    resendMessage(failedMessage: SendableMessageType): void;
+    sendMessage: (params: SendMessageParams) => void;
+    sendFileMessage: (file: File, quoteMessage?: SendableMessageType) => Promise<FileMessage>;
+    sendVoiceMessage: (file: File, duration: number, quoteMessage?: SendableMessageType) => void;
+    sendMultipleFilesMessage: (files: Array<File>, quoteMessage?: SendableMessageType) => Promise<MultipleFilesMessage>;
+    toggleReaction(message: SendableMessageType, emojiKey: string, isReacted: boolean): void;
+    renderUserMentionItem?: (props: {
+        user: User;
+    }) => JSX.Element;
+}
+declare const ChannelProvider: React.FC<ChannelContextProps>;
+export type UseChannelType = () => ChannelProviderInterface;
+declare const useChannelContext: UseChannelType;
+export { ChannelProvider, useChannelContext, };

package/types/modules/Channel/context/compareMessagesForGrouping.d.ts

@@ -0,0 +1,10 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { ReplyType } from '../../../types';
+import { CoreMessageType } from '../../../utils';
+/**
+ * exported, should be backward compatible
+ */
+export declare const compareMessagesForGrouping: (prevMessage: CoreMessageType, currMessage: CoreMessageType, nextMessage: CoreMessageType, currentChannel: GroupChannel, replyType: ReplyType) => [
+    chainTop: boolean,
+    chainBottom: boolean
+];

package/types/modules/Channel/context/const.d.ts

@@ -0,0 +1,9 @@
+export declare const PREV_RESULT_SIZE = 30;
+export declare const NEXT_RESULT_SIZE = 15;
+export declare const MAX_USER_MENTION_COUNT = 10;
+export declare const MAX_USER_SUGGESTION_COUNT = 15;
+export declare const USER_MENTION_TEMP_CHAR = "@";
+export declare enum ThreadReplySelectType {
+    PARENT = "PARENT",
+    THREAD = "THREAD"
+}

package/types/modules/Channel/context/dux/actionTypes.d.ts

@@ -0,0 +1,87 @@
+import { CreateAction } from '../../../../utils/typeHelpers/reducers/createAction';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { CoreMessageType, SendableMessageType } from '../../../../utils';
+import { EmojiContainer } from '@sendbird/chat';
+import { ReactionEvent } from '@sendbird/chat/message';
+import { MessageListParams } from '../ChannelProvider';
+import { FileUploadedPayload } from '../hooks/useSendMultipleFilesMessage';
+export declare const RESET_MESSAGES = "RESET_MESSAGES";
+export declare const FETCH_INITIAL_MESSAGES_START = "FETCH_INITIAL_MESSAGES_START";
+export declare const FETCH_INITIAL_MESSAGES_SUCCESS = "FETCH_INITIAL_MESSAGES_SUCCESS";
+export declare const FETCH_INITIAL_MESSAGES_FAILURE = "FETCH_INITIAL_MESSAGES_FAILURE";
+export declare const FETCH_PREV_MESSAGES_SUCCESS = "FETCH_PREV_MESSAGES_SUCCESS";
+export declare const FETCH_PREV_MESSAGES_FAILURE = "FETCH_PREV_MESSAGES_FAILURE";
+export declare const FETCH_NEXT_MESSAGES_SUCCESS = "FETCH_NEXT_MESSAGES_SUCCESS";
+export declare const FETCH_NEXT_MESSAGES_FAILURE = "FETCH_NEXT_MESSAGES_FAILURE";
+export declare const SEND_MESSAGE_START = "SEND_MESSAGE_START";
+export declare const SEND_MESSAGE_SUCCESS = "SEND_MESSAGE_SUCCESS";
+export declare const SEND_MESSAGE_FAILURE = "SEND_MESSAGE_FAILURE";
+export declare const RESEND_MESSAGE_START = "RESEND_MESSAGE_START";
+export declare const ON_MESSAGE_RECEIVED = "ON_MESSAGE_RECEIVED";
+export declare const ON_MESSAGE_UPDATED = "ON_MESSAGE_UPDATED";
+export declare const ON_MESSAGE_THREAD_INFO_UPDATED = "ON_MESSAGE_THREAD_INFO_UPDATED";
+export declare const ON_MESSAGE_DELETED = "ON_MESSAGE_DELETED";
+export declare const ON_MESSAGE_DELETED_BY_REQ_ID = "ON_MESSAGE_DELETED_BY_REQ_ID";
+export declare const SET_CURRENT_CHANNEL = "SET_CURRENT_CHANNEL";
+export declare const SET_CHANNEL_INVALID = "SET_CHANNEL_INVALID";
+export declare const MARK_AS_READ = "MARK_AS_READ";
+export declare const ON_REACTION_UPDATED = "ON_REACTION_UPDATED";
+export declare const SET_EMOJI_CONTAINER = "SET_EMOJI_CONTAINER";
+export declare const MESSAGE_LIST_PARAMS_CHANGED = "MESSAGE_LIST_PARAMS_CHANGED";
+export declare const ON_FILE_INFO_UPLOADED = "ON_FILE_INFO_UPLOADED";
+type CHANNEL_PAYLOAD_TYPES = {
+    [RESET_MESSAGES]: null;
+    [FETCH_INITIAL_MESSAGES_START]: null;
+    [FETCH_INITIAL_MESSAGES_SUCCESS]: {
+        currentGroupChannel: null | GroupChannel;
+        messages: CoreMessageType[];
+    };
+    [FETCH_PREV_MESSAGES_SUCCESS]: {
+        currentGroupChannel: null | GroupChannel;
+        messages: CoreMessageType[];
+    };
+    [FETCH_NEXT_MESSAGES_SUCCESS]: {
+        currentGroupChannel: null | GroupChannel;
+        messages: CoreMessageType[];
+    };
+    [FETCH_INITIAL_MESSAGES_FAILURE]: {
+        currentGroupChannel: null | GroupChannel;
+    };
+    [FETCH_PREV_MESSAGES_FAILURE]: {
+        currentGroupChannel: null | GroupChannel;
+    };
+    [FETCH_NEXT_MESSAGES_FAILURE]: {
+        currentGroupChannel: null | GroupChannel;
+    };
+    [SEND_MESSAGE_START]: SendableMessageType;
+    [SEND_MESSAGE_SUCCESS]: SendableMessageType;
+    [SEND_MESSAGE_FAILURE]: SendableMessageType;
+    [SET_CURRENT_CHANNEL]: null | GroupChannel;
+    [SET_CHANNEL_INVALID]: null;
+    [ON_MESSAGE_RECEIVED]: {
+        channel: GroupChannel;
+        message: SendableMessageType;
+    };
+    [ON_MESSAGE_UPDATED]: {
+        channel: GroupChannel;
+        message: SendableMessageType;
+    };
+    [ON_MESSAGE_THREAD_INFO_UPDATED]: {
+        channel: GroupChannel;
+        event: any;
+    };
+    [RESEND_MESSAGE_START]: SendableMessageType;
+    [MARK_AS_READ]: {
+        channel: null | GroupChannel;
+    };
+    [ON_MESSAGE_DELETED]: MessageId;
+    [ON_MESSAGE_DELETED_BY_REQ_ID]: RequestId;
+    [SET_EMOJI_CONTAINER]: EmojiContainer;
+    [ON_REACTION_UPDATED]: ReactionEvent;
+    [MESSAGE_LIST_PARAMS_CHANGED]: MessageListParams;
+    [ON_FILE_INFO_UPLOADED]: FileUploadedPayload;
+};
+type MessageId = number;
+type RequestId = string;
+export type ChannelActionTypes = CreateAction<CHANNEL_PAYLOAD_TYPES>;
+export {};

package/types/modules/Channel/context/dux/initialState.d.ts

@@ -0,0 +1,24 @@
+import { CoreMessageType, SendableMessageType } from '../../../../utils';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { EmojiContainer } from '@sendbird/chat';
+import type { MessageListParams as MessageListParamsInternal } from '../ChannelProvider';
+export interface ChannelInitialStateType {
+    allMessages: (SendableMessageType | CoreMessageType)[];
+    localMessages: (SendableMessageType | CoreMessageType)[];
+    loading: boolean;
+    initialized: boolean;
+    /** @deprecated Please use `unreadSinceDate` instead. * */
+    unreadSince: string;
+    unreadSinceDate: Date | null;
+    isInvalid: boolean;
+    currentGroupChannel: GroupChannel | null;
+    hasMorePrev: boolean;
+    oldestMessageTimeStamp: number;
+    hasMoreNext: boolean;
+    latestMessageTimeStamp: number;
+    emojiContainer: EmojiContainer;
+    readStatus: any;
+    messageListParams: null | MessageListParamsInternal;
+}
+declare const initialState: ChannelInitialStateType;
+export default initialState;

package/types/modules/Channel/context/dux/reducers.d.ts

@@ -0,0 +1,3 @@
+import type { ChannelActionTypes } from './actionTypes';
+import { ChannelInitialStateType } from './initialState';
+export default function channelReducer(state: ChannelInitialStateType, action: ChannelActionTypes): ChannelInitialStateType;