botframework-webchat-api 4.13.0 → 4.15.0

package/src/hooks/Composer.tsx

@@ -3,23 +3,17 @@ import PropTypes from 'prop-types';
 import React, { FC, ReactNode, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import updateIn from 'simple-update-in';
 
-import createCustomEvent from '../utils/createCustomEvent';
-import ErrorBoundary from './utils/ErrorBoundary';
-import getAllLocalizedStrings from '../localization/getAllLocalizedStrings';
-import isObject from '../utils/isObject';
-import normalizeLanguage from '../utils/normalizeLanguage';
-// @ts-ignore
-import PrecompiledGlobalize from '../external/PrecompiledGlobalize';
-import StyleOptions from '../StyleOptions';
-
 import {
   clearSuggestedActions,
   connect as createConnectAction,
   createStore,
+  DirectLineActivity,
+  DirectLineJSBotConnection,
   disconnect,
   dismissNotification,
   emitTypingIndicator,
   markActivity,
+  OneOrMany,
   postActivity,
   sendEvent,
   sendFiles,
@@ -33,6 +27,7 @@ import {
   setSendBox,
   setSendTimeout,
   setSendTypingIndicator,
+  singleToArray,
   startDictate,
   startSpeakingActivity,
   stopDictate,
@@ -40,23 +35,47 @@ import {
   submitSendBox
 } from 'botframework-webchat-core';
 
+import { default as WebChatAPIContext } from './internal/WebChatAPIContext';
+import ActivityAcknowledgementComposer from '../providers/ActivityAcknowledgement/ActivityAcknowledgementComposer';
+import ActivityKeyerComposer from '../providers/ActivityKeyer/ActivityKeyerComposer';
+import ActivityMiddleware from '../types/ActivityMiddleware';
+import ActivityStatusMiddleware from '../types/ActivityStatusMiddleware';
+import AttachmentForScreenReaderMiddleware from '../types/AttachmentForScreenReaderMiddleware';
+import AttachmentMiddleware from '../types/AttachmentMiddleware';
+import AvatarMiddleware from '../types/AvatarMiddleware';
+import CardActionMiddleware from '../types/CardActionMiddleware';
+import createCustomEvent from '../utils/createCustomEvent';
 import createDefaultCardActionMiddleware from './middleware/createDefaultCardActionMiddleware';
 import createDefaultGroupActivitiesMiddleware from './middleware/createDefaultGroupActivitiesMiddleware';
 import defaultSelectVoice from './internal/defaultSelectVoice';
+import ErrorBoundary from './utils/ErrorBoundary';
+import getAllLocalizedStrings from '../localization/getAllLocalizedStrings';
+import GroupActivitiesMiddleware from '../types/GroupActivitiesMiddleware';
+import isObject from '../utils/isObject';
+import LocalizedStrings from '../types/LocalizedStrings';
 import mapMap from '../utils/mapMap';
+import normalizeLanguage from '../utils/normalizeLanguage';
+import normalizeStyleOptions from '../normalizeStyleOptions';
 import observableToPromise from './utils/observableToPromise';
+import patchStyleOptionsFromDeprecatedProps from '../patchStyleOptionsFromDeprecatedProps';
+import PrecompiledGlobalizeType from '../types/PrecompiledGlobalize';
+import ScrollToEndButtonMiddleware, { ScrollToEndButtonComponentFactory } from '../types/ScrollToEndButtonMiddleware';
+import StyleOptions from '../StyleOptions';
+import TelemetryMeasurementEvent, { TelemetryExceptionMeasurementEvent } from '../types/TelemetryMeasurementEvent';
+import ToastMiddleware from '../types/ToastMiddleware';
 import Tracker from './internal/Tracker';
+import TypingIndicatorMiddleware from '../types/TypingIndicatorMiddleware';
+import useMarkAllAsAcknowledged from './useMarkAllAsAcknowledged';
 import WebChatReduxContext, { useDispatch } from './internal/WebChatReduxContext';
-import { default as WebChatAPIContext } from './internal/WebChatAPIContext';
 
 import applyMiddleware, {
   forLegacyRenderer as applyMiddlewareForLegacyRenderer,
   forRenderer as applyMiddlewareForRenderer
 } from './middleware/applyMiddleware';
 
-import normalizeStyleOptions from '../normalizeStyleOptions';
-import patchStyleOptionsFromDeprecatedProps from '../patchStyleOptionsFromDeprecatedProps';
-import singleToArray from './utils/singleToArray';
+// PrecompileGlobalize is a generated file and is not ES module. TypeScript don't work with UMD.
+// @ts-ignore
+import PrecompiledGlobalize from '../external/PrecompiledGlobalize';
 
 // List of Redux actions factory we are hoisting as Web Chat functions
 const DISPATCHERS = {
@@ -82,7 +101,7 @@ const DISPATCHERS = {
   submitSendBox
 };
 
-function createCardActionContext({ cardActionMiddleware, directLine, dispatch }) {
+function createCardActionContext({ cardActionMiddleware, directLine, dispatch, markAllAsAcknowledged }) {
   const runMiddleware = applyMiddleware(
     'card action',
     ...singleToArray(cardActionMiddleware),
@@ -90,8 +109,10 @@ function createCardActionContext({ cardActionMiddleware, directLine, dispatch })
   )({ dispatch });
 
   return {
-    onCardAction: (cardAction, { target }: { target?: any } = {}) =>
-      runMiddleware({
+    onCardAction: (cardAction, { target }: { target?: any } = {}) => {
+      markAllAsAcknowledged();
+
+      return runMiddleware({
         cardAction,
         getSignInUrl:
           cardAction.type === 'signin'
@@ -115,7 +136,8 @@ function createCardActionContext({ cardActionMiddleware, directLine, dispatch })
               }
             : null,
         target
-      })
+      });
+    }
   };
 }
 
@@ -151,44 +173,60 @@ function mergeStringsOverrides(localizedStrings, language, overrideLocalizedStri
   return { ...localizedStrings, ...overrideLocalizedStrings };
 }
 
-type ComposerProps = {
-  activityMiddleware: any;
-  activityRenderer: any;
-  activityStatusMiddleware: any;
-  activityStatusRenderer: any;
-  attachmentForScreenReaderMiddleware: any;
-  attachmentMiddleware: any;
-  attachmentRenderer: any;
-  avatarMiddleware: any;
-  avatarRenderer: any;
-  cardActionMiddleware: any;
-  children: ReactNode;
-  dir: string;
-  directLine: any;
-  disabled: boolean;
-  downscaleImageToDataURL: any;
-  grammars: any;
-  groupActivitiesMiddleware: any;
-  groupTimestamp: boolean | number;
-  internalErrorBoxClass: any;
-  internalRenderErrorBox: any;
-  locale: string;
-  onTelemetry: any;
-  overrideLocalizedStrings: any;
-  renderMarkdown: any;
-  selectVoice: any;
-  sendTimeout: number;
-  sendTypingIndicator: any;
-  styleOptions: StyleOptions;
-  toastMiddleware: any;
-  toastRenderer: any;
-  typingIndicatorMiddleware: any;
-  typingIndicatorRenderer: any;
-  userID: string;
-  username: string;
+// It seems "react/require-default-props" did not pick up `ComposerCore.defaultProps`.
+// And it falsely complaint `optional?: string` must have a corresponding `ComposerCore.defaultProps.optional = undefined`, even we already set it below.
+// Since we set both TypeScript `Props` class and `ComposerCore.propTypes`, this check will be done there as well.
+// Ignoring it in TypeScript version should be safe, as we have `propTypes` version to protect us.
+
+/* eslint-disable react/require-default-props */
+type ComposerCoreProps = {
+  activityMiddleware?: OneOrMany<ActivityMiddleware>;
+  activityStatusMiddleware?: OneOrMany<ActivityStatusMiddleware>;
+  attachmentForScreenReaderMiddleware?: OneOrMany<AttachmentForScreenReaderMiddleware>;
+  attachmentMiddleware?: OneOrMany<AttachmentMiddleware>;
+  avatarMiddleware?: OneOrMany<AvatarMiddleware>;
+  cardActionMiddleware?: OneOrMany<CardActionMiddleware>;
+  children?: ReactNode;
+  dir?: string;
+  directLine: DirectLineJSBotConnection;
+  disabled?: boolean;
+  downscaleImageToDataURL?: (blob: Blob, maxWidth: number, maxHeight: number, type: string, quality: number) => string;
+  grammars?: any;
+  groupActivitiesMiddleware?: OneOrMany<GroupActivitiesMiddleware>;
+  internalErrorBoxClass?: React.Component | Function;
+  locale?: string;
+  onTelemetry?: (event: TelemetryMeasurementEvent) => void;
+  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;
+  sendTypingIndicator?: boolean;
+  styleOptions?: StyleOptions;
+  toastMiddleware?: OneOrMany<ToastMiddleware>;
+  typingIndicatorMiddleware?: OneOrMany<TypingIndicatorMiddleware>;
+  userID?: string;
+  username?: string;
+
+  /** @deprecated Please use "activityMiddleware" instead. */
+  activityRenderer?: any; // TODO: [P4] Remove on or after 2022-06-15.
+  /** @deprecated Please use "activityStatusMiddleware" instead. */
+  activityStatusRenderer?: any; // TODO: [P4] Remove on or after 2022-06-15.
+  /** @deprecated Please use "attachmentMiddleware" instead. */
+  attachmentRenderer?: any; // TODO: [P4] Remove on or after 2022-06-15.
+  /** @deprecated Please use "avatarMiddleware" instead. */
+  avatarRenderer?: any; // TODO: [P4] Remove on or after 2022-06-15.
+  /** @deprecated Please use "styleOptions.groupTimestamp" instead. */
+  groupTimestamp?: boolean | number; // TODO: [P4] Remove on or after 2022-01-01
+  /** @deprecated Please use "styleOptions.sendTimeout" instead. */
+  sendTimeout?: number; // TODO: [P4] Remove on or after 2022-01-01.
+  /** @deprecated Please use "toastMiddleware" instead. */
+  toastRenderer?: any; // TODO: [P4] Remove on or after 2022-06-15.
+  /** @deprecated Please use "typingIndicatorRenderer" instead. */
+  typingIndicatorRenderer?: any; // TODO: [P4] Remove on or after 2022-06-15.
 };
+/* eslint-enable react/require-default-props */
 
-const Composer: FC<ComposerProps> = ({
+const ComposerCore: FC<ComposerCoreProps> = ({
   activityMiddleware,
   activityRenderer,
   activityStatusMiddleware,
@@ -212,6 +250,7 @@ const Composer: FC<ComposerProps> = ({
   onTelemetry,
   overrideLocalizedStrings,
   renderMarkdown,
+  scrollToEndButtonMiddleware,
   selectVoice,
   sendTimeout,
   sendTypingIndicator,
@@ -262,16 +301,17 @@ const Composer: FC<ComposerProps> = ({
     };
   }, [dispatch, directLine, userID, username]);
 
-  const cardActionContext = useMemo(() => createCardActionContext({ cardActionMiddleware, directLine, dispatch }), [
-    cardActionMiddleware,
-    directLine,
-    dispatch
-  ]);
+  const markAllAsAcknowledged = useMarkAllAsAcknowledged();
+
+  const cardActionContext = useMemo(
+    () => createCardActionContext({ cardActionMiddleware, directLine, dispatch, markAllAsAcknowledged }),
+    [cardActionMiddleware, directLine, dispatch, markAllAsAcknowledged]
+  );
 
-  const patchedSelectVoice = useMemo(() => selectVoice || defaultSelectVoice.bind(null, { language: locale }), [
-    locale,
-    selectVoice
-  ]);
+  const patchedSelectVoice = useMemo(
+    () => selectVoice || defaultSelectVoice.bind(null, { language: locale }),
+    [locale, selectVoice]
+  );
 
   const groupActivitiesContext = useMemo(
     () =>
@@ -283,7 +323,13 @@ const Composer: FC<ComposerProps> = ({
   );
 
   const hoistedDispatchers = useMemo(
-    () => mapMap(DISPATCHERS, dispatcher => (...args) => dispatch(dispatcher(...args))),
+    () =>
+      mapMap(
+        DISPATCHERS,
+        dispatcher =>
+          (...args) =>
+            dispatch(dispatcher(...args))
+      ),
     [dispatch]
   );
 
@@ -292,14 +338,14 @@ const Composer: FC<ComposerProps> = ({
     [locale, overrideLocalizedStrings]
   );
 
-  const localizedGlobalize = useMemo(() => {
+  const localizedGlobalize = useMemo<PrecompiledGlobalizeType>(() => {
     const { GLOBALIZE, GLOBALIZE_LANGUAGE } = patchedLocalizedStrings || {};
 
     return GLOBALIZE || (GLOBALIZE_LANGUAGE && PrecompiledGlobalize(GLOBALIZE_LANGUAGE)) || PrecompiledGlobalize('en');
   }, [patchedLocalizedStrings]);
 
   const trackDimension = useCallback(
-    (name, data) => {
+    (name: string, data: any) => {
       if (!name || typeof name !== 'string') {
         return console.warn('botframework-webchat: Telemetry dimension name must be a string.');
       }
@@ -331,13 +377,15 @@ const Composer: FC<ComposerProps> = ({
         'activity',
         { strict: false },
         ...singleToArray(activityMiddleware),
-        () => () => ({ activity }) => {
-          if (activity) {
-            throw new Error(`No renderer for activity of type "${activity.type}"`);
-          } else {
-            throw new Error('No activity to render');
+        () =>
+          () =>
+          ({ activity }) => {
+            if (activity) {
+              throw new Error(`No renderer for activity of type "${activity.type}"`);
+            } else {
+              throw new Error('No activity to render');
+            }
           }
-        }
       )({})
     );
   }, [activityMiddleware, activityRenderer]);
@@ -365,19 +413,21 @@ const Composer: FC<ComposerProps> = ({
         'attachment for screen reader',
         { strict: true },
         ...singleToArray(attachmentForScreenReaderMiddleware),
-        () => () => ({ attachment }) => {
-          if (attachment) {
-            console.warn(`No renderer for attachment for screen reader of type "${attachment.contentType}"`);
-            return false;
+        () =>
+          () =>
+          ({ attachment }) => {
+            if (attachment) {
+              console.warn(`No renderer for attachment for screen reader of type "${attachment.contentType}"`);
+              return false;
+            }
+
+            return () => {
+              /**
+               * @todo TODO: [P4] Might be able to throw without returning a function -- investigate and possibly fix
+               */
+              throw new Error('No attachment to render');
+            };
           }
-
-          return () => {
-            /**
-             * @todo TODO: [P4] Might be able to throw without returning a function -- investigate and possibly fix
-             */
-            throw new Error('No attachment to render');
-          };
-        }
       )({}),
     [attachmentForScreenReaderMiddleware]
   );
@@ -395,13 +445,15 @@ const Composer: FC<ComposerProps> = ({
     return applyMiddlewareForLegacyRenderer(
       'attachment',
       ...singleToArray(attachmentMiddleware),
-      () => () => ({ attachment }) => {
-        if (attachment) {
-          throw new Error(`No renderer for attachment of type "${attachment.contentType}"`);
-        } else {
-          throw new Error('No attachment to render');
+      () =>
+        () =>
+        ({ attachment }) => {
+          if (attachment) {
+            throw new Error(`No renderer for attachment of type "${attachment.contentType}"`);
+          } else {
+            throw new Error('No attachment to render');
+          }
         }
-      }
     )({});
   }, [attachmentMiddleware, attachmentRenderer]);
 
@@ -413,8 +465,11 @@ const Composer: FC<ComposerProps> = ({
 
     return (
       avatarRenderer ||
-      applyMiddlewareForRenderer('avatar', { strict: false }, ...singleToArray(avatarMiddleware), () => () => () =>
-        false
+      applyMiddlewareForRenderer(
+        'avatar',
+        { strict: false },
+        ...singleToArray(avatarMiddleware),
+        () => () => () => false
       )({})
     );
   }, [avatarMiddleware, avatarRenderer]);
@@ -431,13 +486,15 @@ const Composer: FC<ComposerProps> = ({
         'toast',
         { strict: false },
         ...singleToArray(toastMiddleware),
-        () => () => ({ notification }) => {
-          if (notification) {
-            throw new Error(`No renderer for notification of type "${notification.contentType}"`);
-          } else {
-            throw new Error('No notification to render');
+        () =>
+          () =>
+          ({ notification }) => {
+            if (notification) {
+              throw new Error(`No renderer for notification of type "${notification.contentType}"`);
+            } else {
+              throw new Error('No notification to render');
+            }
           }
-        }
       )({})
     );
   }, [toastMiddleware, toastRenderer]);
@@ -459,6 +516,17 @@ const Composer: FC<ComposerProps> = ({
     );
   }, [typingIndicatorMiddleware, typingIndicatorRenderer]);
 
+  const scrollToEndButtonRenderer: ScrollToEndButtonComponentFactory = useMemo(
+    () =>
+      applyMiddlewareForRenderer(
+        'scroll to end button',
+        { strict: true },
+        ...singleToArray(scrollToEndButtonMiddleware),
+        () => () => () => false
+      )() as any,
+    [scrollToEndButtonMiddleware]
+  );
+
   /**
    * This is a heavy function, and it is expected to be only called when there is a need to recreate business logic, e.g.
    * - User ID changed, causing all send* functions to be updated
@@ -491,6 +559,7 @@ const Composer: FC<ComposerProps> = ({
       localizedStrings: patchedLocalizedStrings,
       onTelemetry,
       renderMarkdown,
+      scrollToEndButtonRenderer,
       selectVoice: patchedSelectVoice,
       sendTypingIndicator,
       styleOptions: patchedStyleOptions,
@@ -525,6 +594,7 @@ const Composer: FC<ComposerProps> = ({
       patchedToastRenderer,
       patchedTypingIndicatorRenderer,
       renderMarkdown,
+      scrollToEndButtonRenderer,
       sendTypingIndicator,
       telemetryDimensionsRef,
       trackDimension,
@@ -541,59 +611,13 @@ const Composer: FC<ComposerProps> = ({
   );
 };
 
-// We will create a Redux store if it was not passed in
-const ComposeWithStore: FC<ComposerProps & { store: any }> = ({
-  internalRenderErrorBox,
-  onTelemetry,
-  store,
-  ...props
-}) => {
-  const [error, setError] = useState();
-
-  const handleError = useCallback(
-    error => {
-      console.error('botframework-webchat: Uncaught exception', { error });
-
-      onTelemetry && onTelemetry(createCustomEvent('exception', { error, fatal: true }));
-      setError(error);
-    },
-    [onTelemetry, setError]
-  );
-
-  const memoizedStore = useMemo(() => store || createStore(), [store]);
-
-  return error ? (
-    !!internalRenderErrorBox && internalRenderErrorBox({ error, type: 'uncaught exception' })
-  ) : (
-    <ErrorBoundary onError={handleError}>
-      <Provider context={WebChatReduxContext} store={memoizedStore}>
-        <Composer internalRenderErrorBox={internalRenderErrorBox} onTelemetry={onTelemetry} {...props} />
-      </Provider>
-    </ErrorBoundary>
-  );
-};
-
-ComposeWithStore.defaultProps = {
-  internalRenderErrorBox: undefined,
-  onTelemetry: undefined,
-  store: undefined
-};
-
-ComposeWithStore.propTypes = {
-  internalRenderErrorBox: PropTypes.any,
-  onTelemetry: PropTypes.func,
-  store: PropTypes.any
-};
-
-export default ComposeWithStore;
-
 /**
  * @todo TODO: [P3] We should consider moving some data from Redux store to props
  *       Although we use `connectToWebChat` to hide the details of accessor of Redux store,
  *       we should clean up the responsibility between Context and Redux store
  *       We should decide which data is needed for React but not in other environment such as CLI/VSCode
  */
-Composer.defaultProps = {
+ComposerCore.defaultProps = {
   activityMiddleware: undefined,
   activityRenderer: undefined,
   activityStatusMiddleware: undefined,
@@ -616,6 +640,7 @@ Composer.defaultProps = {
   onTelemetry: undefined,
   overrideLocalizedStrings: undefined,
   renderMarkdown: undefined,
+  scrollToEndButtonMiddleware: undefined,
   selectVoice: undefined,
   sendTimeout: undefined,
   sendTypingIndicator: false,
@@ -628,7 +653,7 @@ Composer.defaultProps = {
   username: ''
 };
 
-Composer.propTypes = {
+ComposerCore.propTypes = {
   activityMiddleware: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.func), PropTypes.func]),
   activityRenderer: PropTypes.func,
   activityStatusMiddleware: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.func), PropTypes.func]),
@@ -664,6 +689,7 @@ Composer.propTypes = {
   onTelemetry: PropTypes.func,
   overrideLocalizedStrings: PropTypes.oneOfType([PropTypes.any, PropTypes.func]),
   renderMarkdown: PropTypes.func,
+  scrollToEndButtonMiddleware: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.func), PropTypes.func]),
   selectVoice: PropTypes.func,
   sendTimeout: PropTypes.number,
   sendTypingIndicator: PropTypes.bool,
@@ -675,3 +701,56 @@ Composer.propTypes = {
   userID: PropTypes.string,
   username: PropTypes.string
 };
+
+type ComposerProps = ComposerCoreProps & {
+  internalRenderErrorBox?: any;
+  store?: any;
+};
+
+// We will create a Redux store if it was not passed in
+const Composer: FC<ComposerProps> = ({ internalRenderErrorBox, onTelemetry, store, ...props }) => {
+  const [error, setError] = useState();
+
+  const handleError = useCallback(
+    error => {
+      console.error('botframework-webchat: Uncaught exception', { error });
+
+      onTelemetry &&
+        onTelemetry(createCustomEvent('exception', { error, fatal: true }) as TelemetryExceptionMeasurementEvent);
+      setError(error);
+    },
+    [onTelemetry, setError]
+  );
+
+  const memoizedStore = useMemo(() => store || createStore(), [store]);
+
+  return error ? (
+    !!internalRenderErrorBox && internalRenderErrorBox({ error, type: 'uncaught exception' })
+  ) : (
+    <ErrorBoundary onError={handleError}>
+      <Provider context={WebChatReduxContext} store={memoizedStore}>
+        <ActivityKeyerComposer>
+          <ActivityAcknowledgementComposer>
+            <ComposerCore onTelemetry={onTelemetry} {...props} />
+          </ActivityAcknowledgementComposer>
+        </ActivityKeyerComposer>
+      </Provider>
+    </ErrorBoundary>
+  );
+};
+
+Composer.defaultProps = {
+  internalRenderErrorBox: undefined,
+  onTelemetry: undefined,
+  store: undefined
+};
+
+Composer.propTypes = {
+  internalRenderErrorBox: PropTypes.any,
+  onTelemetry: PropTypes.func,
+  store: PropTypes.any
+};
+
+export default Composer;
+
+export type { ComposerProps };

package/src/hooks/{index.js → index.ts}

@@ -1,5 +1,7 @@
 import useActiveTyping from './useActiveTyping';
 import useActivities from './useActivities';
+import useActivityKeys from './useActivityKeys';
+import useActivityKeysByRead from './useActivityKeysByRead';
 import useAvatarForBot from './useAvatarForBot';
 import useAvatarForUser from './useAvatarForUser';
 import useByteFormatter from './useByteFormatter';
@@ -8,6 +10,7 @@ import useCreateActivityRenderer from './useCreateActivityRenderer';
 import useCreateActivityStatusRenderer from './useCreateActivityStatusRenderer';
 import useCreateAttachmentForScreenReaderRenderer from './useCreateAttachmentForScreenReaderRenderer';
 import useCreateAvatarRenderer from './useCreateAvatarRenderer';
+import useCreateScrollToEndButtonRenderer from './useCreateScrollToEndButtonRenderer';
 import useDateFormatter from './useDateFormatter';
 import useDebouncedNotifications from './useDebouncedNotifications';
 import useDictateInterims from './useDictateInterims';
@@ -16,16 +19,24 @@ import useDirection from './useDirection';
 import useDisabled from './useDisabled';
 import useDismissNotification from './useDismissNotification';
 import useEmitTypingIndicator from './useEmitTypingIndicator';
+import useGetActivityByKey from './useGetActivityByKey';
+import useGetHasAcknowledgedByActivityKey from './useGetHasAcknowledgedByActivityKey';
+import useGetKeyByActivity from './useGetKeyByActivity';
+import useGetKeyByActivityId from './useGetKeyByActivityId';
 import useGetSendTimeoutForActivity from './useGetSendTimeoutForActivity';
 import useGrammars from './useGrammars';
 import useGroupActivities from './useGroupActivities';
 import useGroupTimestamp from './useGroupTimestamp';
 import useLanguage from './useLanguage';
+import useLastAcknowledgedActivityKey from './useLastAcknowledgedActivityKey';
+import useLastReadActivityKey from './useLastReadActivityKey';
 import useLastTypingAt from './useLastTypingAt';
 import useLocalize from './useLocalize'; // Deprecated on or after 2022-02-12
 import useLocalizeDate from './useLocalizeDate'; // Deprecated on or after 2022-02-12
 import useLocalizer from './useLocalizer';
 import useMarkActivityAsSpoken from './useMarkActivityAsSpoken';
+import useMarkActivityKeyAsRead from './useMarkActivityKeyAsRead';
+import useMarkAllAsAcknowledged from './useMarkAllAsAcknowledged';
 import usePerformCardAction from './usePerformCardAction';
 import usePostActivity from './usePostActivity';
 import useReferenceGrammarID from './useReferenceGrammarID';
@@ -63,6 +74,8 @@ import useVoiceSelector from './useVoiceSelector';
 export {
   useActiveTyping,
   useActivities,
+  useActivityKeys,
+  useActivityKeysByRead,
   useAvatarForBot,
   useAvatarForUser,
   useByteFormatter,
@@ -71,6 +84,7 @@ export {
   useCreateActivityStatusRenderer,
   useCreateAttachmentForScreenReaderRenderer,
   useCreateAvatarRenderer,
+  useCreateScrollToEndButtonRenderer,
   useDateFormatter,
   useDebouncedNotifications,
   useDictateInterims,
@@ -79,16 +93,24 @@ export {
   useDisabled,
   useDismissNotification,
   useEmitTypingIndicator,
+  useGetActivityByKey,
+  useGetHasAcknowledgedByActivityKey,
+  useGetKeyByActivity,
+  useGetKeyByActivityId,
   useGetSendTimeoutForActivity,
   useGrammars,
   useGroupActivities,
   useGroupTimestamp,
   useLanguage,
+  useLastAcknowledgedActivityKey,
+  useLastReadActivityKey,
   useLastTypingAt,
   useLocalize,
   useLocalizeDate,
   useLocalizer,
   useMarkActivityAsSpoken,
+  useMarkActivityKeyAsRead,
+  useMarkAllAsAcknowledged,
   usePerformCardAction,
   usePostActivity,
   useReferenceGrammarID,