@kaltura-sdk/avatars 1.14.0

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

@@ -0,0 +1,153 @@
+export declare const tapToTalkState: {
+    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";
+                        };
+                    };
+                };
+            };
+        };
+    };
+};

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

@@ -0,0 +1,49 @@
+import { AskViaTextEvent } from '../../types';
+export declare const textCommunicationState: {
+    id: string;
+    initial: string;
+    on: {
+        AskViaText: {
+            actions: ("appendUserTextEntry" | {
+                type: "sendAskViaText";
+                params: ({ event }: {
+                    event: 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: {};
+    };
+};

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

@@ -0,0 +1,400 @@
+import { DisconnectReasons } from '@unisphere/genie-types';
+import { ErrorActorEvent } from 'xstate';
+export declare const connectingState: {
+    id: string;
+    initial: string;
+    after: {
+        30000: {
+            actions: {
+                type: "setDisconnectData";
+                params: {
+                    reason: DisconnectReasons;
+                    error: Error;
+                };
+            };
+            target: string;
+        };
+    };
+    invoke: {
+        src: "onInitResponse";
+        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: {
+        AgentThreadIdReceived: {
+            actions: "setThreadId";
+        };
+    };
+    states: {
+        initializingRTCSession: {
+            invoke: {
+                id: string;
+                src: "initRTCSession";
+                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;
+                    turnServerUrl: string;
+                    noiseReductionEnabled: boolean | undefined;
+                };
+                onDone: {
+                    target: string;
+                };
+                onError: {
+                    actions: {
+                        type: "setDisconnectData";
+                        params: ({ event }: {
+                            event: ErrorActorEvent;
+                        }) => {
+                            reason: DisconnectReasons;
+                            error: Error;
+                        };
+                    };
+                    target: string;
+                };
+            };
+        };
+        gettingUserMedia: {
+            invoke: {
+                id: string;
+                src: "getUserMedia";
+                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;
+                };
+                onDone: {
+                    target: string;
+                };
+                onError: {
+                    actions: {
+                        type: "setDisconnectData";
+                        params: ({ event }: {
+                            event: ErrorActorEvent;
+                        }) => {
+                            reason: DisconnectReasons;
+                            error: Error;
+                            skipDisconnect: boolean;
+                            suppressNotification: boolean;
+                        };
+                    };
+                    target: string;
+                };
+            };
+        };
+        connectingWebsocket: {
+            invoke: {
+                id: string;
+                src: "connectWebSocket";
+                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>;
+                }) => {
+                    serverUrl: string;
+                    clientId: string | undefined;
+                    debugMode: boolean;
+                    flowId: string | undefined;
+                    stickyId: string | undefined;
+                    level: string;
+                    ks: string;
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                };
+                onDone: {
+                    actions: "setPeerId";
+                    target: string;
+                };
+                onError: {
+                    actions: {
+                        type: "setDisconnectData";
+                        params: ({ event }: {
+                            event: ErrorActorEvent;
+                        }) => {
+                            reason: DisconnectReasons;
+                            error: Error;
+                        };
+                    };
+                    target: string;
+                };
+            };
+        };
+        waitingServerConnect: {
+            invoke: {
+                src: "onServerConnected";
+                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: {
+                ServerConnectedReceived: {
+                    target: string;
+                };
+            };
+            after: {
+                10000: {
+                    actions: {
+                        type: "setDisconnectData";
+                        params: {
+                            reason: DisconnectReasons;
+                            error: Error;
+                        };
+                    };
+                    target: string;
+                };
+            };
+        };
+        joiningRoom: {
+            entry: "sendJoinRoom";
+            type: "parallel";
+            invoke: {
+                src: "onJoinRoom";
+                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;
+                };
+            };
+            after: {
+                10000: {
+                    actions: {
+                        type: "setDisconnectData";
+                        params: {
+                            reason: DisconnectReasons;
+                            error: Error;
+                        };
+                    };
+                    target: string;
+                };
+            };
+            states: {
+                waitingClientConfiguration: {
+                    initial: string;
+                    states: {
+                        waiting: {
+                            on: {
+                                ClientConfigurationReceived: {
+                                    actions: "setClientConfiguration";
+                                    target: string;
+                                };
+                            };
+                        };
+                        done: {
+                            type: "final";
+                        };
+                    };
+                };
+                waitingJoinComplete: {
+                    initial: string;
+                    states: {
+                        waiting: {
+                            on: {
+                                JoinCompleteReceived: {
+                                    target: string;
+                                };
+                            };
+                        };
+                        done: {
+                            type: "final";
+                        };
+                    };
+                };
+            };
+            onDone: {
+                target: string;
+            };
+        };
+        creatingSession: {
+            entry: "sendCreateSession";
+            invoke: {
+                src: "onSessionCreated";
+                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: {
+                SessionCreatedReceived: {
+                    actions: readonly ["setSessionId", "setWebrtcUrl", "setCastMode"];
+                    target: string;
+                };
+                NoAgentReceived: {
+                    actions: {
+                        type: "setDisconnectData";
+                        params: {
+                            reason: DisconnectReasons;
+                            error: Error;
+                        };
+                    };
+                    target: string;
+                };
+            };
+        };
+        reconnectingFromExpiry: {
+            invoke: ({
+                src: "onSessionCreated";
+                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: "onResumingSession";
+                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: {
+                ResumingSessionReceived: {};
+                SessionCreatedReceived: {
+                    actions: readonly ["setSessionId", "setWebrtcUrl"];
+                    target: string;
+                };
+            };
+        };
+        waitingForAgent: {
+            invoke: {
+                src: "onAgentData";
+                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: {
+                ShowAgentReceived: {
+                    target: string;
+                };
+            };
+            after: {
+                10000: {
+                    actions: {
+                        type: "setDisconnectData";
+                        params: {
+                            reason: DisconnectReasons;
+                            error: Error;
+                        };
+                    };
+                    target: string;
+                };
+            };
+        };
+        waitingServerReady: {
+            invoke: {
+                src: "onServerReady";
+                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: {
+                ServerReadyReceived: ({
+                    guard: "shouldWaitPlayerReadyState";
+                    target: string;
+                } | {
+                    target: string;
+                    guard?: undefined;
+                })[];
+            };
+        };
+        waitingPlayerReadyState: {
+            invoke: {
+                src: "onPlayerReadyState";
+                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: {
+                PlayerReady: {
+                    target: string;
+                };
+            };
+        };
+        delayingBeforeConnect: {
+            after: {
+                1000: {
+                    target: string;
+                };
+            };
+        };
+        connectingToASR: {
+            invoke: {
+                src: "connectToASR";
+                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;
+                    serverUrl: string;
+                    peerId: string;
+                };
+                onDone: {
+                    actions: "sendApprovedPermissions";
+                    target: string;
+                };
+                onError: {
+                    actions: {
+                        type: "setDisconnectData";
+                        params: ({ event }: {
+                            event: ErrorActorEvent;
+                        }) => {
+                            reason: DisconnectReasons;
+                            error: Error;
+                        };
+                    };
+                    target: string;
+                };
+            };
+        };
+        done: {
+            always: {
+                target: string;
+            };
+        };
+        error: {
+            always: ({
+                guard: "shouldDisconnect";
+                target: string;
+            } | {
+                guard: "shouldShowDevicePermissionsDenied";
+                target: string;
+            } | {
+                target: string;
+                guard?: undefined;
+            })[];
+        };
+    };
+};

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

@@ -0,0 +1,26 @@
+export declare const disconnectedState: {
+    id: string;
+    entry: "showDisconnectNotification";
+    initial: string;
+    states: {
+        unknown: {
+            always: ({
+                guard: "shouldWaitBeforePurge";
+                target: string;
+            } | {
+                target: string;
+                guard?: undefined;
+            })[];
+        };
+        waitingPurge: {
+            after: {
+                1000: {
+                    target: string;
+                };
+            };
+        };
+        done: {
+            type: "final";
+        };
+    };
+};

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

@@ -0,0 +1,54 @@
+import { DisconnectReasons } from '@unisphere/genie-types';
+import { ErrorActorEvent } from 'xstate';
+export declare const disconnectingState: {
+    id: string;
+    initial: string;
+    states: {
+        stoppingScreenSharing: {
+            entry: ("sendScreenShareStopped" | {
+                type: "setScreenShareActive";
+                params: {
+                    active: boolean;
+                };
+            })[];
+            always: {
+                target: string;
+            };
+        };
+        destroyingConnection: {
+            invoke: {
+                id: string;
+                src: "destroyConnection";
+                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>;
+                }) => {
+                    serverUrl: string;
+                    connectionId: string;
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                };
+                onDone: {
+                    target: string;
+                };
+                onError: {
+                    actions: {
+                        type: "setDisconnectData";
+                        params: ({ event }: {
+                            event: ErrorActorEvent;
+                        }) => {
+                            reason: DisconnectReasons;
+                            error: Error;
+                        };
+                    };
+                    target: string;
+                };
+            };
+        };
+        done: {
+            always: {
+                target: string;
+            };
+        };
+    };
+};