stream-chat-react-native-core 6.7.3 → 7.0.0-rc.10

package/src/contexts/attachmentPickerContext/AttachmentPickerContext.tsx

@@ -2,7 +2,8 @@ import React, { PropsWithChildren, useContext, useEffect, useState } from 'react
 
 import { BottomSheetHandleProps } from '@gorhom/bottom-sheet';
 
-import type { Asset, File } from '../../types/types';
+import type { File } from '../../types/types';
+
 import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
 
 import { isTestEnvironment } from '../utils/isTestEnvironment';
@@ -82,11 +83,11 @@ export type AttachmentPickerContextValue = {
   maxNumberOfFiles: number;
   openPicker: () => void;
   selectedFiles: File[];
-  selectedImages: Asset[];
+  selectedImages: File[];
   setBottomInset: React.Dispatch<React.SetStateAction<number>>;
   setMaxNumberOfFiles: React.Dispatch<React.SetStateAction<number>>;
   setSelectedFiles: React.Dispatch<React.SetStateAction<File[]>>;
-  setSelectedImages: React.Dispatch<React.SetStateAction<Asset[]>>;
+  setSelectedImages: React.Dispatch<React.SetStateAction<File[]>>;
   setSelectedPicker: React.Dispatch<React.SetStateAction<'images' | undefined>>;
   setTopInset: React.Dispatch<React.SetStateAction<number>>;
   topInset: number;
@@ -124,7 +125,7 @@ export const AttachmentPickerProvider = ({
 
   const [bottomInset, setBottomInset] = useState<number>(bottomInsetValue ?? 0);
   const [maxNumberOfFiles, setMaxNumberOfFiles] = useState(10);
-  const [selectedImages, setSelectedImages] = useState<Asset[]>([]);
+  const [selectedImages, setSelectedImages] = useState<File[]>([]);
   const [selectedFiles, setSelectedFiles] = useState<File[]>([]);
   const [selectedPicker, setSelectedPicker] = useState<'images'>();
   const [topInset, setTopInset] = useState<number>(topInsetValue ?? 0);

package/src/contexts/channelContext/ChannelContext.tsx

@@ -6,14 +6,12 @@ import { MarkReadFunctionOptions } from '../../components/Channel/Channel';
 import type { EmptyStateProps } from '../../components/Indicators/EmptyStateIndicator';
 import type { LoadingProps } from '../../components/Indicators/LoadingIndicator';
 import { StickyHeaderProps } from '../../components/MessageList/StickyHeader';
-import type { ChannelUnreadState, DefaultStreamChatGenerics } from '../../types/types';
+import type { ChannelUnreadState } from '../../types/types';
 import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
 
 import { isTestEnvironment } from '../utils/isTestEnvironment';
 
-export type ChannelContextValue<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
+export type ChannelContextValue = {
   /**
    * Instance of channel object from stream-chat package.
    *
@@ -36,7 +34,7 @@ export type ChannelContextValue<
    *
    * @overrideType Channel
    */
-  channel: Channel<StreamChatGenerics>;
+  channel: Channel;
   /**
    * Custom UI component to display empty state when channel has no messages.
    *
@@ -87,11 +85,9 @@ export type ChannelContextValue<
     limit,
     setTargetedMessage,
   }: {
-    channelUnreadState?: ChannelUnreadState<StreamChatGenerics>;
+    channelUnreadState?: ChannelUnreadState;
     limit?: number;
-    setChannelUnreadState?: React.Dispatch<
-      React.SetStateAction<ChannelUnreadState<StreamChatGenerics> | undefined>
-    >;
+    setChannelUnreadState?: React.Dispatch<React.SetStateAction<ChannelUnreadState | undefined>>;
     setTargetedMessage?: (messageId: string) => void;
   }) => Promise<void>;
 
@@ -123,17 +119,15 @@ export type ChannelContextValue<
    * }
    * ```
    */
-  members: ChannelState<StreamChatGenerics>['members'];
+  members: ChannelState['members'];
   /**
    * Custom network down indicator to override the Stream default
    */
   NetworkDownIndicator: React.ComponentType;
-  read: ChannelState<StreamChatGenerics>['read'];
+  read: ChannelState['read'];
   reloadChannel: () => Promise<void>;
   scrollToFirstUnreadThreshold: number;
-  setChannelUnreadState: React.Dispatch<
-    React.SetStateAction<ChannelUnreadState<StreamChatGenerics> | undefined>
-  >;
+  setChannelUnreadState: React.Dispatch<React.SetStateAction<ChannelUnreadState | undefined>>;
   setLastRead: React.Dispatch<React.SetStateAction<Date | undefined>>;
   setTargetedMessage: (messageId?: string) => void;
   /**
@@ -141,7 +135,7 @@ export type ChannelContextValue<
    * Its a map of filename and AbortController
    */
   uploadAbortControllerRef: React.MutableRefObject<Map<string, AbortController>>;
-  channelUnreadState?: ChannelUnreadState<StreamChatGenerics>;
+  channelUnreadState?: ChannelUnreadState;
   disabled?: boolean;
   enableMessageGroupingByUser?: boolean;
   /**
@@ -170,7 +164,7 @@ export type ChannelContextValue<
    */
   targetedMessage?: string;
   threadList?: boolean;
-  watcherCount?: ChannelState<StreamChatGenerics>['watcher_count'];
+  watcherCount?: ChannelState['watcher_count'];
   /**
    *
    * ```json
@@ -194,32 +188,26 @@ export type ChannelContextValue<
    * }
    * ```
    */
-  watchers?: ChannelState<StreamChatGenerics>['watchers'];
+  watchers?: ChannelState['watchers'];
 };
 
 export const ChannelContext = React.createContext(
   DEFAULT_BASE_CONTEXT_VALUE as ChannelContextValue,
 );
 
-export const ChannelProvider = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const ChannelProvider = ({
   children,
   value,
 }: PropsWithChildren<{
-  value: ChannelContextValue<StreamChatGenerics>;
+  value: ChannelContextValue;
 }>) => (
   <ChannelContext.Provider value={value as unknown as ChannelContextValue}>
     {children}
   </ChannelContext.Provider>
 );
 
-export const useChannelContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->() => {
-  const contextValue = useContext(
-    ChannelContext,
-  ) as unknown as ChannelContextValue<StreamChatGenerics>;
+export const useChannelContext = () => {
+  const contextValue = useContext(ChannelContext) as unknown as ChannelContextValue;
 
   if (contextValue === DEFAULT_BASE_CONTEXT_VALUE && !isTestEnvironment()) {
     throw new Error(

package/src/contexts/channelsContext/ChannelsContext.tsx

@@ -16,14 +16,12 @@ import type { ChannelPreviewUnreadCountProps } from '../../components/ChannelPre
 import type { EmptyStateProps } from '../../components/Indicators/EmptyStateIndicator';
 import type { LoadingErrorProps } from '../../components/Indicators/LoadingErrorIndicator';
 import type { LoadingProps } from '../../components/Indicators/LoadingIndicator';
-import type { DefaultStreamChatGenerics } from '../../types/types';
+
 import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
 
 import { isTestEnvironment } from '../utils/isTestEnvironment';
 
-export type ChannelsContextValue<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
+export type ChannelsContextValue = {
   /**
    * Besides the existing default behavior of the ChannelListMessenger component, you can attach
    * additional props to the underlying React Native FlatList.
@@ -41,7 +39,7 @@ export type ChannelsContextValue<
    *
    * **Note:** Don't use `additionalFlatListProps` to access the FlatList ref, use `setFlatListRef`
    */
-  additionalFlatListProps: Partial<FlatListProps<Channel<StreamChatGenerics>>>;
+  additionalFlatListProps: Partial<FlatListProps<Channel>>;
   /**
    * A control prop used to determine whether the first query of the channel list has succeeded.
    */
@@ -49,7 +47,7 @@ export type ChannelsContextValue<
   /**
    * Channels can be either an array of channels or a promise which resolves to an array of channels
    */
-  channels: Channel<StreamChatGenerics>[] | null;
+  channels: Channel[] | null;
   /**
    * Custom indicator to use when channel list is empty
    *
@@ -123,7 +121,7 @@ export type ChannelsContextValue<
    *
    * Default: [ChannelPreviewMessenger](https://getstream.io/chat/docs/sdk/reactnative/ui-components/channel-preview-messenger/)
    */
-  Preview: React.ComponentType<ChannelPreviewMessengerProps<StreamChatGenerics>>;
+  Preview: React.ComponentType<ChannelPreviewMessengerProps>;
   /**
    * Triggered when the channel list is refreshing, displays a loading spinner at the top of the list
    */
@@ -142,7 +140,7 @@ export type ChannelsContextValue<
   //  *
   //  * @param channel A channel object
   //  */
-  // setActiveChannel?: (channel: Channel<StreamChatGenerics>) => void;
+  // setActiveChannel?: (channel: Channel) => void;
   /**
    * Function to gain access to the inner FlatList ref
    *
@@ -155,7 +153,7 @@ export type ChannelsContextValue<
    *  }}
    * ```
    */
-  setFlatListRef: (ref: FlatList<Channel<StreamChatGenerics>> | null) => void;
+  setFlatListRef: (ref: FlatList<Channel> | null) => void;
   /**
    * Custom UI component to display loading channel skeletons
    *
@@ -172,19 +170,19 @@ export type ChannelsContextValue<
    *
    * @param channel A channel object
    */
-  onSelect?: (channel: Channel<StreamChatGenerics>) => void;
+  onSelect?: (channel: Channel) => void;
   /**
    * Custom UI component to render preview avatar.
    *
    * **Default** [ChannelAvatar](https://github.com/GetStream/stream-chat-react-native/blob/main/package/src/components/ChannelPreview/ChannelAvatar.tsx)
    */
-  PreviewAvatar?: React.ComponentType<ChannelAvatarProps<StreamChatGenerics>>;
+  PreviewAvatar?: React.ComponentType<ChannelAvatarProps>;
   /**
    * Custom UI component to render preview of latest message on channel.
    *
    * **Default** [ChannelPreviewMessage](https://github.com/GetStream/stream-chat-react-native/blob/main/package/src/components/ChannelPreview/ChannelPreviewMessage.tsx)
    */
-  PreviewMessage?: React.ComponentType<ChannelPreviewMessageProps<StreamChatGenerics>>;
+  PreviewMessage?: React.ComponentType<ChannelPreviewMessageProps>;
   /**
    * Custom UI component to render muted status.
    *
@@ -196,44 +194,38 @@ export type ChannelsContextValue<
    *
    * **Default** [ChannelPreviewStatus](https://github.com/GetStream/stream-chat-react-native/blob/main/package/src/components/ChannelPreview/ChannelPreviewStatus.tsx)
    */
-  PreviewStatus?: React.ComponentType<ChannelPreviewStatusProps<StreamChatGenerics>>;
+  PreviewStatus?: React.ComponentType<ChannelPreviewStatusProps>;
   /**
    * Custom UI component to render preview avatar.
    *
    * **Default** [ChannelPreviewTitle](https://github.com/GetStream/stream-chat-react-native/blob/main/package/src/components/ChannelPreview/ChannelPreviewTitle.tsx)
    */
-  PreviewTitle?: React.ComponentType<ChannelPreviewTitleProps<StreamChatGenerics>>;
+  PreviewTitle?: React.ComponentType<ChannelPreviewTitleProps>;
   /**
    * Custom UI component to render preview avatar.
    *
    * **Default** [ChannelPreviewUnreadCount](https://github.com/GetStream/stream-chat-react-native/blob/main/package/src/components/ChannelPreview/ChannelPreviewUnreadCount.tsx)
    */
-  PreviewUnreadCount?: React.ComponentType<ChannelPreviewUnreadCountProps<StreamChatGenerics>>;
+  PreviewUnreadCount?: React.ComponentType<ChannelPreviewUnreadCountProps>;
 };
 
 export const ChannelsContext = React.createContext(
   DEFAULT_BASE_CONTEXT_VALUE as ChannelsContextValue,
 );
 
-export const ChannelsProvider = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const ChannelsProvider = ({
   children,
   value,
 }: PropsWithChildren<{
-  value: ChannelsContextValue<StreamChatGenerics>;
+  value: ChannelsContextValue;
 }>) => (
   <ChannelsContext.Provider value={value as unknown as ChannelsContextValue}>
     {children}
   </ChannelsContext.Provider>
 );
 
-export const useChannelsContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->() => {
-  const contextValue = useContext(
-    ChannelsContext,
-  ) as unknown as ChannelsContextValue<StreamChatGenerics>;
+export const useChannelsContext = () => {
+  const contextValue = useContext(ChannelsContext) as unknown as ChannelsContextValue;
 
   if (contextValue === DEFAULT_BASE_CONTEXT_VALUE && !isTestEnvironment()) {
     throw new Error(

package/src/contexts/channelsStateContext/ChannelsStateContext.tsx

@@ -8,7 +8,6 @@ import React, {
   useRef,
 } from 'react';
 
-import type { DefaultStreamChatGenerics } from '../../types/types';
 import { ActiveChannelsProvider } from '../activeChannelsRefContext/ActiveChannelsRefContext';
 
 import type { ThreadContextValue } from '../threadContext/ThreadContext';
@@ -16,50 +15,35 @@ import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
 
 import { isTestEnvironment } from '../utils/isTestEnvironment';
 
-export type ChannelState<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  threadMessages: ThreadContextValue<StreamChatGenerics>['threadMessages'];
+export type ChannelState = {
+  threadMessages: ThreadContextValue['threadMessages'];
 };
 
-type ChannelsState<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  [cid: string]: ChannelState<StreamChatGenerics>;
+type ChannelsState = {
+  [cid: string]: ChannelState;
 };
 
 export type Keys = keyof ChannelState;
 
-export type Payload<
-  Key extends Keys = Keys,
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
+export type Payload<Key extends Keys = Keys> = {
   cid: string;
   key: Key;
-  value: ChannelState<StreamChatGenerics>[Key];
+  value: ChannelState[Key];
 };
 
-type SetStateAction<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  payload: Payload<Keys, StreamChatGenerics>;
+type SetStateAction = {
+  payload: Payload;
   type: 'SET_STATE';
 };
 
-type Action<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> =
-  SetStateAction<StreamChatGenerics>;
+type Action = SetStateAction;
 
-export type ChannelsStateContextValue<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  setState: (value: Payload<Keys, StreamChatGenerics>) => void;
-  state: ChannelsState<StreamChatGenerics>;
+export type ChannelsStateContextValue = {
+  setState: (value: Payload) => void;
+  state: ChannelsState;
 };
 
-type Reducer<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = (
-  state: ChannelsState<StreamChatGenerics>,
-  action: Action<StreamChatGenerics>,
-) => ChannelsState<StreamChatGenerics>;
+type Reducer = (state: ChannelsState, action: Action) => ChannelsState;
 
 function reducer(state: ChannelsState, action: Action) {
   switch (action.type) {
@@ -81,16 +65,10 @@ const ChannelsStateContext = React.createContext(
   DEFAULT_BASE_CONTEXT_VALUE as ChannelsStateContextValue,
 );
 
-export const ChannelsStateProvider = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
-  children,
-}: {
-  children: ReactNode;
-}) => {
-  const [state, dispatch] = useReducer(reducer as unknown as Reducer<StreamChatGenerics>, {});
+export const ChannelsStateProvider = ({ children }: { children: ReactNode }) => {
+  const [state, dispatch] = useReducer(reducer as unknown as Reducer, {});
 
-  const setState = useCallback((payload: Payload<Keys, StreamChatGenerics>) => {
+  const setState = useCallback((payload: Payload) => {
     dispatch({ payload, type: 'SET_STATE' });
   }, []);
 
@@ -116,12 +94,8 @@ export const ChannelsStateProvider = <
   );
 };
 
-export const useChannelsStateContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->() => {
-  const contextValue = useContext(
-    ChannelsStateContext,
-  ) as unknown as ChannelsStateContextValue<StreamChatGenerics>;
+export const useChannelsStateContext = () => {
+  const contextValue = useContext(ChannelsStateContext) as unknown as ChannelsStateContextValue;
 
   if (contextValue === DEFAULT_BASE_CONTEXT_VALUE && !isTestEnvironment()) {
     throw new Error(

package/src/contexts/channelsStateContext/useChannelState.ts

@@ -6,12 +6,7 @@ import { useChannelsStateContext } from './ChannelsStateContext';
 
 import type { ChannelsStateContextValue, ChannelState, Keys } from './ChannelsStateContext';
 
-import type { DefaultStreamChatGenerics } from '../../types/types';
-
-type StateManagerParams<
-  Key extends Keys,
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = ChannelsStateContextValue<StreamChatGenerics> & {
+type StateManagerParams<Key extends Keys> = ChannelsStateContextValue & {
   cid: string;
   key: Key;
 };
@@ -21,20 +16,16 @@ type StateManagerParams<
   updates to the ChannelsStateContext reducer. It receives the cid and key which it wants to update
   and perform the state updates. Also supports a initialState.
 */
-export function useStateManager<
-  Key extends Keys,
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  { cid, key, setState, state }: StateManagerParams<Key, StreamChatGenerics>,
-  initialValue?: ChannelState<StreamChatGenerics>[Key],
+export function useStateManager<Key extends Keys>(
+  { cid, key, setState, state }: StateManagerParams<Key>,
+  initialValue?: ChannelState[Key],
 ) {
   // eslint-disable-next-line react-hooks/exhaustive-deps
   const memoizedInitialValue = useMemo(() => initialValue, []);
-  const value =
-    state[cid]?.[key] || (memoizedInitialValue as ChannelState<StreamChatGenerics>[Key]);
+  const value = state[cid]?.[key] || (memoizedInitialValue as ChannelState[Key]);
 
   const setValue = useCallback(
-    (value: ChannelState<StreamChatGenerics>[Key]) => setState({ cid, key, value }),
+    (value: ChannelState[Key]) => setState({ cid, key, value }),
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [cid, key],
   );
@@ -42,21 +33,17 @@ export function useStateManager<
   return [value, setValue] as const;
 }
 
-export type UseChannelStateValue<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  setThreadMessages: (value: ChannelState<StreamChatGenerics>['threadMessages']) => void;
-  threadMessages: ChannelState<StreamChatGenerics>['threadMessages'];
+export type UseChannelStateValue = {
+  setThreadMessages: (value: ChannelState['threadMessages']) => void;
+  threadMessages: ChannelState['threadMessages'];
 };
 
-export function useChannelState<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  channel: ChannelType<StreamChatGenerics> | undefined,
+export function useChannelState(
+  channel: ChannelType | undefined,
   threadId?: string,
-): UseChannelStateValue<StreamChatGenerics> {
+): UseChannelStateValue {
   const cid = channel?.id || 'id'; // in case channel is not initialized, use generic id string for indexing
-  const { setState, state } = useChannelsStateContext<StreamChatGenerics>();
+  const { setState, state } = useChannelsStateContext();
 
   const [threadMessages, setThreadMessages] = useStateManager(
     {

package/src/contexts/chatContext/ChatContext.tsx

@@ -3,19 +3,16 @@ import type { ImageProps } from 'react-native';
 
 import type { AppSettingsAPIResponse, Channel, Mute, StreamChat } from 'stream-chat';
 
-import type { DefaultStreamChatGenerics } from '../../types/types';
 import { MessageContextValue } from '../messageContext/MessageContext';
 import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
 
 import { isTestEnvironment } from '../utils/isTestEnvironment';
 
-export type ChatContextValue<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
+export type ChatContextValue = {
   /**
    * Object of application settings returned from Stream.
    * */
-  appSettings: AppSettingsAPIResponse<StreamChatGenerics> | null;
+  appSettings: AppSettingsAPIResponse | null;
   /**
    * The StreamChat client object
    *
@@ -32,7 +29,7 @@ export type ChatContextValue<
    *
    * @overrideType StreamChat
    * */
-  client: StreamChat<StreamChatGenerics>;
+  client: StreamChat;
   connectionRecovering: boolean;
   enableOfflineSupport: boolean;
   /**
@@ -40,13 +37,13 @@ export type ChatContextValue<
    */
   ImageComponent: React.ComponentType<ImageProps>;
   isOnline: boolean | null;
-  mutedUsers: Mute<StreamChatGenerics>[];
+  mutedUsers: Mute[];
   /**
    * @param newChannel Channel to set as active.
    *
    * @overrideType Function
    */
-  setActiveChannel: (newChannel?: Channel<StreamChatGenerics>) => void;
+  setActiveChannel: (newChannel?: Channel) => void;
   /**
    * Instance of channel object from stream-chat package.
    *
@@ -64,28 +61,24 @@ export type ChatContextValue<
    *
    * @overrideType Channel
    */
-  channel?: Channel<StreamChatGenerics>;
-} & Partial<Pick<MessageContextValue<StreamChatGenerics>, 'isMessageAIGenerated'>>;
+  channel?: Channel;
+} & Partial<Pick<MessageContextValue, 'isMessageAIGenerated'>>;
 
 export const ChatContext = React.createContext(DEFAULT_BASE_CONTEXT_VALUE as ChatContextValue);
 
-export const ChatProvider = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const ChatProvider = ({
   children,
   value,
 }: PropsWithChildren<{
-  value?: ChatContextValue<StreamChatGenerics>;
+  value?: ChatContextValue;
 }>) => (
   <ChatContext.Provider value={value as unknown as ChatContextValue}>
     {children}
   </ChatContext.Provider>
 );
 
-export const useChatContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->() => {
-  const contextValue = useContext(ChatContext) as unknown as ChatContextValue<StreamChatGenerics>;
+export const useChatContext = () => {
+  const contextValue = useContext(ChatContext) as unknown as ChatContextValue;
 
   if (contextValue === DEFAULT_BASE_CONTEXT_VALUE && !isTestEnvironment()) {
     throw new Error(

package/src/contexts/debugContext/DebugContext.tsx

@@ -1,61 +1,52 @@
 import React, { PropsWithChildren, useContext, useRef } from 'react';
 
-import type { Channel, ChannelState, StreamChat } from 'stream-chat';
-
-import type { MessageType } from '../../components/MessageList/hooks/useMessageList';
-import type { DefaultStreamChatGenerics } from '../../types/types';
+import type { Channel, ChannelState, LocalMessage, StreamChat } from 'stream-chat';
 
 import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
 
-export type DebugDataType<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> =
-  | StreamChat<StreamChatGenerics>['user']
+export type DebugDataType =
+  | StreamChat['user']
   | {
-      data: Channel<StreamChatGenerics>['data'];
-      members: ChannelState<StreamChatGenerics>['members'];
+      data: Channel['data'];
+      members: ChannelState['members'];
     }[]
-  | MessageType<StreamChatGenerics>[];
+  | LocalMessage[];
 
-export type DebugContextValue<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
+export type DebugContextValue = {
   eventType?: string;
   sendEventParams?: {
     action: string;
-    data: DebugDataType<StreamChatGenerics>;
+    data: DebugDataType;
   };
   setEventType?: (data: string) => void;
-  setSendEventParams?: (data: { action: string; data: DebugDataType<StreamChatGenerics> }) => void;
+  setSendEventParams?: (data: { action: string; data: DebugDataType }) => void;
 };
 
 export const DebugContext = React.createContext(
   DEFAULT_BASE_CONTEXT_VALUE as React.MutableRefObject<DebugContextValue>,
 );
 
-export const DebugContextProvider = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const DebugContextProvider = ({
   children,
   useFlipper,
 }: PropsWithChildren<{
   useFlipper: () => {
-    updateData: (ref: React.RefObject<DebugContextValue<StreamChatGenerics>>) => void;
+    updateData: (ref: React.RefObject<DebugContextValue>) => void;
   };
 }>) => {
-  const debugRef = useRef<DebugContextValue<StreamChatGenerics>>({
+  const debugRef = useRef<DebugContextValue>({
     eventType: undefined,
     sendEventParams: undefined,
   });
 
   const { updateData } = useFlipper();
 
-  const ref = useRef<DebugContextValue<StreamChatGenerics>>({
+  const ref = useRef<DebugContextValue>({
     setEventType: (data: string) => {
       debugRef.current.eventType = data;
       updateData(debugRef);
     },
-    setSendEventParams: (data: { action: string; data: DebugDataType<StreamChatGenerics> }) => {
+    setSendEventParams: (data: { action: string; data: DebugDataType }) => {
       debugRef.current.sendEventParams = data;
       updateData(debugRef);
     },