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

package/types/lib/handlers/SessionHandler.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the instance of SessionHandler
+ */
+import { SessionHandler } from '@sendbird/chat';
+export default SessionHandler;

package/types/lib/handlers/UserEventHandler.d.ts

@@ -0,0 +1,5 @@
+import { UserEventHandler } from '@sendbird/chat';
+/**
+ * Returns the class of UserEventHandler
+ */
+export default UserEventHandler;

package/types/lib/hooks/schedulerFactory.d.ts

@@ -0,0 +1,11 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { Logger } from '../SendbirdState';
+export declare function schedulerFactory<T>({ logger, timeout, cb, }: {
+    logger: Logger;
+    timeout?: number;
+    cb: (item: T) => void;
+}): {
+    push: (channel: GroupChannel) => void;
+    clear: () => void;
+    getQueue: () => GroupChannel[];
+};

package/types/lib/hooks/useConnect/__test__/data.mocks.d.ts

@@ -0,0 +1,15 @@
+import { User } from '@sendbird/chat';
+import { ConnectTypes, DisconnectSdkTypes, SetupConnectionTypes, StaticTypes, TriggerTypes } from '../types';
+export declare const mockUser: User;
+export declare const mockUser2: User;
+export declare const mockSdk: import("@sendbird/chat").default;
+export declare const mockSdkDispatcher: (value: import("../../../dux/sdk/actionTypes").SdkActionTypes) => void;
+export declare const mockUserDispatcher: (value: import("../../../dux/user/actionTypes").UserActionTypes) => void;
+export declare const mockInitDashboardConfigs: (sdk: import("@sendbird/chat").default) => Promise<void>;
+export declare const defaultStaticParams: StaticTypes;
+export declare const defaultTriggerParams: TriggerTypes;
+export declare const defaultConnectParams: ConnectTypes;
+export declare const defaultSetupConnectionParams: SetupConnectionTypes;
+export declare const defaultDisconnectSdkParams: DisconnectSdkTypes;
+export declare function generateDisconnectSdkParams(overrides?: Partial<DisconnectSdkTypes>): DisconnectSdkTypes;
+export declare function generateSetUpConnectionParams(overrides?: Partial<SetupConnectionTypes>): SetupConnectionTypes;

package/types/lib/hooks/useConnect/connect.d.ts

@@ -0,0 +1,2 @@
+import { ConnectTypes } from './types';
+export declare function connect({ logger, sdkDispatcher, userDispatcher, initDashboardConfigs, userId, appId, customApiHost, customWebSocketHost, configureSession, nickname, profileUrl, accessToken, sdk, sdkInitParams, customExtensionParams, isMobile, }: ConnectTypes): Promise<void>;

package/types/lib/hooks/useConnect/disconnectSdk.d.ts

@@ -0,0 +1,2 @@
+import { DisconnectSdkTypes } from './types';
+export declare function disconnectSdk({ sdkDispatcher, userDispatcher, sdk, }: DisconnectSdkTypes): Promise<boolean>;

package/types/lib/hooks/useConnect/index.d.ts

@@ -0,0 +1,2 @@
+import { ReconnectType, StaticTypes, TriggerTypes } from './types';
+export default function useConnect(triggerTypes: TriggerTypes, staticTypes: StaticTypes): ReconnectType;

package/types/lib/hooks/useConnect/setupConnection.d.ts

@@ -0,0 +1,18 @@
+import SendbirdChat, { SendbirdError } from '@sendbird/chat';
+import { OpenChannelModule } from '@sendbird/chat/openChannel';
+import { GroupChannelModule } from '@sendbird/chat/groupChannel';
+import { SetupConnectionTypes } from './types';
+import { CustomExtensionParams, SendbirdChatInitParams } from '../../types';
+export declare function getMissingParamError({ userId, appId }: {
+    userId?: string;
+    appId?: string;
+}): string;
+export declare function getConnectSbError(error?: SendbirdError): string;
+export declare function setUpParams({ appId, customApiHost, customWebSocketHost, sdkInitParams, }: {
+    appId: string;
+    customApiHost?: string;
+    customWebSocketHost?: string;
+    sdkInitParams?: SendbirdChatInitParams;
+    customExtensionParams?: CustomExtensionParams;
+}): SendbirdChat & import("@sendbird/chat/lib/__definition").ModuleNamespaces<[...(import("@sendbird/chat/lib/__definition").Module & (GroupChannelModule | OpenChannelModule))[], import("@sendbird/chat/message").MessageModule, import("@sendbird/chat/poll").PollModule], import("@sendbird/chat/message").MessageModule | import("@sendbird/chat/poll").PollModule | (import("@sendbird/chat/lib/__definition").Module & (GroupChannelModule | OpenChannelModule))>;
+export declare function setUpConnection({ logger, sdkDispatcher, userDispatcher, initDashboardConfigs, userId, appId, customApiHost, customWebSocketHost, configureSession, nickname, profileUrl, accessToken, isUserIdUsedForNickname, sdkInitParams, customExtensionParams, isMobile, }: SetupConnectionTypes): Promise<void>;

package/types/lib/hooks/useConnect/types.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="react" />
+import SendbirdChat, { SessionHandler } from '@sendbird/chat';
+import { SendbirdGroupChat } from '@sendbird/chat/groupChannel';
+import { SendbirdOpenChat } from '@sendbird/chat/openChannel';
+import { SdkActionTypes } from '../../dux/sdk/actionTypes';
+import { UserActionTypes } from '../../dux/user/actionTypes';
+import { Logger } from '../../SendbirdState';
+import { SendbirdChatInitParams, CustomExtensionParams } from '../../types';
+type SdkDispatcher = React.Dispatch<SdkActionTypes>;
+type UserDispatcher = React.Dispatch<UserActionTypes>;
+export type TriggerTypes = {
+    userId: string;
+    appId: string;
+    accessToken?: string;
+    isUserIdUsedForNickname?: boolean;
+    isMobile?: boolean;
+};
+export type ConfigureSessionTypes = (sdk: SendbirdChat | SendbirdGroupChat | SendbirdOpenChat) => SessionHandler;
+export type StaticTypes = {
+    nickname: string;
+    profileUrl: string;
+    configureSession?: ConfigureSessionTypes;
+    customApiHost?: string;
+    customWebSocketHost?: string;
+    sdk: SendbirdChat;
+    logger: Logger;
+    sdkDispatcher: SdkDispatcher;
+    userDispatcher: UserDispatcher;
+    initDashboardConfigs: (sdk: SendbirdChat) => Promise<void>;
+    sdkInitParams?: SendbirdChatInitParams;
+    customExtensionParams?: CustomExtensionParams;
+};
+export type ConnectTypes = TriggerTypes & StaticTypes;
+export type SetupConnectionTypes = Omit<ConnectTypes, 'sdk'>;
+export type DisconnectSdkTypes = {
+    sdkDispatcher: SdkDispatcher;
+    userDispatcher: UserDispatcher;
+    sdk: SendbirdChat;
+    logger: Logger;
+};
+export type ReconnectType = () => void;
+export {};

package/types/lib/hooks/useMarkAsDeliveredScheduler.d.ts

@@ -0,0 +1,15 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { Logger } from '../SendbirdState';
+export type MarkAsDeliveredSchedulerType = {
+    push: (channel: GroupChannel) => void;
+    clear: () => void;
+    getQueue: () => GroupChannel[];
+};
+interface DynamicParams {
+    isConnected: boolean;
+}
+interface StaticParams {
+    logger: Logger;
+}
+export declare function useMarkAsDeliveredScheduler({ isConnected, }: DynamicParams, { logger, }: StaticParams): MarkAsDeliveredSchedulerType;
+export {};

package/types/lib/hooks/useMarkAsReadScheduler.d.ts

@@ -0,0 +1,15 @@
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { Logger } from '../SendbirdState';
+export type MarkAsReadSchedulerType = {
+    push: (channel: GroupChannel) => void;
+    clear: () => void;
+    getQueue: () => GroupChannel[];
+};
+interface DynamicParams {
+    isConnected: boolean;
+}
+interface StaticParams {
+    logger: Logger;
+}
+export declare function useMarkAsReadScheduler({ isConnected, }: DynamicParams, { logger, }: StaticParams): MarkAsReadSchedulerType;
+export {};

package/types/lib/hooks/useOnlineStatus.d.ts

@@ -0,0 +1,4 @@
+import type SendbirdChat from '@sendbird/chat';
+import { LoggerInterface } from '../Logger';
+declare function useOnlineStatus(sdk: SendbirdChat, logger: LoggerInterface): boolean;
+export default useOnlineStatus;

package/types/lib/hooks/useTheme.d.ts

@@ -0,0 +1,2 @@
+declare const useTheme: (overrides: Record<string, string>) => void;
+export default useTheme;

package/types/lib/pubSub/index.d.ts

@@ -0,0 +1,9 @@
+export interface PubSubTypes {
+    __getTopics: () => Record<string, string>;
+    subscribe: (topic: string, listener: unknown) => {
+        remove: () => void;
+    };
+    publish: (topic: string, info: unknown) => void;
+}
+declare const pubSubFactory: () => PubSubTypes;
+export default pubSubFactory;

package/types/lib/pubSub/topics.d.ts

@@ -0,0 +1,16 @@
+import { ObjectValues } from '../../utils/typeHelpers/objectValues';
+export declare const PUBSUB_TOPICS: {
+    readonly USER_UPDATED: "USER_UPDATED";
+    readonly SEND_MESSAGE_START: "SEND_MESSAGE_START";
+    readonly SEND_MESSAGE_FAILED: "SEND_MESSAGE_FAILED";
+    readonly SEND_USER_MESSAGE: "SEND_USER_MESSAGE";
+    readonly SEND_FILE_MESSAGE: "SEND_FILE_MESSAGE";
+    readonly ON_FILE_INFO_UPLOADED: "ON_FILE_INFO_UPLOADED";
+    readonly UPDATE_USER_MESSAGE: "UPDATE_USER_MESSAGE";
+    readonly DELETE_MESSAGE: "DELETE_MESSAGE";
+    readonly LEAVE_CHANNEL: "LEAVE_CHANNEL";
+    readonly CREATE_CHANNEL: "CREATE_CHANNEL";
+    readonly UPDATE_OPEN_CHANNEL: "UPDATE_OPEN_CHANNEL";
+};
+export type pubSubTopic = ObjectValues<typeof PUBSUB_TOPICS>;
+export default PUBSUB_TOPICS;

package/types/lib/selectors.d.ts

@@ -0,0 +1,247 @@
+import type { User } from '@sendbird/chat';
+import { FailedMessageHandler, MessageHandler, UserMessage, UserMessageCreateParams } from '@sendbird/chat/message';
+import { GroupChannel, GroupChannelCreateParams } from '@sendbird/chat/groupChannel';
+import { OpenChannel, OpenChannelCreateParams } from '@sendbird/chat/openChannel';
+import { FileMessage, FileMessageCreateParams, SendableMessage, UserMessageUpdateParams } from '@sendbird/chat/lib/__definition';
+import { SendBirdState } from './types';
+import { SendableMessageType } from '../utils';
+/**
+ * 1. UIKit Instances
+ *    a. getSdk
+ *    b. getPubSub
+ * 2. Chat & Connection
+ *    a. getConnect
+ *    b. getDisconnect
+ *    c. getUpdateUserInfo
+ * 3. Channel
+ *    a. getCreateGroupChannel
+ *    b. getCreateOpenChannel
+ *    c. getGetGroupChannel
+ *    d. getGetOpenChannel
+ *    e. getLeaveGroupChannel
+ *    f. getEnterOpenChannel
+ *    g. getExitOpenChannel
+ *    h. getFreezeChannel
+ *    i. getUnfreezeChannel
+ * 4. Message
+ *    a. getSendUserMessage
+ *    b. getSendFileMessage
+ *    c. getUpdateUserMessage
+ *    d. x - getUpdateFileMessage
+ *    e. getDeleteMessage
+ *    f. getResendUserMessage
+ *    g. getResendFileMessage
+ */
+/**
+ * import useSendbirdStateContext from '@sendbird-uikit/useSendbirdStateContext'
+ * import selectors from '@sendbird-uikit/send'
+ * const state = useSendbirdStateContext();
+ */
+/**
+ * const sdk = selectors.getSdk(state);
+ */
+export declare const getSdk: (state: SendBirdState) => import("@sendbird/chat").default & import("@sendbird/chat/lib/__definition").ModuleNamespaces<[import("@sendbird/chat/groupChannel").GroupChannelModule, import("@sendbird/chat/openChannel").OpenChannelModule], import("@sendbird/chat/groupChannel").GroupChannelModule | import("@sendbird/chat/openChannel").OpenChannelModule>;
+/**
+ * const pubSub = selectors.getPubSub(state);
+ */
+export declare const getPubSub: (state: SendBirdState) => any;
+/**
+ * const connect = selectors.getConnect(state);
+ * connect('user-id-sendbirdian', 'access-token-0000')
+ *  .then((user) => {})
+ *  .catch((error) => {})
+ */
+export declare const getConnect: (state: SendBirdState) => (userId: string, accessToken?: string) => Promise<User>;
+/**
+ * const disconnect = selectors.getDisconnect(state);
+ * disconnect()
+ *  .then(() => {})
+ *  .catch((error) => {})
+ */
+export declare const getDisconnect: (state: SendBirdState) => () => Promise<void>;
+/**
+ * const updateUserInfo = selectors.getUpdateUserInfo(state);
+ * updateUserInfo('new-nickname', 'new-profile-url')
+ *  .then((user) => {})
+ *  .catch((error) => {})
+ */
+export declare const getUpdateUserInfo: (state: SendBirdState) => (nickname: string, profileUrl?: string) => Promise<User>;
+/**
+ * const createGroupChannel = selectors.getCreateGroupChannel(state);
+ * createGroupChannel(channelParams: GroupChannelCreateParams)
+ *  .then((channel) => {})
+ *  .catch((error) => {})
+ */
+export declare const getCreateGroupChannel: (state: SendBirdState) => (params: GroupChannelCreateParams) => Promise<GroupChannel>;
+/**
+ * const createOpenChannel = selectors.getCreateOpenChannel(state);
+ * createOpenChannel(channelParams: OpenChannelCreateParams)
+ *  .then((channel) => {})
+ *  .catch((error) => {})
+ */
+export declare const getCreateOpenChannel: (state: SendBirdState) => (params: OpenChannelCreateParams) => Promise<OpenChannel>;
+/**
+ * const getGroupChannel = selectors.getGetGroupChannel(state);
+ * getGroupChannel('channel-url-1234', isSelected)
+ *  .then((channel) => {
+ *    // groupChannel = channel;
+ *    // or
+ *    // setCurrentChannel(channel);
+ *  })
+ *  .catch((error) => {})
+ */
+export declare const getGetGroupChannel: (state: SendBirdState) => (channelUrl: string) => Promise<GroupChannel>;
+/**
+ * const getOpenChannel = selectors.getGetOpenChannel(state);
+ * getOpenChannel('channel-url-12345')
+ *  .then((channel) => {
+ *    // openChannel = channel;
+ *    // or
+ *    // setCurrentChannel(channel);
+ *  })
+ *  .catch((error) => {})
+ */
+export declare const getGetOpenChannel: (state: SendBirdState) => (channelUrl: string) => Promise<OpenChannel>;
+/**
+ * const leaveChannel = selectors.getLeaveGroupChannel(state);
+ * leaveChannel('group-channel-url')
+ *  .then((channel) => {})
+ *  .catch((error) => {})
+ */
+export declare const getLeaveGroupChannel: (state: SendBirdState) => (channelUrl: string) => Promise<void>;
+/**
+ * const enterChannel = selectors.getEnterOpenChannel(state);
+ * enterChannel('open-channel-url')
+ *  .then((channel) => {})
+ *  .catch((error) => {})
+ */
+export declare const getEnterOpenChannel: (state: SendBirdState) => (channelUrl: string) => Promise<OpenChannel>;
+/**
+ * const exitChannel = selectors.getExitOpenChannel(state);
+ * exitChannel('open-channel-url')
+ *  .then((channel) => {})
+ *  .catch((error) => {})
+ */
+export declare const getExitOpenChannel: (state: SendBirdState) => (channelUrl: string) => Promise<OpenChannel>;
+/**
+ * const freezeChannel = selectors.getFreezeChannel(currentChannel);
+ * freezeChannel()
+ *  .then(() => {})
+ *  .catch((error) => {})
+ */
+export declare const getFreezeChannel: () => (channel: GroupChannel | OpenChannel) => Promise<void>;
+/**
+ * const unfreezeChannel = selectors.getUnfreezeChannel(currentChannel);
+ * unfreezeChannel()
+ *  .then((channel) => {})
+ *  .catch((error) => {})
+ */
+export declare const getUnfreezeChannel: () => (channel: GroupChannel | OpenChannel) => Promise<void>;
+export declare class UikitMessageHandler<T extends SendableMessage = SendableMessage> {
+    private _onPending;
+    private _onFailed;
+    private _onSucceeded;
+    triggerPending(message: T): void;
+    triggerFailed(error: Error, message: T): void;
+    triggerSucceeded(message: T): void;
+    onPending(handler: MessageHandler<T>): UikitMessageHandler;
+    onFailed(handler: FailedMessageHandler<T>): UikitMessageHandler;
+    onSucceeded(handler: MessageHandler<T>): UikitMessageHandler;
+}
+/**
+ * const sendUserMessage = selectors.getSendUserMessage(state);
+ * sendUserMessage(
+ *  channel: GroupChannel | OpenChannel,
+ *  params: UserMessageCreateParams,
+ * )
+ *  .onPending((message) => {})
+ *  .onFailed((error, message) => {})
+ *  .onSucceeded((message) => {})
+ */
+export declare const getSendUserMessage: (state: SendBirdState) => (channel: GroupChannel | OpenChannel, params: UserMessageCreateParams) => UikitMessageHandler;
+/**
+ * const sendFileMessage = selectors.getSendFileMessage(state);
+ * sendFileMessage(
+ *  channel: GroupChannel | OpenChannel,
+ *  params: FileMessageCreateParams,
+ * )
+ *  .onPending((message) => {})
+ *  .onFailed((error, message) => {})
+ *  .onSucceeded((message) => {})
+ */
+export declare const getSendFileMessage: (state: SendBirdState) => (channel: GroupChannel | OpenChannel, params: FileMessageCreateParams) => UikitMessageHandler;
+/**
+ * const updateUserMessage = selectors.getUpdateUserMessage(state);
+ * updateUserMessage(
+ *  channel: GroupChannel | OpenChannel,
+ *  messageId: number,
+ *  messageParams: UserMessageUpdateParams,
+ * )
+ *  .then((message) => {})
+ *  .catch((error) => {})
+ */
+export declare const getUpdateUserMessage: (state: SendBirdState) => (channel: GroupChannel | OpenChannel, messageId: number, params: UserMessageUpdateParams) => Promise<UserMessage>;
+/**
+ * const updateFileMessage = selectors.getUpdateFileMessage(state);
+ * updateFileMessage(
+ *  channel: GroupChannel | OpenChannel,
+ *  messageId: number,
+ *  params: FileMessageUpdateParams,
+ * )
+ *  .then((message) => {})
+ *  .catch((error) => {})
+ */
+/**
+ * const deleteMessage = selectors.getDeleteMessage(state);
+ * deleteMessage(
+ *  channel: GroupChannel | OpenChannel,
+ *  message: SendableMessage,
+ * )
+ *  .then((deletedMessage) => {})
+ *  .catch((error) => {})
+ */
+export declare const getDeleteMessage: (state: SendBirdState) => (channel: GroupChannel | OpenChannel, message: SendableMessageType) => Promise<SendableMessageType>;
+/**
+ * const resendUserMessage = selectors.getResendUserMessage(state);
+ * resendUserMessage(
+ *  channel: GroupChannel | OpenChannel,
+ *  failedMessage: UserMessage,
+ * )
+ *  .then(() => {})
+ *  .catch((error) => {})
+ */
+export declare const getResendUserMessage: (state: SendBirdState) => (channel: GroupChannel | OpenChannel, failedMessage: UserMessage) => Promise<UserMessage>;
+/**
+ * const resendFileMessage = selectors.getResendFileMessage(state);
+ * resendFileMessage(
+ *  channel: GroupChannel | OpenChannel,
+ *  failedMessage: FileMessage,
+ *  blob: Blob,
+ * )
+ *  .then(() => {})
+ *  .catch((error) => {})
+ */
+export declare const getResendFileMessage: (state: SendBirdState) => (channel: GroupChannel | OpenChannel, failedMessage: FileMessage, blob: Blob) => Promise<FileMessage>;
+declare const sendbirdSelectors: {
+    getSdk: (state: SendBirdState) => import("@sendbird/chat").default & import("@sendbird/chat/lib/__definition").ModuleNamespaces<[import("@sendbird/chat/groupChannel").GroupChannelModule, import("@sendbird/chat/openChannel").OpenChannelModule], import("@sendbird/chat/groupChannel").GroupChannelModule | import("@sendbird/chat/openChannel").OpenChannelModule>;
+    getPubSub: (state: SendBirdState) => any;
+    getConnect: (state: SendBirdState) => (userId: string, accessToken?: string) => Promise<User>;
+    getDisconnect: (state: SendBirdState) => () => Promise<void>;
+    getUpdateUserInfo: (state: SendBirdState) => (nickname: string, profileUrl?: string) => Promise<User>;
+    getCreateGroupChannel: (state: SendBirdState) => (params: GroupChannelCreateParams) => Promise<GroupChannel>;
+    getCreateOpenChannel: (state: SendBirdState) => (params: OpenChannelCreateParams) => Promise<OpenChannel>;
+    getGetGroupChannel: (state: SendBirdState) => (channelUrl: string) => Promise<GroupChannel>;
+    getGetOpenChannel: (state: SendBirdState) => (channelUrl: string) => Promise<OpenChannel>;
+    getLeaveGroupChannel: (state: SendBirdState) => (channelUrl: string) => Promise<void>;
+    getEnterOpenChannel: (state: SendBirdState) => (channelUrl: string) => Promise<OpenChannel>;
+    getExitOpenChannel: (state: SendBirdState) => (channelUrl: string) => Promise<OpenChannel>;
+    getFreezeChannel: () => (channel: GroupChannel | OpenChannel) => Promise<void>;
+    getUnfreezeChannel: () => (channel: GroupChannel | OpenChannel) => Promise<void>;
+    getSendUserMessage: (state: SendBirdState) => (channel: GroupChannel | OpenChannel, params: UserMessageCreateParams) => UikitMessageHandler;
+    getSendFileMessage: (state: SendBirdState) => (channel: GroupChannel | OpenChannel, params: FileMessageCreateParams) => UikitMessageHandler;
+    getUpdateUserMessage: (state: SendBirdState) => (channel: GroupChannel | OpenChannel, messageId: number, params: UserMessageUpdateParams) => Promise<UserMessage>;
+    getDeleteMessage: (state: SendBirdState) => (channel: GroupChannel | OpenChannel, message: SendableMessageType) => Promise<SendableMessageType>;
+    getResendUserMessage: (state: SendBirdState) => (channel: GroupChannel | OpenChannel, failedMessage: UserMessage) => Promise<UserMessage>;
+    getResendFileMessage: (state: SendBirdState) => (channel: GroupChannel | OpenChannel, failedMessage: FileMessage, blob: Blob) => Promise<FileMessage>;
+};
+export default sendbirdSelectors;

package/types/lib/types.d.ts

@@ -0,0 +1,165 @@
+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';
+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: any;
+    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>;