@voicenter-team/events-sdk 0.0.121 → 0.0.123

package/dist/voicenter-events-sdk.d.ts

@@ -78,6 +78,34 @@ export declare type AllUsersStatusEvent = {
 
 export declare type AllUsersStatusEventSDK = EventTypeData<EventsEnum.ALL_USERS_STATUS>
 
+export declare type AllVoicebotsStatus = {
+    /**
+     * 0 - Connection was establishing successfully.
+     */
+    errorCode?: number;
+    /**
+     * “Ok” - Connection was establishing successfully.
+     */
+    errorDesc?: string;
+    voicebots: Array<Voicebot>;
+    /**
+     * Server time at the moment of the event
+     */
+    servertime: number;
+
+
+    /**
+     * Difference in time between server and client
+     */
+    servertimeoffset: number;
+};
+
+export declare type AllVoiceBotsStatusEventSDK = EventTypeData<EventsEnum.ALL_VOICEBOTS_STATUS>
+
+export declare interface AllVoicebotStatusExtended extends Omit<AllVoicebotsStatus, 'voicebots'> {
+    voicebots: Array<VoicebotExtended>
+}
+
 declare class AuthClass {
     private readonly eventsSdkClass;
     constructor(eventsSdkClass: EventsSdkClass);
@@ -137,7 +165,7 @@ declare interface CurrentCallEnded extends CurrentCallUTCExtended {
     duration: number
 }
 
-declare interface CurrentCallUTCExtended extends ExtensionCall {
+export declare interface CurrentCallUTCExtended extends ExtensionCall {
     callStarted_UTC: number
     callStarted_UTC_CLIENT: number
     callAnswered_UTC: number
@@ -280,6 +308,7 @@ export declare interface EventDataMap {
     [EventsEnum.ALL_EXTENSION_STATUS]: AllExtensionStatusEvent
     [EventsEnum.ALL_DIALER_STATUS]: AllDialersStatusEvent
     [EventsEnum.ALL_USERS_STATUS]: AllUsersStatusEvent
+    [EventsEnum.ALL_VOICEBOTS_STATUS]: AllVoicebotsStatus
     [EventsEnum.QUEUE_EVENT]: QueueEvent
     [EventsEnum.EXTENSION_EVENT]: ExtensionEvent
     [EventsEnum.DIALER_EVENT]: DialerEvent
@@ -288,6 +317,11 @@ export declare interface EventDataMap {
     [EventsEnum.KEEP_ALIVE_RESPONSE]: KeepAliveResponseEvent
     [EventsEnum.ONLINE_STATUS_EVENT]: OnlineStatusEvent
     [EventsEnum.EXTENSIONS_UPDATED]: ExtensionsUpdated
+    [EventsEnum.VOICEBOT_SUBSCRIBED_TO_CALL]: SubscribedToVoicebotCall
+    [EventsEnum.VOICEBOT_SUBSCRIBE_TO_CALL_FAILED]: SubscribeToVoicebotCallFailed
+    [EventsEnum.VOICEBOT_INITIAL_CALL_HISTORY]: InitialVoicebotCallHistory
+    [EventsEnum.VOICEBOT_UNSUBSCRIBED_FROM_CALL]: UnsubscribedFromVoicebotCall
+    [EventsEnum.VOICEBOT_EVENT]: VoicebotEvent
 }
 
 /**
@@ -299,6 +333,9 @@ export declare interface EventDataMapExtended extends EventDataMap {
     [EventsEnum.ALL_EXTENSION_STATUS]: AllExtensionStatusEventExtended
     [EventsEnum.QUEUE_EVENT]: QueueEventUTCExtended
     [EventsEnum.LOGIN_STATUS]: LoginStatusEventUTCExtended
+    [EventsEnum.ALL_VOICEBOTS_STATUS]: AllVoicebotStatusExtended
+    [EventsEnum.VOICEBOT_EVENT]: VoicebotEventExtended
+    [EventsEnum.VOICEBOT_INITIAL_CALL_HISTORY]: InitialVoicebotCallHistoryExtended
 }
 
 declare class EventEmitterClass {
@@ -328,6 +365,12 @@ export declare enum EventsEnum {
     ONLINE_STATUS_EVENT = 'onlineStatusEvent',
     DIALER_EVENT = 'DialerEvent',
     EXTENSIONS_UPDATED = 'ExtensionsUpdated',
+    ALL_VOICEBOTS_STATUS = 'AllVoicebotsStatus',
+    VOICEBOT_SUBSCRIBE_TO_CALL_FAILED = 'subscribeToCallFailed',
+    VOICEBOT_SUBSCRIBED_TO_CALL = 'subscribedToCall',
+    VOICEBOT_INITIAL_CALL_HISTORY = 'initialCallHistory',
+    VOICEBOT_UNSUBSCRIBED_FROM_CALL = 'unsubscribedFromCall',
+    VOICEBOT_EVENT = 'VoicebotEvent',
 }
 
 /**
@@ -576,6 +619,10 @@ export declare type ExtensionCall = {
      */
     callername: string;
     callstatus: CallStatusEnum;
+    /**
+     * cam id
+     */
+    campaignID?: string;
     customdata: CustomData;
     /**
      * Is internal
@@ -760,6 +807,22 @@ export declare interface ExternalLoginResponse<T> {
  */
 export declare type GenericEventWrapper = EventWrappedSocketDataMap[EventTypeNames]
 
+export declare type InitialVoicebotCallHistory = {
+    history: Array<VoicebotEventDataCall>;
+    /**
+     * Voicebot id
+     */
+    voicebotID: number;
+    /**
+     * Ivr unique id
+     */
+    IvrUniqueID: string;
+};
+
+export declare interface InitialVoicebotCallHistoryExtended extends Omit<InitialVoicebotCallHistory, 'history'> {
+    history: Array<VoicebotCallUTCExtended>
+}
+
 export declare type KeepAliveResponseEvent = {
     /**
      * Is ok
@@ -809,6 +872,7 @@ declare class LoggerClass {
     keepAliveEmit(): void;
     keepAliveResponse(data: KeepAliveResponseEvent): void;
     eventLog<T extends EventTypeNames>(eventName: T, data: EventDataMap[T]): void;
+    private getStaticData;
 }
 
 export declare interface LoggerConfig {
@@ -887,7 +951,8 @@ export declare type LoginSuccessEventSDK = EventTypeData<EventsEnum.LOGIN_SUCCES
 
 export declare enum LoginType {
     USER = "User",
-    TOKEN = "Token"
+    TOKEN = "Token",
+    JWT = "Jwt"
 }
 
 export declare type OnlineStatusEvent = {
@@ -1091,7 +1156,9 @@ export declare type ServerEmitEventCallbackRegistry = {
  */
 export declare interface ServerEmitEventDataMap {
     [ServerListenerEventsEnum.UPDATE_MONITORED_EXTENSIONS]: UpdateMonitoredExtensionsPayload
-    [ServerListenerEventsEnum.KEEP_ALIVE]: string
+    [ServerListenerEventsEnum.KEEP_ALIVE]: string,
+    [ServerListenerEventsEnum.SUBSCRIBE_VOICEBOT_CALL_UPDATES]: SubscriptionVoicebotCallUpdatesPayload,
+    [ServerListenerEventsEnum.UNSUBSCRIBE_VOICEBOT_CALL_UPDATES]: SubscriptionVoicebotCallUpdatesPayload
 }
 
 /**
@@ -1102,7 +1169,9 @@ export declare type ServerEmitEventTypeNames = keyof ServerEmitEventDataMap
 
 export declare enum ServerListenerEventsEnum {
     UPDATE_MONITORED_EXTENSIONS = "updateMonitoredExtensions",
-    KEEP_ALIVE = "keepalive"
+    KEEP_ALIVE = "keepalive",
+    SUBSCRIBE_VOICEBOT_CALL_UPDATES = "subscribeVoicebotCallUpdates",
+    UNSUBSCRIBE_VOICEBOT_CALL_UPDATES = "unsubscribeVoicebotCallUpdates"
 }
 
 export declare enum ServerParameter {
@@ -1136,40 +1205,147 @@ export declare interface Socket {
     Version: string
 }
 
+/**
+ * SocketIoClass handles WebSocket connections and real-time event management.
+ * Prevents duplicate connections and events with robust state management.
+ */
 declare class SocketIoClass {
     private readonly eventsSdkClass;
-    constructor(eventsSdkClass: EventsSdkClass);
+    /** The active Socket.IO connection instance */
     io: SocketTyped | undefined;
+    /** The Socket.IO function used to create connections based on version */
     ioFunction: TypedSocketIo | undefined;
+    /** Timestamp of the last received event, used for keep-alive calculations */
     lastEventTimestamp: number;
+    /** Flag indicating whether automatic reconnection should be attempted */
     doReconnect: boolean;
+    /** Current connection state */
+    private connectionState;
+    /** Keep-alive interval handle */
     private keepAliveInterval;
-    private keepReconnectInterval;
-    private keepReconnectTimeout;
-    private connected;
+    /** Reconnection timeout handle */
+    private reconnectTimeout;
+    /** Network reconnect timeout handle (debounced) */
+    private networkReconnectTimeout;
+    /** Current reconnection delay in seconds */
     private reconnectionTime;
+    /** Maximum reconnection delay in seconds */
+    private readonly maxReconnectionDelay;
+    /** Network event cleanup functions */
+    private networkCleanup;
+    /**
+     * Creates an instance of SocketIoClass and sets up network event listeners.
+     */
+    constructor(eventsSdkClass: EventsSdkClass);
+    /**
+     * Sets up network event listeners
+     */
+    private setupNetworkListeners;
+    /**
+     * Handles network online with debouncing to prevent rapid reconnects
+     */
+    private handleNetworkOnline;
+    /**
+     * Determines and sets the appropriate Socket.IO function based on client version.
+     */
     getSocketIoFunction(Client: string): void;
+    /**
+     * Initializes a new Socket.IO connection. Prevents multiple simultaneous connections.
+     */
     initSocketConnection(): void;
+    /**
+     * Clears the keep-alive interval
+     */
     clearKeepAliveInterval(): void;
+    /**
+     * Initializes the keep-alive mechanism
+     */
     initKeepAlive(): void;
-    closeAllConnections(): void;
+    /**
+     * Closes all active connections and cleans up resources properly
+     */
+    closeAllConnections(): Promise<void>;
+    /**
+     * Sets up event listeners for all Socket.IO events
+     */
     initSocketEvents(): void;
+    /**
+     * Updates timestamp on every event to prevent unnecessary keep-alives
+     */
+    private updateEventTimestamp;
     private onLoginSuccessEvent;
     private onQueueEvent;
     private onExtensionEvent;
     private onDialerEvent;
+    private onVoicebotEvent;
+    private onAllVoicebotsStatus;
+    private onVoicebotSubscribedToCall;
+    private onVoicebotSubscribeToCallFailed;
+    private onVoicebotInitialCallHistory;
+    private onVoicebotUnsubscribedFromCall;
     private onLoginStatusEvent;
     private onAllExtensionStatus;
     private onAllDialerStatus;
+    /**
+     * Handles keep-alive response - fixed to prevent multiple connections
+     */
     private onKeepAliveResponse;
     private onExtensionsUpdatedEvent;
+    /**
+     * Handles successful connection
+     */
     private onConnect;
+    /**
+     * Schedules reconnection with exponential backoff
+     */
+    private scheduleReconnect;
+    /**
+     * Handles disconnection
+     */
     private onDisconnect;
+    /**
+     * Handles connection errors
+     */
     private onConnectError;
+    /**
+     * Cleanup when shutting down
+     */
+    destroy(): Promise<void>;
 }
 
 export declare type SocketTyped = Socket_2<EventCallbackRegistry, ServerEmitEventCallbackRegistry>
 
+export declare type SubscribedToVoicebotCall = {
+    /**
+     * subscribe success?
+     */
+    success: boolean;
+    /**
+     * voicebot id
+     */
+    voicebotID: number;
+    /**
+     * ivr id
+     */
+    IvrUniqueID: string;
+};
+
+export declare type SubscribeToVoicebotCallFailed = {
+    /**
+     * error
+     */
+    error: string;
+    /**
+     * success
+     */
+    success: boolean;
+};
+
+export declare interface SubscriptionVoicebotCallUpdatesPayload {
+    voicebotID: number,
+    IvrUniqueID: string
+}
+
 export declare type Summery = {
     /**
      * Representative
@@ -1183,6 +1359,9 @@ export declare type TestEventListener = (event: { test: string }) => void
 
 declare type TypedSocketIo = (...args: Parameters<typeof io>) => SocketTyped;
 
+export declare type UnsubscribedFromVoicebotCall = {
+};
+
 export declare interface UpdateMonitoredExtensionsPayload {
     extensionsString: string
 }
@@ -1206,6 +1385,174 @@ export declare type User = {
 
 export declare type UserSDK = User
 
+export declare type Voicebot = {
+    Calls: Array<VoicebotEventDataCall>;
+    /**
+     * Acc id
+     */
+    AccountID: string;
+    /**
+     * Voicebot id
+     */
+    VoicebotID: number;
+    /**
+     * Voicebot name
+     */
+    VoicebotName: string;
+};
+
+export declare type VoicebotCall = {
+};
+
+export declare type VoicebotCallHistory = {
+};
+
+export declare interface VoicebotCallUTCExtended extends  Omit<VoicebotEventDataCall, 'eventsData'>{
+    callStarted_UTC: number
+    callStarted_UTC_CLIENT: number
+    eventsData: Array<VoicebotEventDataCallEventsDataExtended>
+}
+
+export declare type VoicebotEvent = {
+    data: VoicebotEventData;
+    type: VoicebotEventTypeEnum;
+    reason: VoicebotEventReasonEnum;
+    /**
+     * Event name (voicebot)
+     */
+    eventName: string;
+    /**
+     * servertime
+     */
+    servertime: number;
+    /**
+     * servertimeoffset
+     */
+    servertimeoffset: number;
+    /**
+     * telephonyservertime
+     */
+    telephonyservertime: number;
+};
+
+export declare type VoicebotEventData = {
+    Call: VoicebotEventDataCall;
+    /**
+     * account id
+     */
+    AccountID: number;
+    /**
+     * voicebot id
+     */
+    VoicebotID: number;
+    /**
+     * ivr id
+     */
+    IvrUniqueID: string;
+    /**
+     * voicebot name
+     */
+    VoicebotName: string;
+};
+
+export declare type VoicebotEventDataCall = {
+    /**
+     * did
+     */
+    did: string;
+    /**
+     * ivrid
+     */
+    ivrid: string;
+    /**
+     * CallerID
+     */
+    CallerID: string;
+    /**
+     * callType
+     */
+    callType: string;
+    /**
+     * aiSummary
+     */
+    aiSummary: string;
+    direction: VoicebotEventDataCallDirectionEnum;
+    callStatus: VoicebotEventDataCallStatusEnum;
+    /**
+     * callername
+     */
+    callername?: string;
+    customData: any;
+    eventsData: Array<VoicebotEventDataCallEventsData>;
+    /**
+     * IvrUniqueID
+     */
+    IvrUniqueID: string;
+    /**
+     * callStarted
+     */
+    callStarted: number;
+};
+
+export declare enum VoicebotEventDataCallDirectionEnum {
+    INCOMING = 'INCOMING',
+    OUTGOING = 'OUTGOING',
+}
+
+export declare type VoicebotEventDataCallEventsData = {
+    Role: VoicebotEventDataCallEventsDataRoleEnum;
+    Type: VoicebotEventDataCallEventsDataTypeEnum;
+    ToolName?: string;
+    Timestamp: number;
+    Transcript?: string;
+};
+
+export declare interface VoicebotEventDataCallEventsDataExtended extends VoicebotEventDataCallEventsData {
+    Timestamp_UTC: number
+    Timestamp_UTC_CLIENT: number
+}
+
+export declare type VoicebotEventDataCallEventsDataRoleEnum = {
+};
+
+export declare enum VoicebotEventDataCallEventsDataTypeEnum {
+    CALLSTARTED = 'CallStarted',
+    TRANSCRIPT = 'Transcript',
+    TOOL_EXECUTED = 'ToolExecuted',
+    TOOL_RESPONSE = 'ToolResponse',
+    CALL_ENDED = 'CallEnded',
+}
+
+export declare enum VoicebotEventDataCallStatusEnum {
+    TALKING = 'Talking',
+    ENDED = 'Ended',
+}
+
+export declare interface VoicebotEventDataExtended extends Omit<VoicebotEventData, 'Call'> {
+    Call: VoicebotCallUTCExtended
+}
+
+export declare interface VoicebotEventExtended extends Omit<VoicebotEvent, 'data'> {
+    data: VoicebotEventDataExtended
+}
+
+export declare enum VoicebotEventReasonEnum {
+    CALLSTARTED = 'CALLSTARTED',
+}
+
+export declare type VoiceBotEventSDK = EventTypeData<EventsEnum.VOICEBOT_EVENT>
+
+export declare enum VoicebotEventTypeEnum {
+    UNKNOWN = 'UNKNOWN',
+}
+
+export declare interface VoicebotExtended extends  Omit<Voicebot, 'Calls'> {
+    Calls: Array<VoicebotCallUTCExtended>
+
+}
+
+export declare type VoiceBotInitialCallHistoryEventSDK = EventTypeData<EventsEnum.VOICEBOT_INITIAL_CALL_HISTORY>
+
 /**
  * The structure of received socket events.
  */

package/dist/voicenter-events-sdk.es.js

@@ -2733,6 +2733,11 @@ class te {
         {
           key: "callStarted",
           format: "sec"
+        },
+        {
+          key: "holdStarted",
+          // TODO: should add the holdStarted in TS definitions
+          format: "sec"
         }
       ],
       t.servertime,