@kaltura-sdk/avatars 1.14.0

package/src/lib/avatar-client-manager/machines/avatar-connection/states/connected-state.d.ts

@@ -0,0 +1,751 @@
+export declare const connectedState: {
+    id: string;
+    type: "parallel";
+    entry: readonly ["sendAvatarConversationStartedAnalyticsEvent"];
+    invoke: {
+        src: "onWebSocketNonRecoveredReconnect";
+        input: ({ context }: {
+            context: import("../types").AvatarConnectionMachineContext;
+            event: import("../types").AvatarConnectionMachineEvents;
+            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+        }) => {
+            logger: import("@unisphere/core").UnisphereLoggerType;
+        };
+    };
+    on: {
+        WebsocketReconnected: {
+            actions: "cleanupRtcAndSetPeerId";
+            target: string;
+        };
+    };
+    states: {
+        conversation: {
+            id: string;
+            invoke: ({
+                src: "onConversationEnded";
+                input: ({ context }: {
+                    context: import("../types").AvatarConnectionMachineContext;
+                    event: import("../types").AvatarConnectionMachineEvents;
+                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                }) => {
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                };
+            } | {
+                src: "onAgentTalking";
+                input: ({ context }: {
+                    context: import("../types").AvatarConnectionMachineContext;
+                    event: import("../types").AvatarConnectionMachineEvents;
+                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                }) => {
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                };
+            } | {
+                src: "onConversationTimeWarning";
+                input: ({ context }: {
+                    context: import("../types").AvatarConnectionMachineContext;
+                    event: import("../types").AvatarConnectionMachineEvents;
+                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                }) => {
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                };
+            })[];
+            on: {
+                ConversationEndedReceived: {
+                    actions: {
+                        type: "setDisconnectData";
+                        params: {
+                            reason: import("dist/unisphere/packages/unisphere/types/src").DisconnectReasons;
+                        };
+                    };
+                    target: string;
+                };
+                AgentStartedTalkingReceived: {
+                    actions: readonly ["setAgentTalking", "sendAvatarAnswerAnalyticsEvent"];
+                };
+                AgentFinishedTalkingReceived: {
+                    actions: "setAgentTalking";
+                };
+                ConversationTimeWarningReceived: {
+                    actions: "showTimeWarningNotification";
+                };
+            };
+        };
+        content: {
+            id: string;
+            invoke: {
+                src: "onAgentRawText";
+                input: ({ context }: {
+                    context: import("../types").AvatarConnectionMachineContext;
+                    event: import("../types").AvatarConnectionMachineEvents;
+                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                }) => {
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                };
+            }[];
+            on: {
+                SetContent: {
+                    actions: readonly ["setContentData"];
+                };
+                AgentRawTextMessageCompleted: {
+                    actions: readonly ["setContentData"];
+                };
+            };
+        };
+        textCommunication: {
+            id: string;
+            initial: string;
+            on: {
+                AskViaText: {
+                    actions: ("appendUserTextEntry" | {
+                        type: "sendAskViaText";
+                        params: ({ event }: {
+                            event: import("../types").AskViaTextEvent;
+                        }) => {
+                            message: string;
+                        };
+                    })[];
+                };
+            };
+            states: {
+                unknown: {
+                    always: ({
+                        guard: "isTextChatEnabled";
+                        target: string;
+                    } | {
+                        target: string;
+                        guard?: undefined;
+                    })[];
+                };
+                enabled: {
+                    invoke: {
+                        src: "onChatLog";
+                        input: ({ context }: {
+                            context: import("../types").AvatarConnectionMachineContext;
+                            event: import("../types").AvatarConnectionMachineEvents;
+                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                        }) => {
+                            logger: import("@unisphere/core").UnisphereLoggerType;
+                        };
+                    }[];
+                    on: {
+                        AvatarChatEntryReceived: {
+                            actions: "appendAvatarChatEntry";
+                        };
+                        UserVoiceTurnReceived: {
+                            actions: "appendUserChatEntry";
+                        };
+                    };
+                };
+                disabled: {};
+            };
+        };
+        screenSharing: {
+            id: string;
+            initial: string;
+            states: {
+                idle: {
+                    on: {
+                        StartScreenShare: {
+                            target: string;
+                        };
+                    };
+                };
+                active: {
+                    entry: "sendScreenSharePending";
+                    initial: string;
+                    invoke: {
+                        src: "screenCaptureCycle";
+                        input: ({ context }: {
+                            context: import("../types").AvatarConnectionMachineContext;
+                        }) => {
+                            logger: import("@unisphere/core").UnisphereLoggerType;
+                            serverUrl: string;
+                        };
+                    };
+                    on: {
+                        StopScreenShare: {
+                            target: string;
+                            actions: ("sendScreenShareStopped" | {
+                                type: "setScreenShareActive";
+                                params: {
+                                    active: boolean;
+                                };
+                            })[];
+                        };
+                        ScreenShareEnded: {
+                            target: string;
+                            actions: ("sendScreenShareStopped" | {
+                                type: "setScreenShareActive";
+                                params: {
+                                    active: boolean;
+                                };
+                            })[];
+                        };
+                        ScreenShareError: {
+                            target: string;
+                            actions: ("sendScreenShareStopped" | "showScreenShareErrorNotification" | {
+                                type: "setScreenShareActive";
+                                params: {
+                                    active: boolean;
+                                };
+                            })[];
+                        };
+                    };
+                    states: {
+                        preparing: {
+                            on: {
+                                ScreenShareStreamAcquired: {
+                                    actions: ("sendScreenShareStarted" | {
+                                        type: "setScreenShareActive";
+                                        params: {
+                                            active: boolean;
+                                            ready?: undefined;
+                                        };
+                                    } | {
+                                        type: "setScreenAnalysisReady";
+                                        params: {
+                                            ready: boolean;
+                                            active?: undefined;
+                                        };
+                                    } | {
+                                        type: "setScreenShareStream";
+                                        params: ({ event, }: {
+                                            event: import("../types").ScreenShareStreamAcquiredEvent;
+                                        }) => {
+                                            stream: MediaStream;
+                                        };
+                                    })[];
+                                    target: string;
+                                };
+                            };
+                        };
+                        streaming: {
+                            invoke: {
+                                src: "onScreenAnalysisReady";
+                                input: ({ context, }: {
+                                    context: import("../types").AvatarConnectionMachineContext;
+                                }) => {
+                                    logger: import("@unisphere/core").UnisphereLoggerType;
+                                };
+                            };
+                            on: {
+                                ScreenAnalysisReady: {
+                                    actions: {
+                                        type: "setScreenAnalysisReady";
+                                        params: {
+                                            ready: boolean;
+                                        };
+                                    }[];
+                                };
+                            };
+                            after: {
+                                3000: {
+                                    guard: "isAnalysisNotReady";
+                                    actions: ({
+                                        type: "setScreenAnalysisReady";
+                                        params: {
+                                            ready: boolean;
+                                            delayMs?: undefined;
+                                        };
+                                    } | {
+                                        type: "logAnalysisReadyFallback";
+                                        params: {
+                                            delayMs: number;
+                                            ready?: undefined;
+                                        };
+                                    })[];
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        pauseLifecycle: {
+            id: string;
+            initial: "idle";
+            states: {
+                idle: {
+                    on: {
+                        RequestAvatarPause: {
+                            target: "paused";
+                        };
+                        RequestAvatarPauseAfterSpeaking: {
+                            target: "pendingPause";
+                        };
+                    };
+                };
+                pendingPause: {
+                    on: {
+                        AgentFinishedTalkingReceived: {
+                            target: "paused";
+                        };
+                        RequestAvatarResume: {
+                            target: "idle";
+                        };
+                    };
+                    always: {
+                        guard: import("xstate").GuardPredicate<import("xstate").MachineContext, import("xstate").EventObject, unknown, {
+                            type: "isAgentTalking";
+                            params: undefined;
+                        }>;
+                        target: string;
+                    };
+                };
+                paused: {
+                    entry: ("sendPauseConversation" | "muteAsr" | "captureUserMuteState" | "sendTapToTalkEnd" | "raiseRequestTapToTalkEnd" | {
+                        type: "setTapToTalkActive";
+                        params: {
+                            active: boolean;
+                            startedAt?: undefined;
+                        };
+                    } | {
+                        type: "setTapToTalkStartedAt";
+                        params: {
+                            startedAt: null;
+                            active?: undefined;
+                        };
+                    })[];
+                    invoke: {
+                        src: "onPauseExpiryEvents";
+                        input: ({ context }: {
+                            context: import("../types").AvatarConnectionMachineContext;
+                            event: import("../types").AvatarConnectionMachineEvents;
+                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                        }) => {
+                            logger: import("@unisphere/core").UnisphereLoggerType;
+                        };
+                    }[];
+                    on: {
+                        PauseExpiryWarningReceived: {
+                            actions: readonly ["extendPauseTimeout"];
+                        };
+                        PauseSessionExpiredReceived: {
+                            target: "expired";
+                        };
+                        RequestAvatarResume: {
+                            target: "resuming";
+                        };
+                    };
+                };
+                expired: {
+                    entry: readonly ["leaveAsr"];
+                    invoke: {
+                        src: "onSessionReadyForResume";
+                        input: ({ context }: {
+                            context: import("../types").AvatarConnectionMachineContext;
+                            event: import("../types").AvatarConnectionMachineEvents;
+                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                        }) => {
+                            logger: import("@unisphere/core").UnisphereLoggerType;
+                        };
+                    }[];
+                    on: {
+                        SessionReadyForResumeReceived: {
+                            target: "expiredServerReady";
+                        };
+                        RequestAvatarResume: {
+                            target: "waitingForServerReady";
+                        };
+                    };
+                };
+                expiredServerReady: {
+                    on: {
+                        RequestAvatarResume: {
+                            target: "#AvatarClient.connecting.reconnectingFromExpiry";
+                            actions: readonly ["sendResumeConversation"];
+                        };
+                    };
+                };
+                waitingForServerReady: {
+                    invoke: {
+                        src: "onSessionReadyForResume";
+                        input: ({ context }: {
+                            context: import("../types").AvatarConnectionMachineContext;
+                            event: import("../types").AvatarConnectionMachineEvents;
+                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                        }) => {
+                            logger: import("@unisphere/core").UnisphereLoggerType;
+                        };
+                    }[];
+                    on: {
+                        SessionReadyForResumeReceived: {
+                            target: "#AvatarClient.connecting.reconnectingFromExpiry";
+                            actions: readonly ["sendResumeConversation"];
+                        };
+                    };
+                };
+                resuming: {
+                    entry: readonly ["unmuteAsr", "sendResumeConversation"];
+                    invoke: {
+                        src: "onConversationResumed";
+                        input: ({ context }: {
+                            context: import("../types").AvatarConnectionMachineContext;
+                            event: import("../types").AvatarConnectionMachineEvents;
+                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                        }) => {
+                            logger: import("@unisphere/core").UnisphereLoggerType;
+                        };
+                    }[];
+                    on: {
+                        ConversationResumedReceived: {
+                            target: "idle";
+                        };
+                    };
+                };
+            };
+        };
+        captions: {
+            id: string;
+            initial: string;
+            states: {
+                unknown: {
+                    always: ({
+                        guard: "isCaptionsEnabled";
+                        target: string;
+                    } | {
+                        target: string;
+                        guard?: undefined;
+                    })[];
+                };
+                enabled: {
+                    initial: string;
+                    invoke: {
+                        src: "onCaptions";
+                        input: ({ context }: {
+                            context: import("../types").AvatarConnectionMachineContext;
+                            event: import("../types").AvatarConnectionMachineEvents;
+                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                        }) => {
+                            logger: import("@unisphere/core").UnisphereLoggerType;
+                            config: boolean | import("dist/unisphere/packages/unisphere/types/src").CaptionConfig;
+                        };
+                    }[];
+                    states: {
+                        visible: {
+                            on: {
+                                ToggleCaptions: {
+                                    target: string;
+                                };
+                                CaptionStateUpdated: {
+                                    actions: "setCaptionState";
+                                };
+                            };
+                        };
+                        hidden: {
+                            entry: "clearCaptionState";
+                            on: {
+                                ToggleCaptions: {
+                                    target: string;
+                                };
+                            };
+                        };
+                    };
+                };
+                disabled: {};
+            };
+        };
+        sessionKickoff: {
+            id: string;
+            initial: string;
+            states: {
+                unknown: {
+                    always: ({
+                        guard: "isSessionKickoffRequested";
+                        target: string;
+                    } | {
+                        target: string;
+                        guard?: undefined;
+                    })[];
+                };
+                enabled: {
+                    invoke: {
+                        src: "onSessionKickoffEvents";
+                        input: ({ context }: {
+                            context: import("../types").AvatarConnectionMachineContext;
+                            event: import("../types").AvatarConnectionMachineEvents;
+                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                        }) => {
+                            logger: import("@unisphere/core").UnisphereLoggerType;
+                        };
+                    }[];
+                    on: {
+                        SessionKickOffRequired: ({
+                            guard: ({ event }: {
+                                event: import("../types").SessionKickOffRequiredEvent;
+                            }) => boolean;
+                            actions: {
+                                type: "setSessionKickoffRequired";
+                                params: ({ event }: {
+                                    event: import("../types").SessionKickOffRequiredEvent;
+                                }) => boolean;
+                            };
+                            target: string;
+                        } | {
+                            actions: {
+                                type: "setSessionKickoffRequired";
+                                params: ({ event }: {
+                                    event: import("../types").SessionKickOffRequiredEvent;
+                                }) => boolean;
+                            };
+                            guard?: undefined;
+                            target?: undefined;
+                        })[];
+                        AgentFinishedTalkingReceived: {
+                            guard: "isSessionKickoffActive";
+                            actions: ("raiseAskViaTextKickoff" | {
+                                type: "setSessionKickoffRequired";
+                                params: boolean;
+                            })[];
+                            target: string;
+                        };
+                    };
+                };
+                finished: {};
+                disabled: {};
+            };
+        };
+        kalturaContext: {
+            id: string;
+            initial: string;
+            states: {
+                unknown: {
+                    always: ({
+                        guard: "isKalturaContextEnabled";
+                        target: string;
+                    } | {
+                        target: string;
+                        guard?: undefined;
+                    })[];
+                };
+                enabled: {
+                    invoke: {
+                        src: "onKalturaContextIsActiveChange";
+                        input: ({ context }: {
+                            context: import("../types").AvatarConnectionMachineContext;
+                            event: import("../types").AvatarConnectionMachineEvents;
+                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                        }) => {
+                            logger: import("@unisphere/core").UnisphereLoggerType;
+                            pubSubService: import("@unisphere/runtime").PubSubServiceType;
+                        };
+                    };
+                    on: {
+                        SetKalturaContextActive: {
+                            actions: readonly ["setKalturaContextIsActive", "publishToggleKalturaContextActive", "sendUpdateGenieContext"];
+                        };
+                    };
+                };
+                disabled: {};
+            };
+        };
+        genieIntellect: {
+            id: string;
+            on: {
+                SetDynamicVariables: {
+                    actions: readonly ["setDynamicVariables", "sendUpdateGenieContext"];
+                };
+                AgentClientToolCallCompleted: {
+                    actions: readonly ["logAgentClientToolCallResult"];
+                };
+                AgentClientToolCallLogged: {
+                    actions: readonly ["recordClientToolCallLogEntry"];
+                };
+            };
+            invoke: {
+                src: "onAgentClientToolCall";
+                input: ({ context }: {
+                    context: import("../types").AvatarConnectionMachineContext;
+                    event: import("../types").AvatarConnectionMachineEvents;
+                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                }) => {
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                    getClientToolHandler: import("dist/unisphere/packages/local/shared-utils/src").GetClientToolHandler;
+                    ks: string;
+                    threadId: string | null;
+                };
+            };
+        };
+        tapToTalk: {
+            id: string;
+            initial: string;
+            states: {
+                resolvingEnablement: {
+                    always: ({
+                        guard: "isTapToTalkEnabled";
+                        target: string;
+                    } | {
+                        target: string;
+                        guard?: undefined;
+                    })[];
+                };
+                disabled: {
+                    entry: {
+                        type: "setTapToTalkEnabled";
+                        params: {
+                            enabled: boolean;
+                        };
+                    };
+                    on: {
+                        ToggleTapToTalkMode: {
+                            guard: "shouldEnableTapToTalkMode";
+                            actions: {
+                                type: "toggleTapToTalkMode";
+                                params: {
+                                    enabled: boolean;
+                                };
+                            };
+                            target: string;
+                        };
+                    };
+                };
+                enabled: {
+                    initial: string;
+                    entry: {
+                        type: "setTapToTalkEnabled";
+                        params: {
+                            enabled: boolean;
+                        };
+                    };
+                    invoke: {
+                        src: "onTapToTalkButtonEvents";
+                        input: ({ context }: {
+                            context: import("../types").AvatarConnectionMachineContext;
+                            event: import("../types").AvatarConnectionMachineEvents;
+                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                        }) => {
+                            logger: import("@unisphere/core").UnisphereLoggerType;
+                        };
+                    }[];
+                    on: {
+                        ToggleTapToTalkMode: {
+                            guard: "shouldDisableTapToTalkMode";
+                            actions: {
+                                type: "toggleTapToTalkMode";
+                                params: {
+                                    enabled: boolean;
+                                };
+                            };
+                            target: string;
+                        };
+                        TapToTalkButtonShown: {
+                            actions: {
+                                type: "setTapToTalkButtonVisible";
+                                params: {
+                                    visible: boolean;
+                                };
+                            };
+                        };
+                        TapToTalkButtonHidden: {
+                            actions: {
+                                type: "setTapToTalkButtonVisible";
+                                params: {
+                                    visible: boolean;
+                                };
+                            };
+                        };
+                    };
+                    states: {
+                        idle: {
+                            on: {
+                                RequestTapToTalkStart: {
+                                    target: string;
+                                    actions: ("sendTapToTalkStart" | {
+                                        type: "setTapToTalkActive";
+                                        params: {
+                                            active: boolean;
+                                        };
+                                    } | {
+                                        type: "setTapToTalkStartedAt";
+                                        params: () => {
+                                            startedAt: number;
+                                        };
+                                    })[];
+                                };
+                            };
+                        };
+                        active: {
+                            entry: ("captureUserMuteStateBeforeTapToTalk" | "unmuteAsrForTapToTalk")[];
+                            exit: ("sendTapToTalkEnd" | "restoreMuteStateAfterTapToTalk" | {
+                                type: "setTapToTalkActive";
+                                params: {
+                                    active: boolean;
+                                    startedAt?: undefined;
+                                };
+                            } | {
+                                type: "setTapToTalkStartedAt";
+                                params: {
+                                    startedAt: null;
+                                    active?: undefined;
+                                };
+                            })[];
+                            initial: string;
+                            states: {
+                                recording: {
+                                    on: {
+                                        RequestTapToTalkEnd: {
+                                            target: string;
+                                        };
+                                    };
+                                };
+                                finishing: {
+                                    id: string;
+                                    after: {
+                                        900: string;
+                                    };
+                                };
+                            };
+                        };
+                        awaitingResponse: {
+                            id: string;
+                            on: {
+                                AgentStartedTalkingReceived: {
+                                    target: string;
+                                };
+                                AgentFinishedTalkingReceived: {
+                                    guard: "isEmptyAgentContent";
+                                    target: string;
+                                    actions: "logTapToTalkDropped";
+                                };
+                            };
+                            after: {
+                                4000: {
+                                    target: string;
+                                    actions: "logTapToTalkDropped";
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        agentRecoveryMonitor: {
+            id: string;
+            on: {
+                AgentRecoveryTurnCompleted: ({
+                    guard: "hadAvatarTypeInTurn";
+                    actions: "resetAgentRecoveryRetryCount";
+                } | {
+                    guard: "hasMoreRecoveryRetries";
+                    actions: readonly ["incrementAgentRecoveryRetryCount", "sendReprocessTurn"];
+                } | {
+                    guard: "justExceededRecoveryRetries";
+                    actions: readonly ["incrementAgentRecoveryRetryCount", "showAgentRecoveryExhaustedNotification"];
+                })[];
+                RequestAgentTurnRecovery: {
+                    actions: "sendReprocessTurn";
+                };
+            };
+            invoke: {
+                src: "agentRecoveryMonitor";
+                input: ({ context }: {
+                    context: import("../types").AvatarConnectionMachineContext;
+                    event: import("../types").AvatarConnectionMachineEvents;
+                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../types").AvatarConnectionMachineContext, import("../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                }) => {
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                };
+            };
+        };
+    };
+};