@sendbird/uikit-react-native 1.0.1 → 1.0.2

package/lib/typescript/src/contexts/PlatformService.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { ClipboardServiceInterface, FileServiceInterface, NotificationServiceInterface } from '../platform/types';
+declare type Props = React.PropsWithChildren<{
+    fileService: FileServiceInterface;
+    clipboardService: ClipboardServiceInterface;
+    notificationService: NotificationServiceInterface;
+}>;
+export declare const PlatformServiceContext: React.Context<Props | null>;
+export declare const PlatformServiceProvider: ({ children, fileService, clipboardService, notificationService }: Props) => JSX.Element;
+export {};

package/lib/typescript/src/contexts/SendbirdChat.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { SendbirdChatSDK, SendbirdGroupChannel, SendbirdUser } from '@sendbird/uikit-utils';
+import type { FileType } from '../platform/types';
+declare type Props = React.PropsWithChildren<{
+    sdkInstance: SendbirdChatSDK;
+    enableAutoPushTokenRegistration: boolean;
+}>;
+declare type Context = {
+    sdk: SendbirdChatSDK;
+    currentUser?: SendbirdUser;
+    setCurrentUser: React.Dispatch<React.SetStateAction<SendbirdUser | undefined>>;
+    updateCurrentUserInfo: (nickname: string, profile?: string | FileType) => Promise<SendbirdUser>;
+    markAsDeliveredWithChannel: (channel: SendbirdGroupChannel) => void;
+    features: {
+        autoPushTokenRegistrationEnabled: boolean;
+        deliveryReceiptEnabled: boolean;
+        broadcastChannelEnabled: boolean;
+        superGroupChannelEnabled: boolean;
+        reactionEnabled: boolean;
+    };
+};
+export declare const SendbirdChatContext: React.Context<Context | null>;
+export declare const SendbirdChatProvider: ({ children, sdkInstance, enableAutoPushTokenRegistration }: Props) => JSX.Element;
+export {};

package/lib/typescript/src/domain/groupChannel/component/GroupChannelHeader.d.ts

@@ -0,0 +1,3 @@
+import type { GroupChannelProps } from '../types';
+declare const GroupChannelHeader: ({ onPressHeaderLeft, onPressHeaderRight }: GroupChannelProps['Header']) => JSX.Element;
+export default GroupChannelHeader;

package/lib/typescript/src/domain/groupChannel/component/GroupChannelInput/EditInput.d.ts

@@ -0,0 +1,10 @@
+import type { SendbirdFileMessage, SendbirdUserMessage } from '@sendbird/uikit-utils';
+import type { GroupChannelProps } from '../../types';
+declare type EditInputProps = GroupChannelProps['Input'] & {
+    text: string;
+    setText: (val: string) => void;
+    editMessage: SendbirdUserMessage | SendbirdFileMessage;
+    setEditMessage: (msg?: SendbirdUserMessage | SendbirdFileMessage) => void;
+};
+declare const EditInput: ({ text, setText, editMessage, setEditMessage, onUpdateUserMessage }: EditInputProps) => JSX.Element;
+export default EditInput;

package/lib/typescript/src/domain/groupChannel/component/GroupChannelInput/SendInput.d.ts

@@ -0,0 +1,8 @@
+import type { GroupChannelProps } from '../../types';
+declare type SendInputProps = GroupChannelProps['Input'] & {
+    text: string;
+    setText: (val: string) => void;
+    disabled: boolean;
+};
+declare const SendInput: ({ onSendUserMessage, onSendFileMessage, text, setText, disabled }: SendInputProps) => JSX.Element;
+export default SendInput;

package/lib/typescript/src/domain/groupChannel/component/GroupChannelInput/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+declare const _default: React.MemoExoticComponent<(props: {
+    channel: import("sendbird").GroupChannel;
+    onSendFileMessage: (file: import("../../../..").FileType) => Promise<void>;
+    onSendUserMessage: (text: string) => Promise<void>;
+    onUpdateFileMessage: (editedFile: import("../../../..").FileType, message: import("sendbird").FileMessage) => Promise<void>;
+    onUpdateUserMessage: (editedText: string, message: import("sendbird").UserMessage) => Promise<void>;
+}) => JSX.Element>;
+export default _default;

package/lib/typescript/src/domain/groupChannel/component/GroupChannelMessageList.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import type { SendbirdMessage } from '@sendbird/uikit-utils';
+declare const _default: React.MemoExoticComponent<({ currentUserId, channel, messages, renderMessage, nextMessages, newMessagesFromMembers, onBottomReached, onTopReached, renderNewMessagesButton, renderScrollToBottomButton, onResendFailedMessage, onDeleteMessage, onPressImageMessage, flatListProps, enableMessageGrouping, }: {
+    enableMessageGrouping: boolean;
+    currentUserId?: string | undefined;
+    channel: import("sendbird").GroupChannel;
+    messages: SendbirdMessage[];
+    nextMessages: SendbirdMessage[];
+    newMessagesFromMembers: SendbirdMessage[];
+    onTopReached: () => void;
+    onBottomReached: () => void;
+    onResendFailedMessage: (failedMessage: import("sendbird").FileMessage | import("sendbird").UserMessage) => Promise<void>;
+    onDeleteMessage: (message: import("sendbird").FileMessage | import("sendbird").UserMessage) => Promise<void>;
+    onPressImageMessage?: ((message: import("sendbird").FileMessage, uri: string) => void) | undefined;
+    renderMessage: (props: {
+        message: SendbirdMessage;
+        prevMessage?: SendbirdMessage | undefined;
+        nextMessage?: SendbirdMessage | undefined;
+        onPress?: (() => void) | undefined;
+        onLongPress?: (() => void) | undefined;
+        channel: import("sendbird").GroupChannel;
+        currentUserId?: string | undefined;
+        enableMessageGrouping: boolean;
+    }) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+    renderNewMessagesButton: import("../../..").CommonComponent<{
+        visible: boolean;
+        onPress: () => void;
+        newMessages: SendbirdMessage[];
+    }> | null;
+    renderScrollToBottomButton: import("../../..").CommonComponent<{
+        visible: boolean;
+        onPress: () => void;
+    }> | null;
+    flatListProps?: Omit<import("react-native").FlatListProps<SendbirdMessage>, "data" | "renderItem"> | undefined;
+}) => JSX.Element>;
+export default _default;

package/lib/typescript/src/domain/groupChannel/component/GroupChannelStatusEmpty.d.ts

@@ -0,0 +1,2 @@
+declare const GroupChannelStatusEmpty: () => JSX.Element;
+export default GroupChannelStatusEmpty;

package/lib/typescript/src/domain/groupChannel/component/GroupChannelStatusLoading.d.ts

@@ -0,0 +1,2 @@
+declare const GroupChannelStatusLoading: () => JSX.Element;
+export default GroupChannelStatusLoading;

package/lib/typescript/src/domain/groupChannel/index.d.ts

@@ -0,0 +1,7 @@
+export { default as GroupChannelHeader } from './component/GroupChannelHeader';
+export { default as GroupChannelMessageList } from './component/GroupChannelMessageList';
+export { default as GroupChannelInput } from './component/GroupChannelInput';
+export { default as GroupChannelStatusEmpty } from './component/GroupChannelStatusEmpty';
+export { default as GroupChannelStatusLoading } from './component/GroupChannelStatusLoading';
+export { default as createGroupChannelModule } from './module/createGroupChannelModule';
+export { GroupChannelContextsProvider, GroupChannelContexts } from './module/moduleContext';

package/lib/typescript/src/domain/groupChannel/module/createGroupChannelModule.d.ts

@@ -0,0 +1,3 @@
+import type { GroupChannelModule } from '../types';
+declare const createGroupChannelModule: ({ Header, MessageList, Input, StatusLoading, StatusEmpty, Provider, ...module }?: Partial<GroupChannelModule>) => GroupChannelModule;
+export default createGroupChannelModule;

package/lib/typescript/src/domain/groupChannel/module/moduleContext.d.ts

@@ -0,0 +1,3 @@
+import type { GroupChannelContextsType, GroupChannelModule } from '../types';
+export declare const GroupChannelContexts: GroupChannelContextsType;
+export declare const GroupChannelContextsProvider: GroupChannelModule['Provider'];

package/lib/typescript/src/domain/groupChannel/types.d.ts

@@ -0,0 +1,102 @@
+import type React from 'react';
+import type { FlatListProps } from 'react-native';
+import type { UseGroupChannelMessagesOptions } from '@sendbird/uikit-chat-hooks';
+import type { SendbirdFileMessage, SendbirdFileMessageParams, SendbirdGroupChannel, SendbirdMessage, SendbirdUser, SendbirdUserMessage, SendbirdUserMessageParams } from '@sendbird/uikit-utils';
+import type { FileType } from '../../platform/types';
+import type { CommonComponent } from '../../types';
+export interface GroupChannelProps {
+    Fragment: {
+        channel: SendbirdGroupChannel;
+        onChannelDeleted: () => void;
+        onPressHeaderLeft: GroupChannelProps['Header']['onPressHeaderLeft'];
+        onPressHeaderRight: GroupChannelProps['Header']['onPressHeaderRight'];
+        onBeforeSendFileMessage?: (params: SendbirdFileMessageParams) => SendbirdFileMessageParams | Promise<SendbirdFileMessageParams>;
+        onBeforeSendUserMessage?: (params: SendbirdUserMessageParams) => SendbirdUserMessageParams | Promise<SendbirdUserMessageParams>;
+        onPressImageMessage?: GroupChannelProps['MessageList']['onPressImageMessage'];
+        renderMessage?: GroupChannelProps['MessageList']['renderMessage'];
+        renderNewMessagesButton?: GroupChannelProps['MessageList']['renderNewMessagesButton'];
+        renderScrollToBottomButton?: GroupChannelProps['MessageList']['renderScrollToBottomButton'];
+        enableTypingIndicator?: GroupChannelProps['Provider']['enableTypingIndicator'];
+        enableMessageGrouping?: GroupChannelProps['MessageList']['enableMessageGrouping'];
+        keyboardAvoidOffset?: GroupChannelProps['Provider']['keyboardAvoidOffset'];
+        flatListProps?: GroupChannelProps['MessageList']['flatListProps'];
+        sortComparator?: UseGroupChannelMessagesOptions['sortComparator'];
+        collectionCreator?: UseGroupChannelMessagesOptions['collectionCreator'];
+        queryCreator?: UseGroupChannelMessagesOptions['queryCreator'];
+    };
+    Header: {
+        onPressHeaderLeft: () => void;
+        onPressHeaderRight: () => void;
+    };
+    MessageList: {
+        enableMessageGrouping: boolean;
+        currentUserId?: string;
+        channel: SendbirdGroupChannel;
+        messages: SendbirdMessage[];
+        nextMessages: SendbirdMessage[];
+        newMessagesFromMembers: SendbirdMessage[];
+        onTopReached: () => void;
+        onBottomReached: () => void;
+        onResendFailedMessage: (failedMessage: SendbirdUserMessage | SendbirdFileMessage) => Promise<void>;
+        onDeleteMessage: (message: SendbirdUserMessage | SendbirdFileMessage) => Promise<void>;
+        onPressImageMessage?: (message: SendbirdFileMessage, uri: string) => void;
+        renderMessage: (props: {
+            message: SendbirdMessage;
+            prevMessage?: SendbirdMessage;
+            nextMessage?: SendbirdMessage;
+            onPress?: () => void;
+            onLongPress?: () => void;
+            channel: GroupChannelProps['MessageList']['channel'];
+            currentUserId?: GroupChannelProps['MessageList']['currentUserId'];
+            enableMessageGrouping: GroupChannelProps['MessageList']['enableMessageGrouping'];
+        }) => React.ReactElement | null;
+        renderNewMessagesButton: null | CommonComponent<{
+            visible: boolean;
+            onPress: () => void;
+            newMessages: SendbirdMessage[];
+        }>;
+        renderScrollToBottomButton: null | CommonComponent<{
+            visible: boolean;
+            onPress: () => void;
+        }>;
+        flatListProps?: Omit<FlatListProps<SendbirdMessage>, 'data' | 'renderItem'>;
+    };
+    Input: {
+        channel: SendbirdGroupChannel;
+        onSendFileMessage: (file: FileType) => Promise<void>;
+        onSendUserMessage: (text: string) => Promise<void>;
+        onUpdateFileMessage: (editedFile: FileType, message: SendbirdFileMessage) => Promise<void>;
+        onUpdateUserMessage: (editedText: string, message: SendbirdUserMessage) => Promise<void>;
+    };
+    Provider: {
+        channel: SendbirdGroupChannel;
+        enableTypingIndicator: boolean;
+        keyboardAvoidOffset?: number;
+    };
+}
+/**
+ * Internal context for GroupChannel
+ * For example, the developer can create a custom header
+ * with getting data from the domain context
+ * */
+export interface GroupChannelContextsType {
+    Fragment: React.Context<{
+        headerTitle: string;
+        channel: SendbirdGroupChannel;
+        editMessage?: SendbirdUserMessage | SendbirdFileMessage;
+        setEditMessage: (msg?: SendbirdUserMessage | SendbirdFileMessage) => void;
+        keyboardAvoidOffset?: number;
+    }>;
+    TypingIndicator: React.Context<{
+        typingUsers: SendbirdUser[];
+    }>;
+}
+export interface GroupChannelModule {
+    Provider: CommonComponent<GroupChannelProps['Provider']>;
+    Header: CommonComponent<GroupChannelProps['Header']>;
+    MessageList: CommonComponent<GroupChannelProps['MessageList']>;
+    Input: CommonComponent<GroupChannelProps['Input']>;
+    StatusEmpty: CommonComponent;
+    StatusLoading: CommonComponent;
+}
+export declare type GroupChannelFragment = CommonComponent<GroupChannelProps['Fragment']>;

package/lib/typescript/src/domain/groupChannelList/component/GroupChannelListHeader.d.ts

@@ -0,0 +1,3 @@
+import type { GroupChannelListProps } from '../types';
+declare const GroupChannelListHeader: (_: GroupChannelListProps['Header']) => JSX.Element;
+export default GroupChannelListHeader;

package/lib/typescript/src/domain/groupChannelList/component/GroupChannelListList.d.ts

@@ -0,0 +1,3 @@
+import type { GroupChannelListProps } from '../types';
+declare const GroupChannelListList: ({ renderGroupChannelPreview, groupChannels, onLoadNext, flatListProps, menuItemCreator, }: GroupChannelListProps['List']) => JSX.Element;
+export default GroupChannelListList;

package/lib/typescript/src/domain/groupChannelList/component/GroupChannelListStatusEmpty.d.ts

@@ -0,0 +1,2 @@
+declare const GroupChannelListStatusEmpty: () => JSX.Element;
+export default GroupChannelListStatusEmpty;

package/lib/typescript/src/domain/groupChannelList/component/GroupChannelListStatusLoading.d.ts

@@ -0,0 +1,2 @@
+declare const GroupChannelListStatusLoading: () => JSX.Element;
+export default GroupChannelListStatusLoading;

package/lib/typescript/src/domain/groupChannelList/component/GroupChannelListTypeSelector.d.ts

@@ -0,0 +1,3 @@
+import type { GroupChannelListProps } from '../types';
+declare const GroupChannelListTypeSelector: ({ Header, skipTypeSelection, onSelectType, }: GroupChannelListProps['TypeSelector']) => JSX.Element | null;
+export default GroupChannelListTypeSelector;

package/lib/typescript/src/domain/groupChannelList/index.d.ts

@@ -0,0 +1,7 @@
+export { default as GroupChannelListHeader } from './component/GroupChannelListHeader';
+export { default as GroupChannelListList } from './component/GroupChannelListList';
+export { default as GroupChannelListStatusEmpty } from './component/GroupChannelListStatusEmpty';
+export { default as GroupChannelListStatusLoading } from './component/GroupChannelListStatusLoading';
+export { default as GroupChannelListTypeSelector } from './component/GroupChannelListTypeSelector';
+export { default as createGroupChannelListModule } from './module/createGroupChannelListModule';
+export { GroupChannelListContextsProvider, GroupChannelListContexts } from './module/moduleContext';

package/lib/typescript/src/domain/groupChannelList/module/createGroupChannelListModule.d.ts

@@ -0,0 +1,3 @@
+import type { GroupChannelListModule } from '../types';
+declare const createGroupChannelListModule: ({ Header, List, TypeSelector, StatusLoading, StatusEmpty, Provider, ...module }?: Partial<GroupChannelListModule>) => GroupChannelListModule;
+export default createGroupChannelListModule;

package/lib/typescript/src/domain/groupChannelList/module/moduleContext.d.ts

@@ -0,0 +1,3 @@
+import type { GroupChannelListContextsType, GroupChannelListModule } from '../types';
+export declare const GroupChannelListContexts: GroupChannelListContextsType;
+export declare const GroupChannelListContextsProvider: GroupChannelListModule['Provider'];

package/lib/typescript/src/domain/groupChannelList/types.d.ts

@@ -0,0 +1,81 @@
+import type React from 'react';
+import type { FlatListProps } from 'react-native';
+import type { UseGroupChannelListOptions } from '@sendbird/uikit-chat-hooks';
+import type { ActionMenuItem, BaseHeaderProps } from '@sendbird/uikit-react-native-foundation';
+import type { SendbirdGroupChannel } from '@sendbird/uikit-utils';
+import type { CommonComponent } from '../../types';
+export interface GroupChannelListProps {
+    /** Props for `GroupChannelListFragment` **/
+    Fragment: {
+        /** Navigate to GroupChannelFragment **/
+        onPressChannel: (channel: SendbirdGroupChannel) => void;
+        /** Navigate to GroupChannelCreateFragment **/
+        onPressCreateChannel: (channelType: GroupChannelType) => void;
+        /** Custom Header for TypeSelector, Only replace header component not a module **/
+        TypeSelectorHeader?: null | CommonComponent<BaseHeaderProps<{
+            title: string;
+            right: React.ReactElement;
+            onPressRight: () => void;
+        }>>;
+        /** Method to render GroupChannel preview **/
+        renderGroupChannelPreview?: (channel: SendbirdGroupChannel, onLongPressChannel: () => void) => React.ReactElement | null;
+        /** Custom Query creator for channels query **/
+        queryCreator?: UseGroupChannelListOptions['queryCreator'];
+        /** Sort comparator for sort channels **/
+        sortComparator?: UseGroupChannelListOptions['sortComparator'];
+        /** FlatList props for GroupChannelList.List **/
+        flatListProps?: GroupChannelListProps['List']['flatListProps'];
+        /** Action menu item creator for onLongPress **/
+        menuItemCreator?: GroupChannelListProps['List']['menuItemCreator'];
+    };
+    /** Props for `GroupChannelListModule.Header` **/
+    Header: {};
+    /** Props for `GroupChannelListModule.List` **/
+    List: {
+        /** GroupChannels from SendbirdChat SDK **/
+        groupChannels: SendbirdGroupChannel[];
+        /** Method to render GroupChannel preview **/
+        renderGroupChannelPreview: (channel: SendbirdGroupChannel, onLongPressChannel: () => void) => React.ReactElement | null;
+        /** Method to load more data, called with onEndReached of FlatList **/
+        onLoadNext: () => Promise<void>;
+        /** Prop from Fragment **/
+        flatListProps?: Omit<FlatListProps<SendbirdGroupChannel>, 'data' | 'renderItem'>;
+        /** Prop from Fragment **/
+        menuItemCreator?: (defaultMenuItem: ActionMenuItem) => ActionMenuItem;
+    };
+    /** Props for `GroupChannelListModule.TypeSelector` **/
+    TypeSelector: {
+        /** Prop from Fragment `Fragment.TypeSelectorHeader` **/
+        Header: GroupChannelListProps['Fragment']['TypeSelectorHeader'];
+        /** Prop from Fragment `Fragment.skipTypeSelection` **/
+        skipTypeSelection: boolean;
+        /** Method called when type is selected, call `Fragment.onPressCreateChannel` **/
+        onSelectType: (type: GroupChannelType) => void;
+    };
+}
+/**
+ * Internal context for GroupChannelList
+ * For example, the developer can create a custom header
+ * with getting data from the domain context
+ * */
+export interface GroupChannelListContextsType {
+    Fragment: React.Context<{
+        headerTitle: string;
+    }>;
+    TypeSelector: React.Context<{
+        visible: boolean;
+        show: () => void;
+        hide: () => void;
+        headerTitle: string;
+    }>;
+}
+export interface GroupChannelListModule {
+    Provider: CommonComponent;
+    Header: CommonComponent<GroupChannelListProps['Header']>;
+    List: CommonComponent<GroupChannelListProps['List']>;
+    TypeSelector: CommonComponent<GroupChannelListProps['TypeSelector']>;
+    StatusEmpty: CommonComponent;
+    StatusLoading: CommonComponent;
+}
+export declare type GroupChannelListFragment = CommonComponent<GroupChannelListProps['Fragment']>;
+export declare type GroupChannelType = 'GROUP' | 'SUPER_GROUP' | 'BROADCAST';

package/lib/typescript/src/domain/groupChannelSettings/component/GroupChannelSettingsHeader.d.ts

@@ -0,0 +1,3 @@
+import type { GroupChannelSettingsProps } from '../types';
+declare const GroupChannelSettingsHeader: ({ onPressHeaderLeft }: GroupChannelSettingsProps['Header']) => JSX.Element;
+export default GroupChannelSettingsHeader;

package/lib/typescript/src/domain/groupChannelSettings/component/GroupChannelSettingsInfo.d.ts

@@ -0,0 +1,3 @@
+import type { GroupChannelSettingsProps } from '../types';
+declare const GroupChannelSettingsInfo: (_: GroupChannelSettingsProps['Info']) => JSX.Element | null;
+export default GroupChannelSettingsInfo;

package/lib/typescript/src/domain/groupChannelSettings/component/GroupChannelSettingsMenu.d.ts

@@ -0,0 +1,3 @@
+import type { GroupChannelSettingsProps } from '../types';
+declare const GroupChannelSettingsMenu: ({ onPressMenuMembers, onPressMenuLeaveChannel, menuItemsCreator, }: GroupChannelSettingsProps['Menu']) => JSX.Element;
+export default GroupChannelSettingsMenu;

package/lib/typescript/src/domain/groupChannelSettings/index.d.ts

@@ -0,0 +1,5 @@
+export { default as GroupChannelSettingsHeader } from './component/GroupChannelSettingsHeader';
+export { default as GroupChannelSettingsInfo } from './component/GroupChannelSettingsInfo';
+export { default as GroupChannelSettingsMenu } from './component/GroupChannelSettingsMenu';
+export { default as createGroupChannelSettingsModule } from './module/createGroupChannelSettingsModule';
+export { GroupChannelSettingsContextsProvider, GroupChannelSettingsContexts } from './module/moduleContext';

package/lib/typescript/src/domain/groupChannelSettings/module/createGroupChannelSettingsModule.d.ts

@@ -0,0 +1,3 @@
+import type { GroupChannelSettingsModule } from '../types';
+declare const createGroupChannelSettingsModule: ({ Header, Info, Menu, Provider, ...module }?: Partial<GroupChannelSettingsModule>) => GroupChannelSettingsModule;
+export default createGroupChannelSettingsModule;

package/lib/typescript/src/domain/groupChannelSettings/module/moduleContext.d.ts

@@ -0,0 +1,3 @@
+import type { GroupChannelSettingsContextsType, GroupChannelSettingsModule } from '../types';
+export declare const GroupChannelSettingsContexts: GroupChannelSettingsContextsType;
+export declare const GroupChannelSettingsContextsProvider: GroupChannelSettingsModule['Provider'];

package/lib/typescript/src/domain/groupChannelSettings/types.d.ts

@@ -0,0 +1,45 @@
+import type React from 'react';
+import type { MenuBarProps } from '@sendbird/uikit-react-native-foundation';
+import type { SendbirdGroupChannel } from '@sendbird/uikit-utils';
+import type { CommonComponent } from '../../types';
+export interface GroupChannelSettingsProps {
+    Fragment: {
+        channel: GroupChannelSettingsProps['Provider']['channel'];
+        onPressHeaderLeft: GroupChannelSettingsProps['Header']['onPressHeaderLeft'];
+        onPressMenuMembers: GroupChannelSettingsProps['Menu']['onPressMenuMembers'];
+        onPressMenuLeaveChannel: GroupChannelSettingsProps['Menu']['onPressMenuLeaveChannel'];
+        menuItemsCreator?: GroupChannelSettingsProps['Menu']['menuItemsCreator'];
+    };
+    Header: {
+        onPressHeaderLeft: () => void;
+    };
+    Info: {};
+    Menu: {
+        onPressMenuMembers: () => void;
+        onPressMenuLeaveChannel: () => void;
+        menuItemsCreator?: (defaultMenuItems: MenuBarProps[]) => MenuBarProps[];
+    };
+    Provider: {
+        channel: SendbirdGroupChannel;
+    };
+}
+/**
+ * Internal context for GroupChannelSettings
+ * For example, the developer can create a custom header
+ * with getting data from the domain context
+ * */
+export interface GroupChannelSettingsContextsType {
+    Fragment: React.Context<{
+        channel: SendbirdGroupChannel;
+        headerTitle: string;
+        headerRight: string;
+        onPressHeaderRight: () => void;
+    }>;
+}
+export interface GroupChannelSettingsModule {
+    Provider: CommonComponent<GroupChannelSettingsProps['Provider']>;
+    Header: CommonComponent<GroupChannelSettingsProps['Header']>;
+    Info: CommonComponent<GroupChannelSettingsProps['Info']>;
+    Menu: CommonComponent<GroupChannelSettingsProps['Menu']>;
+}
+export declare type GroupChannelSettingsFragment = CommonComponent<GroupChannelSettingsProps['Fragment']>;

package/lib/typescript/src/domain/groupChannelUserList/types.d.ts

@@ -0,0 +1,42 @@
+import type { UseUserListOptions } from '@sendbird/uikit-chat-hooks';
+import type { SendbirdGroupChannel, SendbirdGroupChannelParams } from '@sendbird/uikit-utils';
+import type { CommonComponent } from '../../types';
+import type { GroupChannelType } from '../groupChannelList/types';
+import type { UserListProps } from '../userList/types';
+declare type UserIds = string[];
+export interface GroupChannelCreateProps<User> {
+    Fragment: {
+        onPressHeaderLeft: () => void;
+        onCreateChannel: (channel: SendbirdGroupChannel) => void;
+        channelType?: GroupChannelType;
+        userIdsGenerator?: (users: User[]) => UserIds;
+        onBeforeCreateChannel?: (params: SendbirdGroupChannelParams, users: User[]) => SendbirdGroupChannelParams | Promise<SendbirdGroupChannelParams>;
+        sortComparator?: UseUserListOptions<User>['sortComparator'];
+        queryCreator?: UseUserListOptions<User>['queryCreator'];
+        renderUser?: UserListProps<User>['List']['renderUser'];
+    };
+}
+export declare type GroupChannelCreateFragment<User> = CommonComponent<GroupChannelCreateProps<User>['Fragment']>;
+export interface GroupChannelInviteProps<User> {
+    Fragment: {
+        channel: SendbirdGroupChannel;
+        onPressHeaderLeft: () => void;
+        onInviteMembers: (channel: SendbirdGroupChannel) => void;
+        userIdsGenerator?: (users: User[]) => UserIds;
+        queryCreator?: UseUserListOptions<User>['queryCreator'];
+        renderUser?: UserListProps<User>['List']['renderUser'];
+        sortComparator?: UseUserListOptions<User>['sortComparator'];
+    };
+}
+export declare type GroupChannelInviteFragment<User> = CommonComponent<GroupChannelInviteProps<User>['Fragment']>;
+export interface GroupChannelMembersProps<User> {
+    Fragment: {
+        channel: SendbirdGroupChannel;
+        onPressHeaderLeft: () => void;
+        onPressHeaderRight: () => void;
+        sortComparator?: UseUserListOptions<User>['sortComparator'];
+        renderUser?: UserListProps<User>['List']['renderUser'];
+    };
+}
+export declare type GroupChannelMembersFragment<User> = CommonComponent<GroupChannelMembersProps<User>['Fragment']>;
+export {};

package/lib/typescript/src/domain/userList/component/UserListHeader.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { UserListProps } from '../types';
+declare const UserListHeader: <T>({ onPressHeaderLeft, onPressHeaderRight, right, left, shouldActivateHeaderRight, }: {
+    right?: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
+    left?: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
+    onPressHeaderLeft: () => void;
+    onPressHeaderRight: (selectedUsers: T[]) => Promise<void>;
+    shouldActivateHeaderRight?: ((selectedUsers: T[]) => boolean) | undefined;
+}) => JSX.Element;
+export default UserListHeader;

package/lib/typescript/src/domain/userList/component/UserListList.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { UserListProps } from '../types';
+declare const UserListList: <T>({ users, onRefresh, refreshing, renderUser, onLoadNext, ListEmptyComponent, }: {
+    users: T[];
+    renderUser: (user: T, selectedUsers: T[], setSelectedUsers: React.Dispatch<React.SetStateAction<T[]>>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+    onLoadNext: () => Promise<void>;
+    onRefresh?: (() => Promise<void>) | undefined;
+    refreshing?: boolean | undefined;
+    ListEmptyComponent?: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
+}) => JSX.Element;
+export default UserListList;

package/lib/typescript/src/domain/userList/component/UserListStatusEmpty.d.ts

@@ -0,0 +1,2 @@
+declare const UserListStatusEmpty: () => JSX.Element;
+export default UserListStatusEmpty;

package/lib/typescript/src/domain/userList/component/UserListStatusError.d.ts

@@ -0,0 +1,3 @@
+import type { UserListModule } from '../types';
+declare const UserListStatusLoading: UserListModule<unknown>['StatusError'];
+export default UserListStatusLoading;

package/lib/typescript/src/domain/userList/component/UserListStatusLoading.d.ts

@@ -0,0 +1,2 @@
+declare const UserListStatusLoading: () => JSX.Element;
+export default UserListStatusLoading;

package/lib/typescript/src/domain/userList/index.d.ts

@@ -0,0 +1,7 @@
+export { default as UserListList } from './component/UserListList';
+export { default as UserListHeader } from './component/UserListHeader';
+export { default as UserListStatusEmpty } from './component/UserListStatusEmpty';
+export { default as UserListStatusError } from './component/UserListStatusError';
+export { default as UserListStatusLoading } from './component/UserListStatusLoading';
+export { default as createUserListModule } from './module/createUserListModule';
+export { UserListContextsProvider, UserListContexts } from './module/moduleContext';

package/lib/typescript/src/domain/userList/module/createUserListModule.d.ts

@@ -0,0 +1,3 @@
+import type { UserListModule } from '../types';
+declare const createUserListModule: <T>({ Header, List, StatusLoading, StatusEmpty, StatusError, Provider, ...module }?: Partial<UserListModule<T>>) => UserListModule<T>;
+export default createUserListModule;

package/lib/typescript/src/domain/userList/module/moduleContext.d.ts

@@ -0,0 +1,3 @@
+import type { UserListContextsType, UserListModule } from '../types';
+export declare const UserListContexts: UserListContextsType<unknown>;
+export declare const UserListContextsProvider: UserListModule<any>['Provider'];

package/lib/typescript/src/domain/userList/types.d.ts

@@ -0,0 +1,58 @@
+import type React from 'react';
+import type { ContextValue } from '@sendbird/uikit-utils';
+import type { CommonComponent } from '../../types';
+export interface UserListProps<User> {
+    /** Props for `UserListModule.Header` **/
+    Header: {
+        right?: React.ReactElement;
+        left?: React.ReactElement;
+        onPressHeaderLeft: () => void;
+        onPressHeaderRight: (selectedUsers: User[]) => Promise<void>;
+        shouldActivateHeaderRight?: (selectedUsers: User[]) => boolean;
+    };
+    /** Props for `UserListModule.List` **/
+    List: {
+        /** User list from SendbirdChat SDK or Custom query {@link Fragment.queryCreator} **/
+        users: User[];
+        /** Render user component **/
+        renderUser: (user: User, selectedUsers: ContextValue<UserListContextsType<User>['List']>['selectedUsers'], setSelectedUsers: ContextValue<UserListContextsType<User>['List']>['setSelectedUsers']) => React.ReactElement | null;
+        /** Load next user list **/
+        onLoadNext: () => Promise<void>;
+        /** Refresh user list **/
+        onRefresh?: () => Promise<void>;
+        /** Refreshing state **/
+        refreshing?: boolean;
+        /** List empty component **/
+        ListEmptyComponent?: React.ReactElement;
+    };
+    /** Props for `UserListModule.Provider` **/
+    Provider: {
+        headerTitle: string;
+        headerRight: (selectedUsers: Array<User>) => string;
+    };
+}
+/**
+ * Internal context for UserList
+ * For example, the developer can create a custom header
+ * with getting data from the domain context
+ * */
+export interface UserListContextsType<User> {
+    Fragment: React.Context<{
+        headerTitle: string;
+        headerRight: string;
+    }>;
+    List: React.Context<{
+        selectedUsers: User[];
+        setSelectedUsers: React.Dispatch<React.SetStateAction<User[]>>;
+    }>;
+}
+export interface UserListModule<User> {
+    Provider: CommonComponent<UserListProps<User>['Provider']>;
+    Header: CommonComponent<UserListProps<User>['Header']>;
+    List: CommonComponent<UserListProps<User>['List']>;
+    StatusEmpty: CommonComponent;
+    StatusLoading: CommonComponent;
+    StatusError: CommonComponent<{
+        onPressRetry: () => void;
+    }>;
+}

package/lib/typescript/src/fragments/createGroupChannelCreateFragment.d.ts

@@ -0,0 +1,4 @@
+import type { GroupChannelCreateFragment } from '../domain/groupChannelUserList/types';
+import type { UserListModule } from '../domain/userList/types';
+declare const createGroupChannelCreateFragment: <UserType>(initModule?: Partial<UserListModule<UserType>> | undefined) => GroupChannelCreateFragment<UserType>;
+export default createGroupChannelCreateFragment;

package/lib/typescript/src/fragments/createGroupChannelFragment.d.ts

@@ -0,0 +1,3 @@
+import type { GroupChannelFragment, GroupChannelModule } from '../domain/groupChannel/types';
+declare const createGroupChannelFragment: (initModule?: Partial<GroupChannelModule>) => GroupChannelFragment;
+export default createGroupChannelFragment;

package/lib/typescript/src/fragments/createGroupChannelInviteFragment.d.ts

@@ -0,0 +1,4 @@
+import type { GroupChannelInviteFragment } from '../domain/groupChannelUserList/types';
+import type { UserListModule } from '../domain/userList/types';
+declare const createGroupChannelInviteFragment: <UserType>(initModule?: Partial<UserListModule<UserType>> | undefined) => GroupChannelInviteFragment<UserType>;
+export default createGroupChannelInviteFragment;