botframework-webchat-core 4.18.1-main.20260518.2a3d1d3 → 4.18.2

package/dist/botframework-webchat-core.d.mts

@@ -1,29 +1,33 @@
-import { D as DirectLineCardAction, W as WebChatActivity } from './WebChatActivity-CYqxBG_4.mjs';
-export { b as DirectLineAttachment, c as DirectLineSuggestedAction } from './WebChatActivity-CYqxBG_4.mjs';
-export { G as GlobalScopePonyfill, c as createStore, w as createStoreWithDevTools, a as createStoreWithOptions } from './createStore-CcvouBrW.mjs';
-import { OrgSchemaCreativeWork as CreativeWorkOutput } from './botframework-webchat-core.org-schema.mjs';
-import * as valibot from 'valibot';
-import { InferOutput } from 'valibot';
-export { O as OneOrMany, P as PromiseWithResolvers, i as isForbiddenPropertyName, s as singleToArray, w as withResolvers } from './_dtsroll-chunks/CAquHfZK-botframework-webchat-base.utils.js';
-import './_dtsroll-chunks/B7Whm73Q-tagged.js';
-import 'redux';
-
-declare function connect({ directLine, userID, username }: {
-    readonly directLine: any;
-    readonly userID: string;
-    readonly username: string;
-}): {
-    type: string;
+import { Store } from 'redux';
+
+const CLEAR_SUGGESTED_ACTIONS = 'WEB_CHAT/CLEAR_SUGGESTED_ACTIONS';
+
+function clearSuggestedActions() {
+  return {
+    type: CLEAR_SUGGESTED_ACTIONS
+  };
+}
+
+const CONNECT = 'DIRECT_LINE/CONNECT';
+
+function connect({ directLine, userID, username }) {
+  return {
+    type: CONNECT,
     payload: {
-        directLine: any;
-        userID: string;
-        username: string;
-    };
-};
+      directLine,
+      userID,
+      username
+    }
+  };
+}
 
-declare function disconnect(): {
-    type: string;
-};
+const DISCONNECT = 'DIRECT_LINE/DISCONNECT';
+
+function disconnect() {
+  return {
+    type: DISCONNECT
+  };
+}
 
 declare const DISMISS_NOTIFICATION = "WEB_CHAT/DISMISS_NOTIFICATION";
 type DismissNotificationAction = {
@@ -34,9 +38,13 @@ type DismissNotificationAction = {
 };
 declare function dismissNotification(id: string): DismissNotificationAction;
 
-declare function emitTypingIndicator(): {
-    type: string;
-};
+const EMIT_TYPING_INDICATOR = 'WEB_CHAT/EMIT_TYPING_INDICATOR';
+
+function emitTypingIndicator() {
+  return {
+    type: EMIT_TYPING_INDICATOR
+  };
+}
 
 type MarkActivityActionType = 'WEB_CHAT/MARK_ACTIVITY';
 type MarkActivityAction = {
@@ -51,11 +59,253 @@ declare function markActivity({ id: activityID }: {
     id: string;
 }, name: string, value: any): MarkActivityAction;
 
-declare const VOICE_MUTE_RECORDING: "WEB_CHAT/VOICE_MUTE_RECORDING";
-type VoiceMuteRecordingAction = {
-    type: typeof VOICE_MUTE_RECORDING;
+type AnyAnd<T> = Omit<any, keyof T> & T;
+
+type DirectLineAttachment = {
+    content?: any;
+    contentType: string;
+    contentUrl?: string;
+    name?: string;
+    thumbnailUrl?: string;
+};
+
+type CardActionWithImageAndTitle = {
+    image: string;
+} | {
+    title: string;
+} | {
+    image: string;
+    title: string;
+};
+/**
+ * A `call` action represents a telephone number that may be called.
+ *
+ * https://github.com/Microsoft/botframework-sdk/blob/main/specs/botframework-activity/botframework-activity.md#call
+ */
+type CallCardAction = CardActionWithImageAndTitle & {
+    type: 'call';
+    value: string;
+};
+/**
+ * A `downloadFile` action represents a hyperlink to be downloaded.
+ *
+ * https://github.com/Microsoft/botframework-sdk/blob/main/specs/botframework-activity/botframework-activity.md#download-file-actions
+ */
+type DownloadFileCardAction = CardActionWithImageAndTitle & {
+    type: 'downloadFile';
+    value: string;
+};
+/**
+ * An `imBack` action represents a text response that is added to the chat feed.
+ *
+ * https://github.com/Microsoft/botframework-sdk/blob/main/specs/botframework-activity/botframework-activity.md#im-back
+ */
+type IMBackCardAction = CardActionWithImageAndTitle & {
+    type: 'imBack';
+    value: string;
+};
+/**
+ * A `messageBack` action represents a text response to be sent via the chat system.
+ *
+ * https://github.com/Microsoft/botframework-sdk/blob/main/specs/botframework-activity/botframework-activity.md#message-back
+ */
+type MessageBackCardAction = CardActionWithImageAndTitle & {
+    displayText?: string;
+    text?: string;
+    type: 'messageBack';
+    value?: {
+        [key: string]: any;
+    };
+};
+/**
+ * An `openUrl` action represents a hyperlink to be handled by the client.
+ *
+ * https://github.com/Microsoft/botframework-sdk/blob/main/specs/botframework-activity/botframework-activity.md#open-url-actions
+ */
+type OpenURLCardAction = CardActionWithImageAndTitle & {
+    type: 'openUrl';
+    value: string;
+};
+/**
+ * A `playAudio` action represents audio media that may be played.
+ *
+ * https://github.com/Microsoft/botframework-sdk/blob/main/specs/botframework-activity/botframework-activity.md#play-audio
+ */
+type PlayAudioCardAction = CardActionWithImageAndTitle & {
+    type: 'playAudio';
+    value: string;
+};
+/**
+ * A `playVideo` action represents video media that may be played.
+ *
+ * https://github.com/Microsoft/botframework-sdk/blob/main/specs/botframework-activity/botframework-activity.md#play-video
+ */
+type PlayVideoCardAction = CardActionWithImageAndTitle & {
+    type: 'playVideo';
+    value: string;
+};
+/**
+ * A `postBack` action represents a text response that is not added to the chat feed.
+ *
+ * https://github.com/Microsoft/botframework-sdk/blob/main/specs/botframework-activity/botframework-activity.md#post-back
+ */
+type PostBackCardAction = CardActionWithImageAndTitle & {
+    type: 'postBack';
+    value: any;
+};
+/**
+ * A `showImage` action represents an image that may be displayed.
+ *
+ * https://github.com/Microsoft/botframework-sdk/blob/main/specs/botframework-activity/botframework-activity.md#show-image-file-actions
+ */
+type ShowImageCardAction = CardActionWithImageAndTitle & {
+    type: 'showImage';
+    value: string;
+};
+/**
+ * A `signin` action represents a hyperlink to be handled by the client's signin system.
+ *
+ * https://github.com/Microsoft/botframework-sdk/blob/main/specs/botframework-activity/botframework-activity.md#signin
+ */
+type SignInCardAction = CardActionWithImageAndTitle & {
+    type: 'signin';
+    value: string;
+};
+/**
+ * A card action represents a clickable or interactive button for use within cards or as suggested actions. They are used to solicit input from users. Despite their name, card actions are not limited to use solely on cards.
+ *
+ * https://github.com/Microsoft/botframework-sdk/blob/main/specs/botframework-activity/botframework-activity.md#card-action
+ */
+type DirectLineCardAction = CallCardAction | DownloadFileCardAction | IMBackCardAction | MessageBackCardAction | OpenURLCardAction | PlayAudioCardAction | PlayVideoCardAction | PostBackCardAction | ShowImageCardAction | SignInCardAction;
+
+type DirectLineSuggestedAction = {
+    actions?: DirectLineCardAction[];
+    to?: string[];
+};
+
+type SupportedRole = 'bot' | 'channel' | 'user';
+type SupportedSendStatus = 'sending' | 'send failed' | 'sent';
+type ChannelData<SendStatus extends SupportedSendStatus | undefined, Type extends string> = AnyAnd<{
+    attachmentSizes?: number[];
+    clientActivityID?: string;
+    'webchat:sequence-id': number;
+    webChat?: {
+        /**
+         * Time when the activity appear in chat history.
+         *
+         * Note: if the activity is updated, this value will also be updated.
+         */
+        receivedAt?: number;
+        /**
+         * Per-activity style options.
+         *
+         * New in 4.18.0.
+         */
+        styleOptions?: Record<string, boolean | number | null | string>;
+    };
+} & (SendStatus extends SupportedSendStatus ? {
+    /**
+     * @deprecated Since 4.15.3: Please use `channelData['webchat:send-status']` or `useSendStatusByActivityKey()` hook instead.
+     *             Please refer to https://github.com/microsoft/BotFramework-WebChat/pull/4362 for details. This field will be removed on or after 2024-07-31.
+     */
+    state?: SendStatus;
+    /**
+     * The send status of the activity.
+     *
+     * - `"sending"`, the activity is in-transit and it has not been timed out;
+     * - `"send failed"`, the activity cannot be delivered permanently and further processing had been stopped;
+     * - `"sent"`, the activity is delivered successfully.
+     *
+     * Due to network-related race conditions, the activity could be marked as `"send failed"` but delivered by the service.
+     * In this case, the activity should continue to mark as `"send failed"`.
+     *
+     * For further details, please see [#4362](https://github.com/microsoft/BotFramework-WebChat/pull/4362).
+     */
+    'webchat:send-status': SendStatus;
+} : {}) & (Type extends 'message' ? {
+    messageBack?: {
+        displayText: string;
+    };
+    postBack?: boolean;
+    speak?: boolean;
+    speechSynthesisUtterance?: SpeechSynthesisUtterance;
+    'webchat:fallback-text'?: string;
+} : {})>;
+type ClientCapabilitiesEntity = {
+    requiresBotState?: boolean;
+    supportsListening?: boolean;
+    supportsTts?: boolean;
+    type: 'ClientCapabilities';
+};
+type Entity = ClientCapabilitiesEntity | {
+    type: string;
+};
+type ChannelAcount<Role extends SupportedRole> = {
+    id: string;
+    name?: string;
+    role: Role;
 };
-declare function muteVoiceRecording(): VoiceMuteRecordingAction;
+type EventActivityEssence = {
+    name: string;
+    type: 'event';
+    value?: any;
+};
+type MessageActivityEssence = {
+    attachmentLayout?: 'carousel' | 'stacked';
+    attachments?: DirectLineAttachment[];
+    channelData: {
+        streamId?: string;
+        streamSequence?: number;
+        streamType?: 'final';
+    };
+    inputHint?: 'accepting' | 'expecting' | 'ignoring';
+    locale?: string;
+    speak?: string;
+    suggestedActions?: DirectLineSuggestedAction;
+    text: string | undefined;
+    textFormat?: 'markdown' | 'plain' | 'xml';
+    type: 'message';
+    value?: any;
+};
+type TypingActivityEssence = {
+    type: 'typing';
+} | {
+    channelData: {
+        streamId: string;
+        streamSequence: number;
+        streamType: 'informative' | 'streaming';
+    };
+    text: string;
+    type: 'typing';
+};
+type TimestampFromServerEssence = {
+    id: string;
+    localTimestamp?: string;
+    timestamp: string;
+};
+type TimestampInTransitEssence = {
+    id?: string;
+    localTimestamp: string;
+    timestamp?: string;
+};
+type TimestampEssence<Role extends SupportedRole, SendStatus extends SupportedSendStatus | undefined> = Role extends 'user' ? SendStatus extends 'sending' | 'send failed' ? TimestampInTransitEssence : TimestampFromServerEssence : TimestampFromServerEssence;
+type CoreActivityEssence<Role extends SupportedRole, SendStatus extends SupportedSendStatus | undefined, Type extends string = 'conversationUpdate' | 'event' | 'invoke' | 'message' | 'typing'> = {
+    channelData: ChannelData<SendStatus, Type>;
+    channelId?: string;
+    entities?: Entity[];
+    from: ChannelAcount<Role>;
+    localTimezone?: string;
+    replyToId?: string;
+    type: string;
+} & TimestampEssence<Role, SendStatus> & (Type extends 'event' ? EventActivityEssence : Type extends 'message' ? MessageActivityEssence : Type extends 'typing' ? TypingActivityEssence : {
+    type: Type;
+});
+type OthersActivity = CoreActivityEssence<'bot' | 'channel', undefined>;
+type SelfActivitySendFailed = CoreActivityEssence<'user', 'send failed'>;
+type SelfActivitySending = CoreActivityEssence<'user', 'sending'>;
+type SelfActivitySent = CoreActivityEssence<'user', 'sent'>;
+type SelfActivity = SelfActivitySendFailed | SelfActivitySending | SelfActivitySent;
+type WebChatActivity = SelfActivity | OthersActivity;
 
 type PostActivityActionType = 'DIRECT_LINE/POST_ACTIVITY';
 type PostActivityAction = {
@@ -69,36 +319,14 @@ type PostActivityAction = {
 };
 declare function postActivity(activity: WebChatActivity, method?: string): PostActivityAction;
 
-declare const VOICE_POST_ACTIVITY: "WEB_CHAT/VOICE_POST_ACTIVITY";
-type VoicePostActivityAction = {
-    type: typeof VOICE_POST_ACTIVITY;
-    payload: {
-        activity: WebChatActivity;
-    };
-};
-declare function postVoiceActivity(activity: WebChatActivity): VoicePostActivityAction;
-
-declare const VOICE_REGISTER_HANDLER: "WEB_CHAT/VOICE_REGISTER_HANDLER";
-type VoiceHandler = {
-    queueAudio: (base64: string) => void;
-    stopAllAudio: () => void;
-};
-type VoiceRegisterHandlerAction = {
-    type: typeof VOICE_REGISTER_HANDLER;
-    payload: {
-        id: string;
-        voiceHandler: VoiceHandler;
-    };
-};
-declare function registerVoiceHandler(id: string, voiceHandler: VoiceHandler): VoiceRegisterHandlerAction;
+const SEND_EVENT = 'WEB_CHAT/SEND_EVENT';
 
-declare function sendEvent(name: string, value: any): {
-    type: string;
-    payload: {
-        name: string;
-        value: any;
-    };
-};
+function sendEvent(name, value) {
+  return {
+    type: SEND_EVENT,
+    payload: { name, value }
+  };
+}
 
 declare function sendFiles(files: readonly Readonly<{
     name: string;
@@ -138,42 +366,50 @@ declare function sendMessage(text: string | undefined, method: string | undefine
     };
 };
 
-declare function sendMessageback(value: any, text: string | undefined, displayText: string | undefined): {
-    type: string;
-    payload: {
-        displayText: string;
-        text: string;
-        value: any;
-    };
-};
+const SEND_MESSAGE_BACK = 'WEB_CHAT/SEND_MESSAGE_BACK';
 
-declare function sendPostback(value: any): {
-    type: string;
-    payload: {
-        value: any;
-    };
-};
+function sendMessageback(value, text, displayText) {
+  return {
+    type: SEND_MESSAGE_BACK,
+    payload: { displayText, text, value }
+  };
+}
 
-declare function setDictateInterims(dictateInterims: readonly string[]): {
-    type: string;
-    payload: {
-        dictateInterims: readonly string[];
-    };
-};
+const SEND_POST_BACK = 'WEB_CHAT/SEND_POST_BACK';
 
-declare function setDictateState(dictateState: number): {
-    type: string;
-    payload: {
-        dictateState: number;
-    };
-};
+function sendPostback(value) {
+  return {
+    type: SEND_POST_BACK,
+    payload: { value }
+  };
+}
 
-declare function setLanguage(language: string): {
-    type: string;
-    payload: {
-        language: string;
-    };
-};
+const SET_DICTATE_INTERIMS = 'WEB_CHAT/SET_DICTATE_INTERIMS';
+
+function setDictateInterims(dictateInterims) {
+  return {
+    type: SET_DICTATE_INTERIMS,
+    payload: { dictateInterims }
+  };
+}
+
+const SET_DICTATE_STATE = 'WEB_CHAT/SET_DICTATE_STATE';
+
+function setDictateState(dictateState) {
+  return {
+    type: SET_DICTATE_STATE,
+    payload: { dictateState }
+  };
+}
+
+const SET_LANGUAGE = 'WEB_CHAT/SET_LANGUAGE';
+
+function setLanguage(language) {
+  return {
+    type: SET_LANGUAGE,
+    payload: { language }
+  };
+}
 
 type Notification = {
     alt: string;
@@ -191,12 +427,14 @@ type SetNotificationAction = {
 };
 declare function setNotification({ alt, data, id, level, message }: Omit<Notification, 'timestamp'>): SetNotificationAction;
 
-declare function setSendBox(text: string): {
-    type: string;
-    payload: {
-        text: string;
-    };
-};
+const SET_SEND_BOX = 'WEB_CHAT/SET_SEND_BOX';
+
+function setSendBox(text) {
+  return {
+    type: SET_SEND_BOX,
+    payload: { text }
+  };
+}
 
 declare function setSendBoxAttachments(attachments: readonly SendBoxAttachment[]): {
     type: string;
@@ -208,12 +446,14 @@ declare function setSendBoxAttachments(attachments: readonly SendBoxAttachment[]
     };
 };
 
-declare function setSendTimeout(sendTimeout: number): {
-    type: string;
-    payload: {
-        sendTimeout: number;
-    };
-};
+const SET_SEND_TIMEOUT = 'WEB_CHAT/SET_SEND_TIMEOUT';
+
+function setSendTimeout(sendTimeout) {
+  return {
+    type: SET_SEND_TIMEOUT,
+    payload: { sendTimeout }
+  };
+}
 
 declare const SET_SEND_TYPING_INDICATOR = "WEB_CHAT/SET_SEND_TYPING_INDICATOR";
 type SetSendTypingIndicatorAction = {
@@ -222,182 +462,338 @@ type SetSendTypingIndicatorAction = {
     };
     type: typeof SET_SEND_TYPING_INDICATOR;
 };
-declare function setSendTypingIndicator(value: boolean): SetSendTypingIndicatorAction;
+declare function setSendTypingIndicator(value: any): SetSendTypingIndicatorAction;
 
-declare const VOICE_SET_STATE: "WEB_CHAT/VOICE_SET_STATE";
-type VoiceState = 'idle' | 'listening' | 'user_speaking' | 'processing' | 'bot_speaking';
-type VoiceSetStateAction = {
-    type: typeof VOICE_SET_STATE;
-    payload: {
-        voiceState: VoiceState;
-    };
-};
-declare function setVoiceState(voiceState: VoiceState): VoiceSetStateAction;
+const START_DICTATE = 'WEB_CHAT/START_DICTATE';
 
-declare function startDictate(): {
-    type: string;
-};
+function startDictate() {
+  return { type: START_DICTATE };
+}
 
-declare function startSpeakingActivity(): {
-    type: string;
-};
+const START_SPEAKING_ACTIVITY = 'WEB_CHAT/START_SPEAKING';
 
-declare const VOICE_START_RECORDING: "WEB_CHAT/VOICE_START_RECORDING";
-type VoiceStartRecordingAction = {
-    type: typeof VOICE_START_RECORDING;
-};
-declare function startVoiceRecording(): VoiceStartRecordingAction;
+function startSpeakingActivity() {
+  return {
+    type: START_SPEAKING_ACTIVITY
+  };
+}
 
-declare function stopDictate(): {
-    type: string;
-};
+const STOP_DICTATE = 'WEB_CHAT/STOP_DICTATE';
 
-declare function stopSpeakingActivity(): {
-    type: string;
-};
+function stopDictate() {
+  return { type: STOP_DICTATE };
+}
 
-declare const VOICE_STOP_RECORDING: "WEB_CHAT/VOICE_STOP_RECORDING";
-type VoiceStopRecordingAction = {
-    type: typeof VOICE_STOP_RECORDING;
-};
-declare function stopVoiceRecording(): VoiceStopRecordingAction;
+const STOP_SPEAKING_ACTIVITY = 'WEB_CHAT/STOP_SPEAKING';
 
-declare function submitSendBox(method?: string, { channelData }?: {
-    channelData: any;
-}): {
-    type: string;
-    payload: {
-        channelData: any;
-        method: string;
-    };
+function stopSpeakingActivity() {
+  return {
+    type: STOP_SPEAKING_ACTIVITY
+  };
+}
+
+const SUBMIT_SEND_BOX = 'WEB_CHAT/SUBMIT_SEND_BOX';
+
+function submitSendBox(method = 'keyboard', { channelData } = {}) {
+  return {
+    type: SUBMIT_SEND_BOX,
+    payload: { channelData, method }
+  };
+}
+
+type GlobalScopeClock = {
+    cancelAnimationFrame?: typeof cancelAnimationFrame;
+    cancelIdleCallback?: typeof cancelIdleCallback;
+    clearImmediate?: typeof clearImmediate;
+    clearInterval: typeof clearInterval;
+    clearTimeout: typeof clearTimeout;
+    Date: typeof Date;
+    requestAnimationFrame?: typeof requestAnimationFrame;
+    requestIdleCallback?: typeof requestIdleCallback;
+    setImmediate?: typeof setImmediate;
+    setInterval: typeof setInterval;
+    setTimeout: typeof setTimeout;
 };
 
-declare const VOICE_UNMUTE_RECORDING: "WEB_CHAT/VOICE_UNMUTE_RECORDING";
-type VoiceUnmuteRecordingAction = {
-    type: typeof VOICE_UNMUTE_RECORDING;
+/**
+ * Ponyfills that are supported by Web Chat.
+ *
+ * If ponyfill is passed, Web Chat will use this ponyfill rather than the one from `globalThis` or `window` object.
+ */
+type GlobalScopePonyfill = GlobalScopeClock;
+
+type CreateStoreOptions = {
+    /**
+     * True, to enable Redux development tools, otherwise, false.
+     *
+     * Because Web Chat use sagas for business logics, some store state are keep at JavaScript heaps.
+     * Time-travelling and saving/restoring store state are not supported.
+     */
+    devTools?: boolean;
+    /**
+     * Ponyfill to overrides specific global scope members.
+     *
+     * This option is for development use only. Not all features in Web Chat are ponyfilled.
+     *
+     * To fake timers, `setTimeout` and related functions can be passed to overrides the original global scope members.
+     *
+     * Please see [#4662](https://github.com/microsoft/BotFramework-WebChat/pull/4662) for details.
+     */
+    ponyfill?: Partial<GlobalScopePonyfill>;
 };
-declare function unmuteVoiceRecording(): VoiceUnmuteRecordingAction;
+/**
+ * Creates a Redux store internally used by Web Chat.
+ *
+ * This store is critical for Web Chat business logics to operate, please use with cautions.
+ */
+declare function withOptions(options: CreateStoreOptions, initialState?: any, ...middlewares: any[]): Store;
+/**
+ * Creates a Redux store internally used by Web Chat.
+ *
+ * This store is critical for Web Chat business logics to operate, please use with cautions.
+ */
+declare function createStore(initialState?: any, ...middlewares: any[]): Store;
+/**
+ * Creates a Redux store internally used by Web Chat, with Redux development tools.
+ *
+ * This store is critical for Web Chat business logics to operate, please use with cautions.
+ *
+ * @deprecated Use `withOptions` instead and pass `{ devTools: true }`
+ */
+declare function withDevTools(initialState?: any, ...middlewares: any[]): Store;
 
-declare const VOICE_UNREGISTER_HANDLER: "WEB_CHAT/VOICE_UNREGISTER_HANDLER";
-type VoiceUnregisterHandlerAction = {
-    type: typeof VOICE_UNREGISTER_HANDLER;
-    payload: {
-        id: string;
-    };
+type OneOrMany<T> = T | T[];
+
+/**
+ * The most generic type of item.
+ *
+ * This is partial implementation of https://schema.org/Thing.
+ *
+ * @see https://schema.org/Thing
+ */
+type Thing = {
+    '@context'?: 'https://schema.org' | undefined;
+    '@id'?: string | undefined;
+    '@type': string;
+    /**
+     * An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. Typically the value is a URI-identified RDF class, and in this case corresponds to the use of rdf:type in RDF. Text values can be used sparingly, for cases where useful information can be added without their being an appropriate schema to reference. In the case of text values, the class label should follow the schema.org [style guide](https://schema.org/docs/styleguide.html).
+     *
+     * @see https://schema.org/additionalType
+     */
+    additionalType?: string | undefined;
+    /**
+     * An alias for the item.
+     *
+     * @see https://schema.org/alternateName
+     */
+    alternateName?: string | undefined;
+    /**
+     * A description of the item.
+     *
+     * @see https://schema.org/description
+     */
+    description?: string | undefined;
+    /**
+     * The name of the item.
+     *
+     * @see https://schema.org/name
+     */
+    name?: string | undefined;
+    /**
+     * Indicates a potential Action, which describes an idealized action in which this thing would play an 'object' role.
+     *
+     * @see https://schema.org/potentialAction
+     */
+    potentialAction?: readonly Action[] | undefined;
+    /**
+     * URL of the item.
+     *
+     * @see https://schema.org/url
+     */
+    url?: string | undefined;
+};
+declare const parseThing: (data: unknown) => Thing;
+
+/**
+ * An enterprise (potentially individual but typically collaborative), planned to achieve a particular aim. Use properties from [Organization](https://schema.org/Organization), [subOrganization](https://schema.org/subOrganization)/[parentOrganization](https://schema.org/parentOrganization) to indicate project sub-structures.
+ *
+ * This is partial implementation of https://schema.org/Project.
+ *
+ * @see https://schema.org/Project
+ */
+type Project = Thing & {
+    /**
+     * A slogan or motto associated with the item.
+     *
+     * @see https://schema.org/slogan
+     */
+    slogan?: string | undefined;
 };
-declare function unregisterVoiceHandler(id: string): VoiceUnregisterHandlerAction;
+declare const parseProject: (data: unknown) => Project;
 
-/** @deprecated This constant is being deprecated, please use string literal instead. Will be remove on or after 2024-07-31. */
-declare const SEND_FAILED: "send failed";
-/** @deprecated This constant is being deprecated, please use string literal instead. Will be remove on or after 2024-07-31. */
-declare const SENDING: "sending";
-/** @deprecated This constant is being deprecated, please use string literal instead. Will be remove on or after 2024-07-31. */
-declare const SENT: "sent";
+/**
+ * An action performed by a direct agent and indirect participants upon a direct object. Optionally happens at a location with the help of an inanimate instrument. The execution of the action may produce a result. Specific action sub-type documentation specifies the exact expectation of each argument/role.
+ *
+ * See also [blog post](http://blog.schema.org/2014/04/announcing-schemaorg-actions.html) and [Actions overview document](https://schema.org/docs/actions.html).
+ *
+ * This is partial implementation of https://schema.org/Action.
+ *
+ * @see https://schema.org/Action
+ */
+type Action = Thing & {
+    /**
+     * Indicates the current disposition of the Action.
+     *
+     * @see https://schema.org/actionStatus
+     */
+    actionStatus?: 'ActiveActionStatus' | 'CompletedActionStatu' | 'FailedActionStatus' | 'PotentialActionStatus' | undefined;
+    /**
+     * The service provider, service operator, or service performer; the goods producer. Another party (a seller) may offer those services or goods on behalf of the provider. A provider may also serve as the seller. Supersedes [carrier](https://schema.org/carrier).
+     *
+     * @see https://schema.org/provider
+     */
+    provider?: Project | undefined;
+};
+declare const parseAction: (data: unknown) => Action;
 
-declare const ActivityClientState_SENDING: typeof SENDING;
-declare const ActivityClientState_SEND_FAILED: typeof SEND_FAILED;
-declare const ActivityClientState_SENT: typeof SENT;
-declare namespace ActivityClientState {
-  export { ActivityClientState_SENDING as SENDING, ActivityClientState_SEND_FAILED as SEND_FAILED, ActivityClientState_SENT as SENT };
-}
+/**
+ * A word, name, acronym, phrase, etc. with a formal definition. Often used in the context of category or subject classification, glossaries or dictionaries, product or creative work types, etc. Use the name property for the term being defined, use termCode if the term has an alpha-numeric code allocated, use description to provide the definition of the term.
+ *
+ * This is partial implementation of https://schema.org/DefinedTerm.
+ *
+ * @see https://schema.org/DefinedTerm
+ */
+type DefinedTerm = Thing & {
+    /**
+     * A [DefinedTermSet](https://schema.org/DefinedTermSet) that contains this term.
+     *
+     * @see https://schema.org/inDefinedTermSet
+     */
+    inDefinedTermSet?: string | undefined;
+    /**
+     * A code that identifies this [DefinedTerm](https://schema.org/DefinedTerm) within a [DefinedTermSet](https://schema.org/DefinedTermSet).
+     *
+     * @see https://schema.org/termCode
+     */
+    termCode?: string | undefined;
+};
+declare const parseDefinedTerm: (data: unknown) => DefinedTerm;
 
-declare const IDLE: 0;
-declare const WILL_START: 1;
-declare const STARTING: 2;
-declare const DICTATING: 3;
-declare const STOPPING: 4;
-
-declare const DictateState_DICTATING: typeof DICTATING;
-declare const DictateState_IDLE: typeof IDLE;
-declare const DictateState_STARTING: typeof STARTING;
-declare const DictateState_STOPPING: typeof STOPPING;
-declare const DictateState_WILL_START: typeof WILL_START;
-declare namespace DictateState {
-  export { DictateState_DICTATING as DICTATING, DictateState_IDLE as IDLE, DictateState_STARTING as STARTING, DictateState_STOPPING as STOPPING, DictateState_WILL_START as WILL_START };
-}
+/**
+ * The most generic kind of creative work, including books, movies, photographs, software programs, etc.
+ *
+ * This is partial implementation of https://schema.org/CreativeWork.
+ *
+ * @see https://schema.org/CreativeWork
+ */
+type CreativeWork = Thing & {
+    /**
+     * An abstract is a short description that summarizes a [CreativeWork](https://schema.org/CreativeWork).
+     *
+     * @see https://schema.org/abstract
+     */
+    abstract?: string | undefined;
+    /**
+     * The author of this content or rating. Please note that author is special in that HTML 5 provides a special mechanism for indicating authorship via the rel tag. That is equivalent to this and may be used interchangeably.
+     *
+     * @see https://schema.org/author
+     */
+    author?: string | undefined;
+    /**
+     * A citation or reference to another creative work, such as another publication, web page, scholarly article, etc.
+     *
+     * @see https://schema.org/citation
+     */
+    citation?: readonly CreativeWork[] | undefined;
+    /**
+     * Keywords or tags used to describe some item. Multiple textual entries in a keywords list are typically delimited by commas, or by repeating the property.
+     *
+     * @see https://schema.org/keywords
+     */
+    keywords?: readonly (DefinedTerm | string)[] | undefined;
+    /**
+     * A pattern that something has, for example 'polka dot', 'striped', 'Canadian flag'. Values are typically expressed as text, although links to controlled value schemes are also supported.
+     *
+     * @see https://schema.org/pattern
+     */
+    pattern?: DefinedTerm | undefined;
+    /**
+     * The textual content of this CreativeWork.
+     *
+     * @see https://schema.org/text
+     */
+    text?: string | undefined;
+    /**
+     * The schema.org [usageInfo](https://schema.org/usageInfo) property indicates further information about a [CreativeWork](https://schema.org/CreativeWork). This property is applicable both to works that are freely available and to those that require payment or other transactions. It can reference additional information, e.g. community expectations on preferred linking and citation conventions, as well as purchasing details. For something that can be commercially licensed, usageInfo can provide detailed, resource-specific information about licensing options.
+     *
+     * This property can be used alongside the license property which indicates license(s) applicable to some piece of content. The usageInfo property can provide information about other licensing options, e.g. acquiring commercial usage rights for an image that is also available under non-commercial creative commons licenses.
+     */
+    usageInfo?: CreativeWork | undefined;
+};
+declare const parseCreativeWork: (data: unknown) => CreativeWork;
+
+/**
+ * A [Claim](https://schema.org/Claim) in Schema.org represents a specific, factually-oriented claim that could be the [itemReviewed](https://schema.org/itemReviewed) in a [ClaimReview](https://schema.org/ClaimReview). The content of a claim can be summarized with the [text](https://schema.org/text) property. Variations on well known claims can have their common identity indicated via [sameAs](https://schema.org/sameAs) links, and summarized with a name. Ideally, a [Claim](https://schema.org/Claim) description includes enough contextual information to minimize the risk of ambiguity or inclarity. In practice, many claims are better understood in the context in which they appear or the interpretations provided by claim reviews.
+ *
+ * Beyond [ClaimReview](https://schema.org/ClaimReview), the Claim type can be associated with related creative works - for example a [ScholarlyArticle](https://schema.org/ScholarlyArticle) or [Question](https://schema.org/Question) might be about some [Claim](https://schema.org/Claim).
+ *
+ * This is partial implementation of https://schema.org/Claim.
+ *
+ * @see https://schema.org/Claim.
+ */
+type Claim = CreativeWork & {
+    /**
+     * Indicates an occurrence of a [Claim](https://schema.org/Claim) in some [CreativeWork](https://schema.org/CreativeWork).
+     *
+     * @see https://schema.org/appearance.
+     */
+    appearance?: CreativeWork | undefined;
+    /**
+     * For a [Claim](https://schema.org/Claim) interpreted from [MediaObject](https://schema.org/MediaObject) content sed to indicate a claim contained, implied or refined from the content of a [MediaObject](https://schema.org/MediaObject).
+     *
+     * @see https://schema.org/claimInterpreter.
+     */
+    claimInterpreter?: Project | undefined;
+    /**
+     * The position of an item in a series or sequence of items.
+     *
+     * @see https://schema.org/position.
+     */
+    position?: number | string;
+};
+declare const parseClaim: (data: unknown) => Claim;
 
 /**
- * Gets the livestreaming metadata of the activity, or `undefined` if the activity is not participating in a livestreaming session.
- *
- * - `sessionId` - ID of the livestreaming session
- * - `sequenceNumber` - sequence number of the activity
- * - `type`
- *   - `"contentless"` - ongoing but no content, should show indicator
- *   - `"interim activity"` - current response, could be partial-from-start, or complete response.
- *     More activities are expected. Future interim activities always replace past interim activities, enable erasing or backtracking response.
- *   - `"informative message"` - optional side-channel informative message describing the current response, e.g. "Searching your document library".
- *     Always replace past informative messages. May interleave with interim activities.
- *   - `"final activity"` - complete-and-final response, always replace past interim activities and remove all informative messages.
- *     This activity indicates end of the session, all future activities must be ignored.
- *   - `undefined` - not part of a livestream session or the activity is not valid
- *
- * @returns {object} Livestreaming metadata of the activity, or `undefined` if the activity is not participating in a livestreaming session.
+ * An action performed by a direct agent and indirect participants upon a direct object. Optionally happens at a location with the help of an inanimate instrument. The execution of the action may produce a result. Specific action sub-type documentation specifies the exact expectation of each argument/role.
+ *
+ * See also [blog post](http://blog.schema.org/2014/04/announcing-schemaorg-actions.html) and [Actions overview document](https://schema.org/docs/actions.html).
+ *
+ * This is partial implementation of https://schema.org/Action.
+ *
+ * @see https://schema.org/Action
  */
-declare function getActivityLivestreamingMetadata(activity: WebChatActivity): Readonly<{
-    sessionId: string;
-    sequenceNumber: number;
-    type: 'contentless' | 'final activity' | 'informative message' | 'interim activity';
-}> | undefined;
+type VoteAction = Action & {
+    /**
+     * A sub property of object. The options subject to this action. Supersedes [option](https://schema.org/option).
+     *
+     * @see https://schema.org/VoteAction
+     */
+    actionOption?: string | undefined;
+};
+declare const parseVoteAction: (data: unknown) => VoteAction;
+
+declare function getOrgSchemaMessage(graph: readonly WebChatActivity['entities'][0][]): CreativeWork | undefined;
 
-type EntityType = NonNullable<WebChatActivity['entities']>[number];
-declare function getOrgSchemaMessage(graph: readonly EntityType[]): CreativeWorkOutput | undefined;
+declare function isForbiddenPropertyName(propertyName: string): boolean;
 
 declare function onErrorResumeNext<T>(fn: () => T): T | undefined;
 declare function onErrorResumeNext<T, U = T>(fn: () => T, defaultValue: U): T | U;
 
-declare const getVoiceActivityRole: (activity: WebChatActivity) => "bot" | "user" | undefined;
-
-declare const getVoiceActivityText: (activity: WebChatActivity) => string | undefined;
-
-declare const VoiceActivitySchema: valibot.ObjectSchema<{
-    readonly name: valibot.StringSchema<undefined>;
-    readonly type: valibot.LiteralSchema<"event", undefined>;
-    readonly value: valibot.LooseObjectSchema<{}, undefined>;
-    readonly valueType: valibot.SchemaWithPipe<readonly [valibot.StringSchema<undefined>, valibot.CheckAction<string, undefined>]>;
-}, undefined>;
-declare const isVoiceActivity: (activity: WebChatActivity) => activity is WebChatActivity & InferOutput<typeof VoiceActivitySchema>;
-
-declare const VoiceTranscriptActivitySchema: valibot.ObjectSchema<{
-    readonly name: valibot.LiteralSchema<"media.end", undefined>;
-    readonly type: valibot.LiteralSchema<"event", undefined>;
-    readonly value: valibot.ObjectSchema<{
-        readonly origin: valibot.PicklistSchema<["agent", "user"], undefined>;
-        readonly transcription: valibot.StringSchema<undefined>;
-    }, undefined>;
-    readonly valueType: valibot.SchemaWithPipe<readonly [valibot.StringSchema<undefined>, valibot.CheckAction<string, undefined>]>;
-}, undefined>;
-declare const isVoiceTranscriptActivity: (activity: WebChatActivity) => activity is WebChatActivity & InferOutput<typeof VoiceTranscriptActivitySchema>;
-
-declare const CLEAR_SUGGESTED_ACTIONS: "WEB_CHAT/CLEAR_SUGGESTED_ACTIONS";
-declare const clearSuggestedActionsActionSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
-    readonly type: valibot.LiteralSchema<"WEB_CHAT/CLEAR_SUGGESTED_ACTIONS", undefined>;
-}, undefined>, valibot.ReadonlyAction<{
-    type: "WEB_CHAT/CLEAR_SUGGESTED_ACTIONS";
-}>]>;
-type ClearSuggestedActionsAction = InferOutput<typeof clearSuggestedActionsActionSchema>;
-declare function clearSuggestedActions(): ClearSuggestedActionsAction;
-
-declare const SET_SUGGESTED_ACTIONS: "WEB_CHAT/SET_SUGGESTED_ACTIONS";
-declare const setSuggestedActionsActionSchema: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
-    readonly payload: valibot.SchemaWithPipe<readonly [valibot.ObjectSchema<{
-        readonly originActivity: valibot.OptionalSchema<valibot.CustomSchema<WebChatActivity, undefined>, undefined>;
-        readonly suggestedActions: valibot.SchemaWithPipe<readonly [valibot.ArraySchema<valibot.CustomSchema<DirectLineCardAction, undefined>, undefined>, valibot.ReadonlyAction<DirectLineCardAction[]>]>;
-    }, undefined>, valibot.ReadonlyAction<{
-        originActivity?: WebChatActivity;
-        readonly suggestedActions: readonly DirectLineCardAction[];
-    }>]>;
-    readonly type: valibot.LiteralSchema<"WEB_CHAT/SET_SUGGESTED_ACTIONS", undefined>;
-}, undefined>, valibot.ReadonlyAction<{
-    readonly payload: Readonly<{
-        originActivity?: WebChatActivity;
-        readonly suggestedActions: readonly DirectLineCardAction[];
-    }>;
-    type: "WEB_CHAT/SET_SUGGESTED_ACTIONS";
-}>]>;
-type SetSuggestedActionsAction = InferOutput<typeof setSuggestedActionsActionSchema>;
-declare function setSuggestedActions(suggestedActions?: readonly DirectLineCardAction[], originActivity?: undefined | WebChatActivity): SetSuggestedActionsAction;
-
-type DirectLineActivity = Exclude<any, [] | boolean | ((...args: unknown[]) => unknown) | number | string>;
+declare function singleToArray<T>(singleOrArray: T | T[]): T[];
+
+declare function warnOnce(message: string): () => void;
+
+type DirectLineActivity = Exclude<any, [] | boolean | Function | number | string>;
 
 type DirectLineMediaCardEssence = {
     aspect?: '4:3' | '16:9';
@@ -520,7 +916,7 @@ declare class Subscription {
  */
 declare class Observer<T> {
     /** Receives the subscription object when `subscribe` is called */
-    start(subscription: Subscription): void;
+    start(subscription: Subscription): any;
     /** Receives the next value in the sequence */
     next: NextFunction<T>;
     /** Receives the sequence error */
@@ -541,16 +937,15 @@ declare class SubscriptionObserver<T> {
 }
 
 declare const Constants: {
-    ActivityClientState: typeof ActivityClientState;
-    DictateState: typeof DictateState;
-};
-
-declare const buildInfoObject: {
-    readonly buildTool?: string | undefined;
-    readonly moduleFormat?: string | undefined;
-    readonly version?: string | undefined;
+    ActivityClientState: any;
+    DictateState: any;
 };
+declare const moduleFormat: string;
 declare const version: string;
+declare const buildInfo: {
+    buildTool: string;
+    moduleFormat: string;
+    version: string;
+};
 
-export { CLEAR_SUGGESTED_ACTIONS, Constants, DirectLineCardAction, Observable, SET_SUGGESTED_ACTIONS, WebChatActivity, buildInfoObject as buildInfo, clearSuggestedActions, clearSuggestedActionsActionSchema, connect, disconnect, dismissNotification, emitTypingIndicator, getActivityLivestreamingMetadata, getOrgSchemaMessage, getVoiceActivityRole, getVoiceActivityText, isVoiceActivity, isVoiceTranscriptActivity, markActivity, muteVoiceRecording, onErrorResumeNext, postActivity, postVoiceActivity, registerVoiceHandler, sendEvent, sendFiles, sendMessage, sendMessageback as sendMessageBack, sendPostback as sendPostBack, setDictateInterims, setDictateState, setLanguage, setNotification, setSendBox, setSendBoxAttachments, setSendTimeout, setSendTypingIndicator, setSuggestedActions, setSuggestedActionsActionSchema, setVoiceState, startDictate, startSpeakingActivity, startVoiceRecording, stopDictate, stopSpeakingActivity, stopVoiceRecording, submitSendBox, unmuteVoiceRecording, unregisterVoiceHandler, version };
-export type { ClearSuggestedActionsAction, DirectLineActivity, DirectLineAnimationCard, DirectLineAudioCard, DirectLineHeroCard, DirectLineJSBotConnection, DirectLineOAuthCard, DirectLineReceiptCard, DirectLineSignInCard, DirectLineThumbnailCard, DirectLineVideoCard, SendBoxAttachment, SetSuggestedActionsAction, VoiceHandler, VoiceState };
+export { Constants, type DirectLineActivity, type DirectLineAnimationCard, type DirectLineAttachment, type DirectLineAudioCard, type DirectLineCardAction, type DirectLineHeroCard, type DirectLineJSBotConnection, type DirectLineOAuthCard, type DirectLineReceiptCard, type DirectLineSignInCard, type DirectLineSuggestedAction, type DirectLineThumbnailCard, type DirectLineVideoCard, type GlobalScopePonyfill, Observable, type OneOrMany, type Action as OrgSchemaAction, type Claim as OrgSchemaClaim, type CreativeWork as OrgSchemaCreativeWork, type DefinedTerm as OrgSchemaDefinedTerm, type Project as OrgSchemaProject, type Thing as OrgSchemaThing, type SendBoxAttachment, type WebChatActivity, buildInfo, clearSuggestedActions, connect, createStore, withDevTools as createStoreWithDevTools, withOptions as createStoreWithOptions, disconnect, dismissNotification, emitTypingIndicator, getOrgSchemaMessage, isForbiddenPropertyName, markActivity, moduleFormat, onErrorResumeNext, parseAction, parseClaim, parseCreativeWork, parseDefinedTerm, parseProject, parseThing, parseVoteAction, postActivity, sendEvent, sendFiles, sendMessage, sendMessageback as sendMessageBack, sendPostback as sendPostBack, setDictateInterims, setDictateState, setLanguage, setNotification, setSendBox, setSendBoxAttachments, setSendTimeout, setSendTypingIndicator, singleToArray, startDictate, startSpeakingActivity, stopDictate, stopSpeakingActivity, submitSendBox, version, warnOnce };