@sendbird/uikit-react 3.7.0 → 3.8.1

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

@@ -0,0 +1,131 @@
+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';
+import { Member } from '@sendbird/chat/groupChannel';
+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;
+    typingMembers: Member[];
+}
+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,93 @@
+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';
+import { Member } from '@sendbird/chat/lib/__definition';
+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";
+export declare const ON_TYPING_STATUS_UPDATED = "ON_TYPING_STATUS_UPDATED";
+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;
+    [ON_TYPING_STATUS_UPDATED]: {
+        channel: GroupChannel;
+        typingMembers: Member[];
+    };
+};
+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,25 @@
+import { CoreMessageType, SendableMessageType } from '../../../../utils';
+import { GroupChannel, Member } 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;
+    typingMembers: Member[];
+}
+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;

package/types/modules/Channel/context/hooks/useDeleteMessageCallback.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { ChannelActionTypes } from '../dux/actionTypes';
+import { LoggerInterface } from '../../../../lib/Logger';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { CoreMessageType } from '../../../../utils';
+type UseDeleteMessageCallbackOptions = {
+    currentGroupChannel: null | GroupChannel;
+    messagesDispatcher: React.Dispatch<ChannelActionTypes>;
+};
+type UseDeleteMessageCallbackParams = {
+    logger: LoggerInterface;
+};
+declare function useDeleteMessageCallback({ currentGroupChannel, messagesDispatcher }: UseDeleteMessageCallbackOptions, { logger }: UseDeleteMessageCallbackParams): (message: CoreMessageType) => Promise<CoreMessageType>;
+export default useDeleteMessageCallback;

package/types/modules/Channel/context/hooks/useGetChannel.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { ChannelActionTypes } from '../dux/actionTypes';
+import { SdkStore } from '../../../../lib/types';
+import { LoggerInterface } from '../../../../lib/Logger';
+import { MarkAsReadSchedulerType } from '../../../../lib/hooks/useMarkAsReadScheduler';
+type UseGetChannelOptions = {
+    channelUrl: string;
+    sdkInit: boolean;
+    disableMarkAsRead: boolean;
+};
+type UseGetChannelParams = {
+    messagesDispatcher: React.Dispatch<ChannelActionTypes>;
+    sdk: SdkStore['sdk'];
+    logger: LoggerInterface;
+    markAsReadScheduler: MarkAsReadSchedulerType;
+};
+declare function useGetChannel({ channelUrl, sdkInit, disableMarkAsRead }: UseGetChannelOptions, { messagesDispatcher, sdk, logger, markAsReadScheduler }: UseGetChannelParams): void;
+export default useGetChannel;

package/types/modules/Channel/context/hooks/useHandleChannelEvents.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { SendableMessageType } from '../../../../utils';
+import { ChannelActionTypes } from '../dux/actionTypes';
+import { LoggerInterface } from '../../../../lib/Logger';
+import { SdkStore } from '../../../../lib/types';
+/**
+ * Handles ChannelEvents and send values to dispatcher using messagesDispatcher
+ * messagesDispatcher: Dispatcher
+ * sdk: sdkInstance
+ * logger: loggerInstance
+ * channelUrl: string
+ * sdkInit: bool
+ */
+interface DynamicParams {
+    sdkInit: boolean;
+    currentUserId: string;
+    currentGroupChannel: GroupChannel;
+    disableMarkAsRead: boolean;
+}
+interface StaticParams {
+    sdk: SdkStore['sdk'];
+    logger: LoggerInterface;
+    scrollRef: React.RefObject<HTMLDivElement>;
+    setQuoteMessage: React.Dispatch<React.SetStateAction<SendableMessageType>>;
+    messagesDispatcher: React.Dispatch<ChannelActionTypes>;
+}
+declare function useHandleChannelEvents({ sdkInit, currentUserId, currentGroupChannel, disableMarkAsRead, }: DynamicParams, { sdk, logger, scrollRef, setQuoteMessage, messagesDispatcher, }: StaticParams): void;
+export default useHandleChannelEvents;

package/types/modules/Channel/context/hooks/useHandleChannelPubsubEvents.d.ts

@@ -0,0 +1,11 @@
+import React, { RefObject } from 'react';
+import { SBUGlobalPubSub } from '../../../../lib/pubSub/topics';
+import { ChannelActionTypes } from '../dux/actionTypes';
+export interface UseHandlePubsubEventsParams {
+    channelUrl: string;
+    sdkInit: boolean;
+    pubSub: SBUGlobalPubSub;
+    dispatcher: React.Dispatch<ChannelActionTypes>;
+    scrollRef: RefObject<HTMLElement>;
+}
+export declare const useHandleChannelPubsubEvents: ({ channelUrl, sdkInit, pubSub, dispatcher, scrollRef, }: UseHandlePubsubEventsParams) => void;

package/types/modules/Channel/context/hooks/useHandleReconnect.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import type { GroupChannel } from '@sendbird/chat/groupChannel';
+import { Logger } from '../../../../lib/SendbirdState';
+import { MarkAsReadSchedulerType } from '../../../../lib/hooks/useMarkAsReadScheduler';
+import { ChannelActionTypes } from '../dux/actionTypes';
+import { SdkStore } from '../../../../lib/types';
+interface DynamicParams {
+    isOnline: boolean;
+    replyType?: string;
+    disableMarkAsRead: boolean;
+    reconnectOnIdle: boolean;
+}
+interface StaticParams {
+    logger: Logger;
+    sdk: SdkStore['sdk'];
+    currentGroupChannel: GroupChannel;
+    scrollRef: React.RefObject<HTMLDivElement>;
+    markAsReadScheduler: MarkAsReadSchedulerType;
+    messagesDispatcher: React.Dispatch<ChannelActionTypes>;
+    userFilledMessageListQuery?: Record<string, any>;
+}
+declare function useHandleReconnect({ isOnline, replyType, disableMarkAsRead, reconnectOnIdle }: DynamicParams, { logger, sdk, scrollRef, currentGroupChannel, messagesDispatcher, markAsReadScheduler, userFilledMessageListQuery, }: StaticParams): void;
+export default useHandleReconnect;

package/types/modules/Channel/context/hooks/useInitialMessagesFetch.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { MessageListParams as MessageListParamsInternal } from '../ChannelProvider';
+import { ReplyType as ReplyTypeInternal } from '../../../../types';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { LoggerInterface } from '../../../../lib/Logger';
+import { ChannelActionTypes } from '../dux/actionTypes';
+type UseInitialMessagesFetchOptions = {
+    currentGroupChannel: GroupChannel;
+    initialTimeStamp: number;
+    userFilledMessageListQuery: MessageListParamsInternal;
+    replyType: ReplyTypeInternal;
+    setIsScrolled: (val: boolean) => void;
+};
+type UseInitialMessagesFetchParams = {
+    logger: LoggerInterface;
+    messagesDispatcher: React.Dispatch<ChannelActionTypes>;
+    scrollRef: React.RefObject<HTMLElement>;
+};
+declare function useInitialMessagesFetch({ currentGroupChannel, initialTimeStamp, userFilledMessageListQuery, replyType, setIsScrolled, }: UseInitialMessagesFetchOptions, { logger, scrollRef, messagesDispatcher }: UseInitialMessagesFetchParams): () => void;
+export default useInitialMessagesFetch;

package/types/modules/Channel/context/hooks/useReconnectOnIdle.d.ts

@@ -0,0 +1,5 @@
+import type { GroupChannel } from '@sendbird/chat/groupChannel';
+declare function useReconnectOnIdle(isOnline: boolean, currentGroupChannel: GroupChannel, reconnectOnIdle?: boolean): {
+    shouldReconnect: boolean;
+};
+export default useReconnectOnIdle;

package/types/modules/Channel/context/hooks/useResendMessageCallback.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { ChannelActionTypes } from '../dux/actionTypes';
+import { SendableMessageType } from '../../../../utils';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { LoggerInterface } from '../../../../lib/Logger';
+type UseResendMessageCallbackOptions = {
+    currentGroupChannel: null | GroupChannel;
+    messagesDispatcher: React.Dispatch<ChannelActionTypes>;
+};
+type UseResendMessageCallbackParams = {
+    logger: LoggerInterface;
+};
+declare function useResendMessageCallback({ currentGroupChannel, messagesDispatcher }: UseResendMessageCallbackOptions, { logger }: UseResendMessageCallbackParams): (failedMessage: SendableMessageType) => void;
+export default useResendMessageCallback;

package/types/modules/Channel/context/hooks/useScrollCallback.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { ReplyType as ReplyTypeInternal } from '../../../../types';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { MessageListParams as MessageListParamsInternal } from '../ChannelProvider';
+import { LoggerInterface } from '../../../../lib/Logger';
+import { ChannelActionTypes } from '../dux/actionTypes';
+import { SdkStore } from '../../../../lib/types';
+type UseScrollCallbackOptions = {
+    currentGroupChannel: GroupChannel;
+    oldestMessageTimeStamp: number;
+    userFilledMessageListQuery: MessageListParamsInternal;
+    replyType: ReplyTypeInternal;
+};
+type UseScrollCallbackParams = {
+    hasMorePrev: boolean;
+    logger: LoggerInterface;
+    messagesDispatcher: React.Dispatch<ChannelActionTypes>;
+    sdk: SdkStore['sdk'];
+};
+declare function useScrollCallback({ currentGroupChannel, oldestMessageTimeStamp, userFilledMessageListQuery, replyType }: UseScrollCallbackOptions, { hasMorePrev, logger, messagesDispatcher, sdk }: UseScrollCallbackParams): () => void;
+export default useScrollCallback;

package/types/modules/Channel/context/hooks/useScrollDownCallback.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { ChannelActionTypes } from '../dux/actionTypes';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { LoggerInterface } from '../../../../lib/Logger';
+import { SdkStore } from '../../../../lib/types';
+import { ReplyType as ReplyTypeInternal } from '../../../../types';
+import { MessageListParams as MessageListParamsInternal } from '../ChannelProvider';
+import { BaseMessage } from '@sendbird/chat/message';
+type UseScrollDownCallbackOptions = {
+    currentGroupChannel: null | GroupChannel;
+    latestMessageTimeStamp: number;
+    userFilledMessageListQuery: MessageListParamsInternal;
+    hasMoreNext: boolean;
+    replyType: ReplyTypeInternal;
+};
+type UseScrollDownCallbackParams = {
+    logger: LoggerInterface;
+    messagesDispatcher: React.Dispatch<ChannelActionTypes>;
+    sdk: SdkStore['sdk'];
+};
+type Callback = (param: [BaseMessage[], null] | [null, unknown]) => void;
+declare function useScrollDownCallback({ currentGroupChannel, latestMessageTimeStamp, userFilledMessageListQuery, hasMoreNext, replyType, }: UseScrollDownCallbackOptions, { logger, messagesDispatcher, sdk }: UseScrollDownCallbackParams): (cb: Callback) => void;
+export default useScrollDownCallback;

package/types/modules/Channel/context/hooks/useScrollToMessage.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import type { BaseMessage } from '@sendbird/chat/message';
+import { LoggerInterface } from '../../../../lib/Logger';
+interface DynamicParams {
+    setInitialTimeStamp: React.Dispatch<React.SetStateAction<number>>;
+    setAnimatedMessageId: React.Dispatch<React.SetStateAction<number>>;
+    allMessages: BaseMessage[];
+    scrollRef: React.RefObject<HTMLDivElement>;
+}
+interface StaticParams {
+    logger: LoggerInterface;
+}
+declare function useScrollToMessage({ setInitialTimeStamp, setAnimatedMessageId, allMessages, scrollRef, }: DynamicParams, { logger }: StaticParams): (createdAt: number, messageId: number) => void;
+export default useScrollToMessage;

package/types/modules/Channel/context/hooks/useSendFileMessageCallback.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { FileMessage, FileMessageCreateParams } from '@sendbird/chat/message';
+import { ChannelActionTypes } from '../dux/actionTypes';
+import { SBUGlobalPubSub } from '../../../../lib/pubSub/topics';
+import { LoggerInterface } from '../../../../lib/Logger';
+import { SendableMessageType } from '../../../../utils';
+import { SendBirdState } from '../../../../lib/types';
+type UseSendFileMessageCallbackOptions = {
+    currentGroupChannel: null | GroupChannel;
+    onBeforeSendFileMessage?: (file: File, quoteMessage: SendableMessageType | null) => FileMessageCreateParams;
+    imageCompression?: SendBirdState['config']['imageCompression'];
+};
+type UseSendFileMessageCallbackParams = {
+    logger: LoggerInterface;
+    pubSub: SBUGlobalPubSub;
+    scrollRef: React.MutableRefObject<HTMLDivElement | null>;
+    messagesDispatcher: React.Dispatch<ChannelActionTypes>;
+};
+export default function useSendFileMessageCallback({ currentGroupChannel, onBeforeSendFileMessage, imageCompression }: UseSendFileMessageCallbackOptions, { logger, pubSub, scrollRef, messagesDispatcher }: UseSendFileMessageCallbackParams): ((compressedFile: File, quoteMessage?: any) => Promise<FileMessage>)[];
+export {};

package/types/modules/Channel/context/hooks/useSendMessageCallback.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { User } from '@sendbird/chat';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { UserMessageCreateParams } from '@sendbird/chat/message';
+import { ChannelActionTypes } from '../dux/actionTypes';
+import { SBUGlobalPubSub } from '../../../../lib/pubSub/topics';
+import { SendableMessageType } from '../../../../utils';
+import { LoggerInterface } from '../../../../lib/Logger';
+type UseSendMessageCallbackOptions = {
+    isMentionEnabled: boolean;
+    currentGroupChannel: null | GroupChannel;
+    onBeforeSendUserMessage?: (message: string, quoteMessage?: SendableMessageType) => UserMessageCreateParams;
+};
+type UseSendMessageCallbackParams = {
+    logger: LoggerInterface;
+    pubSub: SBUGlobalPubSub;
+    scrollRef: React.MutableRefObject<HTMLDivElement | null>;
+    messagesDispatcher: React.Dispatch<ChannelActionTypes>;
+};
+type SendMessageParams = {
+    message: string;
+    quoteMessage?: SendableMessageType;
+    mentionedUsers?: User[];
+    mentionTemplate?: string;
+};
+export default function useSendMessageCallback({ isMentionEnabled, currentGroupChannel, onBeforeSendUserMessage }: UseSendMessageCallbackOptions, { logger, pubSub, scrollRef, messagesDispatcher }: UseSendMessageCallbackParams): readonly [React.MutableRefObject<HTMLInputElement>, ({ quoteMessage, message, mentionTemplate, mentionedUsers, }: SendMessageParams) => void];
+export {};

package/types/modules/Channel/context/hooks/useSendMultipleFilesMessage.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="react" />
+import type { GroupChannel } from '@sendbird/chat/groupChannel';
+import type { MultipleFilesMessageCreateParams, UploadableFileInfo } from '@sendbird/chat/message';
+import { MultipleFilesMessage } from '@sendbird/chat/message';
+import type { Logger } from '../../../../lib/SendbirdState';
+import type { Nullable } from '../../../../types';
+import { SendableMessageType } from '../../../../utils';
+import { PublishingModuleType } from '../../../internalInterfaces';
+export type OnBeforeSendMFMType = (files: Array<File>, quoteMessage?: SendableMessageType) => MultipleFilesMessageCreateParams;
+export interface UseSendMFMDynamicParams {
+    currentChannel: Nullable<GroupChannel>;
+    onBeforeSendMultipleFilesMessage?: OnBeforeSendMFMType;
+    publishingModules: PublishingModuleType[];
+}
+export interface UseSendMFMStaticParams {
+    logger: Logger;
+    pubSub: any;
+    scrollRef?: React.RefObject<HTMLDivElement>;
+}
+export interface FileUploadedPayload {
+    channelUrl: string;
+    requestId: string;
+    index: number;
+    uploadableFileInfo: UploadableFileInfo;
+    error: Error;
+}
+export type SendMFMFunctionType = (files: Array<File>, quoteMessage?: SendableMessageType) => Promise<MultipleFilesMessage>;
+/**
+ * pubSub is used instead of messagesDispatcher to avoid redundantly calling
+ * because this useSendMultipleFilesMessage is used in the Channel and Thread both
+ */
+export declare const useSendMultipleFilesMessage: ({ currentChannel, onBeforeSendMultipleFilesMessage, publishingModules, }: UseSendMFMDynamicParams, { logger, pubSub, scrollRef, }: UseSendMFMStaticParams) => Array<SendMFMFunctionType>;

package/types/modules/Channel/context/hooks/useSendVoiceMessageCallback.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { FileMessageCreateParams } from '@sendbird/chat/message';
+import type { Logger } from '../../../../lib/SendbirdState';
+import { SBUGlobalPubSub } from '../../../../lib/pubSub/topics';
+import type { SendableMessageType } from '../../../../utils';
+import type { Nullable } from '../../../../types';
+import { ChannelActionTypes } from '../dux/actionTypes';
+interface DynamicParams {
+    currentGroupChannel: Nullable<GroupChannel>;
+    onBeforeSendVoiceMessage?: (file: File, quoteMessage?: SendableMessageType) => FileMessageCreateParams;
+}
+interface StaticParams {
+    logger: Logger;
+    pubSub: SBUGlobalPubSub;
+    scrollRef: React.RefObject<HTMLDivElement>;
+    messagesDispatcher: React.Dispatch<ChannelActionTypes>;
+}
+type FuncType = (file: File, duration: number, quoteMessage: SendableMessageType) => void;
+export declare const useSendVoiceMessageCallback: ({ currentGroupChannel, onBeforeSendVoiceMessage, }: DynamicParams, { logger, pubSub, scrollRef, messagesDispatcher, }: StaticParams) => Array<FuncType>;
+export default useSendVoiceMessageCallback;

package/types/modules/Channel/context/hooks/useStatefulFileInfoList.d.ts

@@ -0,0 +1,3 @@
+import { StatefulFileInfo } from '../../../../utils/createStatefulFileInfoList';
+import { CoreMessageType } from '../../../../utils';
+export declare const useStatefulFileInfoList: (message: CoreMessageType) => StatefulFileInfo[];

package/types/modules/Channel/context/hooks/useThreadMessageKindKeySelector.d.ts

@@ -0,0 +1,7 @@
+import { ThreadMessageKindType } from '../../../../ui/MultipleFilesMessageItemBody';
+interface DynamicSideLengthProps {
+    threadMessageKind?: ThreadMessageKindType;
+    isMobile: boolean;
+}
+export declare function useThreadMessageKindKeySelector({ threadMessageKind, isMobile, }: DynamicSideLengthProps): string;
+export {};

package/types/modules/Channel/context/hooks/useToggleReactionCallback.d.ts

@@ -0,0 +1,11 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { LoggerInterface } from '../../../../lib/Logger';
+import { BaseMessage } from '@sendbird/chat/message';
+type UseToggleReactionCallbackOptions = {
+    currentGroupChannel: GroupChannel | null;
+};
+type UseToggleReactionCallbackParams = {
+    logger: LoggerInterface;
+};
+export default function useToggleReactionCallback({ currentGroupChannel }: UseToggleReactionCallbackOptions, { logger }: UseToggleReactionCallbackParams): (message: BaseMessage, key: string, isReacted: boolean) => void;
+export {};