@sendbird/uikit-react 3.7.0 → 3.8.1

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,19 @@
+export type PubSubTypes<T extends keyof any, U extends {
+    topic: T;
+    payload: any;
+}> = {
+    __getTopics: () => Record<T, Set<(data: PayloadByTopic<T, U>) => void>>;
+    subscribe: <K extends T>(topic: K, subscriber: (data: PayloadByTopic<K, U>) => void) => {
+        remove: () => void;
+    };
+    publish: <K extends T>(topic: K, data: PayloadByTopic<K, U>) => void;
+};
+type PayloadByTopic<T extends keyof any, U> = U extends {
+    topic: T;
+    payload: infer P;
+} ? P : never;
+declare const pubSubFactory: <T extends string | number | symbol = string | number | symbol, U extends {
+    topic: T;
+    payload: any;
+} = any>() => PubSubTypes<T, U>;
+export default pubSubFactory;

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

@@ -0,0 +1,86 @@
+import { PublishingModuleType } from '../../modules/internalInterfaces';
+import { UploadableFileInfo } from '@sendbird/chat/message';
+import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { PubSubTypes } from './index';
+import { OpenChannel } from '@sendbird/chat/openChannel';
+import { SendableMessageType } from '../../utils';
+export { PublishingModuleType } from '../../modules/internalInterfaces';
+export declare enum PUBSUB_TOPICS {
+    USER_UPDATED = "USER_UPDATED",
+    SEND_MESSAGE_START = "SEND_MESSAGE_START",
+    SEND_MESSAGE_FAILED = "SEND_MESSAGE_FAILED",
+    SEND_USER_MESSAGE = "SEND_USER_MESSAGE",
+    SEND_FILE_MESSAGE = "SEND_FILE_MESSAGE",
+    ON_FILE_INFO_UPLOADED = "ON_FILE_INFO_UPLOADED",
+    UPDATE_USER_MESSAGE = "UPDATE_USER_MESSAGE",
+    DELETE_MESSAGE = "DELETE_MESSAGE",
+    LEAVE_CHANNEL = "LEAVE_CHANNEL",
+    CREATE_CHANNEL = "CREATE_CHANNEL",
+    UPDATE_OPEN_CHANNEL = "UPDATE_OPEN_CHANNEL"
+}
+type SendMessagePayload = {
+    message: SendableMessageType;
+    channel: GroupChannel | OpenChannel;
+    publishingModules: PublishingModuleType[];
+};
+export type SBUGlobalPubSubTopicPayloadUnion = {
+    topic: PUBSUB_TOPICS.SEND_MESSAGE_START;
+    payload: SendMessagePayload & {
+        message: SendableMessageType & {
+            url?: string;
+            requestState?: 'pending';
+        };
+    };
+} | {
+    topic: PUBSUB_TOPICS.SEND_MESSAGE_FAILED;
+    payload: SendMessagePayload & {
+        error: Error;
+    };
+} | {
+    topic: PUBSUB_TOPICS.SEND_USER_MESSAGE;
+    payload: SendMessagePayload;
+} | {
+    topic: PUBSUB_TOPICS.SEND_FILE_MESSAGE;
+    payload: SendMessagePayload;
+} | {
+    topic: PUBSUB_TOPICS.ON_FILE_INFO_UPLOADED;
+    payload: {
+        response: {
+            channelUrl: string;
+            requestId: string;
+            index: number;
+            uploadableFileInfo: UploadableFileInfo;
+            error: Error;
+        };
+        publishingModules: PublishingModuleType[];
+    };
+} | {
+    topic: PUBSUB_TOPICS.UPDATE_USER_MESSAGE;
+    payload: {
+        message: SendableMessageType;
+        channel: GroupChannel | OpenChannel;
+        publishingModules: PublishingModuleType[];
+        fromSelector?: boolean;
+    };
+} | {
+    topic: PUBSUB_TOPICS.DELETE_MESSAGE;
+    payload: {
+        messageId: number;
+        channel: GroupChannel | OpenChannel;
+    };
+} | {
+    topic: PUBSUB_TOPICS.LEAVE_CHANNEL;
+    payload: {
+        channel: GroupChannel | OpenChannel;
+    };
+} | {
+    topic: PUBSUB_TOPICS.CREATE_CHANNEL;
+    payload: {
+        channel: GroupChannel | OpenChannel;
+    };
+} | {
+    topic: PUBSUB_TOPICS.UPDATE_OPEN_CHANNEL;
+    payload: OpenChannel;
+};
+export type SBUGlobalPubSub = PubSubTypes<PUBSUB_TOPICS, SBUGlobalPubSubTopicPayloadUnion>;
+export default PUBSUB_TOPICS;

package/types/lib/selectors.d.ts

@@ -0,0 +1,248 @@
+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';
+import { PublishingModuleType } from '../modules/internalInterfaces';
+/**
+ * 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) => import("./pubSub/topics").SBUGlobalPubSub;
+/**
+ * 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, publishingModules?: PublishingModuleType[]) => (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, publishingModules?: PublishingModuleType[]) => (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, publishingModules?: PublishingModuleType[]) => (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, publishingModules?: PublishingModuleType[]) => (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, publishingModules?: PublishingModuleType[]) => (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) => import("./pubSub/topics").SBUGlobalPubSub;
+    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, publishingModules?: PublishingModuleType[]) => (channel: GroupChannel | OpenChannel, params: UserMessageCreateParams) => UikitMessageHandler;
+    getSendFileMessage: (state: SendBirdState, publishingModules?: PublishingModuleType[]) => (channel: GroupChannel | OpenChannel, params: FileMessageCreateParams) => UikitMessageHandler;
+    getUpdateUserMessage: (state: SendBirdState, publishingModules?: PublishingModuleType[]) => (channel: GroupChannel | OpenChannel, messageId: number, params: UserMessageUpdateParams) => Promise<UserMessage>;
+    getDeleteMessage: (state: SendBirdState) => (channel: GroupChannel | OpenChannel, message: SendableMessageType) => Promise<SendableMessageType>;
+    getResendUserMessage: (state: SendBirdState, publishingModules?: PublishingModuleType[]) => (channel: GroupChannel | OpenChannel, failedMessage: UserMessage) => Promise<UserMessage>;
+    getResendFileMessage: (state: SendBirdState, publishingModules?: PublishingModuleType[]) => (channel: GroupChannel | OpenChannel, failedMessage: FileMessage, blob: Blob) => Promise<FileMessage>;
+};
+export default sendbirdSelectors;