@sendbird/uikit-react 3.7.0 → 3.8.1

package/types/lib/types.d.ts

@@ -0,0 +1,166 @@
+import React from 'react';
+import type SendbirdChat from '@sendbird/chat';
+import type { User, SendbirdChatParams } from '@sendbird/chat';
+import type { GroupChannel, GroupChannelCreateParams, GroupChannelModule } from '@sendbird/chat/groupChannel';
+import type { OpenChannel, OpenChannelCreateParams, OpenChannelModule } from '@sendbird/chat/openChannel';
+import type { FileMessage, FileMessageCreateParams, UserMessage, UserMessageCreateParams, UserMessageUpdateParams } from '@sendbird/chat/message';
+import { SBUConfig } from '@sendbird/uikit-tools';
+import { Module, ModuleNamespaces } from '@sendbird/chat/lib/__definition';
+import type { RenderUserProfileProps, ReplyType, UserListQuery } from '../types';
+import { UikitMessageHandler } from './selectors';
+import { Logger } from './SendbirdState';
+import { MarkAsReadSchedulerType } from './hooks/useMarkAsReadScheduler';
+import { MarkAsDeliveredSchedulerType } from './hooks/useMarkAsDeliveredScheduler';
+import { PartialDeep } from '../utils/typeHelpers/partialDeep';
+import { CoreMessageType } from '../utils';
+import { UserActionTypes } from './dux/user/actionTypes';
+import { SdkActionTypes } from './dux/sdk/actionTypes';
+import { ReconnectType } from './hooks/useConnect/types';
+import { SBUGlobalPubSub } from './pubSub/topics';
+export declare const Role: {
+    readonly OPERATOR: "operator";
+    readonly NONE: "none";
+};
+export interface SBUEventHandlers {
+    reaction?: {
+        onPressUserProfile?(member: User): void;
+    };
+}
+export interface SendBirdStateConfig {
+    disableUserProfile: boolean;
+    disableMarkAsDelivered: boolean;
+    renderUserProfile?: (props: RenderUserProfileProps) => React.ReactElement;
+    onUserProfileMessage?: (props: GroupChannel) => void;
+    allowProfileEdit: boolean;
+    isOnline: boolean;
+    userId: string;
+    appId: string;
+    accessToken: string;
+    theme: string;
+    pubSub: SBUGlobalPubSub;
+    logger: Logger;
+    setCurrentTheme: (theme: 'light' | 'dark') => void;
+    /** @deprecated Please use setCurrentTheme instead * */
+    setCurrenttheme: (theme: 'light' | 'dark') => void;
+    userListQuery?(): UserListQuery;
+    isReactionEnabled: boolean;
+    isMentionEnabled: boolean;
+    isMultipleFilesMessageEnabled: boolean;
+    isVoiceMessageEnabled?: boolean;
+    uikitUploadSizeLimit: number;
+    uikitMultipleFilesMessageLimit: number;
+    voiceRecord?: {
+        maxRecordingTime: number;
+        minRecordingTime: number;
+    };
+    userMention: {
+        maxMentionCount: number;
+        maxSuggestionCount: number;
+    };
+    imageCompression?: {
+        compressionRate?: number;
+        resizingWidth?: number | string;
+        resizingHeight?: number | string;
+    };
+    markAsReadScheduler: MarkAsReadSchedulerType;
+    markAsDeliveredScheduler: MarkAsDeliveredSchedulerType;
+    isTypingIndicatorEnabledOnChannelList?: boolean;
+    isMessageReceiptStatusEnabledOnChannelList?: boolean;
+    replyType: ReplyType;
+    showSearchIcon?: boolean;
+    groupChannel: {
+        enableOgtag: SBUConfig['groupChannel']['channel']['enableOgtag'];
+        enableTypingIndicator: SBUConfig['groupChannel']['channel']['enableTypingIndicator'];
+        enableDocument: SBUConfig['groupChannel']['channel']['input']['enableDocument'];
+        threadReplySelectType: SBUConfig['groupChannel']['channel']['threadReplySelectType'];
+    };
+    openChannel: {
+        enableOgtag: SBUConfig['openChannel']['channel']['enableOgtag'];
+        enableDocument: SBUConfig['openChannel']['channel']['input']['enableDocument'];
+    };
+}
+export interface SdkStore {
+    error: boolean;
+    initialized: boolean;
+    loading: boolean;
+    sdk: SendbirdChat & ModuleNamespaces<[GroupChannelModule, OpenChannelModule]>;
+}
+export interface UserStore {
+    initialized: boolean;
+    loading: boolean;
+    user: User;
+}
+export interface SendBirdStateStore {
+    sdkStore: SdkStore;
+    userStore: UserStore;
+}
+export type SendBirdState = {
+    config: SendBirdStateConfig;
+    stores: SendBirdStateStore;
+    dispatchers: {
+        sdkDispatcher: React.Dispatch<SdkActionTypes>;
+        userDispatcher: React.Dispatch<UserActionTypes>;
+        reconnect: ReconnectType;
+    };
+    eventHandlers?: SBUEventHandlers;
+};
+type GetSdk = SendbirdChat | undefined;
+type GetConnect = (userId: string, accessToken?: string) => Promise<User>;
+type GetDisconnect = () => Promise<void>;
+type GetUpdateUserInfo = (nickName: string, profileUrl?: string) => Promise<User>;
+type GetCreateGroupChannel = (channelParams: GroupChannelCreateParams) => Promise<GroupChannel>;
+type GetCreateOpenChannel = (channelParams: OpenChannelCreateParams) => Promise<OpenChannel>;
+type GetGetGroupChannel = (channelUrl: string, isSelected?: boolean) => Promise<GroupChannel>;
+type GetGetOpenChannel = (channelUrl: string) => Promise<OpenChannel>;
+type GetLeaveGroupChannel = (channel: GroupChannel) => Promise<void>;
+type GetEnterOpenChannel = (channel: OpenChannel) => Promise<OpenChannel>;
+type GetExitOpenChannel = (channel: OpenChannel) => Promise<void>;
+type GetFreezeChannel = (channel: GroupChannel | OpenChannel) => Promise<void>;
+type GetUnFreezeChannel = (channel: GroupChannel | OpenChannel) => Promise<void>;
+type GetSendUserMessage = (channel: GroupChannel | OpenChannel, userMessageParams: UserMessageCreateParams) => UikitMessageHandler;
+type GetSendFileMessage = (channel: GroupChannel | OpenChannel, fileMessageParams: FileMessageCreateParams) => UikitMessageHandler;
+type GetUpdateUserMessage = (channel: GroupChannel | OpenChannel, messageId: string | number, params: UserMessageUpdateParams) => Promise<UserMessage>;
+type GetDeleteMessage = (channel: GroupChannel | OpenChannel, message: CoreMessageType) => Promise<void>;
+type GetResendUserMessage = (channel: GroupChannel | OpenChannel, failedMessage: UserMessage) => Promise<UserMessage>;
+type GetResendFileMessage = (channel: GroupChannel | OpenChannel, failedMessage: FileMessage) => Promise<FileMessage>;
+export interface sendbirdSelectorsInterface {
+    getSdk: (store: SendBirdState) => GetSdk;
+    getConnect: (store: SendBirdState) => GetConnect;
+    getDisconnect: (store: SendBirdState) => GetDisconnect;
+    getUpdateUserInfo: (store: SendBirdState) => GetUpdateUserInfo;
+    getCreateGroupChannel: (store: SendBirdState) => GetCreateGroupChannel;
+    getCreateOpenChannel: (store: SendBirdState) => GetCreateOpenChannel;
+    getGetGroupChannel: (store: SendBirdState) => GetGetGroupChannel;
+    getGetOpenChannel: (store: SendBirdState) => GetGetOpenChannel;
+    getLeaveGroupChannel: (store: SendBirdState) => GetLeaveGroupChannel;
+    getEnterOpenChannel: (store: SendBirdState) => GetEnterOpenChannel;
+    getExitOpenChannel: (store: SendBirdState) => GetExitOpenChannel;
+    getFreezeChannel: (store: SendBirdState) => GetFreezeChannel;
+    getUnFreezeChannel: (store: SendBirdState) => GetUnFreezeChannel;
+    getSendUserMessage: (store: SendBirdState) => GetSendUserMessage;
+    getSendFileMessage: (store: SendBirdState) => GetSendFileMessage;
+    getUpdateUserMessage: (store: SendBirdState) => GetUpdateUserMessage;
+    getDeleteMessage: (store: SendBirdState) => GetDeleteMessage;
+    getResendUserMessage: (store: SendBirdState) => GetResendUserMessage;
+    getResendFileMessage: (store: SendBirdState) => GetResendFileMessage;
+}
+export interface CommonUIKitConfigProps {
+    replyType?: 'NONE' | 'QUOTE_REPLY' | 'THREAD';
+    isMentionEnabled?: boolean;
+    isReactionEnabled?: boolean;
+    disableUserProfile?: boolean;
+    isVoiceMessageEnabled?: boolean;
+    isTypingIndicatorEnabledOnChannelList?: boolean;
+    isMessageReceiptStatusEnabledOnChannelList?: boolean;
+    showSearchIcon?: boolean;
+}
+export type UIKitOptions = PartialDeep<{
+    common: SBUConfig['common'];
+    groupChannel: SBUConfig['groupChannel']['channel'];
+    groupChannelList: SBUConfig['groupChannel']['channelList'];
+    groupChannelSettings: SBUConfig['groupChannel']['setting'];
+    openChannel: SBUConfig['openChannel']['channel'];
+}>;
+export type SendbirdChatInitParams = Omit<SendbirdChatParams<Module[]>, 'appId'>;
+export type CustomExtensionParams = Record<string, string>;
+export {};

package/types/lib/utils/resolvedReplyType.d.ts

@@ -0,0 +1,28 @@
+import { ReplyType as UpperCaseReplyType } from '../../types';
+import { ThreadReplySelectType } from '../../modules/Channel/context/const';
+type LowerCaseReplyType = Lowercase<UpperCaseReplyType>;
+/**
+ * Dashboard UIKitConfig's replyType is consisted of all lowercases,
+ * we need to convert it into uppercase ones(or vice versa)
+ * when we pass the value to internal components
+ *  - 'thread' <-> 'THREAD'
+ *  - 'quote_reply' <-> 'QUOTE_REPLY'
+ */
+export declare function getCaseResolvedReplyType(replyType: UpperCaseReplyType | LowerCaseReplyType): {
+    lowerCase: LowerCaseReplyType;
+    upperCase: UpperCaseReplyType;
+};
+type UpperCaseThreadReplySelectType = typeof ThreadReplySelectType[keyof typeof ThreadReplySelectType];
+type LowerCaseThreadReplySelectType = Lowercase<UpperCaseThreadReplySelectType>;
+/**
+ * Dashboard UIKitConfig's threadReplySelectType is consisted of all lowercase letters,
+ * we need to convert it into uppercase ones(or vice versa)
+ * when we pass the value to internal components
+ *  - 'thread' <-> 'THREAD'
+ *  - 'parent' <-> 'PARENT'
+ */
+export declare function getCaseResolvedThreadReplySelectType(threadReplySelectType: UpperCaseThreadReplySelectType | LowerCaseThreadReplySelectType): {
+    lowerCase: LowerCaseThreadReplySelectType;
+    upperCase: UpperCaseThreadReplySelectType;
+};
+export {};

package/types/lib/utils/uikitConfigMapper.d.ts

@@ -0,0 +1,5 @@
+import { UIKitOptions, CommonUIKitConfigProps } from '../types';
+export declare function uikitConfigMapper({ legacyConfig, uikitOptions, }: {
+    legacyConfig: CommonUIKitConfigProps;
+    uikitOptions?: UIKitOptions;
+}): UIKitOptions;

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

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { AppLayoutProps } from './types';
+export declare const AppLayout: React.FC<AppLayoutProps>;

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

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { DesktopLayoutProps } from './types';
+export declare const DesktopLayout: React.FC<DesktopLayoutProps>;

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

@@ -0,0 +1,4 @@
+import './mobile.scss';
+import React from 'react';
+import type { MobileLayoutProps } from './types';
+export declare const MobileLayout: React.FC<MobileLayoutProps>;

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';
+import { FileMessage, MultipleFilesMessage } from '@sendbird/chat/message';
+/**
+ * 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 declare const useHandleUploadFiles: ({ sendFileMessage, sendMultipleFilesMessage, quoteMessage, }: useHandleUploadFilesDynamicProps, { logger, }: useHandleUploadFilesStaticProps) => (files: File[]) => Promise<void | FileMessage | MultipleFilesMessage>;
+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/SuggestedMentionList/utils.d.ts

@@ -0,0 +1,3 @@
+import { GroupChannel, Member } from '@sendbird/chat/groupChannel';
+export declare function fetchMembersFromChannel(currentUserId: string, channel: GroupChannel, maxSuggestionCount: number, searchString: string): Promise<Member[]>;
+export declare function fetchMembersFromQuery(currentUserId: string, channel: GroupChannel, maxSuggestionCount: number, searchString: string): Promise<Member[]>;

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;