stream-chat-react-native-core 9.3.1 → 9.4.0-beta.2

package/src/hooks/actions/useChannelMemberActionItems.tsx

@@ -0,0 +1,204 @@
+import React, { useMemo } from 'react';
+import { Alert } from 'react-native';
+
+import type { BlockedUsersState, Channel, ChannelMemberResponse } from 'stream-chat';
+
+import type { ActionItem } from './types';
+import { ChannelActions, useChannelActions } from './useChannelActions';
+import { useUserActions, UserActions } from './useUserActions';
+
+import { useUserMuteActive } from '../../components/Message/hooks/useUserMuteActive';
+import { useTheme, useTranslationContext } from '../../contexts';
+import type { TranslationContextValue } from '../../contexts/translationContext/TranslationContext';
+import { BlockUser, IconProps, Mute, Sound, UserDelete } from '../../icons';
+import { useChannelOwnCapabilities } from '../useChannelOwnCapabilities';
+import { useStateStore } from '../useStateStore';
+
+export type ChannelMemberActionItem = ActionItem<'muteUser' | 'block' | string>;
+
+export type ChannelMemberActionItemsParams = {
+  channel: Channel;
+  channelActions: ChannelActions;
+  isBlocked: boolean;
+  isCurrentUser: boolean;
+  member: ChannelMemberResponse;
+  ownCapabilities: string[] | undefined;
+  t: TranslationContextValue['t'];
+  userActions: UserActions;
+  userMuteActive: boolean;
+};
+
+export type BuildDefaultChannelMemberActionItems = (
+  channelMemberActionItemsParams: ChannelMemberActionItemsParams,
+) => ChannelMemberActionItem[];
+
+const ChannelMemberActionsIcon = ({
+  Icon,
+  ...rest
+}: { Icon: React.ComponentType<IconProps> } & IconProps) => {
+  const {
+    theme: { semantics },
+  } = useTheme();
+
+  return <Icon stroke={semantics.textSecondary} width={20} height={20} {...rest} />;
+};
+
+export const buildDefaultChannelMemberActionItems: BuildDefaultChannelMemberActionItems = (
+  channelMemberActionItemsParams,
+) => {
+  const {
+    channelActions: { removeMembers },
+    isBlocked,
+    isCurrentUser,
+    member,
+    ownCapabilities,
+    t,
+    userActions: { blockUser, muteUser, unblockUser, unmuteUser },
+    userMuteActive,
+  } = channelMemberActionItemsParams;
+
+  const canRemoveMember = ownCapabilities?.includes('update-channel-members') ?? false;
+
+  const actionItems: ChannelMemberActionItem[] = [];
+
+  // Muting or blocking yourself is meaningless, so these actions are only
+  // added for other members.
+  if (!isCurrentUser) {
+    actionItems.push(
+      {
+        action: userMuteActive ? unmuteUser : muteUser,
+        Icon: (props) =>
+          userMuteActive ? (
+            <ChannelMemberActionsIcon Icon={Sound} {...props} />
+          ) : (
+            <ChannelMemberActionsIcon
+              Icon={Mute}
+              {...props}
+              fill={props.fill ?? props.stroke}
+              stroke={undefined}
+            />
+          ),
+        id: 'muteUser',
+        label: userMuteActive ? t('Unmute User') : t('Mute User'),
+        type: 'standard',
+      },
+      {
+        action: isBlocked ? unblockUser : blockUser,
+        Icon: (props) => <ChannelMemberActionsIcon Icon={BlockUser} {...props} />,
+        id: 'block',
+        label: isBlocked ? t('Unblock User') : t('Block User'),
+        type: isBlocked ? 'standard' : 'destructive',
+      },
+    );
+
+    if (canRemoveMember) {
+      actionItems.push({
+        action: () => {
+          const memberId = member.user?.id;
+          if (!memberId) {
+            return;
+          }
+          Alert.alert(
+            t('Remove User'),
+            t('Are you sure you want to remove this member from the channel?'),
+            [
+              { style: 'cancel', text: t('Cancel') },
+              {
+                onPress: async () => {
+                  await removeMembers([memberId]);
+                },
+                style: 'destructive',
+                text: t('Remove'),
+              },
+            ],
+          );
+        },
+        Icon: (props) => <ChannelMemberActionsIcon Icon={UserDelete} {...props} />,
+        id: 'removeMember',
+        label: t('Remove User'),
+        type: 'destructive',
+      });
+    }
+  }
+
+  return actionItems;
+};
+
+export type GetChannelMemberActionItems = (params: {
+  context: ChannelMemberActionItemsParams;
+  defaultItems: ChannelMemberActionItem[];
+}) => ChannelMemberActionItem[];
+
+export const getChannelMemberActionItems: GetChannelMemberActionItems = ({ defaultItems }) =>
+  defaultItems;
+
+type UseChannelMemberActionItemsParams = {
+  channel: Channel;
+  member: ChannelMemberResponse;
+  getChannelMemberActionItems?: GetChannelMemberActionItems;
+};
+
+const blockedUsersStateSelector = (state: BlockedUsersState) =>
+  ({ userIds: state.userIds }) as const;
+
+export const useChannelMemberActionItems = ({
+  channel,
+  member,
+  getChannelMemberActionItems: getChannelMemberActionItemsProp = getChannelMemberActionItems,
+}: UseChannelMemberActionItemsParams) => {
+  const { t } = useTranslationContext();
+  const userActions = useUserActions(member.user);
+  const channelActions = useChannelActions(channel);
+
+  const ownCapabilities = useChannelOwnCapabilities(channel);
+
+  const userMuteActive = useUserMuteActive(member.user);
+
+  const { userIds: blockedUserIds } = useStateStore(
+    channel.getClient().blockedUsers,
+    blockedUsersStateSelector,
+  );
+
+  const isBlocked = blockedUserIds.includes(member.user?.id ?? '');
+
+  const isCurrentUser = member.user?.id === channel.getClient().userID;
+
+  const channelMemberActionItemsParams = useMemo<ChannelMemberActionItemsParams>(
+    () => ({
+      channel,
+      channelActions,
+      isBlocked,
+      isCurrentUser,
+      member,
+      ownCapabilities,
+      t,
+      userActions,
+      userMuteActive,
+    }),
+    [
+      channel,
+      channelActions,
+      isBlocked,
+      isCurrentUser,
+      member,
+      ownCapabilities,
+      t,
+      userActions,
+      userMuteActive,
+    ],
+  );
+
+  const defaultItems = useMemo(
+    () => buildDefaultChannelMemberActionItems(channelMemberActionItemsParams),
+    [channelMemberActionItemsParams],
+  );
+
+  return useMemo(
+    () =>
+      getChannelMemberActionItemsProp({
+        context: channelMemberActionItemsParams,
+        defaultItems,
+      }),
+    [channelMemberActionItemsParams, defaultItems, getChannelMemberActionItemsProp],
+  );
+};

package/src/hooks/actions/useUserActions.ts

@@ -0,0 +1,141 @@
+import { useMemo } from 'react';
+
+import { UserResponse } from 'stream-chat';
+
+import type { ActionHandler, ActionOptions } from './types';
+import { getNotificationErrorOptions } from './useChannelActions';
+
+import { useNotificationApi } from '../../components/Notifications/hooks';
+import { useChatContext, useTranslationContext } from '../../contexts';
+import { useStableCallback } from '../useStableCallback';
+
+export type UserActionOptions = ActionOptions;
+
+export type UserActionHandler = ActionHandler;
+
+export type UserActions = {
+  blockUser: UserActionHandler;
+  muteUser: UserActionHandler;
+  unblockUser: UserActionHandler;
+  unmuteUser: UserActionHandler;
+};
+
+export const useUserActions = (user: UserResponse | undefined): UserActions => {
+  const { client } = useChatContext();
+  const { addNotification } = useNotificationApi();
+  const { t } = useTranslationContext();
+
+  const muteUser = useStableCallback(async (options?: UserActionOptions) => {
+    if (!user?.id) {
+      return;
+    }
+
+    try {
+      await client.muteUser(user.id);
+      addNotification({
+        message: t('{{ user }} has been muted', { user: user.name || user.id }),
+        options: { severity: 'success', type: 'api:user:mute:success' },
+        origin: { context: { user }, emitter: 'UserActions' },
+      });
+      await options?.onSuccess?.();
+    } catch (error) {
+      addNotification({
+        message: t('Error muting a user ...'),
+        options: {
+          ...getNotificationErrorOptions(error),
+          severity: 'error',
+          type: 'api:user:mute:failed',
+        },
+        origin: { context: { user }, emitter: 'UserActions' },
+      });
+    }
+  });
+
+  const unmuteUser = useStableCallback(async (options?: UserActionOptions) => {
+    if (!user?.id) {
+      return;
+    }
+
+    try {
+      await client.unmuteUser(user.id);
+      addNotification({
+        message: t('{{ user }} has been unmuted', { user: user.name || user.id }),
+        options: { severity: 'success', type: 'api:user:unmute:success' },
+        origin: { context: { user }, emitter: 'UserActions' },
+      });
+      await options?.onSuccess?.();
+    } catch (error) {
+      addNotification({
+        message: t('Error unmuting a user ...'),
+        options: {
+          ...getNotificationErrorOptions(error),
+          severity: 'error',
+          type: 'api:user:unmute:failed',
+        },
+        origin: { context: { user }, emitter: 'UserActions' },
+      });
+    }
+  });
+
+  const blockUser = useStableCallback(async (options?: UserActionOptions) => {
+    if (!user?.id) {
+      return;
+    }
+
+    try {
+      await client.blockUser(user.id);
+      addNotification({
+        message: t('User blocked'),
+        options: { severity: 'success', type: 'api:user:block:success' },
+        origin: { context: { user }, emitter: 'UserActions' },
+      });
+      await options?.onSuccess?.();
+    } catch (error) {
+      addNotification({
+        message: t('Failed to block user'),
+        options: {
+          ...getNotificationErrorOptions(error),
+          severity: 'error',
+          type: 'api:user:block:failed',
+        },
+        origin: { context: { user }, emitter: 'UserActions' },
+      });
+    }
+  });
+
+  const unblockUser = useStableCallback(async (options?: UserActionOptions) => {
+    if (!user?.id) {
+      return;
+    }
+
+    try {
+      await client.unBlockUser(user.id);
+      addNotification({
+        message: t('User unblocked'),
+        options: { severity: 'success', type: 'api:user:unblock:success' },
+        origin: { context: { user }, emitter: 'UserActions' },
+      });
+      await options?.onSuccess?.();
+    } catch (error) {
+      addNotification({
+        message: t('Failed to block user'),
+        options: {
+          ...getNotificationErrorOptions(error),
+          severity: 'error',
+          type: 'api:user:block:failed',
+        },
+        origin: { context: { user }, emitter: 'UserActions' },
+      });
+    }
+  });
+
+  return useMemo<UserActions>(
+    () => ({
+      blockUser,
+      muteUser,
+      unblockUser,
+      unmuteUser,
+    }),
+    [blockUser, muteUser, unblockUser, unmuteUser],
+  );
+};

package/src/hooks/index.ts

@@ -1,5 +1,14 @@
 export * from '../a11y';
+export * from './actions';
 export * from './useAppStateListener';
+export * from './useChannelMemberCount';
+export * from './useChannelName';
+export * from './useChannelImage';
+export * from './useChannelMembershipState';
+export * from './useChannelOwnCapabilities';
+export * from './useChannelMuteActive';
+export * from './useIsDirectChat';
+export * from './useIsChannelMember';
 export * from './useStreami18n';
 export * from './useViewport';
 export * from './useScreenDimensions';

package/src/hooks/useChannelImage.ts

@@ -0,0 +1,12 @@
+import { Channel, EventTypes } from 'stream-chat';
+
+import { useSelectedChannelState } from './useSelectedChannelState';
+
+const selector = (channel: Channel) => channel.data?.image;
+const keys: EventTypes[] = ['channel.updated'];
+
+export function useChannelImage(channel: Channel): string | undefined;
+export function useChannelImage(channel?: Channel): string | undefined;
+export function useChannelImage(channel?: Channel) {
+  return useSelectedChannelState({ channel, selector, stateChangeEventKeys: keys });
+}

package/src/hooks/useChannelMemberCount.ts

@@ -0,0 +1,12 @@
+import { Channel, EventTypes } from 'stream-chat';
+
+import { useSelectedChannelState } from './useSelectedChannelState';
+
+const selector = (channel: Channel) => channel.data?.member_count ?? 0;
+const keys: EventTypes[] = ['channel.updated'];
+
+export function useChannelMemberCount(channel: Channel): number;
+export function useChannelMemberCount(channel?: Channel): number | undefined;
+export function useChannelMemberCount(channel?: Channel) {
+  return useSelectedChannelState({ channel, selector, stateChangeEventKeys: keys });
+}

package/src/{components/ChannelList/hooks → hooks}/useChannelMembershipState.ts

@@ -1,6 +1,6 @@
 import { Channel, ChannelMemberResponse, EventTypes } from 'stream-chat';
 
-import { useSelectedChannelState } from '../../../hooks/useSelectedChannelState';
+import { useSelectedChannelState } from './useSelectedChannelState';
 
 const selector = (channel: Channel) => channel.state.membership;
 const keys: EventTypes[] = ['member.updated'];

package/src/hooks/useChannelMuteActive.ts

@@ -0,0 +1,25 @@
+import { Channel } from 'stream-chat';
+
+import { getOtherUserInDirectChannel } from './actions/useChannelActions';
+
+import { useIsDirectChat } from './useIsDirectChat';
+
+import { useMutedChannels } from '../components/ChannelList/hooks/useMutedChannels';
+import { useUserMuteActive } from '../components/Message/hooks/useUserMuteActive';
+
+export const useChannelMuteActive = (channel: Channel) => {
+  const isDirectChat = useIsDirectChat(channel);
+  const mutedChannels = useMutedChannels(channel);
+  const otherUser = getOtherUserInDirectChannel(channel)?.user;
+  const otherUserMuted = useUserMuteActive(otherUser);
+
+  const channelMuted = !!mutedChannels.find(
+    (mutedChannel) => channel.cid === mutedChannel.channel?.cid,
+  );
+
+  if (!isDirectChat) {
+    return channelMuted;
+  }
+
+  return channelMuted || otherUserMuted;
+};

package/src/hooks/useChannelName.ts

@@ -0,0 +1,12 @@
+import { Channel, EventTypes } from 'stream-chat';
+
+import { useSelectedChannelState } from './useSelectedChannelState';
+
+const selector = (channel: Channel) => channel.data?.name;
+const keys: EventTypes[] = ['channel.updated'];
+
+export function useChannelName(channel: Channel): string | undefined;
+export function useChannelName(channel?: Channel): string | undefined;
+export function useChannelName(channel?: Channel) {
+  return useSelectedChannelState({ channel, selector, stateChangeEventKeys: keys });
+}

package/src/hooks/useChannelOwnCapabilities.ts

@@ -0,0 +1,12 @@
+import { Channel, EventTypes } from 'stream-chat';
+
+import { useSelectedChannelState } from './useSelectedChannelState';
+
+const selector = (channel: Channel) => channel.data?.own_capabilities as string[] | undefined;
+const keys: EventTypes[] = ['capabilities.changed'];
+
+export function useChannelOwnCapabilities(channel: Channel): string[] | undefined;
+export function useChannelOwnCapabilities(channel?: Channel): string[] | undefined;
+export function useChannelOwnCapabilities(channel?: Channel) {
+  return useSelectedChannelState({ channel, selector, stateChangeEventKeys: keys });
+}

package/src/hooks/useIsChannelMember.ts

@@ -0,0 +1,20 @@
+import { useMemo } from 'react';
+
+import type { Channel } from 'stream-chat';
+
+import { useChannelMembersState } from '../components/ChannelList/hooks/useChannelMembersState';
+
+/**
+ * Determines whether the user with the given id is already a member of the channel.
+ */
+export const useIsChannelMember = (channel: Channel, userId?: string) => {
+  const members = useChannelMembersState(channel);
+
+  return useMemo(() => {
+    if (!userId) {
+      return false;
+    }
+
+    return Object.values(members).some((member) => member.user?.id === userId);
+  }, [members, userId]);
+};

package/src/{components/ChannelList/hooks → hooks}/useIsDirectChat.ts

@@ -2,9 +2,8 @@ import { useMemo } from 'react';
 
 import type { Channel } from 'stream-chat';
 
-import { useChannelMembersState } from './useChannelMembersState';
-
-import { useChatContext } from '../../../contexts';
+import { useChannelMembersState } from '../components/ChannelList/hooks/useChannelMembersState';
+import { useChatContext } from '../contexts';
 
 export const useIsDirectChat = (channel: Channel) => {
   const { client } = useChatContext();

package/src/hooks/useSyncClientEvents.ts

@@ -56,3 +56,50 @@ export function useSyncClientEventsToChannel<O>({
 
   return useSyncExternalStore(subscribe, getSnapshot);
 }
+
+export function useSyncClientEvents<O>(_: {
+  client: StreamChat;
+  selector: (client: StreamChat) => O;
+  stateChangeEventKeys: EventTypes[];
+}): O;
+export function useSyncClientEvents<O>(_: {
+  client?: StreamChat | undefined;
+  selector: (client: StreamChat) => O;
+  stateChangeEventKeys: EventTypes[];
+}): O | undefined;
+export function useSyncClientEvents<O>({
+  client,
+  selector,
+  stateChangeEventKeys = ['all'],
+}: {
+  selector: (client: StreamChat) => O;
+  client?: StreamChat;
+  stateChangeEventKeys: EventTypes[];
+}): O | undefined {
+  const subscribe = useCallback(
+    (onStoreChange: (value: O) => void) => {
+      if (!client) {
+        return noop;
+      }
+
+      const subscriptions = stateChangeEventKeys.map((et) =>
+        client.on(et, () => {
+          onStoreChange(selector(client));
+        }),
+      );
+
+      return () => subscriptions.forEach((subscription) => subscription.unsubscribe());
+    },
+    [client, selector, stateChangeEventKeys],
+  );
+
+  const getSnapshot = useCallback(() => {
+    if (!client) {
+      return undefined;
+    }
+
+    return selector(client);
+  }, [client, selector]);
+
+  return useSyncExternalStore(subscribe, getSnapshot);
+}

package/src/i18n/ar.json

@@ -90,6 +90,7 @@
   "No chats here yet…": "لا توجد محادثات هنا بعد…",
   "No items exist": "لا توجد عناصر",
   "No threads here yet": "لا توجد مواضيع هنا بعد",
+  "No user found": "لم يتم العثور على مستخدم",
   "Not supported": "غير مدعوم",
   "Nothing yet...": "لا شيء بعد...",
   "Ok": "حسناً",
@@ -235,11 +236,16 @@
   "Delete Group": "حذف المجموعة",
   "Leave Chat": "مغادرة الدردشة",
   "Leave Group": "مغادرة المجموعة",
+  "Mute Chat": "كتم الدردشة",
   "Mute Group": "كتم المجموعة",
+  "Admin": "مسؤول",
+  "Moderator": "مشرف",
   "Offline": "غير متصل",
   "Online": "متصل",
+  "Owner": "مالك",
   "Unarchive Chat": "إلغاء أرشفة الدردشة",
   "Unarchive Group": "إلغاء أرشفة المجموعة",
+  "Unmute Chat": "إلغاء كتم الدردشة",
   "Unmute Group": "إلغاء كتم المجموعة",
   "{{memberCount}} members, {{onlineCount}} online_one": "{{memberCount}} عضو، {{onlineCount}} متصل",
   "{{memberCount}} members, {{onlineCount}} online_other": "{{memberCount}} أعضاء، {{onlineCount}} متصل",
@@ -293,10 +299,14 @@
   "a11y/you reacted": "تفاعلت",
   "a11y/{{count}} new messages": "{{count}} new messages",
   "a11y/Add attachment": "Add attachment",
+  "a11y/Add members": "إضافة أعضاء",
+  "a11y/Clear search": "مسح البحث",
+  "a11y/Close": "Close",
   "a11y/Close attachments": "Close attachments",
   "a11y/Remove attachment": "Remove Attachment",
   "a11y/Close poll": "Close poll",
   "a11y/Close poll creation": "Close poll creation",
+  "a11y/Confirm add members": "تأكيد إضافة الأعضاء",
   "a11y/Create poll": "Create poll",
   "a11y/Decrease maximum votes": "Decrease maximum votes",
   "a11y/Delete voice recording": "Delete voice recording",
@@ -319,11 +329,29 @@
   "a11y/Select image": "Select image",
   "a11y/Select video": "Select video",
   "a11y/Send voice recording": "Send voice recording",
+  "a11y/Search users to add": "البحث عن مستخدمين لإضافتهم",
+  "a11y/Select {{name}}": "تحديد {{name}}",
+  "a11y/{{name}} is already a member": "{{name}} عضو بالفعل",
   "a11y/Share Button": "Share Button",
   "a11y/Start voice recording": "Start voice recording",
   "a11y/Stop voice recording": "Stop voice recording",
+  "Add": "إضافة",
+  "Add Members": "إضافة أعضاء",
+  "Contact Info": "معلومات جهة الاتصال",
+  "Edit": "تعديل",
+  "Files": "الملفات",
+  "Group Info": "معلومات المجموعة",
+  "timestamp/UserActivityStatus": "آخر ظهور {{ timestamp | fromNowFormatter }}",
+  "Photos & Videos": "الصور ومقاطع الفيديو",
+  "Pinned Messages": "الرسائل المثبتة",
+  "View all": "عرض الكل",
+  "{{count}} members_one": "{{count}} عضو",
+  "{{count}} members_other": "{{count}} أعضاء",
+  "{{count}} members_many": "{{count}} أعضاء",
+  "a11y/Back": "رجوع",
   "a11y/Notifications": "Notifications",
   "a11y/Dismiss notification": "Dismiss notification",
+  "a11y/Edit channel": "تعديل القناة",
   "Attachment upload blocked due to {{reason}}": "تم حظر رفع المرفق بسبب {{reason}}",
   "Attachment upload failed due to {{reason}}": "فشل رفع المرفق بسبب {{reason}}",
   "Command not available": "الأمر غير متاح",
@@ -346,19 +374,30 @@
   "Wait until all attachments have uploaded": "انتظر حتى يتم رفع جميع المرفقات",
   "Cannot seek in the recording": "لا يمكن التنقل داخل التسجيل",
   "Channel archived": "تمت أرشفة القناة",
+  "Channel deleted": "تم حذف القناة",
+  "Channel image updated": "تم تحديث صورة القناة",
   "Channel muted": "تم كتم القناة",
+  "Channel name updated": "تم تحديث اسم القناة",
   "Channel pinned": "تم تثبيت القناة",
   "Channel unarchived": "تم إلغاء أرشفة القناة",
   "Channel unmuted": "تم إلغاء كتم القناة",
   "Channel unpinned": "تم إلغاء تثبيت القناة",
   "Edit message request failed": "فشل طلب تعديل الرسالة",
+  "Failed to add members": "فشل إضافة الأعضاء",
   "Failed to block user": "فشل حظر المستخدم",
+  "Failed to delete channel": "فشل حذف القناة",
   "Failed to leave channel": "فشل مغادرة القناة",
+  "Failed to load users": "فشل تحميل المستخدمين",
   "Failed to play the recording": "فشل تشغيل التسجيل",
   "Failed to update channel archive status": "فشل تحديث حالة أرشفة القناة",
+  "Failed to update channel image": "فشل تحديث صورة القناة",
   "Failed to update channel mute status": "فشل تحديث حالة كتم القناة",
+  "Failed to update channel name": "فشل تحديث اسم القناة",
   "Failed to update channel pinned status": "فشل تحديث حالة تثبيت القناة",
   "Left channel": "تمت مغادرة القناة",
+  "{{count}} members added_one": "تمت إضافة {{count}} عضو",
+  "{{count}} members added_other": "تمت إضافة {{count}} أعضاء",
+  "{{count}} members added_many": "تمت إضافة {{count}} أعضاء",
   "Recording format is not supported and cannot be reproduced": "تنسيق التسجيل غير مدعوم ولا يمكن تشغيله",
   "Send message request failed": "فشل طلب إرسال الرسالة",
   "User blocked": "تم حظر المستخدم",
@@ -368,9 +407,28 @@
   "size limit": "حد الحجم",
   "unknown error": "خطأ غير معروف",
   "unsupported file type": "نوع ملف غير مدعوم",
+  "Already a member": "عضو بالفعل",
+  "Channel name": "اسم القناة",
+  "Edit Group Picture": "تعديل صورة المجموعة",
+  "Choose Image": "اختيار صورة",
+  "Take Photo": "التقاط صورة",
+  "Upload": "رفع",
+  "a11y/Channel name": "اسم القناة",
+  "a11y/Confirm edit channel": "تأكيد تعديل القناة",
+  "a11y/Upload channel image": "رفع صورة القناة",
+  "Reset Picture": "إعادة تعيين الصورة",
+  "a11y/Close edit picture sheet": "إغلاق نافذة تعديل الصورة",
+  "Muted": "مكتوم",
+  "Failed to load members": "فشل تحميل الأعضاء",
+  "Remove User": "إزالة المستخدم",
+  "Remove": "إزالة",
+  "Are you sure you want to remove this member from the channel?": "هل أنت متأكد أنك تريد إزالة هذا العضو من القناة؟",
+  "{{count}} members removed_one": "تمت إزالة {{count}} عضو",
+  "{{count}} members removed_other": "تمت إزالة {{count}} أعضاء",
+  "{{count}} members removed_many": "تمت إزالة {{count}} أعضاء",
+  "Failed to remove members": "فشل إزالة الأعضاء",
   "a11y/Double tap and hold to activate contextual menu": "انقر نقرًا مزدوجًا مع الاستمرار لتفعيل قائمة السياق",
   "a11y/Swipe right to go through different actions": "اسحب لليمين للتنقل بين الإجراءات المختلفة",
-  "a11y/Close": "Close",
   "a11y/Bottom sheet opened. Activate the close action or use the escape gesture to dismiss.": "Bottom sheet opened. Activate the close action or use the escape gesture to dismiss.",
   "a11y/{{count}} unread messages": "{{count}} رسائل غير مقروءة",
   "a11y/Message from you": "رسالة منك",