botframework-webchat-api 4.15.1 → 4.15.2-main.20220413.af6e8a3

package/src/StyleOptions.ts

@@ -1,4 +1,4 @@
-import { DirectLineActivity } from 'botframework-webchat-core';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 type StyleOptions = {
   /**
@@ -675,7 +675,7 @@ type StyleOptions = {
    */
   groupTimestamp?: boolean | number;
 
-  sendTimeout?: number | ((activity: DirectLineActivity) => number);
+  sendTimeout?: number | ((activity: WebChatActivity) => number);
   sendTimeoutForAttachments?: number;
 
   /**

package/src/hooks/Composer.tsx

@@ -2,18 +2,14 @@ import { Provider } from 'react-redux';
 import PropTypes from 'prop-types';
 import React, { FC, ReactNode, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import updateIn from 'simple-update-in';
-
 import {
   clearSuggestedActions,
   connect as createConnectAction,
   createStore,
-  DirectLineActivity,
-  DirectLineJSBotConnection,
   disconnect,
   dismissNotification,
   emitTypingIndicator,
   markActivity,
-  OneOrMany,
   postActivity,
   sendEvent,
   sendFiles,
@@ -34,6 +30,7 @@ import {
   stopSpeakingActivity,
   submitSendBox
 } from 'botframework-webchat-core';
+import type { DirectLineJSBotConnection, OneOrMany, WebChatActivity } from 'botframework-webchat-core';
 
 import { default as WebChatAPIContext } from './internal/WebChatAPIContext';
 import ActivityAcknowledgementComposer from '../providers/ActivityAcknowledgement/ActivityAcknowledgementComposer';
@@ -199,7 +196,7 @@ type ComposerCoreProps = {
   overrideLocalizedStrings?: LocalizedStrings | ((strings: LocalizedStrings, language: string) => LocalizedStrings);
   renderMarkdown?: (markdown: string, { markdownRespectCRLF: boolean }, { externalLinkAlt: string }) => string;
   scrollToEndButtonMiddleware?: OneOrMany<ScrollToEndButtonMiddleware>;
-  selectVoice?: (voices: typeof window.SpeechSynthesisVoice[], activity: DirectLineActivity) => void;
+  selectVoice?: (voices: typeof window.SpeechSynthesisVoice[], activity: WebChatActivity) => void;
   sendTypingIndicator?: boolean;
   styleOptions?: StyleOptions;
   toastMiddleware?: OneOrMany<ToastMiddleware>;
@@ -666,6 +663,8 @@ ComposerCore.propTypes = {
   cardActionMiddleware: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.func), PropTypes.func]),
   children: PropTypes.any,
   dir: PropTypes.oneOf(['auto', 'ltr', 'rtl']),
+  // PropTypes.shape({ ... }) did not honor isRequired for its members.
+  // @ts-ignore
   directLine: PropTypes.shape({
     activity$: PropTypes.shape({
       subscribe: PropTypes.func.isRequired

package/src/hooks/internal/WebChatAPIContext.ts

@@ -1,5 +1,5 @@
 import { createContext } from 'react';
-import { DirectLineActivity, DirectLineJSBotConnection } from 'botframework-webchat-core';
+import type { DirectLineJSBotConnection, WebChatActivity } from 'botframework-webchat-core';
 
 import { AttachmentForScreenReaderComponentFactory } from '../../types/AttachmentForScreenReaderMiddleware';
 import { AvatarComponentFactory } from '../../types/AvatarMiddleware';
@@ -38,10 +38,10 @@ type WebChatAPIContext = {
   markActivity?: ({ id: string }, name: string, value?: any) => void;
   onCardAction?: PerformCardAction;
   onTelemetry?: (event: TelemetryMeasurementEvent) => void;
-  postActivity?: (activity: DirectLineActivity) => Observable<string>;
+  postActivity?: (activity: WebChatActivity) => Observable<string>;
   renderMarkdown?: (markdown: string, { markdownRespectCRLF: boolean }, { externalLinkAlt: string }) => string;
   scrollToEndButtonRenderer?: ScrollToEndButtonComponentFactory;
-  selectVoice?: (voices: typeof window.SpeechSynthesisVoice[], activity: DirectLineActivity) => void;
+  selectVoice?: (voices: typeof window.SpeechSynthesisVoice[], activity: WebChatActivity) => void;
   sendEvent?: (name: string, value: any) => void;
   sendFiles?: (files: File[]) => void;
   sendMessage?: (text: string, method?: string, { channelData }?: { channelData?: any }) => void;

package/src/hooks/middleware/createDefaultGroupActivitiesMiddleware.ts

@@ -1,9 +1,10 @@
-import { Constants, DirectLineActivity } from 'botframework-webchat-core';
+import { Constants } from 'botframework-webchat-core';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import GroupActivitiesMiddleware from '../../types/GroupActivitiesMiddleware';
 
 const {
-  ActivityClientState: { SENT }
+  ActivityClientState: { SENDING, SEND_FAILED, SENT }
 } = Constants;
 
 function bin<T>(items: T[], grouping: (last: T, current: T) => boolean): T[][] {
@@ -25,13 +26,24 @@ function bin<T>(items: T[], grouping: (last: T, current: T) => boolean): T[][] {
   return bins;
 }
 
-function sending(activity: DirectLineActivity): boolean {
-  return activity.from.role === 'user' && activity.channelData && activity.channelData.state !== SENT;
+function sending(activity) {
+  if (activity.from.role === 'user') {
+    const state = activity.channelData?.state;
+
+    switch (state) {
+      case SENDING:
+      case SEND_FAILED:
+        return state;
+
+      default:
+        return SENT;
+    }
+  }
 }
 
 function shouldGroupTimestamp(
-  activityX: DirectLineActivity,
-  activityY: DirectLineActivity,
+  activityX: WebChatActivity,
+  activityY: WebChatActivity,
   groupTimestamp: boolean | number
 ): boolean {
   if (groupTimestamp === false) {

package/src/hooks/useActiveTyping.ts

@@ -10,15 +10,17 @@ function useActiveTyping(expireAfter?: number): [{ [userId: string]: Typing }] {
 
   const [{ typingAnimationDuration }] = useStyleOptions();
   const forceRender = useForceRender();
-  const typing: { [userId: string]: { at: number; name: string; role: string } } = useSelector(({ typing }) => typing);
+  const typing: { [userId: string]: { at: number; last: number; name: string; role: string } } = useSelector(
+    ({ typing }) => typing
+  );
 
   if (typeof expireAfter !== 'number') {
     expireAfter = typingAnimationDuration;
   }
 
   const activeTyping: { [userId: string]: Typing } = Object.entries(typing).reduce(
-    (activeTyping, [id, { at, name, role }]) => {
-      const until = at + expireAfter;
+    (activeTyping, [id, { at, last, name, role }]) => {
+      const until = last + expireAfter;
 
       if (until > now) {
         return { ...activeTyping, [id]: { at, expireAt: until, name, role } };

package/src/hooks/useActivities.ts

@@ -1,7 +1,7 @@
-import { DirectLineActivity } from 'botframework-webchat-core';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import { useSelector } from './internal/WebChatReduxContext';
 
-export default function useActivities(): [DirectLineActivity[]] {
+export default function useActivities(): [WebChatActivity[]] {
   return [useSelector(({ activities }) => activities)];
 }

package/src/hooks/useCreateActivityStatusRenderer.tsx

@@ -1,10 +1,11 @@
 /* eslint react/prop-types: "off" */
 /* eslint react/require-default-props: "off" */
 
-import { Constants, DirectLineActivity } from 'botframework-webchat-core';
-import React, { ReactNode, useMemo } from 'react';
+import { Constants } from 'botframework-webchat-core';
+import PropTypes from 'prop-types';
+import React, { ReactNode, useMemo, VFC } from 'react';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
-import SendState from '../types/SendState';
 import useGetSendTimeoutForActivity from './useGetSendTimeoutForActivity';
 import useTimePassed from './internal/useTimePassed';
 import useWebChatAPIContext from './internal/useWebChatAPIContext';
@@ -13,32 +14,48 @@ const {
   ActivityClientState: { SEND_FAILED, SENDING, SENT }
 } = Constants;
 
-const ActivityStatusContainer = ({ activity, hideTimestamp, nextVisibleActivity }) => {
+type ActivityStatusContainerProps = {
+  activity: WebChatActivity;
+  hideTimestamp: boolean;
+  nextVisibleActivity: WebChatActivity;
+};
+
+const ActivityStatusContainer: VFC<ActivityStatusContainerProps> = ({
+  activity,
+  hideTimestamp,
+  nextVisibleActivity
+}) => {
   const { activityStatusRenderer: createActivityStatusRenderer } = useWebChatAPIContext();
   const getSendTimeoutForActivity = useGetSendTimeoutForActivity();
 
   // SEND_FAILED from the activity is ignored, and is instead based on styleOptions.sendTimeout.
   // Note that the derived state is time-sensitive. The useTimePassed() hook is used to make sure it changes over time.
   const {
-    channelData: { clientTimestamp = 0, state } = {},
     from: { role }
-  }: {
-    channelData: {
-      clientTimestamp?: number;
-      state?: SendState;
-    };
-    from: {
-      role: string;
-    };
-  } = activity;
-
-  const activitySent = state !== SENDING && state !== SEND_FAILED;
+  }: WebChatActivity = activity;
+
   const fromUser = role === 'user';
-  const sendTimeout = getSendTimeoutForActivity({ activity });
+  let activitySent: boolean;
+  let sendTimeoutAt: number;
+
+  if (fromUser) {
+    const state = activity.channelData?.state;
+    const sendTimeout = getSendTimeoutForActivity({ activity });
+
+    activitySent = state !== SENDING && state !== SEND_FAILED;
 
-  const pastTimeout = useTimePassed(fromUser && !activitySent ? new Date(clientTimestamp).getTime() + sendTimeout : 0);
+    // If no timestamp, we assume the "sending" will be timed out as "send failed".
+    sendTimeoutAt = !activitySent
+      ? new Date(activity.localTimestamp || new Date(0).toISOString()).getTime() + sendTimeout
+      : 0;
+  } else {
+    activitySent = true;
+    sendTimeoutAt = 0;
+  }
 
-  const sendState = activitySent || !fromUser ? SENT : pastTimeout ? SEND_FAILED : SENDING;
+  const pastTimeout = useTimePassed(sendTimeoutAt);
+
+  const sendState = activitySent ? SENT : pastTimeout ? SEND_FAILED : SENDING;
 
   return useMemo(
     () =>
@@ -53,13 +70,30 @@ const ActivityStatusContainer = ({ activity, hideTimestamp, nextVisibleActivity
   );
 };
 
+ActivityStatusContainer.defaultProps = {
+  hideTimestamp: false,
+  nextVisibleActivity: undefined
+};
+
+ActivityStatusContainer.propTypes = {
+  // PropTypes cannot fully capture TypeScript types.
+  // @ts-ignore
+  activity: PropTypes.shape({
+    channelData: PropTypes.shape({ state: PropTypes.string }),
+    from: PropTypes.shape({ role: PropTypes.string }).isRequired,
+    localTimestamp: PropTypes.string
+  }).isRequired,
+  hideTimestamp: PropTypes.bool,
+  nextVisibleActivity: PropTypes.any
+};
+
 export default function useCreateActivityStatusRenderer(): (renderOptions: {
-  activity: DirectLineActivity;
-  nextVisibleActivity: DirectLineActivity;
+  activity: WebChatActivity;
+  nextVisibleActivity: WebChatActivity;
 }) => (props: { hideTimestamp?: boolean }) => ReactNode {
   return useMemo(
     () =>
-      ({ activity, nextVisibleActivity }: { activity: DirectLineActivity; nextVisibleActivity: DirectLineActivity }) =>
+      ({ activity, nextVisibleActivity }: { activity: WebChatActivity; nextVisibleActivity: WebChatActivity }) =>
       ({ hideTimestamp }: { hideTimestamp?: boolean } = {}) =>
         (
           <ActivityStatusContainer

package/src/hooks/useCreateAvatarRenderer.ts

@@ -1,5 +1,5 @@
-import { DirectLineActivity } from 'botframework-webchat-core';
 import { useMemo } from 'react';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import { AvatarComponentFactory } from '../types/AvatarMiddleware';
 import useStyleOptions from './useStyleOptions';
@@ -8,7 +8,7 @@ import useWebChatAPIContext from './internal/useWebChatAPIContext';
 export default function useCreateAvatarRenderer(): ({
   activity
 }: {
-  activity: DirectLineActivity;
+  activity: WebChatActivity;
 }) => AvatarComponentFactory {
   const [styleOptions] = useStyleOptions();
   const { avatarRenderer } = useWebChatAPIContext();

package/src/hooks/useGetSendTimeoutForActivity.ts

@@ -1,9 +1,9 @@
-import { DirectLineActivity } from 'botframework-webchat-core';
 import { useMemo } from 'react';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import useStyleOptions from './useStyleOptions';
 
-export default function useGetSendTimeoutForActivity(): ({ activity }: { activity: DirectLineActivity }) => number {
+export default function useGetSendTimeoutForActivity(): ({ activity }: { activity: WebChatActivity }) => number {
   const [{ sendTimeout, sendTimeoutForAttachments }] = useStyleOptions();
 
   return useMemo(
@@ -13,7 +13,7 @@ export default function useGetSendTimeoutForActivity(): ({ activity }: { activit
           return sendTimeout(activity);
         }
 
-        return activity.attachments && activity.attachments.length ? sendTimeoutForAttachments : sendTimeout;
+        return activity.type === 'message' && activity.attachments?.length ? sendTimeoutForAttachments : sendTimeout;
       },
     [sendTimeout, sendTimeoutForAttachments]
   );

package/src/hooks/useGroupActivities.ts

@@ -1,10 +1,10 @@
-import { DirectLineActivity } from 'botframework-webchat-core';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import useWebChatAPIContext from './internal/useWebChatAPIContext';
 
-export default function useGroupActivities(): ({ activities }: { activities: DirectLineActivity[] }) => {
-  sender: DirectLineActivity[][];
-  status: DirectLineActivity[][];
+export default function useGroupActivities(): ({ activities }: { activities: WebChatActivity[] }) => {
+  sender: WebChatActivity[][];
+  status: WebChatActivity[][];
 } {
   return useWebChatAPIContext().groupActivities;
 }

package/src/hooks/useMarkActivityAsSpoken.ts

@@ -1,9 +1,9 @@
-import { DirectLineActivity } from 'botframework-webchat-core';
 import { useCallback } from 'react';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import useMarkActivity from './internal/useMarkActivity';
 
-export default function useMarkActivityAsSpoken(): (activity: DirectLineActivity) => void {
+export default function useMarkActivityAsSpoken(): (activity: WebChatActivity) => void {
   const markActivity = useMarkActivity();
 
   return useCallback(activity => markActivity(activity, 'speak', false), [markActivity]);

package/src/hooks/usePostActivity.ts

@@ -1,8 +1,8 @@
-import { DirectLineActivity } from 'botframework-webchat-core';
 import Observable from 'core-js/features/observable';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import useWebChatAPIContext from './internal/useWebChatAPIContext';
 
-export default function usePostActivity(): (activity: DirectLineActivity) => Observable<string> {
+export default function usePostActivity(): (activity: WebChatActivity) => Observable<string> {
   return useWebChatAPIContext().postActivity;
 }

package/src/hooks/useSendFiles.ts

@@ -5,7 +5,14 @@ import { useCallback } from 'react';
 import useTrackEvent from './useTrackEvent';
 import useWebChatAPIContext from './internal/useWebChatAPIContext';
 
-export default function useSendFiles(): (files: File[]) => void {
+type PostActivityFile = {
+  name: string;
+  size: number;
+  thumbnail?: string;
+  url: string;
+};
+
+export default function useSendFiles(): (files: PostActivityFile[]) => void {
   const { sendFiles } = useWebChatAPIContext();
   const trackEvent = useTrackEvent();
 

package/src/hooks/useSendTimeoutForActivity.ts

@@ -1,11 +1,11 @@
-import { DirectLineActivity } from 'botframework-webchat-core';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import useGetSendTimeoutForActivity from './useGetSendTimeoutForActivity';
 
 let showDeprecationNotes = true;
 
 /** @deprecated Please use "useGetSendTimeoutForActivity()" instead. */
-export default function useSendTimeoutForActivity(activity: DirectLineActivity) {
+export default function useSendTimeoutForActivity(activity: WebChatActivity) {
   if (showDeprecationNotes) {
     console.warn(
       'botframework-webchat: "useSendTimeoutForActivity" is deprecated and will be removed on or after 2022-07-28. Please use "useGetSendTimeoutForActivity()" instead.'

package/src/hooks/useSuggestedActions.ts

@@ -1,5 +1,5 @@
-import { DirectLineSuggestedAction } from 'botframework-webchat-core';
 import { useCallback } from 'react';
+import type { DirectLineSuggestedAction } from 'botframework-webchat-core';
 
 import { useSelector } from './internal/WebChatReduxContext';
 import useWebChatAPIContext from './internal/useWebChatAPIContext';

package/src/hooks/useTimeoutForSend.ts

@@ -1,8 +1,8 @@
-import { DirectLineActivity } from 'botframework-webchat-core';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import useStyleOptions from './useStyleOptions';
 
-export default function useTimeoutForSend(): [number | ((activity: DirectLineActivity) => number)] {
+export default function useTimeoutForSend(): [number | ((activity: WebChatActivity) => number)] {
   const [{ sendTimeout }] = useStyleOptions();
 
   return [sendTimeout];

package/src/localization/en-US.json

@@ -18,7 +18,7 @@
   "ACTIVITY_YOU_ATTACHED_ALT": "You attached:",
   "_ACTIVITY_YOU_ATTACHED_ALT.comment": "This is for screen reader and is narrated before each attachments sent by the user.",
   "ACTIVITY_NUM_ATTACHMENTS_ONE_ALT": "1 attachment.",
-  "_ACTIVITY_NUM_ATTACHMENTS_OONE_ALT.comment": "This is for screen reader and only narrated when the message arrive. The narration when the message arrive, could be \"Bot WC said: Hello, World! 1 attachment. Sent at 2020-01-02 12:34 PM.\". This is for plural rule of \"one\".",
+  "_ACTIVITY_NUM_ATTACHMENTS_ONE_ALT.comment": "This is for screen reader and only narrated when the message arrive. The narration when the message arrive, could be \"Bot WC said: Hello, World! 1 attachment. Sent at 2020-01-02 12:34 PM.\". This is for plural rule of \"one\".",
   "ACTIVITY_NUM_ATTACHMENTS_FEW_ALT": "$1 attachments.",
   "_ACTIVITY_NUM_ATTACHMENTS_FEW_ALT.comment": "$1 is the number of attachments. This is for plural rule of \"few\".",
   "ACTIVITY_NUM_ATTACHMENTS_MANY_ALT": "$1 attachments.",
@@ -137,5 +137,8 @@
   "TRANSCRIPT_NEW_MESSAGES": "New messages",
   "TRANSCRIPT_TERMINATOR_TEXT": "End of chat history",
   "TYPING_INDICATOR_ALT": "Showing typing indicator",
-  "_TYPING_INDICATOR_ALT.comment": "This is for screen reader for the label that will be narrated when the other party is typing a message."
+  "_TYPING_INDICATOR_SINGLE_TEXT.comment": "This shows when a single user is typing.",
+  "TYPING_INDICATOR_SINGLE_TEXT": "$1 is typing.",
+  "_TYPING_INDICATOR_MULTIPLE_TEXT.comment": "This shows when two or more users are typing simultaneously.",
+  "TYPING_INDICATOR_MULTIPLE_TEXT": "$1 and others are typing."
 }

package/src/providers/ActivityKeyer/ActivityKeyerComposer.tsx

@@ -1,8 +1,7 @@
 import PropTypes from 'prop-types';
 import React, { useCallback, useMemo, useRef } from 'react';
-
-import type { DirectLineActivity } from 'botframework-webchat-core';
 import type { FC } from 'react';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import ActivityKeyerContext, { ActivityKeyerContextType } from './private/Context';
 import getActivityId from './private/getActivityId';
@@ -12,9 +11,9 @@ import useActivities from '../../hooks/useActivities';
 import useActivityKeyerContext from './private/useContext';
 
 type ActivityIdToKeyMap = Map<string, string>;
-type ActivityToKeyMap = Map<DirectLineActivity, string>;
+type ActivityToKeyMap = Map<WebChatActivity, string>;
 type ClientActivityIdToKeyMap = Map<string, string>;
-type KeyToActivityMap = Map<string, DirectLineActivity>;
+type KeyToActivityMap = Map<string, WebChatActivity>;
 
 /**
  * React context composer component to assign a perma-key to every activity.
@@ -80,13 +79,13 @@ const ActivityKeyerComposer: FC<{}> = ({ children }) => {
     return Object.freeze([Object.freeze(nextActivityKeys)]) as readonly [readonly string[]];
   }, [activities, activityIdToKeyMapRef, activityToKeyMapRef, clientActivityIdToKeyMapRef, keyToActivityMapRef]);
 
-  const getActivityByKey: (key?: string) => DirectLineActivity | undefined = useCallback(
-    (key?: string): DirectLineActivity | undefined => key && keyToActivityMapRef.current.get(key),
+  const getActivityByKey: (key?: string) => undefined | WebChatActivity = useCallback(
+    (key?: string): undefined | WebChatActivity => key && keyToActivityMapRef.current.get(key),
     [keyToActivityMapRef]
   );
 
-  const getKeyByActivity: (activity?: DirectLineActivity) => string | undefined = useCallback(
-    (activity?: DirectLineActivity) => activity && activityToKeyMapRef.current.get(activity),
+  const getKeyByActivity: (activity?: WebChatActivity) => string | undefined = useCallback(
+    (activity?: WebChatActivity) => activity && activityToKeyMapRef.current.get(activity),
     [activityToKeyMapRef]
   );
 

package/src/providers/ActivityKeyer/private/Context.ts

@@ -1,11 +1,10 @@
 import { createContext } from 'react';
-
-import type { DirectLineActivity } from 'botframework-webchat-core';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 type ActivityKeyerContextType = {
   activityKeysState: readonly [readonly string[]];
-  getActivityByKey: (key?: string) => DirectLineActivity | undefined;
-  getKeyByActivity: (activity?: DirectLineActivity) => string | undefined;
+  getActivityByKey: (key?: string) => undefined | WebChatActivity;
+  getKeyByActivity: (activity?: WebChatActivity) => string | undefined;
   getKeyByActivityId: (activityKey?: string) => string | undefined;
 };
 

package/src/providers/ActivityKeyer/private/getActivityId.ts

@@ -1,5 +1,5 @@
-import type { DirectLineActivity } from 'botframework-webchat-core';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
-export default function getActivityId(activity: DirectLineActivity): string {
+export default function getActivityId(activity: WebChatActivity): string {
   return activity.id;
 }

package/src/providers/ActivityKeyer/private/getClientActivityId.ts

@@ -1,5 +1,5 @@
-import type { DirectLineActivity } from 'botframework-webchat-core';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
-export default function getClientActivityId(activity: DirectLineActivity): string {
+export default function getClientActivityId(activity: WebChatActivity): string {
   return activity.channelData?.clientActivityID;
 }

package/src/providers/ActivityKeyer/useGetActivityByKey.ts

@@ -1,7 +1,7 @@
-import type { DirectLineActivity } from 'botframework-webchat-core';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import useActivityKeyerContext from './private/useContext';
 
-export default function useGetActivityByKey(): (key?: string) => DirectLineActivity | undefined {
+export default function useGetActivityByKey(): (key?: string) => undefined | WebChatActivity {
   return useActivityKeyerContext().getActivityByKey;
 }

package/src/providers/ActivityKeyer/useGetKeyByActivity.ts

@@ -1,7 +1,7 @@
-import type { DirectLineActivity } from 'botframework-webchat-core';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import useActivityKeyerContext from './private/useContext';
 
-export default function useGetKeyByActivity(): (activity?: DirectLineActivity) => string | undefined {
+export default function useGetKeyByActivity(): (activity?: WebChatActivity) => string | undefined {
   return useActivityKeyerContext().getKeyByActivity;
 }

package/src/types/ActivityMiddleware.ts

@@ -1,5 +1,5 @@
-import { DirectLineActivity } from 'botframework-webchat-core';
 import { ReactNode } from 'react';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import { AvatarComponentFactory } from './AvatarMiddleware';
 import { RenderAttachment } from './AttachmentMiddleware';
@@ -14,8 +14,8 @@ type ActivityProps = {
 type ActivityComponent = (props: ActivityProps) => Exclude<ReactNode, boolean>;
 
 type ActivityComponentFactoryOptions = {
-  activity: DirectLineActivity;
-  nextVisibleActivity: DirectLineActivity;
+  activity: WebChatActivity;
+  nextVisibleActivity: WebChatActivity;
 };
 
 type ActivityComponentFactory = (options: ActivityComponentFactoryOptions) => ActivityComponent | false;

package/src/types/ActivityStatusMiddleware.ts

@@ -1,17 +1,17 @@
-import { DirectLineActivity } from 'botframework-webchat-core';
 import { ReactNode } from 'react';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import SendState from './SendState';
 
 // TODO: Migrate this legacy middleware signature.
 type RenderActivityStatusOptions = {
-  activity: DirectLineActivity;
+  activity: WebChatActivity;
   hideTimestamp: boolean;
   sendState: SendState;
 
   // "nextVisibleActivity" is for backward compatibility, please remove this line on or after 2022-07-22.
   /** @deprecated */
-  nextVisibleActivity: DirectLineActivity;
+  nextVisibleActivity: WebChatActivity;
 
   // "sameTimestampGroup" is for backward compatibility, please remove this line on or after 2022-07-22.
   /** @deprecated */

package/src/types/AttachmentForScreenReaderMiddleware.ts

@@ -1,4 +1,4 @@
-import { DirectLineActivity, DirectLineAttachment } from 'botframework-webchat-core';
+import type { DirectLineAttachment, WebChatActivity } from 'botframework-webchat-core';
 
 // TODO: We should consider using a prop for "attachmentMiddleware" to render for screen reader, instead of having another middleware.
 
@@ -6,7 +6,7 @@ import ComponentMiddleware, { ComponentFactory } from './ComponentMiddleware';
 
 type AttachmentForScreenReaderComponentFactoryOptions = [
   {
-    activity: DirectLineActivity;
+    activity: WebChatActivity;
     attachment: DirectLineAttachment;
   }
 ];

package/src/types/AttachmentMiddleware.ts

@@ -1,8 +1,8 @@
-import { DirectLineActivity, DirectLineAttachment } from 'botframework-webchat-core';
 import { ReactNode } from 'react';
+import type { DirectLineAttachment, WebChatActivity } from 'botframework-webchat-core';
 
 type AttachmentProps = {
-  activity: DirectLineActivity;
+  activity: WebChatActivity;
   attachment: DirectLineAttachment;
 };
 

package/src/types/AvatarMiddleware.ts

@@ -1,11 +1,11 @@
-import { DirectLineActivity } from 'botframework-webchat-core';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import { StrictStyleOptions } from '../StyleOptions';
 import ComponentMiddleware, { ComponentFactory } from './ComponentMiddleware';
 
 type AvatarComponentFactoryArguments = [
   {
-    activity: DirectLineActivity;
+    activity: WebChatActivity;
     fromUser: boolean;
     styleOptions: StrictStyleOptions;
   }

package/src/types/CardActionMiddleware.ts

@@ -1,4 +1,4 @@
-import { DirectLineCardAction } from 'botframework-webchat-core';
+import type { DirectLineCardAction } from 'botframework-webchat-core';
 
 import FunctionMiddleware from './FunctionMiddleware';
 

package/src/types/GroupActivitiesMiddleware.ts

@@ -1,21 +1,21 @@
-import { DirectLineActivity } from 'botframework-webchat-core';
+import type { WebChatActivity } from 'botframework-webchat-core';
 
 import FunctionMiddleware, { CallFunction } from './FunctionMiddleware';
 
 type GroupActivities = CallFunction<
-  [{ activities: DirectLineActivity[] }],
+  [{ activities: WebChatActivity[] }],
   {
-    sender: DirectLineActivity[][];
-    status: DirectLineActivity[][];
+    sender: WebChatActivity[][];
+    status: WebChatActivity[][];
   }
 >;
 
 type GroupActivitiesMiddleware = FunctionMiddleware<
   [],
-  [{ activities: DirectLineActivity[] }],
+  [{ activities: WebChatActivity[] }],
   {
-    sender: DirectLineActivity[][];
-    status: DirectLineActivity[][];
+    sender: WebChatActivity[][];
+    status: WebChatActivity[][];
   }
 >;