@sendbird/uikit-react 3.7.0 → 3.8.0

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,10 @@
+import React, { RefObject } from 'react';
+import { ChannelActionTypes } from '../dux/actionTypes';
+export interface UseHandlePubsubEventsParams {
+    channelUrl: string;
+    sdkInit: boolean;
+    pubSub: any;
+    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 { ChannelActionTypes } from '../dux/actionTypes';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { LoggerInterface } from '../../../../lib/Logger';
+import { PubSubTypes } from '../../../../lib/pubSub';
+import { SendableMessageType } from '../../../../utils';
+import { SendBirdState } from '../../../../lib/types';
+import { FileMessage, FileMessageCreateParams } from '@sendbird/chat/message';
+type UseSendFileMessageCallbackOptions = {
+    currentGroupChannel: null | GroupChannel;
+    onBeforeSendFileMessage?: (file: File, quoteMessage: SendableMessageType | null) => FileMessageCreateParams;
+    imageCompression?: SendBirdState['config']['imageCompression'];
+};
+type UseSendFileMessageCallbackParams = {
+    logger: LoggerInterface;
+    pubSub: PubSubTypes;
+    scrollRef: React.MutableRefObject<HTMLDivElement | null>;
+    messagesDispatcher: React.Dispatch<ChannelActionTypes>;
+};
+export default function useSendFileMessageCallback({ currentGroupChannel, onBeforeSendFileMessage, imageCompression }: UseSendFileMessageCallbackOptions, { logger, pubSub, scrollRef, messagesDispatcher }: UseSendFileMessageCallbackParams): ((file: 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 { SendableMessageType } from '../../../../utils';
+import { LoggerInterface } from '../../../../lib/Logger';
+import { PubSubTypes } from '../../../../lib/pubSub';
+type UseSendMessageCallbackOptions = {
+    isMentionEnabled: boolean;
+    currentGroupChannel: null | GroupChannel;
+    onBeforeSendUserMessage?: (message: string, quoteMessage?: SendableMessageType) => UserMessageCreateParams;
+};
+type UseSendMessageCallbackParams = {
+    logger: LoggerInterface;
+    pubSub: PubSubTypes;
+    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,20 @@
+import React from 'react';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { FileMessageCreateParams } from '@sendbird/chat/message';
+import type { Logger } from '../../../../lib/SendbirdState';
+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: any;
+    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 {};

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

@@ -0,0 +1,26 @@
+import React from 'react';
+import { ChannelActionTypes } from '../dux/actionTypes';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { UserMessage, UserMessageUpdateParams } from '@sendbird/chat/message';
+import { LoggerInterface } from '../../../../lib/Logger';
+import { PubSubTypes } from '../../../../lib/pubSub';
+import { SendbirdError, User } from '@sendbird/chat';
+type UseUpdateMessageCallbackOptions = {
+    currentGroupChannel: null | GroupChannel;
+    messagesDispatcher: React.Dispatch<ChannelActionTypes>;
+    onBeforeUpdateUserMessage?: (text: string) => UserMessageUpdateParams;
+    isMentionEnabled: boolean;
+};
+type UseUpdateMessageCallbackParams = {
+    logger: LoggerInterface;
+    pubSub: PubSubTypes;
+};
+type UpdateMessageParams = {
+    messageId: number;
+    message: string;
+    mentionedUsers?: User[];
+    mentionTemplate?: string;
+};
+type UpdateMessageCallback = (err: SendbirdError, message: UserMessage) => void;
+declare function useUpdateMessageCallback({ currentGroupChannel, messagesDispatcher, onBeforeUpdateUserMessage, isMentionEnabled, }: UseUpdateMessageCallbackOptions, { logger, pubSub }: UseUpdateMessageCallbackParams): (props: UpdateMessageParams, callback?: UpdateMessageCallback) => void;
+export default useUpdateMessageCallback;

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import { EmojiContainer } from '@sendbird/chat';
+import { GroupChannel, Member } from '@sendbird/chat/groupChannel';
+import { CoreMessageType, SendableMessageType } from '../../../utils';
+import { BaseMessage } from '@sendbird/chat/message';
+export declare const scrollToRenderedMessage: (scrollRef: React.MutableRefObject<HTMLElement>, initialTimeStamp: number, setIsScrolled?: (val: boolean) => void) => void;
+export declare const scrollIntoLast: (initialTry: number, scrollRef: React.MutableRefObject<HTMLElement>, setIsScrolled?: (val: boolean) => void) => void;
+export declare const isOperator: (groupChannel?: GroupChannel) => boolean;
+export declare const isDisabledBecauseFrozen: (groupChannel?: GroupChannel) => boolean;
+export declare const isDisabledBecauseMuted: (groupChannel?: GroupChannel) => boolean;
+export declare const getAllEmojisMapFromEmojiContainer: (emojiContainer: EmojiContainer) => Map<any, any>;
+export declare const getNicknamesMapFromMembers: (members?: Member[]) => Map<string, string>;
+export declare const mergeAndSortMessages: (oldMessages: BaseMessage[], newMessages: BaseMessage[]) => BaseMessage[];
+export declare const getMessageCreatedAt: (message: BaseMessage) => string;
+export declare const isSameGroup: (message: SendableMessageType | BaseMessage, comparingMessage: SendableMessageType | BaseMessage, currentChannel: GroupChannel) => boolean;
+export declare const passUnsuccessfullMessages: (allMessages: (CoreMessageType | SendableMessageType)[], newMessage: CoreMessageType | SendableMessageType) => (import("@sendbird/chat/message").AdminMessage | import("@sendbird/chat/message").UserMessage | import("@sendbird/chat/message").FileMessage | import("@sendbird/chat/message").MultipleFilesMessage)[];
+export declare const pxToNumber: (px: string | number) => number;
+export declare const isAboutSame: (a: number, b: number, px: number) => boolean;

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

@@ -0,0 +1,7 @@
+import React from 'react';
+import { ChannelContextProps } from './context/ChannelProvider';
+import { ChannelUIProps } from './components/ChannelUI';
+export interface ChannelProps extends ChannelContextProps, ChannelUIProps {
+}
+declare const Channel: React.FC<ChannelProps>;
+export default Channel;

package/types/modules/ChannelList/components/AddChannel/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const AddChannel: React.VoidFunctionComponent;
+export default AddChannel;

package/types/modules/ChannelList/components/ChannelListHeader/index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import './index.scss';
+interface ChannelListHeaderInterface {
+    renderHeader?: (props: void) => React.ReactElement;
+    renderTitle?: () => React.ReactElement;
+    renderIconButton?: (props: void) => React.ReactElement;
+    onEdit?: (props: void) => void;
+    allowProfileEdit?: boolean;
+}
+declare const ChannelListHeader: React.FC<ChannelListHeaderInterface>;
+export default ChannelListHeader;

package/types/modules/ChannelList/components/ChannelListUI/index.d.ts

@@ -0,0 +1,23 @@
+import './channel-list-ui.scss';
+import React from 'react';
+import type { GroupChannel, Member } from '@sendbird/chat/groupChannel';
+import type { User } from '@sendbird/chat';
+interface RenderChannelPreviewProps {
+    channel: GroupChannel;
+    onLeaveChannel(channel: GroupChannel, onLeaveChannelCb?: (c: GroupChannel) => void): void;
+}
+interface RenderUserProfileProps {
+    user: Member | User;
+    currentUserId: string;
+    close(): void;
+}
+export interface ChannelListUIProps {
+    renderChannelPreview?: (props: RenderChannelPreviewProps) => React.ReactElement;
+    renderUserProfile?: (props: RenderUserProfileProps) => React.ReactElement;
+    renderHeader?: (props: void) => React.ReactElement;
+    renderPlaceHolderError?: (props: void) => React.ReactElement;
+    renderPlaceHolderLoading?: (props: void) => React.ReactElement;
+    renderPlaceHolderEmptyList?: (props: void) => React.ReactElement;
+}
+declare const ChannelListUI: React.FC<ChannelListUIProps>;
+export default ChannelListUI;

package/types/modules/ChannelList/components/ChannelPreview/index.d.ts

@@ -0,0 +1,16 @@
+import './channel-preview.scss';
+import React from 'react';
+import type { GroupChannel } from '@sendbird/chat/groupChannel';
+interface ChannelPreviewInterface {
+    channel: GroupChannel;
+    isActive?: boolean;
+    isTyping?: boolean;
+    onClick: () => void;
+    onLeaveChannel?: () => void;
+    renderChannelAction: (props: {
+        channel: GroupChannel;
+    }) => React.ReactElement;
+    tabIndex: number;
+}
+declare const ChannelPreview: React.FC<ChannelPreviewInterface>;
+export default ChannelPreview;

package/types/modules/ChannelList/components/ChannelPreview/utils.d.ts

@@ -0,0 +1,10 @@
+import type { GroupChannel } from '@sendbird/chat/groupChannel';
+export declare const getChannelTitle: (channel?: GroupChannel, currentUserId?: string, stringSet?: import("../../../../ui/Label/stringSet").StringSet) => string;
+export declare const getLastMessageCreatedAt: ({ channel, locale, stringSet }: {
+    channel: any;
+    locale: any;
+    stringSet?: import("../../../../ui/Label/stringSet").StringSet;
+}) => string;
+export declare const getTotalMembers: (channel?: GroupChannel) => number;
+export declare const getLastMessage: (channel?: GroupChannel, stringSet?: import("../../../../ui/Label/stringSet").StringSet) => any;
+export declare const getChannelUnreadMessageCount: (channel?: GroupChannel) => number;

package/types/modules/ChannelList/components/ChannelPreviewAction.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+type ChannelPreviewActionProps = {
+    channel?: GroupChannel;
+    disabled: boolean;
+    onLeaveChannel(): void;
+};
+export default function ChannelPreviewAction({ channel, disabled, onLeaveChannel }: ChannelPreviewActionProps): JSX.Element;
+export {};

package/types/modules/ChannelList/components/LeaveChannel/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+export type LeaveChannelProps = {
+    channel?: GroupChannel;
+    onSubmit: () => void;
+    onCancel: () => void;
+};
+declare const LeaveChannel: React.FC<LeaveChannelProps>;
+export default LeaveChannel;

package/types/modules/ChannelList/components/Placeholder.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { PlaceHolderTypes } from '../../../ui/PlaceHolder';
+type ChannelsPlaceholderProps = {
+    type: keyof typeof PlaceHolderTypes;
+};
+export default function ChannelsPlaceholder({ type }: ChannelsPlaceholderProps): JSX.Element;
+export {};

package/types/modules/ChannelList/context/ChannelListProvider.d.ts

@@ -0,0 +1,75 @@
+import React from 'react';
+import type { User } from '@sendbird/chat';
+import { GroupChannel, GroupChannelCreateParams, GroupChannelListQuery as GroupChannelListQuerySb, GroupChannelUserIdsFilter } from '@sendbird/chat/groupChannel';
+import { RenderUserProfileProps } from '../../../types';
+import { ChannelListActionTypes } from '../dux/actionTypes';
+import { CHANNEL_TYPE } from '../../CreateChannel/types';
+export interface ApplicationUserListQueryInternal {
+    limit?: number;
+    userIdsFilter?: Array<string>;
+    metaDataKeyFilter?: string;
+    metaDataValuesFilter?: Array<string>;
+}
+export interface GroupChannelListQueryParamsInternal {
+    limit?: number;
+    includeEmpty?: boolean;
+    order?: 'latest_last_message' | 'chronological' | 'channel_name_alphabetical' | 'metadata_value_alphabetical';
+    userIdsExactFilter?: Array<string>;
+    userIdsIncludeFilter?: Array<string>;
+    userIdsIncludeFilterQueryType?: 'AND' | 'OR';
+    nicknameContainsFilter?: string;
+    channelNameContainsFilter?: string;
+    customTypesFilter?: Array<string>;
+    customTypeStartsWithFilter?: string;
+    channelUrlsFilter?: Array<string>;
+    superChannelFilter?: 'all' | 'super' | 'nonsuper' | 'broadcast_only' | 'exclusive_only';
+    publicChannelFilter?: 'all' | 'public' | 'private';
+    metadataOrderKeyFilter?: string;
+    memberStateFilter?: 'all' | 'joined_only' | 'invited_only' | 'invited_by_friend' | 'invited_by_non_friend';
+    hiddenChannelFilter?: 'all' | 'unhidden_only' | 'hidden_only' | 'hidden_allow_auto_unhide' | 'hidden_prevent_auto_unhide';
+    unreadChannelFilter?: 'all' | 'unread_message';
+    includeFrozen?: boolean;
+    userIdsFilter?: GroupChannelUserIdsFilter;
+}
+interface ChannelListQueries {
+    applicationUserListQuery?: ApplicationUserListQueryInternal;
+    channelListQuery?: GroupChannelListQueryParamsInternal;
+}
+type OverrideInviteUserType = {
+    users: Array<string>;
+    onClose: () => void;
+    channelType: CHANNEL_TYPE;
+};
+export interface ChannelListProviderProps {
+    allowProfileEdit?: boolean;
+    onBeforeCreateChannel?(users: Array<string>): GroupChannelCreateParams;
+    overrideInviteUser?(params: OverrideInviteUserType): void;
+    onThemeChange?(theme: string): void;
+    onProfileEditSuccess?(user: User): void;
+    onChannelSelect?(channel: GroupChannel | null): void;
+    sortChannelList?: (channels: GroupChannel[]) => GroupChannel[];
+    queries?: ChannelListQueries;
+    children?: React.ReactElement;
+    className?: string | string[];
+    renderUserProfile?: (props: RenderUserProfileProps) => React.ReactElement;
+    disableUserProfile?: boolean;
+    disableAutoSelect?: boolean;
+    activeChannelUrl?: string;
+    typingChannels?: Array<GroupChannel>;
+    isTypingIndicatorEnabled?: boolean;
+    isMessageReceiptStatusEnabled?: boolean;
+}
+export interface ChannelListProviderInterface extends ChannelListProviderProps {
+    initialized: boolean;
+    loading: boolean;
+    allChannels: GroupChannel[];
+    currentChannel: GroupChannel;
+    channelListQuery: GroupChannelListQueryParamsInternal;
+    currentUserId: string;
+    channelListDispatcher: React.Dispatch<ChannelListActionTypes>;
+    channelSource: GroupChannelListQuerySb | null;
+    fetchChannelList: () => void;
+}
+declare const ChannelListProvider: React.FC<ChannelListProviderProps>;
+declare function useChannelListContext(): ChannelListProviderInterface;
+export { ChannelListProvider, useChannelListContext };

package/types/modules/ChannelList/context/hooks/useActiveChannelUrl.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { Logger } from '../../../../lib/SendbirdState';
+import { SdkStore } from '../../../../lib/types';
+export type DynamicProps = {
+    activeChannelUrl?: string;
+    channels?: GroupChannel[];
+    sdk?: SdkStore['sdk'];
+};
+export type StaticProps = {
+    logger: Logger;
+    channelListDispatcher: React.Dispatch<any>;
+};
+declare function useActiveChannelUrl({ activeChannelUrl, channels, sdk, }: DynamicProps, { logger, channelListDispatcher, }: StaticProps): void;
+export default useActiveChannelUrl;

package/types/modules/ChannelList/context/hooks/useFetchChannelList.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { GroupChannelListQuery } from '@sendbird/chat/groupChannel';
+import { Nullable } from '../../../../types';
+import { Logger } from '../../../../lib/SendbirdState';
+import { MarkAsDeliveredSchedulerType } from '../../../../lib/hooks/useMarkAsDeliveredScheduler';
+import { ChannelListActionTypes } from '../../dux/actionTypes';
+interface DynamicProps {
+    channelSource: Nullable<GroupChannelListQuery>;
+    disableMarkAsDelivered: boolean;
+}
+interface StaticProps {
+    channelListDispatcher: React.Dispatch<ChannelListActionTypes>;
+    logger: Logger;
+    markAsDeliveredScheduler: MarkAsDeliveredSchedulerType;
+}
+export declare const useFetchChannelList: ({ channelSource, disableMarkAsDelivered, }: DynamicProps, { channelListDispatcher, logger, markAsDeliveredScheduler, }: StaticProps) => () => Promise<void>;
+export {};