stream-chat-react 12.15.0 → 13.0.0-rc.2

package/dist/components/ChannelPreview/ChannelPreview.d.ts

@@ -1,13 +1,12 @@
-import React, { ReactNode } from 'react';
-import { ChatContextValue } from '../../context/ChatContext';
-import { MessageDeliveryStatus } from './hooks/useMessageDeliveryStatus';
-import type { Channel } from 'stream-chat';
+import React from 'react';
+import type { ReactNode } from 'react';
+import type { Channel, LocalMessage } from 'stream-chat';
+import type { MessageDeliveryStatus } from './hooks/useMessageDeliveryStatus';
+import type { ChatContextValue } from '../../context/ChatContext';
 import type { ChannelAvatarProps } from '../Avatar/ChannelAvatar';
 import type { GroupChannelDisplayInfo } from './utils';
-import type { StreamMessage } from '../../context/ChannelStateContext';
 import type { TranslationContextValue } from '../../context/TranslationContext';
-import type { DefaultStreamChatGenerics } from '../../types/types';
-export type ChannelPreviewUIComponentProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = ChannelPreviewProps<StreamChatGenerics> & {
+export type ChannelPreviewUIComponentProps = ChannelPreviewProps & {
     /** Image of Channel to display */
     displayImage?: string;
     /** Title of Channel to display */
@@ -15,7 +14,7 @@ export type ChannelPreviewUIComponentProps<StreamChatGenerics extends DefaultStr
     /** Title of Channel to display */
     groupChannelDisplayInfo?: GroupChannelDisplayInfo;
     /** The last message received in a channel */
-    lastMessage?: StreamMessage<StreamChatGenerics>;
+    lastMessage?: LocalMessage;
     /** @deprecated Use latestMessagePreview prop instead. */
     latestMessage?: ReactNode;
     /** Latest message preview to display, will be a string or JSX element supporting markdown. */
@@ -25,32 +24,32 @@ export type ChannelPreviewUIComponentProps<StreamChatGenerics extends DefaultStr
     /** Number of unread Messages */
     unread?: number;
 };
-export type ChannelPreviewProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+export type ChannelPreviewProps = {
     /** Comes from either the `channelRenderFilterFn` or `usePaginatedChannels` call from [ChannelList](https://github.com/GetStream/stream-chat-react/blob/master/src/components/ChannelList/ChannelList.tsx) */
-    channel: Channel<StreamChatGenerics>;
+    channel: Channel;
     /** If the component's channel is the active (selected) Channel */
     active?: boolean;
     /** Current selected channel object */
-    activeChannel?: Channel<StreamChatGenerics>;
+    activeChannel?: Channel;
     /** UI component to display an avatar, defaults to [Avatar](https://github.com/GetStream/stream-chat-react/blob/master/src/components/Avatar/Avatar.tsx) component and accepts the same props as: [ChannelAvatar](https://github.com/GetStream/stream-chat-react/blob/master/src/components/Avatar/ChannelAvatar.tsx) */
-    Avatar?: React.ComponentType<ChannelAvatarProps<StreamChatGenerics>>;
+    Avatar?: React.ComponentType<ChannelAvatarProps>;
     /** Forces the update of preview component on channel update */
     channelUpdateCount?: number;
     /** Custom class for the channel preview root */
     className?: string;
     /** Custom function that generates the message preview in ChannelPreview component */
-    getLatestMessagePreview?: (channel: Channel<StreamChatGenerics>, t: TranslationContextValue['t'], userLanguage: TranslationContextValue['userLanguage']) => ReactNode;
+    getLatestMessagePreview?: (channel: Channel, t: TranslationContextValue['t'], userLanguage: TranslationContextValue['userLanguage'], isMessageAIGenerated: ChatContextValue['isMessageAIGenerated']) => ReactNode;
     key?: string;
     /** Custom ChannelPreview click handler function */
     onSelect?: (event: React.MouseEvent) => void;
     /** Custom UI component to display the channel preview in the list, defaults to and accepts same props as: [ChannelPreviewMessenger](https://github.com/GetStream/stream-chat-react/blob/master/src/components/ChannelPreview/ChannelPreviewMessenger.tsx) */
-    Preview?: React.ComponentType<ChannelPreviewUIComponentProps<StreamChatGenerics>>;
+    Preview?: React.ComponentType<ChannelPreviewUIComponentProps>;
     /** Setter for selected Channel */
-    setActiveChannel?: ChatContextValue<StreamChatGenerics>['setActiveChannel'];
+    setActiveChannel?: ChatContextValue['setActiveChannel'];
     /** Object containing watcher parameters */
     watchers?: {
         limit?: number;
         offset?: number;
     };
 };
-export declare const ChannelPreview: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: ChannelPreviewProps<StreamChatGenerics>) => React.JSX.Element | null;
+export declare const ChannelPreview: (props: ChannelPreviewProps) => React.JSX.Element | null;

package/dist/components/ChannelPreview/ChannelPreview.js

@@ -6,7 +6,7 @@ import { useChannelPreviewInfo } from './hooks/useChannelPreviewInfo';
 import { getLatestMessagePreview as defaultGetLatestMessagePreview } from './utils';
 import { useChatContext } from '../../context/ChatContext';
 import { useTranslationContext } from '../../context/TranslationContext';
-import { useMessageDeliveryStatus, } from './hooks/useMessageDeliveryStatus';
+import { useMessageDeliveryStatus } from './hooks/useMessageDeliveryStatus';
 export const ChannelPreview = (props) => {
     const { active, channel, channelUpdateCount, getLatestMessagePreview = defaultGetLatestMessagePreview, Preview = ChannelPreviewMessenger, } = props;
     const { channel: activeChannel, client, isMessageAIGenerated, setActiveChannel, } = useChatContext('ChannelPreview');

package/dist/components/ChannelPreview/ChannelPreviewActionButtons.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import type { Channel, ExtendableGenerics } from 'stream-chat';
-export type ChannelPreviewActionButtonsProps<SCG extends ExtendableGenerics> = {
-    channel: Channel<SCG>;
+import type { Channel } from 'stream-chat';
+export type ChannelPreviewActionButtonsProps = {
+    channel: Channel;
 };
-export declare function ChannelPreviewActionButtons<SCG extends ExtendableGenerics>({ channel, }: ChannelPreviewActionButtonsProps<SCG>): React.JSX.Element;
+export declare function ChannelPreviewActionButtons({ channel, }: ChannelPreviewActionButtonsProps): React.JSX.Element;

package/dist/components/ChannelPreview/ChannelPreviewMessenger.d.ts

@@ -1,8 +1,7 @@
 import React from 'react';
 import type { ChannelPreviewUIComponentProps } from './ChannelPreview';
-import type { DefaultStreamChatGenerics } from '../../types/types';
 /**
  * Used as preview component for channel item in [ChannelList](#channellist) component.
  * Its best suited for messenger type chat.
  */
-export declare const ChannelPreviewMessenger: <SCG extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: ChannelPreviewUIComponentProps<SCG>) => React.JSX.Element;
+export declare const ChannelPreviewMessenger: (props: ChannelPreviewUIComponentProps) => React.JSX.Element;

package/dist/components/ChannelPreview/hooks/useChannelPreviewInfo.d.ts

@@ -1,13 +1,12 @@
 import type { Channel } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export type ChannelPreviewInfoParams<StreamChatGenerics extends DefaultStreamChatGenerics> = {
-    channel: Channel<StreamChatGenerics>;
+export type ChannelPreviewInfoParams = {
+    channel: Channel;
     /** Manually set the image to render, defaults to the Channel image */
     overrideImage?: string;
     /** Set title manually */
     overrideTitle?: string;
 };
-export declare const useChannelPreviewInfo: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: ChannelPreviewInfoParams<StreamChatGenerics>) => {
+export declare const useChannelPreviewInfo: (props: ChannelPreviewInfoParams) => {
     displayImage: string | undefined;
     displayTitle: string | undefined;
     groupChannelDisplayInfo: import("../utils").GroupChannelDisplayInfo | undefined;

package/dist/components/ChannelPreview/hooks/useIsChannelMuted.d.ts

@@ -1,6 +1,5 @@
 import type { Channel } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useIsChannelMuted: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(channel: Channel<StreamChatGenerics>) => {
+export declare const useIsChannelMuted: (channel: Channel) => {
     createdAt: Date | null;
     expiresAt: Date | null;
     muted: boolean;

package/dist/components/ChannelPreview/hooks/useMessageDeliveryStatus.d.ts

@@ -1,16 +1,14 @@
-import type { Channel } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-import type { StreamMessage } from '../../../context';
+import type { Channel, LocalMessage } from 'stream-chat';
 export declare enum MessageDeliveryStatus {
     DELIVERED = "delivered",
     READ = "read"
 }
-type UseMessageStatusParamsChannelPreviewProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
-    channel: Channel<StreamChatGenerics>;
+type UseMessageStatusParamsChannelPreviewProps = {
+    channel: Channel;
     /** The last message received in a channel */
-    lastMessage?: StreamMessage<StreamChatGenerics>;
+    lastMessage?: LocalMessage;
 };
-export declare const useMessageDeliveryStatus: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ channel, lastMessage, }: UseMessageStatusParamsChannelPreviewProps<StreamChatGenerics>) => {
+export declare const useMessageDeliveryStatus: ({ channel, lastMessage, }: UseMessageStatusParamsChannelPreviewProps) => {
     messageDeliveryStatus: MessageDeliveryStatus | undefined;
 };
 export {};

package/dist/components/ChannelPreview/icons.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef } from 'react';
 export declare const Icon: {
     ArchiveBox: (props: ComponentPropsWithoutRef<'svg'>) => React.JSX.Element;
     Pin: (props: ComponentPropsWithoutRef<'svg'>) => React.JSX.Element;

package/dist/components/ChannelPreview/utils.d.ts

@@ -1,14 +1,14 @@
-import React, { ReactNode } from 'react';
+import React from 'react';
+import type { ReactNode } from 'react';
 import type { Channel, UserResponse } from 'stream-chat';
 import type { TranslationContextValue } from '../../context/TranslationContext';
-import type { DefaultStreamChatGenerics } from '../../types/types';
-import { ChatContextValue } from '../../context';
+import type { ChatContextValue } from '../../context';
 export declare const renderPreviewText: (text: string) => React.JSX.Element;
-export declare const getLatestMessagePreview: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(channel: Channel<StreamChatGenerics>, t: TranslationContextValue['t'], userLanguage?: TranslationContextValue['userLanguage'], isMessageAIGenerated?: ChatContextValue<StreamChatGenerics>['isMessageAIGenerated']) => ReactNode;
+export declare const getLatestMessagePreview: (channel: Channel, t: TranslationContextValue['t'], userLanguage?: TranslationContextValue['userLanguage'], isMessageAIGenerated?: ChatContextValue['isMessageAIGenerated']) => ReactNode;
 export type GroupChannelDisplayInfo = {
     image?: string;
     name?: string;
 }[];
-export declare const getGroupChannelDisplayInfo: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(channel: Channel<StreamChatGenerics>) => GroupChannelDisplayInfo | undefined;
-export declare const getDisplayTitle: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(channel: Channel<StreamChatGenerics>, currentUser?: UserResponse<StreamChatGenerics>) => string | undefined;
-export declare const getDisplayImage: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(channel: Channel<StreamChatGenerics>, currentUser?: UserResponse<StreamChatGenerics>) => string | undefined;
+export declare const getGroupChannelDisplayInfo: (channel: Channel) => GroupChannelDisplayInfo | undefined;
+export declare const getDisplayTitle: (channel: Channel, currentUser?: UserResponse) => string | undefined;
+export declare const getDisplayImage: (channel: Channel, currentUser?: UserResponse) => string | undefined;

package/dist/components/ChannelSearch/ChannelSearch.d.ts

@@ -1,19 +1,18 @@
 import React from 'react';
-import { ChannelSearchControllerParams } from './hooks/useChannelSearch';
+import type { ChannelSearchControllerParams } from './hooks/useChannelSearch';
 import type { AdditionalSearchBarProps, SearchBarProps } from './SearchBar';
-import { AdditionalSearchInputProps, SearchInputProps } from './SearchInput';
-import { AdditionalSearchResultsProps } from './SearchResults';
-import type { DefaultStreamChatGenerics } from '../../types/types';
+import type { AdditionalSearchInputProps, SearchInputProps } from './SearchInput';
+import type { AdditionalSearchResultsProps } from './SearchResults';
 export type AdditionalChannelSearchProps = {
     /** Custom UI component to display the search bar with text input */
     SearchBar?: React.ComponentType<SearchBarProps>;
     /** Custom UI component to display the search text input */
     SearchInput?: React.ComponentType<SearchInputProps>;
 };
-export type ChannelSearchProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = AdditionalSearchBarProps & AdditionalSearchInputProps & AdditionalSearchResultsProps<StreamChatGenerics> & AdditionalChannelSearchProps & ChannelSearchControllerParams<StreamChatGenerics>;
+export type ChannelSearchProps = AdditionalSearchBarProps & AdditionalSearchInputProps & AdditionalSearchResultsProps & AdditionalChannelSearchProps & ChannelSearchControllerParams;
 /**
  * The ChannelSearch component makes a query users call and displays the results in a list.
  * Clicking on a list item will navigate you into a channel with the selected user. It can be used
  * on its own or added to the ChannelList component by setting the `showChannelSearch` prop to true.
  */
-export declare const ChannelSearch: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: ChannelSearchProps<StreamChatGenerics>) => React.JSX.Element;
+export declare const ChannelSearch: (props: ChannelSearchProps) => React.JSX.Element;

package/dist/components/ChannelSearch/ChannelSearch.js

@@ -1,8 +1,8 @@
 import clsx from 'clsx';
 import React from 'react';
-import { useChannelSearch, } from './hooks/useChannelSearch';
+import { useChannelSearch } from './hooks/useChannelSearch';
 import { SearchBar as DefaultSearchBar } from './SearchBar';
-import { SearchInput as DefaultSearchInput, } from './SearchInput';
+import { SearchInput as DefaultSearchInput } from './SearchInput';
 import { SearchResults } from './SearchResults';
 const UnMemoizedChannelSearch = (props) => {
     const { AppMenu, ClearInputIcon, ExitSearchIcon, MenuIcon, placeholder, popupResults = false, SearchBar = DefaultSearchBar, SearchEmpty, SearchInput = DefaultSearchInput, SearchInputIcon, SearchLoading, SearchResultItem, SearchResultsHeader, SearchResultsList, ...channelSearchParams } = props;

package/dist/components/ChannelSearch/SearchBar.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { SearchInputProps } from './SearchInput';
+import type { SearchInputProps } from './SearchInput';
 export type AppMenuProps = {
     close?: () => void;
 };

package/dist/components/ChannelSearch/SearchBar.js

@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useRef, useState, } from 'react';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
 import clsx from 'clsx';
 import { MenuIcon as DefaultMenuIcon, SearchIcon as DefaultSearchInputIcon, ReturnIcon, XIcon, } from './icons';
 import { SearchInput as DefaultSearchInput } from './SearchInput';

package/dist/components/ChannelSearch/SearchResults.d.ts

@@ -1,21 +1,20 @@
 import React from 'react';
-import { ChannelOrUserResponse } from './utils';
-import type { DefaultStreamChatGenerics } from '../../types/types';
-export type SearchResultsHeaderProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = Pick<SearchResultsProps<StreamChatGenerics>, 'results'>;
-export type SearchResultsListProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = Required<Pick<SearchResultsProps<StreamChatGenerics>, 'results' | 'SearchResultItem' | 'selectResult'>> & {
+import type { ChannelOrUserResponse } from './utils';
+export type SearchResultsHeaderProps = Pick<SearchResultsProps, 'results'>;
+export type SearchResultsListProps = Required<Pick<SearchResultsProps, 'results' | 'SearchResultItem' | 'selectResult'>> & {
     focusedUser?: number;
 };
-export type SearchResultItemProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = Pick<SearchResultsProps<StreamChatGenerics>, 'selectResult'> & {
+export type SearchResultItemProps = Pick<SearchResultsProps, 'selectResult'> & {
     index: number;
-    result: ChannelOrUserResponse<StreamChatGenerics>;
+    result: ChannelOrUserResponse;
     focusedUser?: number;
 };
-export type SearchResultsController<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
-    results: Array<ChannelOrUserResponse<StreamChatGenerics>>;
+export type SearchResultsController = {
+    results: Array<ChannelOrUserResponse>;
     searching: boolean;
-    selectResult: (result: ChannelOrUserResponse<StreamChatGenerics>) => Promise<void> | void;
+    selectResult: (result: ChannelOrUserResponse) => Promise<void> | void;
 };
-export type AdditionalSearchResultsProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+export type AdditionalSearchResultsProps = {
     /** Display search results as an absolutely positioned popup, defaults to false and shows inline */
     popupResults?: boolean;
     /** Custom UI component to display empty search results */
@@ -23,11 +22,11 @@ export type AdditionalSearchResultsProps<StreamChatGenerics extends DefaultStrea
     /** Custom UI component to display the search loading state */
     SearchLoading?: React.ComponentType;
     /** Custom UI component to display a search result list item, defaults to and accepts the same props as: [DefaultSearchResultItem](https://github.com/GetStream/stream-chat-react/blob/master/src/components/ChannelSearch/SearchResults.tsx) */
-    SearchResultItem?: React.ComponentType<SearchResultItemProps<StreamChatGenerics>>;
+    SearchResultItem?: React.ComponentType<SearchResultItemProps>;
     /** Custom UI component to display the search results header */
     SearchResultsHeader?: React.ComponentType;
     /** Custom UI component to display all the search results, defaults to and accepts the same props as: [DefaultSearchResultsList](https://github.com/GetStream/stream-chat-react/blob/master/src/components/ChannelSearch/SearchResults.tsx)  */
-    SearchResultsList?: React.ComponentType<SearchResultsListProps<StreamChatGenerics>>;
+    SearchResultsList?: React.ComponentType<SearchResultsListProps>;
 };
-export type SearchResultsProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = AdditionalSearchResultsProps<StreamChatGenerics> & SearchResultsController<StreamChatGenerics>;
-export declare const SearchResults: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: SearchResultsProps<StreamChatGenerics>) => React.JSX.Element;
+export type SearchResultsProps = AdditionalSearchResultsProps & SearchResultsController;
+export declare const SearchResults: (props: SearchResultsProps) => React.JSX.Element;

package/dist/components/ChannelSearch/SearchResults.js

@@ -11,7 +11,7 @@ const DefaultSearchEmpty = () => {
         React.createElement(SearchIcon, null),
         t('No results found')));
 };
-const DefaultSearchResultsHeader = ({ results, }) => {
+const DefaultSearchResultsHeader = ({ results }) => {
     const { t } = useTranslationContext('SearchResultsHeader');
     return (React.createElement("div", { className: 'str-chat__channel-search-results-header', "data-testid": 'channel-search-results-header' }, t('searchResultsCount', {
         count: results.length,

package/dist/components/ChannelSearch/hooks/useChannelSearch.d.ts

@@ -1,29 +1,28 @@
-import React from 'react';
-import { ChannelOrUserResponse } from '../utils';
+import type React from 'react';
+import type { ChannelOrUserResponse } from '../utils';
 import type { Channel, ChannelFilters, ChannelOptions, ChannelSort, UserFilters, UserOptions, UserSort } from 'stream-chat';
 import type { SearchBarController } from '../SearchBar';
 import type { SearchInputController } from '../SearchInput';
 import type { SearchResultsController } from '../SearchResults';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export type ChannelSearchFunctionParams<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+export type ChannelSearchFunctionParams = {
     setQuery: React.Dispatch<React.SetStateAction<string>>;
-    setResults: React.Dispatch<React.SetStateAction<ChannelOrUserResponse<StreamChatGenerics>[]>>;
+    setResults: React.Dispatch<React.SetStateAction<ChannelOrUserResponse[]>>;
     setSearching: React.Dispatch<React.SetStateAction<boolean>>;
 };
-export type SearchController<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = SearchInputController & SearchBarController & SearchResultsController<StreamChatGenerics>;
-export type SearchQueryParams<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+export type SearchController = SearchInputController & SearchBarController & SearchResultsController;
+export type SearchQueryParams = {
     channelFilters?: {
-        filters?: ChannelFilters<StreamChatGenerics>;
+        filters?: ChannelFilters;
         options?: ChannelOptions;
-        sort?: ChannelSort<StreamChatGenerics>;
+        sort?: ChannelSort;
     };
     userFilters?: {
-        filters?: UserFilters<StreamChatGenerics> | ((query: string) => UserFilters<StreamChatGenerics>);
+        filters?: UserFilters | ((query: string) => UserFilters);
         options?: UserOptions;
-        sort?: UserSort<StreamChatGenerics>;
+        sort?: UserSort;
     };
 };
-export type ChannelSearchParams<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+export type ChannelSearchParams = {
     /** The type of channel to create on user result select, defaults to `messaging` */
     channelType?: string;
     /** Clear search state / results on every click outside the search input, defaults to true */
@@ -35,7 +34,7 @@ export type ChannelSearchParams<StreamChatGenerics extends DefaultStreamChatGene
     /** Callback invoked when the search UI is deactivated */
     onSearchExit?: () => void;
     /** Custom handler function to run on search result item selection */
-    onSelectResult?: (params: ChannelSearchFunctionParams<StreamChatGenerics>, result: ChannelOrUserResponse<StreamChatGenerics>) => Promise<void> | void;
+    onSelectResult?: (params: ChannelSearchFunctionParams, result: ChannelOrUserResponse) => Promise<void> | void;
     /** The number of milliseconds to debounce the search query. The default interval is 200ms. */
     searchDebounceIntervalMs?: number;
     /** Boolean to search for channels in the server query, default is false and just searches for users */
@@ -43,12 +42,12 @@ export type ChannelSearchParams<StreamChatGenerics extends DefaultStreamChatGene
     /** Boolean to search for users in the server query, default is true and just searches for users */
     searchForUsers?: boolean;
     /** Custom search function to override the default implementation */
-    searchFunction?: (params: ChannelSearchFunctionParams<StreamChatGenerics>, event: React.BaseSyntheticEvent) => Promise<void> | void;
+    searchFunction?: (params: ChannelSearchFunctionParams, event: React.BaseSyntheticEvent) => Promise<void> | void;
     /** Object containing filters/sort/options overrides for user / channel search */
-    searchQueryParams?: SearchQueryParams<StreamChatGenerics>;
+    searchQueryParams?: SearchQueryParams;
 };
-export type ChannelSearchControllerParams<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = ChannelSearchParams<StreamChatGenerics> & {
+export type ChannelSearchControllerParams = ChannelSearchParams & {
     /** Set the array of channels displayed in the ChannelList */
-    setChannels?: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>;
+    setChannels?: React.Dispatch<React.SetStateAction<Array<Channel>>>;
 };
-export declare const useChannelSearch: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ channelType, clearSearchOnClickOutside, disabled, onSearch: onSearchCallback, onSearchExit, onSelectResult, searchDebounceIntervalMs, searchForChannels, searchForUsers, searchFunction, searchQueryParams, setChannels, }: ChannelSearchControllerParams<StreamChatGenerics>) => SearchController<StreamChatGenerics>;
+export declare const useChannelSearch: ({ channelType, clearSearchOnClickOutside, disabled, onSearch: onSearchCallback, onSearchExit, onSelectResult, searchDebounceIntervalMs, searchForChannels, searchForUsers, searchFunction, searchQueryParams, setChannels, }: ChannelSearchControllerParams) => SearchController;

package/dist/components/ChannelSearch/hooks/useChannelSearch.js

@@ -103,18 +103,14 @@ export const useChannelSearch = ({ channelType = 'messaging', clearSearchOnClick
         const promises = [];
         try {
             if (searchForChannels) {
-                promises.push(client.queryChannels(
-                // @ts-expect-error valid query
-                {
+                promises.push(client.queryChannels({
                     members: { $in: [client.userID] },
                     name: { $autocomplete: text },
                     ...searchQueryParams?.channelFilters?.filters,
                 }, searchQueryParams?.channelFilters?.sort || {}, { limit: 5, ...searchQueryParams?.channelFilters?.options }));
             }
             if (searchForUsers) {
-                promises.push(client.queryUsers(
-                // @ts-expect-error valid query
-                {
+                promises.push(client.queryUsers({
                     $or: [{ id: { $autocomplete: text } }, { name: { $autocomplete: text } }],
                     ...searchQueryParams?.userFilters?.filters,
                 }, { id: 1, ...searchQueryParams?.userFilters?.sort }, { limit: 8, ...searchQueryParams?.userFilters?.options }));

package/dist/components/ChannelSearch/utils.d.ts

@@ -1,4 +1,3 @@
 import type { Channel, UserResponse } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../types/types';
-export type ChannelOrUserResponse<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = Channel<StreamChatGenerics> | UserResponse<StreamChatGenerics>;
-export declare const isChannel: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(output: ChannelOrUserResponse<StreamChatGenerics>) => output is Channel<StreamChatGenerics>;
+export type ChannelOrUserResponse = Channel | UserResponse;
+export declare const isChannel: (output: ChannelOrUserResponse) => output is Channel;

package/dist/components/Chat/Chat.d.ts

@@ -1,14 +1,14 @@
-import React, { PropsWithChildren } from 'react';
-import type { StreamChat } from 'stream-chat';
+import React from 'react';
 import { SearchController } from 'stream-chat';
-import { CustomClasses } from '../../context/ChatContext';
+import type { PropsWithChildren } from 'react';
+import type { StreamChat } from 'stream-chat';
+import type { CustomClasses } from '../../context/ChatContext';
 import type { MessageContextValue } from '../../context';
 import type { SupportedTranslations } from '../../i18n/types';
 import type { Streami18n } from '../../i18n/Streami18n';
-import type { DefaultStreamChatGenerics } from '../../types/types';
-export type ChatProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+export type ChatProps = {
     /** The StreamChat client object */
-    client: StreamChat<StreamChatGenerics>;
+    client: StreamChat;
     /** Object containing custom CSS classnames to override the library's default container CSS */
     customClasses?: CustomClasses;
     /** Sets the default fallback language for UI component translation, defaults to 'en' for English */
@@ -18,7 +18,7 @@ export type ChatProps<StreamChatGenerics extends DefaultStreamChatGenerics = Def
     /** Initial status of mobile navigation */
     initialNavOpen?: boolean;
     /** Instance of SearchController class that allows to control all the search operations. */
-    searchController?: SearchController<StreamChatGenerics>;
+    searchController?: SearchController;
     /** Used for injecting className/s to the Channel and ChannelList components */
     theme?: string;
     /**
@@ -29,9 +29,9 @@ export type ChatProps<StreamChatGenerics extends DefaultStreamChatGenerics = Def
      * Note: requires importing `stream-chat-react/css/v2/emoji-replacement.css` style sheet
      */
     useImageFlagEmojisOnWindows?: boolean;
-} & Partial<Pick<MessageContextValue<StreamChatGenerics>, 'isMessageAIGenerated'>>;
+} & Partial<Pick<MessageContextValue, 'isMessageAIGenerated'>>;
 /**
  * Wrapper component for a StreamChat application. Chat needs to be placed around any other chat components
  * as it provides the ChatContext.
  */
-export declare const Chat: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: PropsWithChildren<ChatProps<StreamChatGenerics>>) => React.JSX.Element | null;
+export declare const Chat: (props: PropsWithChildren<ChatProps>) => React.JSX.Element | null;

package/dist/components/Chat/hooks/useChannelsQueryState.d.ts

@@ -1,4 +1,4 @@
-import { Dispatch, SetStateAction } from 'react';
+import type { Dispatch, SetStateAction } from 'react';
 import type { APIErrorResponse, ErrorFromResponse } from 'stream-chat';
 type ChannelQueryState = 'uninitialized' | 'reload' | 'load-more' | null;
 export interface ChannelsQueryState {

package/dist/components/Chat/hooks/useChat.d.ts

@@ -1,22 +1,22 @@
-import { TranslationContextValue } from '../../../context/TranslationContext';
-import { Streami18n, SupportedTranslations } from '../../../i18n';
+import type { TranslationContextValue } from '../../../context/TranslationContext';
+import type { SupportedTranslations } from '../../../i18n';
+import { Streami18n } from '../../../i18n';
 import type { AppSettingsAPIResponse, Channel, Mute, StreamChat } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export type UseChatParams<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
-    client: StreamChat<StreamChatGenerics>;
+export type UseChatParams = {
+    client: StreamChat;
     defaultLanguage?: SupportedTranslations;
     i18nInstance?: Streami18n;
     initialNavOpen?: boolean;
 };
-export declare const useChat: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ client, defaultLanguage, i18nInstance, initialNavOpen, }: UseChatParams<StreamChatGenerics>) => {
-    channel: Channel<StreamChatGenerics> | undefined;
+export declare const useChat: ({ client, defaultLanguage, i18nInstance, initialNavOpen, }: UseChatParams) => {
+    channel: Channel | undefined;
     closeMobileNav: () => void;
-    getAppSettings: () => Promise<AppSettingsAPIResponse<StreamChatGenerics>>;
+    getAppSettings: () => Promise<AppSettingsAPIResponse>;
     latestMessageDatesByChannels: {};
-    mutes: Mute<StreamChatGenerics>[];
+    mutes: Mute[];
     navOpen: boolean | undefined;
     openMobileNav: () => NodeJS.Timeout;
-    setActiveChannel: (activeChannel?: Channel<StreamChatGenerics>, watchers?: {
+    setActiveChannel: (activeChannel?: Channel, watchers?: {
         limit?: number;
         offset?: number;
     }, event?: React.BaseSyntheticEvent) => Promise<void>;

package/dist/components/Chat/hooks/useChat.js

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
-import { defaultDateTimeParser, isLanguageSupported, Streami18n, } from '../../../i18n';
+import { defaultDateTimeParser, isLanguageSupported, Streami18n } from '../../../i18n';
 export const useChat = ({ client, defaultLanguage = 'en', i18nInstance, initialNavOpen, }) => {
     const [translators, setTranslators] = useState({
         t: (key) => key,
@@ -10,7 +10,7 @@ export const useChat = ({ client, defaultLanguage = 'en', i18nInstance, initialN
     const [mutes, setMutes] = useState([]);
     const [navOpen, setNavOpen] = useState(initialNavOpen);
     const [latestMessageDatesByChannels, setLatestMessageDatesByChannels] = useState({});
-    const clientMutes = client.user?.mutes || [];
+    const clientMutes = client.user?.mutes ?? [];
     const closeMobileNav = () => setNavOpen(false);
     const openMobileNav = () => setTimeout(() => setNavOpen(true), 100);
     const appSettings = useRef(null);
@@ -24,7 +24,7 @@ export const useChat = ({ client, defaultLanguage = 'en', i18nInstance, initialN
     useEffect(() => {
         if (!client)
             return;
-        const version = "12.15.0";
+        const version = "13.0.0-rc.2";
         const userAgent = client.getUserAgent();
         if (!userAgent.includes('stream-chat-react')) {
             // result looks like: 'stream-chat-react-2.3.2-stream-chat-javascript-client-browser-2.2.2'

package/dist/components/Chat/hooks/useCreateChatClient.d.ts

@@ -1,11 +1,11 @@
 import { StreamChat } from 'stream-chat';
-import type { DefaultGenerics, ExtendableGenerics, OwnUserResponse, StreamChatOptions, TokenOrProvider, UserResponse } from 'stream-chat';
+import type { OwnUserResponse, StreamChatOptions, TokenOrProvider, UserResponse } from 'stream-chat';
 /**
  * React hook to create, connect and return `StreamChat` client.
  */
-export declare const useCreateChatClient: <SCG extends ExtendableGenerics = DefaultGenerics>({ apiKey, options, tokenOrProvider, userData, }: {
+export declare const useCreateChatClient: ({ apiKey, options, tokenOrProvider, userData, }: {
     apiKey: string;
     tokenOrProvider: TokenOrProvider;
-    userData: OwnUserResponse<SCG> | UserResponse<SCG>;
+    userData: OwnUserResponse | UserResponse;
     options?: StreamChatOptions;
-}) => StreamChat<SCG> | null;
+}) => StreamChat | null;

package/dist/components/Chat/hooks/useCreateChatContext.d.ts

@@ -1,3 +1,2 @@
 import type { ChatContextValue } from '../../../context/ChatContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useCreateChatContext: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(value: ChatContextValue<StreamChatGenerics>) => ChatContextValue<StreamChatGenerics>;
+export declare const useCreateChatContext: (value: ChatContextValue) => ChatContextValue;

package/dist/components/Dialog/DialogAnchor.d.ts

@@ -1,5 +1,6 @@
-import { Placement } from '@popperjs/core';
-import React, { ComponentProps, PropsWithChildren } from 'react';
+import type { Placement } from '@popperjs/core';
+import type { ComponentProps, PropsWithChildren } from 'react';
+import React from 'react';
 export interface DialogAnchorOptions {
     open: boolean;
     placement: Placement;
@@ -21,4 +22,4 @@ export type DialogAnchorProps = PropsWithChildren<Partial<DialogAnchorOptions>>
     focus?: boolean;
     trapFocus?: boolean;
 } & ComponentProps<'div'>;
-export declare const DialogAnchor: ({ children, className, focus, id, placement, referenceElement, trapFocus, ...restDivProps }: DialogAnchorProps) => React.JSX.Element | null;
+export declare const DialogAnchor: ({ children, className, focus, id, placement, referenceElement, tabIndex, trapFocus, ...restDivProps }: DialogAnchorProps) => React.JSX.Element | null;

package/dist/components/Dialog/DialogAnchor.js

@@ -37,7 +37,7 @@ export function useDialogAnchor({ open, placement, referenceElement, }) {
         styles,
     };
 }
-export const DialogAnchor = ({ children, className, focus = true, id, placement = 'auto', referenceElement = null, trapFocus, ...restDivProps }) => {
+export const DialogAnchor = ({ children, className, focus = true, id, placement = 'auto', referenceElement = null, tabIndex, trapFocus, ...restDivProps }) => {
     const dialog = useDialog({ id });
     const open = useDialogIsOpen(id);
     const { attributes, setPopperElement, styles } = useDialogAnchor({
@@ -64,5 +64,5 @@ export const DialogAnchor = ({ children, className, focus = true, id, placement
     }
     return (React.createElement(DialogPortalEntry, { dialogId: id },
         React.createElement(FocusScope, { autoFocus: focus, contain: trapFocus, restoreFocus: true },
-            React.createElement("div", { ...restDivProps, ...attributes.popper, className: clsx('str-chat__dialog-contents', className), "data-testid": 'str-chat__dialog-contents', ref: setPopperElement, style: styles.popper, tabIndex: 0 }, children))));
+            React.createElement("div", { ...restDivProps, ...attributes.popper, className: clsx('str-chat__dialog-contents', className), "data-testid": 'str-chat__dialog-contents', ref: setPopperElement, style: styles.popper, tabIndex: typeof tabIndex !== 'undefined' ? tabIndex : 0 }, children))));
 };

package/dist/components/Dialog/DialogMenu.d.ts

@@ -1,3 +1,4 @@
-import React, { ComponentProps } from 'react';
+import type { ComponentProps } from 'react';
+import React from 'react';
 export type DialogMenuButtonProps = ComponentProps<'button'>;
 export declare const DialogMenuButton: ({ children, className, ...props }: DialogMenuButtonProps) => React.JSX.Element;

package/dist/components/Dialog/DialogPortal.d.ts

@@ -1,4 +1,5 @@
-import React, { PropsWithChildren } from 'react';
+import type { PropsWithChildren } from 'react';
+import React from 'react';
 export declare const DialogPortalDestination: () => React.JSX.Element;
 type DialogPortalEntryProps = {
     dialogId: string;

package/dist/components/Dialog/FormDialog.d.ts

@@ -1,4 +1,5 @@
-import React, { ComponentProps } from 'react';
+import type { ComponentProps } from 'react';
+import React from 'react';
 type FormElements = 'input' | 'textarea';
 type FieldId = string;
 type Validator = (value: string | readonly string[] | number | boolean | undefined) => Error | undefined;

package/dist/components/Dialog/FormDialog.js

@@ -1,4 +1,4 @@
-import React, { useCallback, useState, } from 'react';
+import React, { useCallback, useState } from 'react';
 import clsx from 'clsx';
 import { FieldError } from '../Form/FieldError';
 import { useTranslationContext } from '../../context';