stream-chat-react-native-core 6.6.8-beta.3 → 7.0.0-rc.2

package/src/components/ChannelList/hooks/listeners/useNewMessage.ts

@@ -4,10 +4,7 @@ import type { Channel, Event } from 'stream-chat';
 
 import { useChatContext } from '../../../../contexts/chatContext/ChatContext';
 
-import type {
-  ChannelListEventListenerOptions,
-  DefaultStreamChatGenerics,
-} from '../../../../types/types';
+import type { ChannelListEventListenerOptions } from '../../../../types/types';
 import { moveChannelUp } from '../../utils';
 import {
   isChannelArchived,
@@ -16,31 +13,28 @@ import {
   shouldConsiderPinnedChannels,
 } from '../utils';
 
-type Parameters<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> =
-  {
-    lockChannelOrder: boolean;
-    setChannels: React.Dispatch<React.SetStateAction<Channel<StreamChatGenerics>[] | null>>;
-    onNewMessage?: (
-      lockChannelOrder: boolean,
-      setChannels: React.Dispatch<React.SetStateAction<Channel<StreamChatGenerics>[] | null>>,
-      event: Event<StreamChatGenerics>,
-      options?: ChannelListEventListenerOptions<StreamChatGenerics>,
-    ) => void;
-    options?: ChannelListEventListenerOptions<StreamChatGenerics>;
-  };
+type Parameters = {
+  lockChannelOrder: boolean;
+  setChannels: React.Dispatch<React.SetStateAction<Channel[] | null>>;
+  onNewMessage?: (
+    lockChannelOrder: boolean,
+    setChannels: React.Dispatch<React.SetStateAction<Channel[] | null>>,
+    event: Event,
+    options?: ChannelListEventListenerOptions,
+  ) => void;
+  options?: ChannelListEventListenerOptions;
+};
 
-export const useNewMessage = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const useNewMessage = ({
   lockChannelOrder,
   onNewMessage,
   options,
   setChannels,
-}: Parameters<StreamChatGenerics>) => {
-  const { client } = useChatContext<StreamChatGenerics>();
+}: Parameters) => {
+  const { client } = useChatContext();
 
   useEffect(() => {
-    const handleEvent = (event: Event<StreamChatGenerics>) => {
+    const handleEvent = (event: Event) => {
       if (typeof onNewMessage === 'function') {
         onNewMessage(lockChannelOrder, setChannels, event, options);
       } else {
@@ -80,7 +74,7 @@ export const useNewMessage = <
             return [...channels];
           }
 
-          return moveChannelUp<StreamChatGenerics>({
+          return moveChannelUp({
             channels,
             channelToMove: targetChannel,
             channelToMoveIndexWithinChannels: targetChannelIndex,

package/src/components/ChannelList/hooks/listeners/useNewMessageNotification.ts

@@ -4,35 +4,29 @@ import type { Channel, Event } from 'stream-chat';
 
 import { useChatContext } from '../../../../contexts/chatContext/ChatContext';
 
-import type {
-  ChannelListEventListenerOptions,
-  DefaultStreamChatGenerics,
-} from '../../../../types/types';
+import type { ChannelListEventListenerOptions } from '../../../../types/types';
 import { getChannel, moveChannelUp } from '../../utils';
 import { isChannelArchived } from '../utils';
 
-type Parameters<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> =
-  {
-    setChannels: React.Dispatch<React.SetStateAction<Channel<StreamChatGenerics>[] | null>>;
-    onNewMessageNotification?: (
-      setChannels: React.Dispatch<React.SetStateAction<Channel<StreamChatGenerics>[] | null>>,
-      event: Event<StreamChatGenerics>,
-      options?: ChannelListEventListenerOptions<StreamChatGenerics>,
-    ) => void;
-    options?: ChannelListEventListenerOptions<StreamChatGenerics>;
-  };
+type Parameters = {
+  setChannels: React.Dispatch<React.SetStateAction<Channel[] | null>>;
+  onNewMessageNotification?: (
+    setChannels: React.Dispatch<React.SetStateAction<Channel[] | null>>,
+    event: Event,
+    options?: ChannelListEventListenerOptions,
+  ) => void;
+  options?: ChannelListEventListenerOptions;
+};
 
-export const useNewMessageNotification = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const useNewMessageNotification = ({
   onNewMessageNotification,
   options,
   setChannels,
-}: Parameters<StreamChatGenerics>) => {
-  const { client } = useChatContext<StreamChatGenerics>();
+}: Parameters) => {
+  const { client } = useChatContext();
 
   useEffect(() => {
-    const handleEvent = async (event: Event<StreamChatGenerics>) => {
+    const handleEvent = async (event: Event) => {
       if (typeof onNewMessageNotification === 'function') {
         onNewMessageNotification(setChannels, event, options);
       } else {

package/src/components/ChannelList/hooks/listeners/useRemovedFromChannelNotification.ts

@@ -4,27 +4,22 @@ import type { Channel, Event } from 'stream-chat';
 
 import { useChatContext } from '../../../../contexts/chatContext/ChatContext';
 
-import type { DefaultStreamChatGenerics } from '../../../../types/types';
-
-type Parameters<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> =
-  {
-    setChannels: React.Dispatch<React.SetStateAction<Channel<StreamChatGenerics>[] | null>>;
-    onRemovedFromChannel?: (
-      setChannels: React.Dispatch<React.SetStateAction<Channel<StreamChatGenerics>[] | null>>,
-      event: Event<StreamChatGenerics>,
-    ) => void;
-  };
+type Parameters = {
+  setChannels: React.Dispatch<React.SetStateAction<Channel[] | null>>;
+  onRemovedFromChannel?: (
+    setChannels: React.Dispatch<React.SetStateAction<Channel[] | null>>,
+    event: Event,
+  ) => void;
+};
 
-export const useRemovedFromChannelNotification = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const useRemovedFromChannelNotification = ({
   onRemovedFromChannel,
   setChannels,
-}: Parameters<StreamChatGenerics>) => {
-  const { client } = useChatContext<StreamChatGenerics>();
+}: Parameters) => {
+  const { client } = useChatContext();
 
   useEffect(() => {
-    const handleEvent = (event: Event<StreamChatGenerics>) => {
+    const handleEvent = (event: Event) => {
       if (typeof onRemovedFromChannel === 'function') {
         onRemovedFromChannel(setChannels, event);
       } else {

package/src/components/ChannelList/hooks/listeners/useUserPresence.ts

@@ -4,24 +4,16 @@ import type { Channel, Event } from 'stream-chat';
 
 import { useChatContext } from '../../../../contexts/chatContext/ChatContext';
 
-import type { DefaultStreamChatGenerics } from '../../../../types/types';
-
-type Parameters<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> =
-  {
-    setChannels: React.Dispatch<React.SetStateAction<Channel<StreamChatGenerics>[]>>;
-    setForceUpdate: React.Dispatch<React.SetStateAction<number>>;
-  };
-
-export const useUserPresence = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
-  setChannels,
-  setForceUpdate,
-}: Parameters<StreamChatGenerics>) => {
-  const { client } = useChatContext<StreamChatGenerics>();
+type Parameters = {
+  setChannels: React.Dispatch<React.SetStateAction<Channel[]>>;
+  setForceUpdate: React.Dispatch<React.SetStateAction<number>>;
+};
+
+export const useUserPresence = ({ setChannels, setForceUpdate }: Parameters) => {
+  const { client } = useChatContext();
 
   useEffect(() => {
-    const handleEvent = (event: Event<StreamChatGenerics>) => {
+    const handleEvent = (event: Event) => {
       setChannels((channels) => {
         if (!channels) {
           return channels;

package/src/components/ChannelList/hooks/useChannelMembershipState.ts

@@ -2,21 +2,11 @@ import { Channel, ChannelMemberResponse, EventTypes } from 'stream-chat';
 
 import { useSelectedChannelState } from './useSelectedChannelState';
 
-import { DefaultStreamChatGenerics } from '../../../types/types';
-
-const selector = <StreamChatGenerics extends DefaultStreamChatGenerics>(
-  channel: Channel<StreamChatGenerics>,
-) => channel.state.membership;
+const selector = (channel: Channel) => channel.state.membership;
 const keys: EventTypes[] = ['member.updated'];
 
-export function useChannelMembershipState<StreamChatGenerics extends DefaultStreamChatGenerics>(
-  channel: Channel<StreamChatGenerics>,
-): ChannelMemberResponse<StreamChatGenerics>;
-export function useChannelMembershipState<StreamChatGenerics extends DefaultStreamChatGenerics>(
-  channel?: Channel<StreamChatGenerics>,
-): ChannelMemberResponse<StreamChatGenerics> | undefined;
-export function useChannelMembershipState<StreamChatGenerics extends DefaultStreamChatGenerics>(
-  channel?: Channel<StreamChatGenerics>,
-) {
+export function useChannelMembershipState(channel: Channel): ChannelMemberResponse;
+export function useChannelMembershipState(channel?: Channel): ChannelMemberResponse | undefined;
+export function useChannelMembershipState(channel?: Channel) {
   return useSelectedChannelState({ channel, selector, stateChangeEventKeys: keys });
 }

package/src/components/ChannelList/hooks/useCreateChannelsContext.ts

@@ -1,11 +1,8 @@
 import { useMemo } from 'react';
 
 import type { ChannelsContextValue } from '../../../contexts/channelsContext/ChannelsContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
 
-export const useCreateChannelsContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const useCreateChannelsContext = ({
   additionalFlatListProps,
   channelListInitialized,
   channels,
@@ -38,7 +35,7 @@ export const useCreateChannelsContext = <
   reloadList,
   setFlatListRef,
   Skeleton,
-}: ChannelsContextValue<StreamChatGenerics>) => {
+}: ChannelsContextValue) => {
   const channelValueString = channels
     ?.map(
       (channel) =>
@@ -49,7 +46,7 @@ export const useCreateChannelsContext = <
           .join()}`,
     )
     .join();
-  const channelsContext: ChannelsContextValue<StreamChatGenerics> = useMemo(
+  const channelsContext: ChannelsContextValue = useMemo(
     () => ({
       additionalFlatListProps,
       channelListInitialized,

package/src/components/ChannelList/hooks/usePaginatedChannels.ts

@@ -14,7 +14,7 @@ import { useStateStore } from '../../../hooks';
 import { useIsMountedRef } from '../../../hooks/useIsMountedRef';
 
 import { getChannelsForFilterSort } from '../../../store/apis/getChannelsForFilterSort';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
+
 import { ONE_SECOND_IN_MS } from '../../../utils/date';
 import { DBSyncManager } from '../../../utils/DBSyncManager';
 import { MAX_QUERY_CHANNELS_LIMIT } from '../utils';
@@ -24,15 +24,14 @@ const waitSeconds = (seconds: number) =>
     setTimeout(resolve, seconds * ONE_SECOND_IN_MS);
   });
 
-type Parameters<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> =
-  {
-    channelManager: ChannelManager<StreamChatGenerics>;
-    enableOfflineSupport: boolean;
-    filters: ChannelFilters<StreamChatGenerics>;
-    options: ChannelOptions;
-    setForceUpdate: React.Dispatch<React.SetStateAction<number>>;
-    sort: ChannelSort<StreamChatGenerics>;
-  };
+type Parameters = {
+  channelManager: ChannelManager;
+  enableOfflineSupport: boolean;
+  filters: ChannelFilters;
+  options: ChannelOptions;
+  setForceUpdate: React.Dispatch<React.SetStateAction<number>>;
+  sort: ChannelSort;
+};
 
 const DEFAULT_OPTIONS = {
   message_limit: 10,
@@ -45,31 +44,27 @@ type QueryType = 'queryLocalDB' | 'reload' | 'refresh' | 'loadChannels';
 
 export type QueryChannels = (queryType?: QueryType, retryCount?: number) => Promise<void>;
 
-const selector = <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(
-  nextValue: ChannelManagerState<StreamChatGenerics>,
-) =>
+const selector = (nextValue: ChannelManagerState) =>
   ({
     channelListInitialized: nextValue.initialized,
     channels: nextValue.channels,
     pagination: nextValue.pagination,
   }) as const;
 
-export const usePaginatedChannels = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const usePaginatedChannels = ({
   channelManager,
   enableOfflineSupport,
   filters = {},
   options = DEFAULT_OPTIONS,
   setForceUpdate,
   sort = {},
-}: Parameters<StreamChatGenerics>) => {
+}: Parameters) => {
   const [error, setError] = useState<Error | undefined>(undefined);
   const [staticChannelsActive, setStaticChannelsActive] = useState<boolean>(false);
   const [activeQueryType, setActiveQueryType] = useState<QueryType | null>('queryLocalDB');
   const activeChannels = useActiveChannelsRefContext();
   const isMountedRef = useIsMountedRef();
-  const { client } = useChatContext<StreamChatGenerics>();
+  const { client } = useChatContext();
   const { channelListInitialized, channels, pagination } =
     useStateStore(channelManager?.state, selector) ?? {};
   const hasNextPage = pagination?.hasNext;

package/src/components/ChannelList/hooks/useSelectedChannelState.ts

@@ -3,33 +3,25 @@ import { useCallback } from 'react';
 import type { Channel, EventTypes } from 'stream-chat';
 import { useSyncExternalStore } from 'use-sync-external-store/shim';
 
-import { DefaultStreamChatGenerics } from '../../../types/types';
-
 const noop = () => {};
 
-export function useSelectedChannelState<
-  StreamChatGenerics extends DefaultStreamChatGenerics,
-  O,
->(_: {
-  channel: Channel<StreamChatGenerics>;
-  selector: (channel: Channel<StreamChatGenerics>) => O;
+export function useSelectedChannelState<O>(_: {
+  channel: Channel;
+  selector: (channel: Channel) => O;
   stateChangeEventKeys?: EventTypes[];
 }): O;
-export function useSelectedChannelState<
-  StreamChatGenerics extends DefaultStreamChatGenerics,
-  O,
->(_: {
-  selector: (channel: Channel<StreamChatGenerics>) => O;
-  channel?: Channel<StreamChatGenerics> | undefined;
+export function useSelectedChannelState<O>(_: {
+  selector: (channel: Channel) => O;
+  channel?: Channel | undefined;
   stateChangeEventKeys?: EventTypes[];
 }): O | undefined;
-export function useSelectedChannelState<StreamChatGenerics extends DefaultStreamChatGenerics, O>({
+export function useSelectedChannelState<O>({
   channel,
   selector,
   stateChangeEventKeys = ['all'],
 }: {
-  selector: (channel: Channel<StreamChatGenerics>) => O;
-  channel?: Channel<StreamChatGenerics>;
+  selector: (channel: Channel) => O;
+  channel?: Channel;
   stateChangeEventKeys?: EventTypes[];
 }): O | undefined {
   const subscribe = useCallback(

package/src/components/ChannelList/hooks/utils/index.ts

@@ -1,13 +1,8 @@
 import { Channel, ChannelSortBase } from 'stream-chat';
 
-import { DefaultStreamChatGenerics } from '../../../../types/types';
 import { ChannelListProps } from '../../ChannelList';
 
-export const isChannelPinned = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  channel: Channel<StreamChatGenerics>,
-) => {
+export const isChannelPinned = (channel: Channel) => {
   if (!channel) {
     return false;
   }
@@ -17,11 +12,7 @@ export const isChannelPinned = <
   return !!member?.pinned_at;
 };
 
-export const isChannelArchived = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  channel: Channel<StreamChatGenerics>,
-) => {
+export const isChannelArchived = (channel: Channel) => {
   if (!channel) {
     return false;
   }
@@ -31,11 +22,7 @@ export const isChannelArchived = <
   return !!member?.archived_at;
 };
 
-export const shouldConsiderArchivedChannels = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  filters: ChannelListProps<StreamChatGenerics>['filters'],
-) => {
+export const shouldConsiderArchivedChannels = (filters: ChannelListProps['filters']) => {
   if (!filters) {
     return false;
   }
@@ -43,21 +30,19 @@ export const shouldConsiderArchivedChannels = <
   return typeof filters.archived === 'boolean';
 };
 
-export const extractSortValue = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const extractSortValue = ({
   atIndex,
   sort,
   targetKey,
 }: {
   atIndex: number;
-  targetKey: keyof ChannelSortBase<StreamChatGenerics>;
-  sort?: ChannelListProps<StreamChatGenerics>['sort'];
+  targetKey: keyof ChannelSortBase;
+  sort?: ChannelListProps['sort'];
 }) => {
   if (!sort) {
     return null;
   }
-  let option: null | ChannelSortBase<StreamChatGenerics> = null;
+  let option: null | ChannelSortBase = null;
 
   if (Array.isArray(sort)) {
     option = sort[atIndex] ?? null;
@@ -85,11 +70,7 @@ export const extractSortValue = <
 /**
  * Returns true only if `{ pinned_at: -1 }` or `{ pinned_at: 1 }` option is first within the `sort` array.
  */
-export const shouldConsiderPinnedChannels = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  sort: ChannelListProps<StreamChatGenerics>['sort'],
-) => {
+export const shouldConsiderPinnedChannels = (sort: ChannelListProps['sort']) => {
   const value = extractSortValue({
     atIndex: 0,
     sort,
@@ -103,9 +84,7 @@ export const shouldConsiderPinnedChannels = <
   return Math.abs(value) === 1;
 };
 
-export function findPinnedAtSortOrder<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({ sort }: { sort: ChannelListProps<StreamChatGenerics>['sort'] }) {
+export function findPinnedAtSortOrder({ sort }: { sort: ChannelListProps['sort'] }) {
   if (!sort) {
     return null;
   }
@@ -127,9 +106,7 @@ export function findPinnedAtSortOrder<
   }
 }
 
-export function findLastPinnedChannelIndex<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({ channels }: { channels: Channel<StreamChatGenerics>[] }) {
+export function findLastPinnedChannelIndex({ channels }: { channels: Channel[] }) {
   let lastPinnedChannelIndex: number | null = null;
 
   for (const channel of channels) {

package/src/components/ChannelList/utils.ts

@@ -2,29 +2,23 @@ import type { Channel, ChannelSort, StreamChat } from 'stream-chat';
 
 import { findLastPinnedChannelIndex, shouldConsiderPinnedChannels } from './hooks/utils';
 
-import type { DefaultStreamChatGenerics } from '../../types/types';
-
-type MoveParameters<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  channels: Array<Channel<StreamChatGenerics>>;
-  channelToMove: Channel<StreamChatGenerics>;
+type MoveParameters = {
+  channels: Array<Channel>;
+  channelToMove: Channel;
   /**
    * If the index of the channel within `channels` list which is being moved upwards
    * (`channelToMove`) is known, you can supply it to skip extra calculation.
    */
   channelToMoveIndexWithinChannels?: number;
-  sort?: ChannelSort<StreamChatGenerics>;
+  sort?: ChannelSort;
 };
 
-export const moveChannelUp = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
+export const moveChannelUp = ({
   channels,
   channelToMove,
   channelToMoveIndexWithinChannels,
   sort,
-}: MoveParameters<StreamChatGenerics>) => {
+}: MoveParameters) => {
   // get index of channel to move up
   const targetChannelIndex =
     channelToMoveIndexWithinChannels ??
@@ -66,21 +60,13 @@ export const moveChannelUp = <
   return newChannels;
 };
 
-type GetParameters<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
-  client: StreamChat<StreamChatGenerics>;
+type GetParameters = {
+  client: StreamChat;
   id: string;
   type: string;
 };
 
-export const getChannel = async <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->({
-  client,
-  id,
-  type,
-}: GetParameters<StreamChatGenerics>) => {
+export const getChannel = async ({ client, id, type }: GetParameters) => {
   const channel = client.channel(type, id);
   await channel.watch();
   return channel;

package/src/components/ChannelPreview/ChannelAvatar.tsx

@@ -6,13 +6,11 @@ import { useChannelPreviewDisplayPresence } from './hooks/useChannelPreviewDispl
 
 import { ChatContextValue, useChatContext } from '../../contexts/chatContext/ChatContext';
 import { useTheme } from '../../contexts/themeContext/ThemeContext';
-import type { DefaultStreamChatGenerics } from '../../types/types';
+
 import { Avatar } from '../Avatar/Avatar';
 import { GroupAvatar } from '../Avatar/GroupAvatar';
 
-export type ChannelAvatarProps<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = Pick<ChannelPreviewProps<StreamChatGenerics>, 'channel'> & {
+export type ChannelAvatarProps = Pick<ChannelPreviewProps, 'channel'> & {
   /**
    * The size of the avatar.
    */
@@ -22,10 +20,8 @@ export type ChannelAvatarProps<
 /**
  * This UI component displays an avatar for a particular channel.
  */
-export const ChannelAvatarWithContext = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  props: ChannelAvatarProps<StreamChatGenerics> & Pick<ChatContextValue, 'ImageComponent'>,
+export const ChannelAvatarWithContext = (
+  props: ChannelAvatarProps & Pick<ChatContextValue, 'ImageComponent'>,
 ) => {
   const { channel, ImageComponent, size: propSize } = props;
   const {
@@ -63,12 +59,8 @@ export const ChannelAvatarWithContext = <
   );
 };
 
-export const ChannelAvatar = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  props: ChannelAvatarProps<StreamChatGenerics>,
-) => {
-  const { ImageComponent } = useChatContext<StreamChatGenerics>();
+export const ChannelAvatar = (props: ChannelAvatarProps) => {
+  const { ImageComponent } = useChatContext();
 
   return <ChannelAvatarWithContext {...props} ImageComponent={ImageComponent} />;
 };

package/src/components/ChannelPreview/ChannelPreview.tsx

@@ -10,27 +10,19 @@ import {
 } from '../../contexts/channelsContext/ChannelsContext';
 import { ChatContextValue, useChatContext } from '../../contexts/chatContext/ChatContext';
 
-import type { DefaultStreamChatGenerics } from '../../types/types';
-
-export type ChannelPreviewProps<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = Partial<Pick<ChatContextValue<StreamChatGenerics>, 'client'>> &
-  Partial<Pick<ChannelsContextValue<StreamChatGenerics>, 'Preview' | 'forceUpdate'>> & {
+export type ChannelPreviewProps = Partial<Pick<ChatContextValue, 'client'>> &
+  Partial<Pick<ChannelsContextValue, 'Preview' | 'forceUpdate'>> & {
     /**
      * Instance of Channel from stream-chat package.
      */
-    channel: Channel<StreamChatGenerics>;
+    channel: Channel;
   };
 
-export const ChannelPreview = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  props: ChannelPreviewProps<StreamChatGenerics>,
-) => {
+export const ChannelPreview = (props: ChannelPreviewProps) => {
   const { channel, client: propClient, forceUpdate: propForceUpdate, Preview: propPreview } = props;
 
-  const { client: contextClient } = useChatContext<StreamChatGenerics>();
-  const { Preview: contextPreview } = useChannelsContext<StreamChatGenerics>();
+  const { client: contextClient } = useChatContext();
+  const { Preview: contextPreview } = useChannelsContext();
 
   const client = propClient || contextClient;
   const Preview = propPreview || contextPreview;

package/src/components/ChannelPreview/ChannelPreviewMessage.tsx

@@ -5,8 +5,6 @@ import type { LatestMessagePreview } from './hooks/useLatestMessagePreview';
 
 import { useTheme } from '../../contexts/themeContext/ThemeContext';
 
-import type { DefaultStreamChatGenerics } from '../../types/types';
-
 const styles = StyleSheet.create({
   bold: { fontWeight: '600' },
   message: {
@@ -15,20 +13,14 @@ const styles = StyleSheet.create({
   },
 });
 
-export type ChannelPreviewMessageProps<
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
-> = {
+export type ChannelPreviewMessageProps = {
   /**
    * Latest message on a channel, formatted for preview.
    */
-  latestMessagePreview: LatestMessagePreview<StreamChatGenerics>;
+  latestMessagePreview: LatestMessagePreview;
 };
 
-export const ChannelPreviewMessage = <
-  StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
->(
-  props: ChannelPreviewMessageProps<StreamChatGenerics>,
-) => {
+export const ChannelPreviewMessage = (props: ChannelPreviewMessageProps) => {
   const { latestMessagePreview } = props;
 
   const {