@sendbird/uikit-react 3.7.0 → 3.8.0

package/types/modules/MessageSearch/context/MessageSearchProvider.d.ts

@@ -0,0 +1,41 @@
+import React from 'react';
+import { SendbirdError } from '@sendbird/chat';
+import type { MessageSearchQuery } from '@sendbird/chat/message';
+import type { GroupChannel } from '@sendbird/chat/groupChannel';
+import type { MessageSearchQueryParams } from '@sendbird/chat/lib/__definition';
+import { ClientSentMessages } from '../../../types';
+import { State as MessageSearchReducerState } from './dux/initialState';
+import { CallbackReturn as UseScrollCallbackType } from './hooks/useScrollCallback';
+export interface MessageSearchProviderProps {
+    channelUrl: string;
+    children?: React.ReactElement;
+    searchString?: string;
+    requestString?: string;
+    messageSearchQuery?: MessageSearchQueryParams;
+    onResultLoaded?(messages?: Array<ClientSentMessages>, error?: SendbirdError): void;
+    onResultClick?(message: ClientSentMessages): void;
+}
+interface MessageSearchProviderInterface extends MessageSearchProviderProps {
+    retryCount: number;
+    setRetryCount: React.Dispatch<React.SetStateAction<number>>;
+    selectedMessageId: number;
+    setSelectedMessageId: React.Dispatch<React.SetStateAction<number>>;
+    messageSearchDispatcher: (props: {
+        type: string;
+        payload: any;
+    }) => void;
+    scrollRef: React.MutableRefObject<HTMLDivElement>;
+    allMessages: MessageSearchReducerState['allMessages'];
+    loading: boolean;
+    isInvalid: boolean;
+    currentChannel: GroupChannel;
+    currentMessageSearchQuery: MessageSearchQuery;
+    hasMoreResult: boolean;
+    onScroll: UseScrollCallbackType;
+    handleRetryToConnect: () => void;
+    handleOnScroll: (e: React.BaseSyntheticEvent) => void;
+}
+declare const MessageSearchProvider: React.FC<MessageSearchProviderProps>;
+export type UseMessageSearchType = () => MessageSearchProviderInterface;
+declare const useMessageSearchContext: UseMessageSearchType;
+export { MessageSearchProvider, useMessageSearchContext, };

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

@@ -0,0 +1,8 @@
+export declare const GET_SEARCHED_MESSAGES = "GET_SEARCHED_MESSAGES";
+export declare const GET_NEXT_SEARCHED_MESSAGES = "GET_NEXT_SEARCHED_MESSAGES";
+export declare const START_MESSAGE_SEARCH = "START_MESSAGE_SEARCH";
+export declare const START_GETTING_SEARCHED_MESSAGES = "START_GETTING_SEARCHED_MESSAGES";
+export declare const SET_QUERY_INVALID = "SET_QUERY_INVALID";
+export declare const SET_CURRENT_CHANNEL = "SET_CURRENT_CHANNEL";
+export declare const CHANNEL_INVALID = "CHANNEL_INVALID";
+export declare const RESET_SEARCH_STRING = "RESET_SEARCH_STRING";

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

@@ -0,0 +1,14 @@
+import type { GroupChannel } from '@sendbird/chat/groupChannel';
+import { MessageSearchQuery } from '@sendbird/chat/message';
+import { ClientFileMessage, ClientUserMessage } from '../../../../types';
+export interface State {
+    allMessages: Array<ClientFileMessage | ClientUserMessage>;
+    loading: boolean;
+    isInvalid: boolean;
+    initialized: boolean;
+    currentChannel: GroupChannel;
+    currentMessageSearchQuery: MessageSearchQuery;
+    hasMoreResult: boolean;
+}
+declare const initialState: State;
+export default initialState;

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

@@ -0,0 +1,7 @@
+import { State as initialStateInterface } from './initialState';
+interface ActionInterface {
+    type: string;
+    payload?: any;
+}
+export default function reducer(state: initialStateInterface, action: ActionInterface): initialStateInterface;
+export {};

package/types/modules/MessageSearch/context/hooks/useGetSearchedMessages.d.ts

@@ -0,0 +1,24 @@
+import type { GroupChannel } from '@sendbird/chat/groupChannel';
+import type { MessageSearchQueryParams } from '@sendbird/chat/lib/__definition';
+import type { SendbirdError } from '@sendbird/chat';
+import type { Logger } from '../../../../lib/SendbirdState';
+import { CoreMessageType } from '../../../../utils';
+import { SdkStore } from '../../../../lib/types';
+interface MainProps {
+    currentChannel: GroupChannel;
+    channelUrl: string;
+    requestString?: string;
+    messageSearchQuery?: MessageSearchQueryParams;
+    onResultLoaded?: (messages?: Array<CoreMessageType>, error?: SendbirdError) => void;
+    retryCount: number;
+}
+interface ToolProps {
+    sdk: SdkStore['sdk'];
+    logger: Logger;
+    messageSearchDispatcher: (props: {
+        type: string;
+        payload: any;
+    }) => void;
+}
+declare function useGetSearchedMessages({ currentChannel, channelUrl, requestString, messageSearchQuery, onResultLoaded, retryCount }: MainProps, { sdk, logger, messageSearchDispatcher }: ToolProps): void;
+export default useGetSearchedMessages;

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

@@ -0,0 +1,20 @@
+import type { SendbirdError } from '@sendbird/chat';
+import type { MessageSearchQuery } from '@sendbird/chat/message';
+import { CoreMessageType } from '../../../../utils';
+import { LoggerInterface } from '../../../../lib/Logger';
+interface MainProps {
+    currentMessageSearchQuery: MessageSearchQuery;
+    hasMoreResult: boolean;
+    onResultLoaded?: (messages?: Array<CoreMessageType>, error?: SendbirdError) => void;
+}
+type MessageSearchDispatcherType = {
+    type: string;
+    payload: any;
+};
+interface ToolProps {
+    logger: LoggerInterface;
+    messageSearchDispatcher: (payload: MessageSearchDispatcherType) => void;
+}
+export type CallbackReturn = (callback: (messages: Array<CoreMessageType>, error: any) => void) => void;
+declare function useScrollCallback({ currentMessageSearchQuery, hasMoreResult, onResultLoaded }: MainProps, { logger, messageSearchDispatcher }: ToolProps): CallbackReturn;
+export default useScrollCallback;

package/types/modules/MessageSearch/context/hooks/useSearchStringEffect.d.ts

@@ -0,0 +1,11 @@
+interface DynamicParams {
+    searchString: string;
+}
+interface StaticParams {
+    messageSearchDispatcher: (param: {
+        type: string;
+        payload: any;
+    }) => void;
+}
+declare function useSearchStringEffect({ searchString }: DynamicParams, { messageSearchDispatcher }: StaticParams): string;
+export default useSearchStringEffect;

package/types/modules/MessageSearch/context/hooks/useSetChannel.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from '../../../../lib/SendbirdState';
+import { SdkStore } from '../../../../lib/types';
+interface MainProps {
+    channelUrl: string;
+    sdkInit: boolean;
+}
+interface ToolProps {
+    sdk: SdkStore['sdk'];
+    logger: Logger;
+    messageSearchDispatcher: (param: {
+        type: string;
+        payload: any;
+    }) => void;
+}
+declare function useSetChannel({ channelUrl, sdkInit }: MainProps, { sdk, logger, messageSearchDispatcher }: ToolProps): void;
+export default useSetChannel;

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import './index.scss';
+import { MessageSearchUIProps } from './components/MessageSearchUI';
+import { MessageSearchProviderProps } from './context/MessageSearchProvider';
+export interface MessageSearchPannelProps extends MessageSearchUIProps, MessageSearchProviderProps {
+    onResultClick?: (message: any) => void;
+    onCloseClick?: () => void;
+}
+declare function MessageSearchPannel(props: MessageSearchPannelProps): JSX.Element;
+export default MessageSearchPannel;

package/types/modules/OpenChannel/components/FrozenChannelNotification/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import './frozen-channel-notification.scss';
+declare const FrozenNotification: () => JSX.Element;
+export default FrozenNotification;

package/types/modules/OpenChannel/components/OpenChannelHeader/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import './open-channel-header.scss';
+export default function OpenchannelConversationHeader(): JSX.Element;

package/types/modules/OpenChannel/components/OpenChannelInput/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export type MessageInputWrapperProps = {
+    value?: string;
+};
+declare const _default: React.ForwardRefExoticComponent<MessageInputWrapperProps & React.RefAttributes<HTMLInputElement>>;
+export default _default;

package/types/modules/OpenChannel/components/OpenChannelMessage/RemoveMessageModal.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { ClientFileMessage, ClientUserMessage } from '../../../../types';
+import { CoreMessageType } from '../../../../utils';
+interface Props {
+    message: CoreMessageType;
+    onCloseModal(): void;
+    onDeleteMessage(message: ClientUserMessage | ClientFileMessage, callback?: () => void): void;
+}
+export default function RemoveMessageModal({ message, onCloseModal, onDeleteMessage, }: Props): JSX.Element;
+export {};

package/types/modules/OpenChannel/components/OpenChannelMessage/index.d.ts

@@ -0,0 +1,12 @@
+import React, { ReactElement } from 'react';
+import type { RenderMessageProps } from '../../../../types';
+import { CoreMessageType } from '../../../../utils';
+export type OpenChannelMessageProps = {
+    renderMessage?: (props: RenderMessageProps) => React.ElementType<RenderMessageProps>;
+    message: CoreMessageType;
+    chainTop?: boolean;
+    chainBottom?: boolean;
+    hasSeparator?: boolean;
+    editDisabled?: boolean;
+};
+export default function MessagOpenChannelMessageeHoc(props: OpenChannelMessageProps): ReactElement;

package/types/modules/OpenChannel/components/OpenChannelMessage/utils.d.ts

@@ -0,0 +1,37 @@
+import { CoreMessageType } from '../../../../utils';
+export declare const MessageTypes: {
+    ADMIN: string;
+    USER: string;
+    FILE: string;
+    THUMBNAIL: string;
+    OG: string;
+    UNKNOWN: string;
+};
+export declare const SendingMessageStatus: {
+    NONE: string;
+    SUCCEEDED: string;
+    FAILED: string;
+    PENDING: string;
+};
+type MessageTypeOptions = {
+    isOgMessageEnabledInOpenChannel?: boolean;
+};
+export declare const getMessageType: (message: CoreMessageType, options?: MessageTypeOptions) => string;
+declare const _default: {
+    MessageTypes: {
+        ADMIN: string;
+        USER: string;
+        FILE: string;
+        THUMBNAIL: string;
+        OG: string;
+        UNKNOWN: string;
+    };
+    SendingMessageStatus: {
+        NONE: string;
+        SUCCEEDED: string;
+        FAILED: string;
+        PENDING: string;
+    };
+    getMessageType: (message: CoreMessageType, options?: MessageTypeOptions) => string;
+};
+export default _default;

package/types/modules/OpenChannel/components/OpenChannelMessageList/index.d.ts

@@ -0,0 +1,9 @@
+import './openchannel-message-list.scss';
+import React from 'react';
+import { RenderMessageProps } from '../../../../types';
+export type OpenchannelMessageListProps = {
+    renderMessage?: (props: RenderMessageProps) => React.ElementType<RenderMessageProps>;
+    renderPlaceHolderEmptyList?: () => React.ReactElement;
+};
+declare const _default: React.ForwardRefExoticComponent<OpenchannelMessageListProps & React.RefAttributes<HTMLDivElement>>;
+export default _default;

package/types/modules/OpenChannel/components/OpenChannelUI/index.d.ts

@@ -0,0 +1,13 @@
+import './open-channel-ui.scss';
+import React from 'react';
+import { RenderMessageProps } from '../../../../types';
+export interface OpenChannelUIProps {
+    renderMessage?: (props: RenderMessageProps) => React.ElementType<RenderMessageProps>;
+    renderHeader?: () => React.ReactElement;
+    renderInput?: () => React.ReactElement;
+    renderPlaceHolderEmptyList?: () => React.ReactElement;
+    renderPlaceHolderError?: () => React.ReactElement;
+    renderPlaceHolderLoading?: () => React.ReactElement;
+}
+declare const OpenChannelUI: React.FC<OpenChannelUIProps>;
+export default OpenChannelUI;

package/types/modules/OpenChannel/context/OpenChannelProvider.d.ts

@@ -0,0 +1,52 @@
+import React from 'react';
+import type { FileMessageCreateParams, UserMessageCreateParams } from '@sendbird/chat/message';
+import { RenderUserProfileProps } from '../../../types';
+import { State as MessageStoreState } from './dux/initialState';
+type OpenChannelQueries = {
+    messageListParams?: {
+        replyType?: string;
+        messageType?: string;
+        prevResultSize?: number;
+        nextResultSize?: number;
+        reverse?: boolean;
+        isInclusive?: boolean;
+        includeMetaArray?: boolean;
+        includeParentMessageInfo?: boolean;
+        showSubchannelMessagesOnly?: boolean;
+        customTypes?: Array<string>;
+        senderUserIds?: Array<string>;
+    };
+};
+export interface OpenChannelProviderProps {
+    channelUrl: string;
+    children?: React.ReactElement;
+    isMessageGroupingEnabled?: boolean;
+    queries?: OpenChannelQueries;
+    messageLimit?: number;
+    onBeforeSendUserMessage?(text: string): UserMessageCreateParams;
+    onBeforeSendFileMessage?(file_: File): FileMessageCreateParams;
+    onChatHeaderActionClick?(): void;
+    onBackClick?(): void;
+    disableUserProfile?: boolean;
+    renderUserProfile?: (props: RenderUserProfileProps) => React.ReactElement;
+}
+interface OpenChannelInterface extends OpenChannelProviderProps, MessageStoreState {
+    messageInputRef: React.RefObject<HTMLInputElement>;
+    conversationScrollRef: React.RefObject<HTMLDivElement>;
+    disabled: boolean;
+    amIBanned: boolean;
+    amIMuted: boolean;
+    amIOperator: boolean;
+    fetchMore: boolean;
+    checkScrollBottom: () => boolean;
+    onScroll: (callback: () => void) => void;
+    handleSendMessage: any;
+    handleFileUpload: any;
+    updateMessage: any;
+    deleteMessage: any;
+    resendMessage: any;
+}
+declare const OpenChannelProvider: React.FC<OpenChannelProviderProps>;
+export type UseOpenChannelType = () => OpenChannelInterface;
+declare const useOpenChannelContext: UseOpenChannelType;
+export { OpenChannelProvider, useOpenChannelContext, };

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

@@ -0,0 +1,37 @@
+export declare const SET_CURRENT_CHANNEL = "SET_CURRENT_CHANNEL";
+export declare const SET_CHANNEL_INVALID = "SET_CHANNEL_INVALID";
+export declare const RESET_MESSAGES = "RESET_MESSAGES";
+export declare const EXIT_CURRENT_CHANNEL = "EXIT_CURRENT_CHANNEL";
+export declare const GET_PREV_MESSAGES_START = "GET_PREV_MESSAGES_START";
+export declare const GET_PREV_MESSAGES_SUCESS = "GET_PREV_MESSAGES_SUCESS";
+export declare const GET_PREV_MESSAGES_FAIL = "GET_PREV_MESSAGES_FAIL";
+export declare const SENDING_MESSAGE_FAILED = "SENDING_MESSAGE_FAILED";
+export declare const SENDING_MESSAGE_SUCCEEDED = "SENDING_MESSAGE_SUCCEEDED";
+export declare const SENDING_MESSAGE_START = "SENDING_MESSAGE_START";
+export declare const RESENDING_MESSAGE_START = "RESENDING_MESSAGE_START";
+export declare const FETCH_PARTICIPANT_LIST = "FETCH_PARTICIPANT_LIST";
+export declare const FETCH_BANNED_USER_LIST = "FETCH_BANNED_USER_LIST";
+export declare const FETCH_MUTED_USER_LIST = "FETCH_MUTED_USER_LIST";
+export declare const TRIM_MESSAGE_LIST = "TRIM_MESSAGE_LIST";
+export declare const ON_MESSAGE_RECEIVED = "ON_MESSAGE_RECEIVED";
+export declare const ON_MESSAGE_UPDATED = "ON_MESSAGE_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 ON_OPERATOR_UPDATED = "ON_OPERATOR_UPDATED";
+export declare const ON_USER_ENTERED = "ON_USER_ENTERED";
+export declare const ON_USER_EXITED = "ON_USER_EXITED";
+export declare const ON_USER_MUTED = "ON_USER_MUTED";
+export declare const ON_USER_UNMUTED = "ON_USER_UNMUTED";
+export declare const ON_USER_BANNED = "ON_USER_BANNED";
+export declare const ON_USER_UNBANNED = "ON_USER_UNBANNED";
+export declare const ON_CHANNEL_FROZEN = "ON_CHANNEL_FROZEN";
+export declare const ON_CHANNEL_UNFROZEN = "ON_CHANNEL_UNFROZEN";
+export declare const ON_CHANNEL_CHANGED = "ON_CHANNEL_CHANGED";
+export declare const ON_CHANNEL_DELETED = "ON_CHANNEL_DELETED";
+export declare const ON_META_DATA_CREATED = "ON_META_DATA_CREATED";
+export declare const ON_META_DATA_UPDATED = "ON_META_DATA_UPDATED";
+export declare const ON_META_DATA_DELETED = "ON_META_DATA_DELETED";
+export declare const ON_META_COUNTERS_CREATED = "ON_META_COUNTERS_CREATED";
+export declare const ON_META_COUNTERS_UPDATED = "ON_META_COUNTERS_UPDATED";
+export declare const ON_META_COUNTERS_DELETED = "ON_META_COUNTERS_DELETED";
+export declare const ON_MENTION_RECEIVED = "ON_MENTION_RECEIVED";

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

@@ -0,0 +1,19 @@
+import type { User } from '@sendbird/chat';
+import type { OpenChannel } from '@sendbird/chat/openChannel';
+import { CoreMessageType } from '../../../../utils';
+export interface State {
+    allMessages: Array<CoreMessageType>;
+    loading: boolean;
+    initialized: boolean;
+    currentOpenChannel: OpenChannel;
+    isInvalid: boolean;
+    hasMore: boolean;
+    lastMessageTimestamp: number;
+    frozen: boolean;
+    operators: Array<User>;
+    participants: Array<User>;
+    bannedParticipantIds: Array<string>;
+    mutedParticipantIds: Array<string>;
+}
+declare const initialState: State;
+export default initialState;

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

@@ -0,0 +1,7 @@
+import { State as initialStateInterface } from './initialState';
+interface ActionInterface {
+    type: string;
+    payload?: any;
+}
+export default function reducer(state: initialStateInterface, action: ActionInterface): initialStateInterface;
+export {};

package/types/modules/OpenChannel/context/hooks/useCheckScrollBottom.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { LoggerInterface } from '../../../../lib/Logger';
+interface DynamicParams {
+    conversationScrollRef: React.RefObject<HTMLDivElement>;
+}
+interface StaticParams {
+    logger: LoggerInterface;
+}
+declare function useCheckScrollBottom({ conversationScrollRef }: DynamicParams, { logger }: StaticParams): () => boolean;
+export default useCheckScrollBottom;

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

@@ -0,0 +1,17 @@
+import type { OpenChannel } from '@sendbird/chat/openChannel';
+import { SendableMessageType } from '../../../../utils';
+import { Logger } from '../../../../lib/SendbirdState';
+interface DynamicParams {
+    currentOpenChannel: OpenChannel;
+}
+type MessagesDispatcherType = {
+    type: string;
+    payload: any;
+};
+interface StaticParams {
+    logger: Logger;
+    messagesDispatcher: (dispatcher: MessagesDispatcherType) => void;
+}
+type CallbackReturn = (message: SendableMessageType, callback?: () => void) => void;
+declare function useDeleteMessageCallback({ currentOpenChannel }: DynamicParams, { logger, messagesDispatcher }: StaticParams): CallbackReturn;
+export default useDeleteMessageCallback;

package/types/modules/OpenChannel/context/hooks/useFileUploadCallback.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="react" />
+import type { OpenChannel } from '@sendbird/chat/openChannel';
+import type { FileMessageCreateParams } from '@sendbird/chat/message';
+import type { Logger } from '../../../../lib/SendbirdState';
+import { SdkStore } from '../../../../lib/types';
+interface DynamicParams {
+    currentOpenChannel: OpenChannel;
+    onBeforeSendFileMessage: (file: File) => FileMessageCreateParams;
+    checkScrollBottom: () => boolean;
+    imageCompression?: {
+        compressionRate?: number;
+        resizingWidth?: number | string;
+        resizingHeight?: number | string;
+    };
+}
+interface StaticParams {
+    sdk: SdkStore['sdk'];
+    logger: Logger;
+    messagesDispatcher: (props: {
+        type: string;
+        payload: any;
+    }) => void;
+    scrollRef: React.MutableRefObject<HTMLElement>;
+}
+type CallbackReturn = (files: Array<File> | File) => void;
+declare function useFileUploadCallback({ currentOpenChannel, checkScrollBottom, imageCompression, onBeforeSendFileMessage, }: DynamicParams, { sdk, logger, messagesDispatcher, scrollRef }: StaticParams): CallbackReturn;
+export default useFileUploadCallback;

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

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import { OpenChannel } from '@sendbird/chat/openChannel';
+import { Logger } from '../../../../lib/SendbirdState';
+import { SdkStore } from '../../../../lib/types';
+type MessagesDispatcherType = {
+    type: string;
+    payload: any;
+};
+interface DynamicParams {
+    currentOpenChannel: OpenChannel;
+    checkScrollBottom: () => boolean;
+}
+interface StaticParams {
+    sdk: SdkStore['sdk'];
+    logger: Logger;
+    scrollRef: React.RefObject<HTMLElement>;
+    messagesDispatcher: (props: MessagesDispatcherType) => void;
+}
+declare function useHandleChannelEvents({ currentOpenChannel, checkScrollBottom }: DynamicParams, { sdk, logger, messagesDispatcher, scrollRef }: StaticParams): void;
+export default useHandleChannelEvents;

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

@@ -0,0 +1,14 @@
+import type { OpenChannel } from '@sendbird/chat/openChannel';
+import React from 'react';
+import type { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+interface DynamicParams {
+    currentOpenChannel: OpenChannel;
+    userFilledMessageListParams?: Record<string, any>;
+}
+interface StaticParams {
+    logger: Logger;
+    messagesDispatcher: CustomUseReducerDispatcher;
+    scrollRef: React.RefObject<HTMLElement>;
+}
+declare function useInitialMessagesFetch({ currentOpenChannel, userFilledMessageListParams }: DynamicParams, { logger, messagesDispatcher, scrollRef }: StaticParams): void;
+export default useInitialMessagesFetch;

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

@@ -0,0 +1,17 @@
+import type { OpenChannel } from '@sendbird/chat/openChannel';
+import { SendableMessageType } from '../../../../utils';
+import { Logger } from '../../../../lib/SendbirdState';
+interface DynamicParams {
+    currentOpenChannel: OpenChannel;
+}
+type MessagesDispatcherType = {
+    type: string;
+    payload: any;
+};
+interface StaticParams {
+    logger: Logger;
+    messagesDispatcher: (dispatcher: MessagesDispatcherType) => void;
+}
+type CallbackReturn = (failedMessage: SendableMessageType) => void;
+declare function useResendMessageCallback({ currentOpenChannel }: DynamicParams, { logger, messagesDispatcher }: StaticParams): CallbackReturn;
+export default useResendMessageCallback;

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

@@ -0,0 +1,18 @@
+import type { OpenChannel } from '@sendbird/chat/openChannel';
+import type { CustomUseReducerDispatcher, Logger } from '../../../../lib/SendbirdState';
+import { SdkStore } from '../../../../lib/types';
+interface DynamicParams {
+    currentOpenChannel: OpenChannel;
+    lastMessageTimestamp: number;
+    fetchMore?: boolean;
+}
+interface StaticParams {
+    sdk: SdkStore['sdk'];
+    logger: Logger;
+    messagesDispatcher: CustomUseReducerDispatcher;
+    hasMore: boolean;
+    userFilledMessageListParams?: Record<string, any>;
+}
+type CallbackReturn = (callback: () => void) => void;
+declare function useScrollCallback({ currentOpenChannel, lastMessageTimestamp, fetchMore }: DynamicParams, { sdk, logger, messagesDispatcher, hasMore, userFilledMessageListParams }: StaticParams): CallbackReturn;
+export default useScrollCallback;

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

@@ -0,0 +1,22 @@
+import type { UserMessageCreateParams } from '@sendbird/chat/message';
+import type { OpenChannel } from '@sendbird/chat/openChannel';
+import React from 'react';
+import type { Logger } from '../../../../lib/SendbirdState';
+import { SdkStore } from '../../../../lib/types';
+interface DynamicParams {
+    currentOpenChannel: OpenChannel;
+    onBeforeSendUserMessage: (text: string) => UserMessageCreateParams;
+    checkScrollBottom: () => boolean;
+    messageInputRef: React.RefObject<HTMLInputElement>;
+}
+interface StaticParams {
+    sdk: SdkStore['sdk'];
+    logger: Logger;
+    messagesDispatcher: (props: {
+        type: string;
+        payload: any;
+    }) => void;
+    scrollRef: React.RefObject<HTMLElement>;
+}
+declare function useSendMessageCallback({ currentOpenChannel, onBeforeSendUserMessage, checkScrollBottom, messageInputRef }: DynamicParams, { sdk, logger, messagesDispatcher, scrollRef }: StaticParams): () => void;
+export default useSendMessageCallback;

package/types/modules/OpenChannel/context/hooks/useSetChannel.d.ts

@@ -0,0 +1,20 @@
+import type { OpenChannel } from '@sendbird/chat/openChannel';
+import type { Logger } from '../../../../lib/SendbirdState';
+import { SdkStore } from '../../../../lib/types';
+interface DynamicParams {
+    channelUrl: string;
+    sdkInit: boolean;
+    fetchingParticipants: boolean;
+    userId: string;
+    currentOpenChannel: OpenChannel;
+}
+interface StaticParams {
+    sdk: SdkStore['sdk'];
+    logger: Logger;
+    messagesDispatcher: ({ type, payload }: {
+        type: string;
+        payload: any;
+    }) => void;
+}
+declare function useSetChannel({ channelUrl, sdkInit, fetchingParticipants, userId, currentOpenChannel }: DynamicParams, { sdk, logger, messagesDispatcher }: StaticParams): void;
+export default useSetChannel;

package/types/modules/OpenChannel/context/hooks/useTrimMessageList.d.ts

@@ -0,0 +1,17 @@
+import { LoggerInterface } from '../../../../lib/Logger';
+interface DynamicParams {
+    messagesLength: number;
+    messageLimit: number;
+}
+type MessagesDispatcherType = {
+    type: string;
+    payload: {
+        messageLimit: number;
+    };
+};
+interface StaticParams {
+    messagesDispatcher: (dispatcher: MessagesDispatcherType) => void;
+    logger: LoggerInterface;
+}
+declare function useTrimMessageList({ messagesLength, messageLimit }: DynamicParams, { messagesDispatcher, logger }: StaticParams): void;
+export default useTrimMessageList;

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

@@ -0,0 +1,17 @@
+import type { UserMessageUpdateParams } from '@sendbird/chat/message';
+import type { Logger } from '../../../../lib/SendbirdState';
+import type { OpenChannel } from '@sendbird/chat/openChannel';
+interface DynamicParams {
+    currentOpenChannel: OpenChannel;
+    onBeforeSendUserMessage?: (text: any) => UserMessageUpdateParams;
+}
+interface StaticParams {
+    logger: Logger;
+    messagesDispatcher: (props: {
+        type: string;
+        payload: any;
+    }) => void;
+}
+type CallbackReturn = (messageId: any, text: any, callback: any) => void;
+declare function useUpdateMessageCallback({ currentOpenChannel, onBeforeSendUserMessage }: DynamicParams, { logger, messagesDispatcher }: StaticParams): CallbackReturn;
+export default useUpdateMessageCallback;

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

@@ -0,0 +1,16 @@
+import type React from 'react';
+import type { User } from '@sendbird/chat';
+import type { OpenChannel, ParticipantListQuery } from '@sendbird/chat/openChannel';
+import { Logger } from '../../../lib/SendbirdState';
+import { CoreMessageType, SendableMessageType } from '../../../utils';
+export declare const getMessageCreatedAt: (message: SendableMessageType) => string;
+export declare const shouldFetchMore: (messageLength: number, maxMessages: number) => boolean;
+export declare const scrollIntoLast: (initialTry: number, scrollRef: React.RefObject<HTMLElement>) => void;
+export declare const isSameGroup: (message: CoreMessageType, comparingMessage: CoreMessageType) => boolean;
+export declare const compareMessagesForGrouping: (prevMessage: CoreMessageType, currMessage: CoreMessageType, nextMessage: CoreMessageType) => [boolean, boolean];
+export declare const kFormatter: (num: number) => string;
+export declare const isOperator: (openChannel: OpenChannel, userId: string) => boolean;
+export declare const isDisabledBecauseFrozen: (openChannel: OpenChannel, userId: string) => boolean;
+export declare const isDisabledBecauseMuted: (mutedParticipantIds: Array<string>, userId: string) => boolean;
+export declare const fetchWithListQuery: (listQuery: ParticipantListQuery, logger: Logger, eachQueryNextCallback: (users: Array<User>) => void) => void;
+export declare const pxToNumber: (px: string | number) => number | void;

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

@@ -0,0 +1,7 @@
+import React from 'react';
+import { OpenChannelUIProps } from './components/OpenChannelUI';
+import { OpenChannelProviderProps } from './context/OpenChannelProvider';
+export interface OpenChannelProps extends OpenChannelProviderProps, OpenChannelUIProps {
+}
+declare const OpenChannel: React.FC<OpenChannelProps>;
+export default OpenChannel;