@sendbird/uikit-react 3.7.0-rc.1 → 3.8.0

package/types/modules/Thread/components/ThreadUI/index.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import './index.scss';
+import { ParentMessageStateTypes, ThreadListStateTypes } from '../../types';
+import { SendableMessageType } from '../../../../utils';
+export interface ThreadUIProps {
+    renderHeader?: () => React.ReactElement;
+    renderParentMessageInfo?: () => React.ReactElement;
+    renderMessage?: (props: {
+        message: SendableMessageType;
+        chainTop: boolean;
+        chainBottom: boolean;
+        hasSeparator: boolean;
+    }) => React.ReactElement;
+    renderFileUploadIcon?: () => React.ReactElement;
+    renderVoiceMessageIcon?: () => React.ReactElement;
+    renderSendMessageIcon?: () => React.ReactElement;
+    renderMessageInput?: () => React.ReactElement;
+    renderCustomSeparator?: () => React.ReactElement;
+    renderParentMessageInfoPlaceholder?: (type: ParentMessageStateTypes) => React.ReactElement;
+    renderThreadListPlaceHolder?: (type: ThreadListStateTypes) => React.ReactElement;
+}
+declare const ThreadUI: React.FC<ThreadUIProps>;
+export default ThreadUI;

package/types/modules/Thread/components/ThreadUI/useMemorizedHeader.d.ts

@@ -0,0 +1,6 @@
+import React, { ReactElement } from 'react';
+export interface UseMemorizedHeaderProps {
+    renderHeader?: () => React.ReactElement;
+}
+declare const useMemorizedHeader: ({ renderHeader }: UseMemorizedHeaderProps) => ReactElement;
+export default useMemorizedHeader;

package/types/modules/Thread/components/ThreadUI/useMemorizedParentMessageInfo.d.ts

@@ -0,0 +1,11 @@
+import React, { ReactElement } from 'react';
+import { ParentMessageStateTypes } from '../../types';
+import { SendableMessageType } from '../../../../utils';
+export interface UseMemorizedParentMessageInfoProps {
+    parentMessage: SendableMessageType;
+    parentMessageState: ParentMessageStateTypes;
+    renderParentMessageInfo?: () => React.ReactElement;
+    renderParentMessageInfoPlaceholder?: (type: ParentMessageStateTypes) => React.ReactElement;
+}
+declare const useMemorizedParentMessageInfo: ({ parentMessage, parentMessageState, renderParentMessageInfo, renderParentMessageInfoPlaceholder, }: UseMemorizedParentMessageInfoProps) => ReactElement;
+export default useMemorizedParentMessageInfo;

package/types/modules/Thread/components/ThreadUI/useMemorizedThreadList.d.ts

@@ -0,0 +1,8 @@
+import React, { ReactElement } from 'react';
+import { ThreadListStateTypes } from '../../types';
+export interface UseMemorizedThreadListProps {
+    threadListState: ThreadListStateTypes;
+    renderThreadListPlaceHolder?: (tyep: ThreadListStateTypes) => React.ReactElement;
+}
+declare const useMemorizedThreadList: ({ threadListState, renderThreadListPlaceHolder, }: UseMemorizedThreadListProps) => ReactElement;
+export default useMemorizedThreadList;

package/types/modules/Thread/consts.d.ts

@@ -0,0 +1,2 @@
+export declare const PREV_THREADS_FETCH_SIZE = 30;
+export declare const NEXT_THREADS_FETCH_SIZE = 30;

package/types/modules/Thread/context/ThreadProvider.d.ts

@@ -0,0 +1,43 @@
+import React, { ReactElement } from 'react';
+import { User } from '@sendbird/chat';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import type { BaseMessage, FileMessage, FileMessageCreateParams, MultipleFilesMessage, MultipleFilesMessageCreateParams, UserMessageCreateParams } from '@sendbird/chat/message';
+import { ThreadContextInitialState } from './dux/initialState';
+import { SendMessageParams } from './hooks/useSendUserMessageCallback';
+import { SendableMessageType } from '../../../utils';
+export type ThreadProviderProps = {
+    children?: React.ReactElement;
+    channelUrl: string;
+    message: SendableMessageType | null;
+    onHeaderActionClick?: () => void;
+    onMoveToParentMessage?: (props: {
+        message: SendableMessageType;
+        channel: GroupChannel;
+    }) => void;
+    onBeforeSendUserMessage?: (message: string, quotedMessage?: SendableMessageType) => UserMessageCreateParams;
+    onBeforeSendFileMessage?: (file: File, quotedMessage?: SendableMessageType) => FileMessageCreateParams;
+    onBeforeSendVoiceMessage?: (file: File, quotedMessage?: SendableMessageType) => FileMessageCreateParams;
+    onBeforeSendMultipleFilesMessage?: (files: Array<File>, quotedMessage?: SendableMessageType) => MultipleFilesMessageCreateParams;
+    disableUserProfile?: boolean;
+    renderUserProfile?: (props: {
+        user: User;
+        close: () => void;
+    }) => ReactElement;
+    isMultipleFilesMessageEnabled?: boolean;
+};
+export interface ThreadProviderInterface extends ThreadProviderProps, ThreadContextInitialState {
+    fetchPrevThreads: (callback?: (messages?: Array<BaseMessage>) => void) => void;
+    fetchNextThreads: (callback?: (messages?: Array<BaseMessage>) => void) => void;
+    toggleReaction: (message: any, key: any, isReacted: any) => void;
+    sendMessage: (props: 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>;
+    resendMessage: (failedMessage: SendableMessageType) => void;
+    updateMessage: (props: any, callback?: () => void) => void;
+    deleteMessage: (message: SendableMessageType) => Promise<SendableMessageType>;
+    nicknamesMap: Map<string, string>;
+}
+export declare const ThreadProvider: React.FC<ThreadProviderProps>;
+export type UseThreadContextType = () => ThreadProviderInterface;
+export declare const useThreadContext: UseThreadContextType;

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

@@ -0,0 +1,37 @@
+export declare enum ThreadContextActionTypes {
+    INIT_USER_ID = "INIT_USER_ID",
+    GET_CHANNEL_START = "GET_CHANNEL_START",
+    GET_CHANNEL_SUCCESS = "GET_CHANNEL_SUCCESS",
+    GET_CHANNEL_FAILURE = "GET_CHANNEL_FAILURE",
+    SET_EMOJI_CONTAINER = "SET_EMOJI_CONTAINER",
+    GET_PARENT_MESSAGE_START = "GET_PARENT_MESSAGE_START",
+    GET_PARENT_MESSAGE_SUCCESS = "GET_PARENT_MESSAGE_SUCCESS",
+    GET_PARENT_MESSAGE_FAILURE = "GET_PARENT_MESSAGE_FAILURE",
+    INITIALIZE_THREAD_LIST_START = "INITIALIZE_THREAD_LIST_START",
+    INITIALIZE_THREAD_LIST_SUCCESS = "INITIALIZE_THREAD_LIST_SUCCESS",
+    INITIALIZE_THREAD_LIST_FAILURE = "INITIALIZE_THREAD_LIST_FAILURE",
+    GET_PREV_MESSAGES_START = "GET_PREV_MESSAGES_START",
+    GET_PREV_MESSAGES_SUCESS = "GET_PREV_MESSAGES_SUCESS",
+    GET_PREV_MESSAGES_FAILURE = "GET_PREV_MESSAGES_FAILURE",
+    GET_NEXT_MESSAGES_START = "GET_NEXT_MESSAGES_START",
+    GET_NEXT_MESSAGES_SUCESS = "GET_NEXT_MESSAGES_SUCESS",
+    GET_NEXT_MESSAGES_FAILURE = "GET_NEXT_MESSAGES_FAILURE",
+    SEND_MESSAGE_START = "SEND_MESSAGE_START",
+    SEND_MESSAGE_SUCESS = "SEND_MESSAGE_SUCESS",
+    SEND_MESSAGE_FAILURE = "SEND_MESSAGE_FAILURE",
+    RESEND_MESSAGE_START = "RESEND_MESSAGE_START",
+    ON_MESSAGE_DELETED_BY_REQ_ID = "ON_MESSAGE_DELETED_BY_REQ_ID",
+    ON_MESSAGE_RECEIVED = "ON_MESSAGE_RECEIVED",
+    ON_MESSAGE_UPDATED = "ON_MESSAGE_UPDATED",
+    ON_MESSAGE_DELETED = "ON_MESSAGE_DELETED",
+    ON_REACTION_UPDATED = "ON_REACTION_UPDATED",
+    ON_FILE_INFO_UPLOADED = "ON_FILE_INFO_UPLOADED",
+    ON_USER_MUTED = "ON_USER_MUTED",
+    ON_USER_UNMUTED = "ON_USER_UNMUTED",
+    ON_USER_BANNED = "ON_USER_BANNED",
+    ON_USER_UNBANNED = "ON_USER_UNBANNED",
+    ON_USER_LEFT = "ON_USER_LEFT",
+    ON_CHANNEL_FROZEN = "ON_CHANNEL_FROZEN",
+    ON_CHANNEL_UNFROZEN = "ON_CHANNEL_UNFROZEN",
+    ON_OPERATOR_UPDATED = "ON_OPERATOR_UPDATED"
+}

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

@@ -0,0 +1,21 @@
+import { EmojiContainer } from '@sendbird/chat';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { ChannelStateTypes, ParentMessageStateTypes, ThreadListStateTypes } from '../../types';
+import { CoreMessageType, SendableMessageType } from '../../../../utils';
+export interface ThreadContextInitialState {
+    currentChannel: GroupChannel;
+    allThreadMessages: Array<CoreMessageType>;
+    localThreadMessages: Array<CoreMessageType>;
+    parentMessage: SendableMessageType;
+    channelState: ChannelStateTypes;
+    parentMessageState: ParentMessageStateTypes;
+    threadListState: ThreadListStateTypes;
+    hasMorePrev: boolean;
+    hasMoreNext: boolean;
+    emojiContainer: EmojiContainer;
+    isMuted: boolean;
+    isChannelFrozen: boolean;
+    currentUserId: string;
+}
+declare const initialState: ThreadContextInitialState;
+export default initialState;

package/types/modules/Thread/context/dux/reducer.d.ts

@@ -0,0 +1,8 @@
+import { ThreadContextActionTypes as actionTypes } from './actionTypes';
+import { ThreadContextInitialState } from './initialState';
+interface ActionInterface {
+    type: actionTypes;
+    payload?: any;
+}
+export default function reducer(state: ThreadContextInitialState, action: ActionInterface): ThreadContextInitialState;
+export {};

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

@@ -0,0 +1,12 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+import { SendableMessageType } from '../../../../utils';
+interface DynamicProps {
+    currentChannel: GroupChannel;
+    threadDispatcher: CustomUseReducerDispatcher;
+}
+interface StaticProps {
+    logger: Logger;
+}
+export default function useDeleteMessageCallback({ currentChannel, threadDispatcher, }: DynamicProps, { logger, }: StaticProps): (message: SendableMessageType) => Promise<SendableMessageType>;
+export {};

package/types/modules/Thread/context/hooks/useGetAllEmoji.d.ts

@@ -0,0 +1,11 @@
+import { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+import { SdkStore } from '../../../../lib/types';
+interface DanamicPrpos {
+    sdk: SdkStore['sdk'];
+}
+interface StaticProps {
+    logger: Logger;
+    threadDispatcher: CustomUseReducerDispatcher;
+}
+export default function useGetAllEmoji({ sdk, }: DanamicPrpos, { logger, threadDispatcher, }: StaticProps): void;
+export {};

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

@@ -0,0 +1,18 @@
+import { Logger } from '../../../../lib/SendbirdState';
+import { SendableMessageType } from '../../../../utils';
+import { SdkStore } from '../../../../lib/types';
+interface DynamicProps {
+    channelUrl: string;
+    sdkInit: boolean;
+    message: SendableMessageType;
+}
+interface StaticProps {
+    sdk: SdkStore['sdk'];
+    logger: Logger;
+    threadDispatcher: (props: {
+        type: string;
+        payload?: any;
+    }) => void;
+}
+export default function useGetChannel({ channelUrl, sdkInit, message, }: DynamicProps, { sdk, logger, threadDispatcher, }: StaticProps): void;
+export {};

package/types/modules/Thread/context/hooks/useGetNextThreadsCallback.d.ts

@@ -0,0 +1,17 @@
+import { BaseMessage } from '@sendbird/chat/message';
+import { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+import { ThreadListStateTypes } from '../../types';
+import { SendableMessageType } from '../../../../utils';
+interface DynamicProps {
+    hasMoreNext: boolean;
+    parentMessage: SendableMessageType;
+    threadListState: ThreadListStateTypes;
+    latestMessageTimeStamp: number;
+    isReactionEnabled?: boolean;
+}
+interface StaticProps {
+    logger: Logger;
+    threadDispatcher: CustomUseReducerDispatcher;
+}
+export default function useGetNextThreadsCallback({ hasMoreNext, parentMessage, threadListState, latestMessageTimeStamp, isReactionEnabled, }: DynamicProps, { logger, threadDispatcher, }: StaticProps): (callback: (messages?: Array<BaseMessage>) => void) => void;
+export {};

package/types/modules/Thread/context/hooks/useGetParentMessage.d.ts

@@ -0,0 +1,15 @@
+import { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+import { BaseMessage } from '@sendbird/chat/message';
+import { SdkStore } from '../../../../lib/types';
+interface DynamicProps {
+    channelUrl: string;
+    sdkInit: boolean;
+    parentMessage?: BaseMessage;
+}
+interface StaticProps {
+    sdk: SdkStore['sdk'];
+    logger: Logger;
+    threadDispatcher: CustomUseReducerDispatcher;
+}
+export default function useGetParentMessage({ channelUrl, sdkInit, parentMessage, }: DynamicProps, { sdk, logger, threadDispatcher, }: StaticProps): void;
+export {};

package/types/modules/Thread/context/hooks/useGetPrevThreadsCallback.d.ts

@@ -0,0 +1,17 @@
+import { BaseMessage } from '@sendbird/chat/message';
+import { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+import { ThreadListStateTypes } from '../../types';
+import { SendableMessageType } from '../../../../utils';
+interface DynamicProps {
+    hasMorePrev: boolean;
+    parentMessage: SendableMessageType;
+    threadListState: ThreadListStateTypes;
+    oldestMessageTimeStamp: number;
+    isReactionEnabled?: boolean;
+}
+interface StaticProps {
+    logger: Logger;
+    threadDispatcher: CustomUseReducerDispatcher;
+}
+export default function useGetPrevThreadsCallback({ hasMorePrev, parentMessage, threadListState, oldestMessageTimeStamp, isReactionEnabled, }: DynamicProps, { logger, threadDispatcher, }: StaticProps): (callback?: (messages?: Array<BaseMessage>) => void) => void;
+export {};

package/types/modules/Thread/context/hooks/useGetThreadList.d.ts

@@ -0,0 +1,14 @@
+import { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+import { SendableMessageType } from '../../../../utils';
+interface DynamicProps {
+    sdkInit: boolean;
+    parentMessage: SendableMessageType;
+    anchorMessage?: SendableMessageType;
+    isReactionEnabled?: boolean;
+}
+interface StaticProps {
+    logger: Logger;
+    threadDispatcher: CustomUseReducerDispatcher;
+}
+export default function useGetThreadList({ sdkInit, parentMessage, anchorMessage, isReactionEnabled, }: DynamicProps, { logger, threadDispatcher, }: StaticProps): void;
+export {};

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

@@ -0,0 +1,13 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+import { SdkStore } from '../../../../lib/types';
+interface DynamicProps {
+    sdk: SdkStore['sdk'];
+    currentChannel: GroupChannel;
+}
+interface StaticProps {
+    logger: Logger;
+    threadDispatcher: CustomUseReducerDispatcher;
+}
+export default function useHandleChannelEvents({ sdk, currentChannel, }: DynamicProps, { logger, threadDispatcher, }: StaticProps): void;
+export {};

package/types/modules/Thread/context/hooks/useHandleThreadPubsubEvents.d.ts

@@ -0,0 +1,15 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+import { SendableMessageType } from '../../../../utils';
+interface DynamicProps {
+    sdkInit: boolean;
+    currentChannel: GroupChannel;
+    parentMessage: SendableMessageType;
+}
+interface StaticProps {
+    logger: Logger;
+    pubSub: any;
+    threadDispatcher: CustomUseReducerDispatcher;
+}
+export default function useHandleThreadPubsubEvents({ sdkInit, currentChannel, parentMessage, }: DynamicProps, { pubSub, threadDispatcher, }: StaticProps): void;
+export {};

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

@@ -0,0 +1,13 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+import { SendableMessageType } from '../../../../utils';
+interface DynamicProps {
+    currentChannel: GroupChannel;
+}
+interface StaticProps {
+    logger: Logger;
+    pubSub: any;
+    threadDispatcher: CustomUseReducerDispatcher;
+}
+export default function useResendMessageCallback({ currentChannel, }: DynamicProps, { logger, pubSub, threadDispatcher, }: StaticProps): (failedMessage: SendableMessageType) => void;
+export {};

package/types/modules/Thread/context/hooks/useSendFileMessage.d.ts

@@ -0,0 +1,16 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { FileMessage, FileMessageCreateParams } from '@sendbird/chat/message';
+import { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+import { SendableMessageType } from '../../../../utils';
+interface DynamicProps {
+    currentChannel: GroupChannel;
+    onBeforeSendFileMessage?: (file: File, quotedMessage?: SendableMessageType) => FileMessageCreateParams;
+}
+interface StaticProps {
+    logger: Logger;
+    pubSub: any;
+    threadDispatcher: CustomUseReducerDispatcher;
+}
+export type SendFileMessageFunctionType = (file: File, quoteMessage?: SendableMessageType) => Promise<FileMessage>;
+export default function useSendFileMessageCallback({ currentChannel, onBeforeSendFileMessage, }: DynamicProps, { logger, pubSub, threadDispatcher, }: StaticProps): SendFileMessageFunctionType;
+export {};

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

@@ -0,0 +1,8 @@
+export * from '../../../Channel/context/hooks/useSendMultipleFilesMessage';
+export { PublishingModuleType } from '../../../internalInterfaces';
+/**
+ * We have to reduce the duplicated logics between the modules Channel and Thread.
+ * We need to make a new directory place for both and bring the duplicated logics
+ * to there.
+ * The most of the custom hooks should be there.
+ */

package/types/modules/Thread/context/hooks/useSendUserMessageCallback.d.ts

@@ -0,0 +1,24 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { UserMessageCreateParams } from '@sendbird/chat/message';
+import { User } from '@sendbird/chat';
+import { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+import { SendableMessageType } from '../../../../utils';
+export type OnBeforeSendUserMessageType = (message: string, quoteMessage?: SendableMessageType) => UserMessageCreateParams;
+interface DynamicProps {
+    isMentionEnabled: boolean;
+    currentChannel: GroupChannel;
+    onBeforeSendUserMessage?: OnBeforeSendUserMessageType;
+}
+interface StaticProps {
+    logger: Logger;
+    pubSub: any;
+    threadDispatcher: CustomUseReducerDispatcher;
+}
+export type SendMessageParams = {
+    message: string;
+    quoteMessage?: SendableMessageType;
+    mentionTemplate?: string;
+    mentionedUsers?: Array<User>;
+};
+export default function useSendUserMessageCallback({ isMentionEnabled, currentChannel, onBeforeSendUserMessage, }: DynamicProps, { logger, pubSub, threadDispatcher, }: StaticProps): (props: SendMessageParams) => void;
+export {};

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

@@ -0,0 +1,16 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { FileMessageCreateParams } from '@sendbird/chat/message';
+import { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+import { SendableMessageType } from '../../../../utils';
+interface DynamicParams {
+    currentChannel: GroupChannel;
+    onBeforeSendVoiceMessage?: (file: File, quoteMessage?: SendableMessageType) => FileMessageCreateParams;
+}
+interface StaticParams {
+    logger: Logger;
+    pubSub: any;
+    threadDispatcher: CustomUseReducerDispatcher;
+}
+type FuncType = (file: File, duration: number, quoteMessage: SendableMessageType) => void;
+export declare const useSendVoiceMessageCallback: ({ currentChannel, onBeforeSendVoiceMessage, }: DynamicParams, { logger, pubSub, threadDispatcher, }: StaticParams) => FuncType;
+export default useSendVoiceMessageCallback;

package/types/modules/Thread/context/hooks/useToggleReactionsCallback.d.ts

@@ -0,0 +1,10 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { Logger } from '../../../../lib/SendbirdState';
+interface DynamicProps {
+    currentChannel: GroupChannel;
+}
+interface StaticProps {
+    logger: Logger;
+}
+export default function useToggleReactionCallback({ currentChannel, }: DynamicProps, { logger, }: StaticProps): (message: any, key: any, isReacted: any) => void;
+export {};

package/types/modules/Thread/context/hooks/useUpdateMessageCallback.d.ts

@@ -0,0 +1,13 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+interface DynamicProps {
+    currentChannel: GroupChannel;
+    isMentionEnabled?: boolean;
+}
+interface StaticProps {
+    logger: Logger;
+    pubSub: any;
+    threadDispatcher: CustomUseReducerDispatcher;
+}
+export default function useUpdateMessageCallback({ currentChannel, isMentionEnabled, }: DynamicProps, { logger, pubSub, threadDispatcher, }: StaticProps): (props: any) => void;
+export {};

package/types/modules/Thread/context/utils.d.ts

@@ -0,0 +1,15 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { BaseMessage } from '@sendbird/chat/message';
+import { SendableMessageType } from '../../../utils';
+export declare const getNicknamesMapFromMembers: (members?: any[]) => Map<string, string>;
+export declare const getParentMessageFrom: (message: SendableMessageType | null) => SendableMessageType | BaseMessage;
+export declare const isParentMessage: (message: SendableMessageType) => boolean;
+export declare const isThreadMessage: (message: SendableMessageType) => boolean;
+export declare const isAboutSame: (a: number, b: number, px: number) => boolean;
+export declare const isEmpty: (val: unknown) => boolean;
+export declare function compareIds(a: number | string, b: number | string): boolean;
+export declare const getMessageCreatedAt: (message: SendableMessageType) => string;
+export declare const isReadMessage: (channel: GroupChannel, message: SendableMessageType) => boolean;
+export declare const isSameGroup: (message: SendableMessageType, comparingMessage: SendableMessageType, currentChannel: GroupChannel) => boolean;
+export declare const compareMessagesForGrouping: (prevMessage: SendableMessageType, currMessage: SendableMessageType, nextMessage: SendableMessageType, currentChannel: GroupChannel, replyType: string) => [boolean, boolean];
+export declare const scrollIntoLast: (intialTry?: number) => void;

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import { ThreadProviderProps } from './context/ThreadProvider';
+import { ThreadUIProps } from './components/ThreadUI';
+export interface ThreadProps extends ThreadProviderProps, ThreadUIProps {
+    className?: string;
+}
+declare const Thread: React.FC<ThreadProps>;
+export default Thread;

package/types/modules/Thread/types.d.ts

@@ -0,0 +1,18 @@
+export declare enum ChannelStateTypes {
+    NIL = "NIL",
+    LOADING = "LOADING",
+    INVALID = "INVALID",
+    INITIALIZED = "INITIALIZED"
+}
+export declare enum ParentMessageStateTypes {
+    NIL = "NIL",
+    LOADING = "LOADING",
+    INVALID = "INVALID",
+    INITIALIZED = "INITIALIZED"
+}
+export declare enum ThreadListStateTypes {
+    NIL = "NIL",
+    LOADING = "LOADING",
+    INVALID = "INVALID",
+    INITIALIZED = "INITIALIZED"
+}

package/types/modules/internalInterfaces.d.ts

@@ -0,0 +1,4 @@
+export declare enum PublishingModuleType {
+    CHANNEL = "CHANNEL",
+    THREAD = "THREAD"
+}

package/types/types.d.ts

@@ -0,0 +1,55 @@
+import type { User } from '@sendbird/chat';
+import type { Member } from '@sendbird/chat/groupChannel';
+import type { AdminMessage, FileMessage, MultipleFilesMessage, UserMessage } from '@sendbird/chat/message';
+import { CoreMessageType } from './utils';
+export type ReplyType = 'NONE' | 'QUOTE_REPLY' | 'THREAD';
+export type Nullable<T> = T | null;
+export type SpaceFromTriggerType = {
+    x: number;
+    y: number;
+    top?: number;
+    left?: number;
+    height?: number;
+};
+export interface UserListQuery {
+    hasNext?: boolean;
+    next(): Promise<Array<User>>;
+    get isLoading(): boolean;
+}
+export interface RenderUserProfileProps {
+    user: User | Member;
+    currentUserId: string;
+    close(): void;
+}
+export interface SendBirdProviderConfig {
+    logLevel?: 'debug' | 'warning' | 'error' | 'info' | 'all' | Array<string>;
+    userMention?: {
+        maxMentionCount?: number;
+        maxSuggestionCount?: number;
+    };
+    isREMUnitEnabled?: boolean;
+}
+export interface ClientMessage {
+    reqId: string;
+    file?: File;
+    localUrl?: string;
+    _sender: User;
+}
+export interface RenderMessageProps {
+    message: CoreMessageType;
+    chainTop: boolean;
+    chainBottom: boolean;
+}
+export interface RenderCustomSeparatorProps {
+    message: CoreMessageType;
+}
+export interface ClientUserMessage extends UserMessage, ClientMessage {
+}
+export interface ClientFileMessage extends FileMessage, ClientMessage {
+}
+export interface ClientAdminMessage extends AdminMessage, ClientMessage {
+}
+export interface ClientMultipleFilesMessage extends MultipleFilesMessage, ClientMessage {
+}
+export type EveryMessage = ClientUserMessage | ClientFileMessage | ClientMultipleFilesMessage | ClientAdminMessage;
+export type ClientSentMessages = ClientUserMessage | ClientFileMessage | ClientMultipleFilesMessage;

package/types/ui/Accordion/AccordionGroup.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement } from 'react';
+interface Props {
+    children: Array<ReactElement> | ReactElement;
+    className?: string;
+}
+export default function AccordionGroup({ children, className, }: Props): ReactElement;
+export {};

package/types/ui/Accordion/context.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface ContextValue {
+    setOpened(accordion: string): void;
+    opened: string;
+}
+export declare const Consumer: React.Consumer<ContextValue>;
+export declare const Provider: React.Provider<ContextValue>;
+export {};

package/types/ui/Accordion/index.d.ts

@@ -0,0 +1,13 @@
+import { ReactElement } from 'react';
+import './index.scss';
+import AccordionGroup_ from './AccordionGroup';
+interface Props {
+    className?: string | Array<string>;
+    id: string;
+    renderTitle(): ReactElement;
+    renderContent(): ReactElement;
+    renderFooter?(): ReactElement;
+}
+export default function Accordion({ className, id, renderTitle, renderContent, renderFooter, }: Props): ReactElement;
+export declare const AccordionGroup: typeof AccordionGroup_;
+export {};

package/types/ui/AdminMessage/adminMessageDummyData.mock.d.ts

@@ -0,0 +1,29 @@
+declare const _default: {
+    _iid: string;
+    messageId: number;
+    messageType: string;
+    channelUrl: string;
+    data: {
+        type: string;
+        inviter: {
+            nickname: string;
+            user_id: string;
+            profile_url: string;
+            metadata: {};
+        };
+        users: {
+            nickname: string;
+            user_id: string;
+            profile_url: string;
+            metadata: {};
+        }[];
+    };
+    customType: string;
+    createdAt: number;
+    updatedAt: number;
+    channelType: string;
+    mentionType: string;
+    message: string;
+    isAdminMessage: () => boolean;
+};
+export default _default;

package/types/ui/AdminMessage/index.d.ts

@@ -0,0 +1,9 @@
+import { ReactElement } from 'react';
+import { AdminMessage as AdminMessageType } from '@sendbird/chat/message';
+import './index.scss';
+interface AdminMessageProps {
+    className?: string | Array<string>;
+    message: AdminMessageType;
+}
+export default function AdminMessage({ className, message, }: AdminMessageProps): ReactElement;
+export {};

package/types/ui/Avatar/MutedAvatarOverlay.d.ts

@@ -0,0 +1,8 @@
+import './muted-avatar-overlay.scss';
+import { ReactElement } from 'react';
+interface Props {
+    height?: number;
+    width?: number;
+}
+export default function MutedAvatarOverlay(props: Props): ReactElement;
+export {};