@voicenter-team/events-sdk 0.0.25 → 0.0.27

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

@@ -1,36 +1,23 @@
+import { AllDialersStatusEvent } from '@voicenter-team/real-time-events-types';
+import { AllExtensionStatusEvent } from '@voicenter-team/real-time-events-types';
+import { AllUsersStatusEvent } from '@voicenter-team/real-time-events-types';
 import { DebouncedFuncLeading } from 'lodash';
+import { DialerEvent } from '@voicenter-team/real-time-events-types';
+import { EventsEnum } from '@voicenter-team/real-time-events-types';
+import { ExtensionEvent } from '@voicenter-team/real-time-events-types';
+import { ExtensionsUpdated } from '@voicenter-team/real-time-events-types';
 import { io } from 'socket.io-client';
+import { KeepAliveResponseEvent } from '@voicenter-team/real-time-events-types';
 import { LoggerOptions } from '@voicenter-team/socketio-storage-logger/dist/storage-logger';
+import { LoginStatusEvent } from '@voicenter-team/real-time-events-types';
+import { LoginSuccessEvent } from '@voicenter-team/real-time-events-types';
+import { QueueEvent } from '@voicenter-team/real-time-events-types';
 import { Socket as Socket_2 } from 'socket.io-client';
 
 export declare type ActiveRoomListener = (event: number | undefined) => void
 
 export declare type addRoomListener = (value: string) => void
 
-/**
- * Data structure for all dialers status event.
- */
-export declare interface AllDialersStatusEvent extends CommonEventProperties {
-    // Array of Dialer objects
-    dialers: Dialer[]
-}
-
-/**
- * Data structure for all extension status event.
- */
-export declare interface AllExtensionStatusEvent extends CommonEventProperties {
-    // Array of Extension objects
-    extensions: Extension[]
-}
-
-/**
- * Data structure for all users status event.
- */
-export declare interface AllUsersStatusEvent extends CommonEventProperties {
-    // Array of User objects
-    users: User[]
-}
-
 declare class AuthClass {
     private readonly eventsSdkClass;
     constructor(eventsSdkClass: EventsSdkClass);
@@ -51,18 +38,6 @@ declare class AuthClass {
 
 export declare type CallAddingProgressListener = (callId: string | undefined) => void
 
-export declare enum CallStatusEnum {
-    RINGING = "Ringing",
-    TALKING = "Talking",
-    DIALING = "Dialing",
-    HOLD = "Hold"
-}
-
-export declare enum CallTypeEnum {
-    INCOMING = "Incoming",
-    OUTGOING = "Outgoing"
-}
-
 export declare type changeActiveCallsListener = (event: { [key: string]: string }) => void
 
 export declare type changeActiveInputMediaDeviceListener = (event: string) => void
@@ -77,69 +52,6 @@ export declare type changeIsMutedListener = (value: boolean) => void
 
 export declare type changeMuteWhenJoinListener = (value: boolean) => void
 
-/**
- * Base structure for all event types, containing common properties.
- */
-export declare interface CommonEventProperties {
-    // Error code, 0 indicates no error
-    errorCode?: number
-    // Description of the error, "Ok" indicates successful connection
-    errorDesc?: string
-    // Server time at the moment of the event
-    serverTime: number
-    // Difference in time between server and client
-    serverTimeOffset: number
-}
-
-export declare interface CustomData {
-    DoNotCallMeStatus?: string,
-    DoNotCallMeStatusCode?: DoNotCallMeStatusCodeEnum,
-    DoNotCallMeTokenName?: string,
-    DoNotCallMetransactionId?: string,
-    IsDoNotCallMe?: string
-}
-
-export declare interface Dialer {
-    campaignID: number,
-    name: string,
-    typeID: number,
-    type: DialerType,
-    code: string,
-    calls: unknown,
-    statistics: unknown
-}
-
-/**
- * Data structure for dialer event.
- */
-export declare interface DialerEvent extends CommonEventProperties {
-    data: Dialer
-    eventName: EventNameEnum.DIALER
-    //reason: ExtensionEventReasonEnum // TODO: do research for dialer 'reason' prop
-    telephonyServerTime?: number
-    callerID?: string
-    ivrUniqueId?: string
-    dialStatus?: string
-    //cause?: ExtensionHangupCauseEnum // TODO: do research for dialer 'cause' prop
-}
-
-export declare enum DialerType {
-    AUTOMATIC = "Automatic",
-    IVR = "IVR"
-}
-
-export declare enum DirectionEnum {
-    INCOMING = "Incoming",
-    OUTGOING = "Outgoing",
-    SPY = "Spy",
-    CLICK2CALL = "Click2call"
-}
-
-export declare enum DoNotCallMeStatusCodeEnum {
-    RESPONSE_FROM_API_VALID = "RESPONSE_FROM_API_VALID",
-    RESPONSE_FROM_API_INVALID = "RESPONSE_FROM_API_INVALID"
-}
-
 /**
  * This type defines a map where each key is an event name, and the value is an array of callback functions associated with that event.
  * This structure is used to manage event listeners for different events
@@ -171,6 +83,7 @@ export declare interface EventDataMap {
     [EventsEnum.LOGIN_STATUS]: LoginStatusEvent
     [EventsEnum.KEEP_ALIVE_RESPONSE]: KeepAliveResponseEvent
     [EventsEnum.ONLINE_STATUS_EVENT]: OnlineStatusEvent
+    [EventsEnum.EXTENSIONS_UPDATED]: ExtensionsUpdated
 }
 
 declare class EventEmitterClass {
@@ -185,35 +98,6 @@ declare class EventEmitterClass {
     emit<T extends EventTypeNames>(event: T, data: EventTypeData<T>): void;
 }
 
-/**
- * All the eventNames that can be received from the server. Exists only in EXTENSION_EVENT and QueueEvent
- */
-export declare enum EventNameEnum {
-    EXTENSION = "extension",
-    QUEUE = "queue",
-    DIALER = "dialer"
-}
-
-/**
- * All events that can be received from the server.
- */
-export declare enum EventsEnum {
-    ALL_DIALER_STATUS = "AllDialersStatus",
-    ALL_EXTENSION_STATUS = "AllExtensionsStatus",
-    ALL_USERS_STATUS = "AllUsersStatus",
-    CONNECT = "connect",
-    DISCONNECT = "disconnect",
-    CONNECT_ERROR_EVENT = "connect_error",
-    EXTENSION_EVENT = "ExtensionEvent",
-    KEEP_ALIVE = "keepalive",
-    KEEP_ALIVE_RESPONSE = "keepaliveResponse",
-    LOGIN_STATUS = "loginStatus",
-    LOGIN_SUCCESS = "loginSuccess",
-    QUEUE_EVENT = "QueueEvent",
-    ONLINE_STATUS_EVENT = "onlineStatusEvent",
-    DIALER_EVENT = "DialerEvent"
-}
-
 /**
  * This is a generic type for callback functions used in event handling.
  * It takes a generic event name and defines a callback function that receives wrapped socket event data for that specific event.
@@ -333,94 +217,6 @@ export declare type EventWrappedSocketDataMap = {
     [K in EventTypeNames]: WrappedSocketEvent<K>
 }
 
-export declare interface Extension {
-    calls: ExtensionCall[],
-    userID: number,
-    userName: string,
-    number: number,
-    extenUser: string,
-    accountID: number,
-    topAccountID: number,
-    summery: Summery,
-    onlineUserID: number,
-    representative: number,
-    representativeStatus: number,
-    lastCallEventEpoch: number,
-    lastAnsweredCallEventEpoch: number,
-    lastHangupCallEpoch: number,
-    representativeUpdated: number,
-    peerStatus: unknown,
-    currentCall?: ExtensionCall,
-}
-
-export declare interface ExtensionCall {
-    callStarted: number,
-    calldurationinterval: number,
-    callAnswered: number,
-    answered: number,
-    callername: string,
-    callerphone: string,
-    outgoingcallername?: string,
-    outgoingcallerphone?: string,
-    callstatus: CallStatusEnum,
-    customdata: CustomData,
-    direction: DirectionEnum,
-    ivrid: string,
-    recording: Recording,
-    did: string,
-    relatedIvrUniqueIDs?: string[],
-    callType?: CallTypeEnum,
-    ip: string,
-    isInternal: boolean
-    blcServerID: number,
-    isOpensips: boolean,
-    channel: string,
-    channel2: string,
-    queueID?: number,
-    isSpyed?: boolean,
-    blcServerId?: number,
-    originalCallerID?: string,
-    originalCallerName?: string,
-    actualDialedNumber?: number
-}
-
-/**
- * Data structure for extension event.
- */
-export declare interface ExtensionEvent extends CommonEventProperties {
-    data: Extension
-    eventName: EventNameEnum.EXTENSION
-    reason: ExtensionEventReasonEnum
-    telephonyServerTime?: number
-    callerID?: string
-    ivrUniqueId?: string
-    dialStatus?: string
-    cause?: ExtensionHangupCauseEnum
-}
-
-/**
- * All the reasons for the extension event, e.g. a new call is ringing or dialing from an extension.
- */
-export declare enum ExtensionEventReasonEnum {
-    NEW_CALL = "NEWCALL",
-    ANSWER = "ANSWER",
-    HOLD = "HOLD",
-    UNHOLD = "UNHOLD",
-    HANGUP = "HANGUP",
-    USER_STATUS_UPDATE = "userStatusUpdate"
-}
-
-export declare enum ExtensionHangupCauseEnum {
-    NORMAL_HANGUP = "Normal hangup",
-    USER_BUSY = "User busy",
-    CALL_REJECTED = "Call Rejected",
-    UNALLOCATED_NUMBER = "Unallocated (unassigned) number",
-    UNKNOWN = "Unknown",
-    NO_USER_RESPONDING = "No user responding",
-    USER_ALERTING = "User alerting, no answer",
-    ANSWERED_ELSEWHERE = "Answered elsewhere"
-}
-
 export declare interface ExternalLoginNewStackResponseData {
     AccessToken: string,
     RefreshToken: string
@@ -449,13 +245,6 @@ export declare interface ExternalLoginResponse<T> {
  */
 export declare type GenericEventWrapper = EventWrappedSocketDataMap[EventTypeNames]
 
-/**
- * Data structure for keep alive response event.
- */
-export declare interface KeepAliveResponseEvent extends CommonEventProperties {
-    isOk: boolean
-}
-
 export declare type ListenerCallbackFnType<T extends ListenersKeyType> = OpenSIPSEventMap[T]
 
 export declare type ListenersCallbackFnType = OpenSIPSEventMap[ListenersKeyType]
@@ -504,16 +293,6 @@ export declare interface LoginSessionPayload {
     password: string
 }
 
-/**
- * Data structure for login status event.
- */
-export declare interface LoginStatusEvent extends CommonEventProperties {
-    // Array of Queue objects
-    queues: Queue[]
-}
-
-export declare type LoginSuccessEvent = CommonEventProperties
-
 declare enum LoginType {
     USER = "User",
     TOKEN = "Token"
@@ -542,44 +321,6 @@ export declare interface OpenSIPSEventMap {
     changeCallStatus: changeCallStatusListener
 }
 
-export declare interface Queue {
-    QueueID: number,
-    QueueName: string,
-    Calls: QueueCall[],
-    UserId?: number,
-    DistributorID?: number,
-    IsDistributedQueue?: boolean,
-    AnsweredAgent?: string,
-}
-
-export declare interface QueueCall {
-    CallerID: string,
-    CallerName: string,
-    IvrUniqueID: string,
-    JoinTimeStamp: number,
-    calldurationinterval: number,
-    ivrid: string,
-    isDistributedQueue?: boolean
-}
-
-/**
- * Data structure for queue event.
- */
-export declare interface QueueEvent extends CommonEventProperties {
-    eventName: EventNameEnum.QUEUE,
-    reason: QueueEventReasonEnum,
-    telephonyServerTime: number,
-    ivrUniqueId: string,
-    data: Queue
-}
-
-export declare enum QueueEventReasonEnum {
-    ANSWER = "ANSWER",
-    ABANDONED = "ABANDONED",
-    EXIT = "EXIT",
-    JOIN = "JOIN"
-}
-
 export declare type readyListener = (value: boolean) => void
 
 export declare interface ReconnectOptions {
@@ -590,13 +331,6 @@ export declare interface ReconnectOptions {
     maxReconnectionDelay: number;
 }
 
-export declare interface Recording {
-    Filename: string,
-    Options: string,
-    ApproximateURL: string,
-    IsMuted: number
-}
-
 export declare type removeRoomListener = (value: string) => void
 
 export declare type RoomDeletedListener = (roomId: number) => void
@@ -663,23 +397,12 @@ declare class SocketIoClass {
 
 export declare type SocketTyped = Socket_2<EventCallbackRegistry, Record<EventsEnum, any>>
 
-export declare interface Summery {
-    representative: string
-}
-
 export declare type TestEventListener = (event: { test: string }) => void
 
 declare type TypedSocketIo = (...args: Parameters<typeof io>) => SocketTyped;
 
 export declare type updateRoomListener = (value: string) => void
 
-export declare interface User {
-    userID: number,
-    userName: string,
-    accountID: number
-
-}
-
 export declare type WrappedSocketEvent<T extends EventsEnum> = {
     name: T
     data: EventDataMap[T]