stream-chat-react 12.13.1 → 13.0.0-rc.1

package/dist/components/Message/MessageText.d.ts

@@ -1,10 +1,10 @@
 import React from 'react';
-import type { MessageContextValue, StreamMessage } from '../../context';
-import type { DefaultStreamChatGenerics } from '../../types/types';
-export type MessageTextProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+import type { LocalMessage } from 'stream-chat';
+import type { MessageContextValue } from '../../context';
+export type MessageTextProps = {
     customInnerClass?: string;
     customWrapperClass?: string;
-    message?: StreamMessage<StreamChatGenerics>;
+    message?: LocalMessage;
     theme?: string;
-} & Pick<MessageContextValue<StreamChatGenerics>, 'renderText'>;
-export declare const MessageText: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: MessageTextProps<StreamChatGenerics>) => React.JSX.Element | null;
+} & Pick<MessageContextValue, 'renderText'>;
+export declare const MessageText: (props: MessageTextProps) => React.JSX.Element | null;

package/dist/components/Message/MessageTimestamp.d.ts

@@ -1,9 +1,8 @@
 import React from 'react';
-import type { StreamMessage } from '../../context/ChannelStateContext';
+import type { LocalMessage } from 'stream-chat';
 import type { TimestampFormatterOptions } from '../../i18n/types';
-import type { DefaultStreamChatGenerics } from '../../types/types';
-export type MessageTimestampProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = TimestampFormatterOptions & {
+export type MessageTimestampProps = TimestampFormatterOptions & {
     customClass?: string;
-    message?: StreamMessage<StreamChatGenerics>;
+    message?: LocalMessage;
 };
-export declare const MessageTimestamp: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: MessageTimestampProps<StreamChatGenerics>) => React.JSX.Element;
+export declare const MessageTimestamp: (props: MessageTimestampProps) => React.JSX.Element;

package/dist/components/Message/QuotedMessage.d.ts

@@ -1,5 +1,4 @@
 import React from 'react';
 import type { MessageContextValue } from '../../context/MessageContext';
-export type QuotedMessageProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = Pick<MessageContextValue<StreamChatGenerics>, 'renderText'>;
-import type { DefaultStreamChatGenerics } from '../../types/types';
-export declare const QuotedMessage: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ renderText: propsRenderText, }: QuotedMessageProps) => React.JSX.Element | null;
+export type QuotedMessageProps = Pick<MessageContextValue, 'renderText'>;
+export declare const QuotedMessage: ({ renderText: propsRenderText }: QuotedMessageProps) => React.JSX.Element | null;

package/dist/components/Message/QuotedMessage.js

@@ -9,7 +9,7 @@ import { useMessageContext } from '../../context/MessageContext';
 import { useTranslationContext } from '../../context/TranslationContext';
 import { useChannelActionContext } from '../../context/ChannelActionContext';
 import { renderText as defaultRenderText } from './renderText';
-export const QuotedMessage = ({ renderText: propsRenderText, }) => {
+export const QuotedMessage = ({ renderText: propsRenderText }) => {
     const { Attachment = DefaultAttachment, Avatar: ContextAvatar } = useComponentContext('QuotedMessage');
     const { client } = useChatContext();
     const { isMyMessage, message, renderText: contextRenderText, } = useMessageContext('QuotedMessage');

package/dist/components/Message/StreamedMessageText.d.ts

@@ -1,8 +1,7 @@
 import React from 'react';
-import { MessageTextProps } from './MessageText';
-import type { DefaultStreamChatGenerics } from '../../types/types';
-export type StreamedMessageTextProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = Pick<MessageTextProps<StreamChatGenerics>, 'message' | 'renderText'> & {
+import type { MessageTextProps } from './MessageText';
+export type StreamedMessageTextProps = Pick<MessageTextProps, 'message' | 'renderText'> & {
     renderingLetterCount?: number;
     streamingLetterIntervalMs?: number;
 };
-export declare const StreamedMessageText: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: StreamedMessageTextProps<StreamChatGenerics>) => React.JSX.Element;
+export declare const StreamedMessageText: (props: StreamedMessageTextProps) => React.JSX.Element;

package/dist/components/Message/hooks/useActionHandler.d.ts

@@ -1,7 +1,6 @@
-import { StreamMessage } from '../../../context/ChannelStateContext';
 import type React from 'react';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
+import type { LocalMessage } from 'stream-chat';
 export type FormData = Record<string, string>;
 export type ActionHandlerReturnType = (dataOrName?: string | FormData, value?: string, event?: React.BaseSyntheticEvent) => Promise<void> | void;
 export declare const handleActionWarning = "Action handler was called, but it is missing one of its required arguments. \nMake sure the ChannelAction and ChannelState contexts are properly set and the hook is initialized with a valid message.";
-export declare function useActionHandler<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>): ActionHandlerReturnType;
+export declare function useActionHandler(message?: LocalMessage): ActionHandlerReturnType;

package/dist/components/Message/hooks/useActionHandler.js

@@ -1,5 +1,5 @@
 import { useChannelActionContext } from '../../../context/ChannelActionContext';
-import { useChannelStateContext, } from '../../../context/ChannelStateContext';
+import { useChannelStateContext } from '../../../context/ChannelStateContext';
 export const handleActionWarning = `Action handler was called, but it is missing one of its required arguments. 
 Make sure the ChannelAction and ChannelState contexts are properly set and the hook is initialized with a valid message.`;
 export function useActionHandler(message) {

package/dist/components/Message/hooks/useDeleteHandler.d.ts

@@ -1,8 +1,7 @@
+import type { LocalMessage } from 'stream-chat';
 import type { ReactEventHandler } from '../types';
-import type { StreamMessage } from '../../../context/ChannelStateContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export type DeleteMessageNotifications<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
-    getErrorNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
+export type DeleteMessageNotifications = {
+    getErrorNotification?: (message: LocalMessage) => string;
     notify?: (notificationText: string, type: 'success' | 'error') => void;
 };
-export declare const useDeleteHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>, notifications?: DeleteMessageNotifications<StreamChatGenerics>) => ReactEventHandler;
+export declare const useDeleteHandler: (message?: LocalMessage, notifications?: DeleteMessageNotifications) => ReactEventHandler;

package/dist/components/Message/hooks/useFlagHandler.d.ts

@@ -1,10 +1,9 @@
+import type { LocalMessage } from 'stream-chat';
 import type { ReactEventHandler } from '../types';
-import type { StreamMessage } from '../../../context/ChannelStateContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
 export declare const missingUseFlagHandlerParameterWarning = "useFlagHandler was called but it is missing one or more necessary parameters.";
-export type FlagMessageNotifications<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
-    getErrorNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
-    getSuccessNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
+export type FlagMessageNotifications = {
+    getErrorNotification?: (message: LocalMessage) => string;
+    getSuccessNotification?: (message: LocalMessage) => string;
     notify?: (notificationText: string, type: 'success' | 'error') => void;
 };
-export declare const useFlagHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>, notifications?: FlagMessageNotifications<StreamChatGenerics>) => ReactEventHandler;
+export declare const useFlagHandler: (message?: LocalMessage, notifications?: FlagMessageNotifications) => ReactEventHandler;

package/dist/components/Message/hooks/useMarkUnreadHandler.d.ts

@@ -1,9 +1,8 @@
-import type { StreamMessage } from '../../../context';
+import type { LocalMessage } from 'stream-chat';
 import type { ReactEventHandler } from '../types';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export type MarkUnreadHandlerNotifications<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
-    getErrorNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
-    getSuccessNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
+export type MarkUnreadHandlerNotifications = {
+    getErrorNotification?: (message: LocalMessage) => string;
+    getSuccessNotification?: (message: LocalMessage) => string;
     notify?: (notificationText: string, type: 'success' | 'error') => void;
 };
-export declare const useMarkUnreadHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>, notifications?: MarkUnreadHandlerNotifications<StreamChatGenerics>) => ReactEventHandler;
+export declare const useMarkUnreadHandler: (message?: LocalMessage, notifications?: MarkUnreadHandlerNotifications) => ReactEventHandler;

package/dist/components/Message/hooks/useMentionsHandler.d.ts

@@ -1,13 +1,11 @@
 import type React from 'react';
-import type { UserResponse } from 'stream-chat';
+import type { LocalMessage, UserResponse } from 'stream-chat';
 import type { ReactEventHandler } from '../types';
-import type { StreamMessage } from '../../../context/ChannelStateContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export type CustomMentionHandler<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = (event: React.BaseSyntheticEvent, mentioned_users: UserResponse<StreamChatGenerics>[]) => void;
-export type MentionedUserEventHandler<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = (event: React.BaseSyntheticEvent, mentionedUsers: UserResponse<StreamChatGenerics>[]) => void;
-export declare const useMentionsHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>, customMentionHandler?: {
-    onMentionsClick?: CustomMentionHandler<StreamChatGenerics>;
-    onMentionsHover?: CustomMentionHandler<StreamChatGenerics>;
+export type CustomMentionHandler = (event: React.BaseSyntheticEvent, mentioned_users: UserResponse[]) => void;
+export type MentionedUserEventHandler = (event: React.BaseSyntheticEvent, mentionedUsers: UserResponse[]) => void;
+export declare const useMentionsHandler: (message?: LocalMessage, customMentionHandler?: {
+    onMentionsClick?: CustomMentionHandler;
+    onMentionsHover?: CustomMentionHandler;
 }) => {
     onMentionsClick: ReactEventHandler;
     onMentionsHover: ReactEventHandler;

package/dist/components/Message/hooks/useMessageTextStreaming.d.ts

@@ -1,6 +1,5 @@
-import type { DefaultStreamChatGenerics } from '../../../types/types';
 import type { StreamedMessageTextProps } from '../StreamedMessageText';
-export type UseMessageTextStreamingProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = Pick<StreamedMessageTextProps<StreamChatGenerics>, 'streamingLetterIntervalMs' | 'renderingLetterCount'> & {
+export type UseMessageTextStreamingProps = Pick<StreamedMessageTextProps, 'streamingLetterIntervalMs' | 'renderingLetterCount'> & {
     text: string;
 };
 /**
@@ -11,6 +10,6 @@ export type UseMessageTextStreamingProps<StreamChatGenerics extends DefaultStrea
  * @param {string} text - The text that we want to render in a typewriter fashion.
  * @returns {{ streamedMessageText: string }} - A substring of the text property, up until we've finished rendering the typewriter animation.
  */
-export declare const useMessageTextStreaming: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ renderingLetterCount, streamingLetterIntervalMs, text, }: UseMessageTextStreamingProps<StreamChatGenerics>) => {
+export declare const useMessageTextStreaming: ({ renderingLetterCount, streamingLetterIntervalMs, text, }: UseMessageTextStreamingProps) => {
     streamedMessageText: string;
 };

package/dist/components/Message/hooks/useMuteHandler.d.ts

@@ -1,11 +1,9 @@
-import { StreamMessage } from '../../../context/ChannelStateContext';
-import type { UserResponse } from 'stream-chat';
+import type { LocalMessage, UserResponse } from 'stream-chat';
 import type { ReactEventHandler } from '../types';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
 export declare const missingUseMuteHandlerParamsWarning = "useMuteHandler was called but it is missing one or more necessary parameter.";
-export type MuteUserNotifications<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
-    getErrorNotification?: (user: UserResponse<StreamChatGenerics>) => string;
-    getSuccessNotification?: (user: UserResponse<StreamChatGenerics>) => string;
+export type MuteUserNotifications = {
+    getErrorNotification?: (user: UserResponse) => string;
+    getSuccessNotification?: (user: UserResponse) => string;
     notify?: (notificationText: string, type: 'success' | 'error') => void;
 };
-export declare const useMuteHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>, notifications?: MuteUserNotifications<StreamChatGenerics>) => ReactEventHandler;
+export declare const useMuteHandler: (message?: LocalMessage, notifications?: MuteUserNotifications) => ReactEventHandler;

package/dist/components/Message/hooks/useMuteHandler.js

@@ -1,5 +1,5 @@
 import { isUserMuted, validateAndGetMessage } from '../utils';
-import { useChannelStateContext, } from '../../../context/ChannelStateContext';
+import { useChannelStateContext } from '../../../context/ChannelStateContext';
 import { useChatContext } from '../../../context/ChatContext';
 import { useTranslationContext } from '../../../context/TranslationContext';
 export const missingUseMuteHandlerParamsWarning = 'useMuteHandler was called but it is missing one or more necessary parameter.';

package/dist/components/Message/hooks/useOpenThreadHandler.d.ts

@@ -1,4 +1,3 @@
+import type { LocalMessage } from 'stream-chat';
 import type { ReactEventHandler } from '../types';
-import type { StreamMessage } from '../../../context/ChannelStateContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useOpenThreadHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>, customOpenThread?: (message: StreamMessage<StreamChatGenerics>, event: React.BaseSyntheticEvent) => void) => ReactEventHandler;
+export declare const useOpenThreadHandler: (message?: LocalMessage, customOpenThread?: (message: LocalMessage, event: React.BaseSyntheticEvent) => void) => ReactEventHandler;

package/dist/components/Message/hooks/usePinHandler.d.ts

@@ -1,6 +1,5 @@
-import { StreamMessage } from '../../../context/ChannelStateContext';
+import type { LocalMessage } from 'stream-chat';
 import type { ReactEventHandler } from '../types';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
 export type PinEnabledUserRoles<T extends string = string> = Partial<Record<T, boolean>> & {
     admin?: boolean;
     anonymous?: boolean;
@@ -19,11 +18,11 @@ export type PinPermissions<T extends string = string, U extends string = string>
     messaging?: PinEnabledUserRoles<U>;
     team?: PinEnabledUserRoles<U>;
 };
-export type PinMessageNotifications<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
-    getErrorNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
+export type PinMessageNotifications = {
+    getErrorNotification?: (message: LocalMessage) => string;
     notify?: (notificationText: string, type: 'success' | 'error') => void;
 };
-export declare const usePinHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message: StreamMessage<StreamChatGenerics>, _permissions?: PinPermissions, notifications?: PinMessageNotifications<StreamChatGenerics>) => {
+export declare const usePinHandler: (message: LocalMessage, _permissions?: PinPermissions, notifications?: PinMessageNotifications) => {
     canPin: boolean;
     handlePin: ReactEventHandler;
 };

package/dist/components/Message/hooks/usePinHandler.js

@@ -1,6 +1,6 @@
 import { defaultPinPermissions, validateAndGetMessage } from '../utils';
 import { useChannelActionContext } from '../../../context/ChannelActionContext';
-import { useChannelStateContext, } from '../../../context/ChannelStateContext';
+import { useChannelStateContext } from '../../../context/ChannelStateContext';
 import { useChatContext } from '../../../context/ChatContext';
 import { useTranslationContext } from '../../../context/TranslationContext';
 export const usePinHandler = (message, 

package/dist/components/Message/hooks/useReactionHandler.d.ts

@@ -1,5 +1,4 @@
-import React from 'react';
-import { StreamMessage } from '../../../context/ChannelStateContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
+import type React from 'react';
+import type { LocalMessage } from 'stream-chat';
 export declare const reactionHandlerWarning = "Reaction handler was called, but it is missing one of its required arguments.\nMake sure the ChannelAction and ChannelState contexts are properly set and the hook is initialized with a valid message.";
-export declare const useReactionHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>) => (reactionType: string, event?: React.BaseSyntheticEvent) => Promise<void>;
+export declare const useReactionHandler: (message?: LocalMessage) => (reactionType: string, event?: React.BaseSyntheticEvent) => Promise<void>;

package/dist/components/Message/hooks/useReactionHandler.js

@@ -1,9 +1,9 @@
 import { useCallback } from 'react';
 import throttle from 'lodash.throttle';
+import { useThreadContext } from '../../Threads';
 import { useChannelActionContext } from '../../../context/ChannelActionContext';
-import { useChannelStateContext, } from '../../../context/ChannelStateContext';
+import { useChannelStateContext } from '../../../context/ChannelStateContext';
 import { useChatContext } from '../../../context/ChatContext';
-import { useThreadContext } from '../../Threads';
 export const reactionHandlerWarning = `Reaction handler was called, but it is missing one of its required arguments.
 Make sure the ChannelAction and ChannelState contexts are properly set and the hook is initialized with a valid message.`;
 export const useReactionHandler = (message) => {
@@ -69,7 +69,6 @@ export const useReactionHandler = (message) => {
         const tempMessage = createMessagePreview(add, newReaction, message);
         try {
             updateMessage(tempMessage);
-            // @ts-expect-error message type mismatch
             thread?.upsertReplyLocally({ message: tempMessage });
             const messageResponse = add
                 ? await channel.sendReaction(id, { type })
@@ -80,7 +79,6 @@ export const useReactionHandler = (message) => {
         catch (error) {
             // revert to the original message if the API call fails
             updateMessage(message);
-            // @ts-expect-error message type mismatch
             thread?.upsertReplyLocally({ message });
         }
     }, 1000);

package/dist/components/Message/hooks/useReactionsFetcher.d.ts

@@ -1,11 +1,9 @@
-import { StreamMessage } from '../../../context';
-import { DefaultStreamChatGenerics } from '../../../types/types';
-import { ReactionResponse, ReactionSort } from 'stream-chat';
-import { ReactionType } from '../../Reactions/types';
+import type { LocalMessage, ReactionResponse, ReactionSort } from 'stream-chat';
+import type { ReactionType } from '../../Reactions/types';
 export declare const MAX_MESSAGE_REACTIONS_TO_FETCH = 1000;
-type FetchMessageReactionsNotifications<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
-    getErrorNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
+type FetchMessageReactionsNotifications = {
+    getErrorNotification?: (message: LocalMessage) => string;
     notify?: (notificationText: string, type: 'success' | 'error') => void;
 };
-export declare function useReactionsFetcher<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message: StreamMessage<StreamChatGenerics>, notifications?: FetchMessageReactionsNotifications<StreamChatGenerics>): (reactionType?: ReactionType<StreamChatGenerics>, sort?: ReactionSort<StreamChatGenerics>) => Promise<ReactionResponse<DefaultStreamChatGenerics>[]>;
+export declare function useReactionsFetcher(message: LocalMessage, notifications?: FetchMessageReactionsNotifications): (reactionType?: ReactionType, sort?: ReactionSort) => Promise<ReactionResponse[]>;
 export {};

package/dist/components/Message/hooks/useRetryHandler.d.ts

@@ -1,3 +1,2 @@
-import { RetrySendMessage } from '../../../context/ChannelActionContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useRetryHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(customRetrySendMessage?: RetrySendMessage<StreamChatGenerics>) => RetrySendMessage<StreamChatGenerics>;
+import type { RetrySendMessage } from '../../../context/ChannelActionContext';
+export declare const useRetryHandler: (customRetrySendMessage?: RetrySendMessage) => RetrySendMessage;

package/dist/components/Message/hooks/useRetryHandler.js

@@ -1,4 +1,4 @@
-import { useChannelActionContext, } from '../../../context/ChannelActionContext';
+import { useChannelActionContext } from '../../../context/ChannelActionContext';
 export const useRetryHandler = (customRetrySendMessage) => {
     const { retrySendMessage: contextRetrySendMessage } = useChannelActionContext('useRetryHandler');
     const retrySendMessage = customRetrySendMessage || contextRetrySendMessage;

package/dist/components/Message/hooks/useUserHandler.d.ts

@@ -1,12 +1,11 @@
 /// <reference types="react" />
 import type { User } from 'stream-chat';
 import type { ReactEventHandler } from '../types';
-import type { StreamMessage } from '../../../context/ChannelStateContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export type UserEventHandler<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = (event: React.BaseSyntheticEvent, user: User<StreamChatGenerics>) => void;
-export declare const useUserHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>, eventHandlers?: {
-    onUserClickHandler?: UserEventHandler<StreamChatGenerics>;
-    onUserHoverHandler?: UserEventHandler<StreamChatGenerics>;
+import type { LocalMessage } from 'stream-chat';
+export type UserEventHandler = (event: React.BaseSyntheticEvent, user: User) => void;
+export declare const useUserHandler: (message?: LocalMessage, eventHandlers?: {
+    onUserClickHandler?: UserEventHandler;
+    onUserHoverHandler?: UserEventHandler;
 }) => {
     onUserClick: ReactEventHandler;
     onUserHover: ReactEventHandler;

package/dist/components/Message/hooks/useUserRole.d.ts

@@ -1,6 +1,5 @@
-import { StreamMessage } from '../../../context/ChannelStateContext';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useUserRole: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message: StreamMessage<StreamChatGenerics>, onlySenderCanEdit?: boolean, disableQuotedMessages?: boolean) => {
+import type { LocalMessage } from 'stream-chat';
+export declare const useUserRole: (message: LocalMessage, onlySenderCanEdit?: boolean, disableQuotedMessages?: boolean) => {
     canDelete: boolean;
     canEdit: boolean;
     canFlag: boolean;

package/dist/components/Message/hooks/useUserRole.js

@@ -1,4 +1,4 @@
-import { useChannelStateContext, } from '../../../context/ChannelStateContext';
+import { useChannelStateContext } from '../../../context/ChannelStateContext';
 import { useChatContext } from '../../../context/ChatContext';
 export const useUserRole = (message, onlySenderCanEdit, disableQuotedMessages) => {
     const { channel, channelCapabilities = {} } = useChannelStateContext('useUserRole');

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

@@ -1,10 +1,10 @@
 import React from 'react';
 import type { PinIndicatorProps } from './types';
-import type { DefaultStreamChatGenerics, IconProps } from '../../types/types';
+import type { IconProps } from '../../types/types';
 export declare const ActionsIcon: ({ className }: IconProps) => React.JSX.Element;
 export declare const ReactionIcon: ({ className }: IconProps) => React.JSX.Element;
 export declare const ThreadIcon: ({ className }: IconProps) => React.JSX.Element;
 export declare const PinIcon: () => React.JSX.Element;
-export declare const PinIndicator: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ message, t, }: PinIndicatorProps<StreamChatGenerics>) => React.JSX.Element | null;
+export declare const PinIndicator: ({ message, t }: PinIndicatorProps) => React.JSX.Element | null;
 export declare const MessageDeliveredIcon: () => React.JSX.Element;
 export declare const MessageErrorIcon: () => React.JSX.Element;

package/dist/components/Message/icons.js

@@ -9,7 +9,7 @@ export const ThreadIcon = ({ className = '' }) => (React.createElement("svg", {
     React.createElement("path", { d: 'M8.516 3c4.78 0 4.972 6.5 4.972 6.5-1.6-2.906-2.847-3.184-4.972-3.184v2.872L3.772 4.994 8.516.5V3zM.484 5l4.5-4.237v1.78L2.416 5l2.568 2.125v1.828L.484 5z', fillRule: 'evenodd' })));
 export const PinIcon = () => (React.createElement("svg", { height: '13', viewBox: '0 0 14 13', width: '14', xmlns: 'http://www.w3.org/2000/svg' },
     React.createElement("path", { d: 'M13.3518 6.686L6.75251 0.0866699L5.80984 1.02867L6.75318 1.972V1.97334L3.45318 5.272L3.45251 5.27334L2.50984 4.32934L1.56718 5.27267L4.39584 8.10067L0.624512 11.8713L1.56718 12.814L5.33851 9.04334L8.16718 11.8713L9.10984 10.9293L8.16718 9.986L11.4672 6.686L12.4098 7.62867L13.3518 6.686ZM7.22451 9.04267L7.22385 9.04334L4.39584 6.21467L7.69518 2.91467L10.5232 5.74267L7.22451 9.04267Z', fillRule: 'evenodd' })));
-export const PinIndicator = ({ message, t, }) => {
+export const PinIndicator = ({ message, t }) => {
     if (!message || !t)
         return null;
     return (React.createElement("div", { style: { alignItems: 'center', display: 'flex' } },

package/dist/components/Message/renderText/componentRenderers/Anchor.d.ts

@@ -1,2 +1,3 @@
-import React, { ComponentProps } from 'react';
+import type { ComponentProps } from 'react';
+import React from 'react';
 export declare const Anchor: ({ children, href }: ComponentProps<'a'>) => React.JSX.Element;

package/dist/components/Message/renderText/componentRenderers/Emoji.d.ts

@@ -1,3 +1,3 @@
 import React from 'react';
-import { PropsWithChildrenOnly } from '../../../../types/types';
+import type { PropsWithChildrenOnly } from '../../../../types/types';
 export declare const Emoji: ({ children }: PropsWithChildrenOnly) => React.JSX.Element;

package/dist/components/Message/renderText/componentRenderers/Mention.d.ts

@@ -1,9 +1,9 @@
-import React, { PropsWithChildren } from 'react';
+import type { PropsWithChildren } from 'react';
+import React from 'react';
 import type { UserResponse } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../../types/types';
-export type MentionProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = PropsWithChildren<{
+export type MentionProps = PropsWithChildren<{
     node: {
-        mentionedUser: UserResponse<StreamChatGenerics>;
+        mentionedUser: UserResponse;
     };
 }>;
-export declare const Mention: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ children, node: { mentionedUser }, }: MentionProps<StreamChatGenerics>) => React.JSX.Element;
+export declare const Mention: ({ children, node: { mentionedUser } }: MentionProps) => React.JSX.Element;

package/dist/components/Message/renderText/componentRenderers/Mention.js

@@ -1,2 +1,2 @@
 import React from 'react';
-export const Mention = ({ children, node: { mentionedUser }, }) => (React.createElement("span", { className: 'str-chat__message-mention', "data-user-id": mentionedUser.id }, children));
+export const Mention = ({ children, node: { mentionedUser } }) => (React.createElement("span", { className: 'str-chat__message-mention', "data-user-id": mentionedUser.id }, children));

package/dist/components/Message/renderText/rehypePlugins/mentionsMarkdownPlugin.d.ts

@@ -1,4 +1,3 @@
 import type { Nodes } from 'hast-util-find-and-replace/lib';
 import type { UserResponse } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../../types';
-export declare const mentionsMarkdownPlugin: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(mentioned_users: UserResponse<StreamChatGenerics>[]) => () => (tree: Nodes) => void;
+export declare const mentionsMarkdownPlugin: (mentioned_users: UserResponse[]) => () => (tree: Nodes) => void;

package/dist/components/Message/renderText/renderText.d.ts

@@ -1,19 +1,19 @@
-import React, { ComponentType } from 'react';
-import { MentionProps } from './componentRenderers';
+import React from 'react';
+import type { ComponentType } from 'react';
 import type { Options } from 'react-markdown/lib';
 import type { UserResponse } from 'stream-chat';
 import type { PluggableList } from 'unified';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
+import type { MentionProps } from './componentRenderers';
 export type RenderTextPluginConfigurator = (defaultPlugins: PluggableList) => PluggableList;
 export declare const defaultAllowedTagNames: Array<keyof JSX.IntrinsicElements | 'emoji' | 'mention'>;
 export declare const markDownRenderers: RenderTextOptions['customMarkDownRenderers'];
-export type RenderTextOptions<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+export type RenderTextOptions = {
     allowedTagNames?: Array<keyof JSX.IntrinsicElements | 'emoji' | 'mention' | (string & {})>;
     customMarkDownRenderers?: Options['components'] & Partial<{
         emoji: ComponentType;
-        mention: ComponentType<MentionProps<StreamChatGenerics>>;
+        mention: ComponentType<MentionProps>;
     }>;
     getRehypePlugins?: RenderTextPluginConfigurator;
     getRemarkPlugins?: RenderTextPluginConfigurator;
 };
-export declare const renderText: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(text?: string, mentionedUsers?: UserResponse<StreamChatGenerics>[], { allowedTagNames, customMarkDownRenderers, getRehypePlugins, getRemarkPlugins, }?: RenderTextOptions) => React.JSX.Element | null;
+export declare const renderText: (text?: string, mentionedUsers?: UserResponse[], { allowedTagNames, customMarkDownRenderers, getRehypePlugins, getRemarkPlugins, }?: RenderTextOptions) => React.JSX.Element | null;

package/dist/components/Message/renderText/types.d.ts

@@ -1,2 +1,2 @@
-import { Content, Root } from 'hast';
+import type { Content, Root } from 'hast';
 export type HNode = Content | Root;

package/dist/components/Message/types.d.ts

@@ -3,27 +3,26 @@ import type { ReactNode } from 'react';
 import type { ReactionSort, UserResponse } from 'stream-chat';
 import type { PinPermissions, UserEventHandler } from './hooks';
 import type { MessageActionsArray } from './utils';
+import type { LocalMessage } from 'stream-chat';
 import type { GroupStyle } from '../MessageList/utils';
 import type { MessageInputProps } from '../MessageInput/MessageInput';
 import type { ReactionDetailsComparator, ReactionsComparator } from '../Reactions/types';
 import type { ChannelActionContextValue } from '../../context/ChannelActionContext';
-import type { StreamMessage } from '../../context/ChannelStateContext';
 import type { ComponentContextValue } from '../../context/ComponentContext';
 import type { MessageContextValue } from '../../context/MessageContext';
 import type { RenderTextOptions } from './renderText';
-import type { CustomTrigger, DefaultStreamChatGenerics } from '../../types/types';
 export type ReactEventHandler = (event: React.BaseSyntheticEvent) => Promise<void> | void;
-export type MessageProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics, V extends CustomTrigger = CustomTrigger> = {
+export type MessageProps = {
     /** The message object */
-    message: StreamMessage<StreamChatGenerics>;
+    message: LocalMessage;
     /** Additional props for underlying MessageInput component, [available props](https://getstream.io/chat/docs/sdk/react/message-input-components/message_input/#props) */
-    additionalMessageInputProps?: MessageInputProps<StreamChatGenerics, V>;
+    additionalMessageInputProps?: MessageInputProps;
     /** Call this function to keep message list scrolled to the bottom when the scroll height increases, e.g. an element appears below the last message (only used in the `VirtualizedMessageList`) */
     autoscrollToBottom?: () => void;
     /** If true, picking a reaction from the `ReactionSelector` component will close the selector */
     closeReactionSelectorOnClick?: boolean;
     /** Object containing custom message actions and function handlers */
-    customMessageActions?: MessageContextValue<StreamChatGenerics>['customMessageActions'];
+    customMessageActions?: MessageContextValue['customMessageActions'];
     /** If true, disables the ability for users to quote messages, defaults to false */
     disableQuotedMessages?: boolean;
     /** When true, the message is the last one in a group sent by a specific user (only used in the `VirtualizedMessageList`) */
@@ -33,23 +32,23 @@ export type MessageProps<StreamChatGenerics extends DefaultStreamChatGenerics =
     /** Override the default formatting of the date. This is a function that has access to the original date object, returns a string  */
     formatDate?: (date: Date) => string;
     /** Function that returns the notification text to be displayed when a delete message request fails */
-    getDeleteMessageErrorNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
+    getDeleteMessageErrorNotification?: (message: LocalMessage) => string;
     /** Function that returns the notification text to be displayed when loading message reactions fails */
-    getFetchReactionsErrorNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
+    getFetchReactionsErrorNotification?: (message: LocalMessage) => string;
     /** Function that returns the notification text to be displayed when a flag message request fails */
-    getFlagMessageErrorNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
+    getFlagMessageErrorNotification?: (message: LocalMessage) => string;
     /** Function that returns the notification text to be displayed when a flag message request succeeds */
-    getFlagMessageSuccessNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
+    getFlagMessageSuccessNotification?: (message: LocalMessage) => string;
     /** Function that returns the notification text to be displayed when mark channel messages unread request fails */
-    getMarkMessageUnreadErrorNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
+    getMarkMessageUnreadErrorNotification?: (message: LocalMessage) => string;
     /** Function that returns the notification text to be displayed when mark channel messages unread request succeeds */
-    getMarkMessageUnreadSuccessNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
+    getMarkMessageUnreadSuccessNotification?: (message: LocalMessage) => string;
     /** Function that returns the notification text to be displayed when a mute user request fails */
-    getMuteUserErrorNotification?: (user: UserResponse<StreamChatGenerics>) => string;
+    getMuteUserErrorNotification?: (user: UserResponse) => string;
     /** Function that returns the notification text to be displayed when a mute user request succeeds */
-    getMuteUserSuccessNotification?: (user: UserResponse<StreamChatGenerics>) => string;
+    getMuteUserSuccessNotification?: (user: UserResponse) => string;
     /** Function that returns the notification text to be displayed when a pin message request fails */
-    getPinMessageErrorNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
+    getPinMessageErrorNotification?: (message: LocalMessage) => string;
     /** If true, group messages sent by each user (only used in the `VirtualizedMessageList`) */
     groupedByUser?: boolean;
     /** A list of styles to apply to this message, i.e. top, bottom, single */
@@ -61,7 +60,7 @@ export type MessageProps<StreamChatGenerics extends DefaultStreamChatGenerics =
     /** Latest message id on current channel */
     lastReceivedId?: string | null;
     /** UI component to display a Message in MessageList, overrides value in [ComponentContext](https://getstream.io/chat/docs/sdk/react/contexts/component_context/#message) */
-    Message?: ComponentContextValue<StreamChatGenerics>['Message'];
+    Message?: ComponentContextValue['Message'];
     /** Array of allowed message actions (ex: ['edit', 'delete', 'flag', 'mute', 'pin', 'quote', 'react', 'reply']). To disable all actions, provide an empty array. */
     messageActions?: MessageActionsArray;
     /** DOMRect object for parent MessageList component */
@@ -69,25 +68,25 @@ export type MessageProps<StreamChatGenerics extends DefaultStreamChatGenerics =
     /** If true, only the sender of the message has editing privileges */
     onlySenderCanEdit?: boolean;
     /** Custom mention click handler to override default in [ChannelActionContext](https://getstream.io/chat/docs/sdk/react/contexts/channel_action_context/) */
-    onMentionsClick?: ChannelActionContextValue<StreamChatGenerics>['onMentionsClick'];
+    onMentionsClick?: ChannelActionContextValue['onMentionsClick'];
     /** Custom mention hover handler to override default in [ChannelActionContext](https://getstream.io/chat/docs/sdk/react/contexts/channel_action_context/) */
-    onMentionsHover?: ChannelActionContextValue<StreamChatGenerics>['onMentionsHover'];
+    onMentionsHover?: ChannelActionContextValue['onMentionsHover'];
     /** Custom function to run on user avatar click */
-    onUserClick?: UserEventHandler<StreamChatGenerics>;
+    onUserClick?: UserEventHandler;
     /** Custom function to run on user avatar hover */
-    onUserHover?: UserEventHandler<StreamChatGenerics>;
+    onUserHover?: UserEventHandler;
     /** Custom open thread handler to override default in [ChannelActionContext](https://getstream.io/chat/docs/sdk/react/contexts/channel_action_context/) */
-    openThread?: ChannelActionContextValue<StreamChatGenerics>['openThread'];
+    openThread?: ChannelActionContextValue['openThread'];
     /** @deprecated in favor of `channelCapabilities - The user roles allowed to pin messages in various channel types */
     pinPermissions?: PinPermissions;
     /** Sort options to provide to a reactions query */
-    reactionDetailsSort?: ReactionSort<StreamChatGenerics>;
+    reactionDetailsSort?: ReactionSort;
     /** A list of users that have read this Message if the message is the last one and was posted by my user */
-    readBy?: UserResponse<StreamChatGenerics>[];
+    readBy?: UserResponse[];
     /** Custom function to render message text content, defaults to the renderText function: [utils](https://github.com/GetStream/stream-chat-react/blob/master/src/utils.ts) */
-    renderText?: (text?: string, mentioned_users?: UserResponse<StreamChatGenerics>[], options?: RenderTextOptions) => ReactNode;
+    renderText?: (text?: string, mentioned_users?: UserResponse[], options?: RenderTextOptions) => ReactNode;
     /** Custom retry send message handler to override default in [ChannelActionContext](https://getstream.io/chat/docs/sdk/react/contexts/channel_action_context/) */
-    retrySendMessage?: ChannelActionContextValue<StreamChatGenerics>['retrySendMessage'];
+    retrySendMessage?: ChannelActionContextValue['retrySendMessage'];
     /** Comparator function to sort the list of reacted users
      * @deprecated use `reactionDetailsSort` instead
      */
@@ -99,8 +98,8 @@ export type MessageProps<StreamChatGenerics extends DefaultStreamChatGenerics =
     /** render HTML instead of markdown. Posting HTML is only allowed server-side */
     unsafeHTML?: boolean;
 };
-export type MessageUIComponentProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = Partial<MessageContextValue<StreamChatGenerics>>;
-export type PinIndicatorProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
-    message?: StreamMessage<StreamChatGenerics>;
+export type MessageUIComponentProps = Partial<MessageContextValue>;
+export type PinIndicatorProps = {
+    message?: LocalMessage;
     t?: TFunction;
 };