@voicenter-team/events-sdk 0.0.11 → 0.0.13

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

@@ -0,0 +1,535 @@
+import { DebouncedFuncLeading } from 'lodash';
+import { io } from 'socket.io-client';
+import { Socket } from 'socket.io-client';
+
+/**
+ * Data structure for all dialers status event.
+ */
+declare interface AllDialersStatusEvent extends CommonEventProperties {
+    // Array of Dialer objects
+    dialers: Dialer[]
+}
+
+/**
+ * Data structure for all extension status event.
+ */
+declare interface AllExtensionStatusEvent extends CommonEventProperties {
+    // Array of Extension objects
+    extensions: Extension[]
+}
+
+/**
+ * Data structure for all users status event.
+ */
+declare interface AllUsersStatusEvent extends CommonEventProperties {
+    // Array of User objects
+    users: User[]
+}
+
+declare class AuthClass {
+    private readonly eventsSdkClass;
+    constructor(eventsSdkClass: EventsSdkClass);
+    private delay;
+    lastLoginTimestamp: number | undefined;
+    token: string | undefined;
+    private storageKey;
+    login(options: EventsSdkOptions): Promise<void>;
+    updateLastLoginTimestamp(): void;
+    private checkLoginStatus;
+    private userLoginFunction;
+    private onLoginResponse;
+    handleTokenExpiry(): void;
+    private externalLogin;
+    private getSettings;
+    private refreshToken;
+}
+
+declare enum CallStatusEnum {
+    RINGING = "Ringing",
+    TALKING = "Talking",
+    DIALING = "Dialing",
+    HOLD = "Hold"
+}
+
+declare enum CallTypeEnum {
+    INCOMING = "Incoming",
+    OUTGOING = "Outgoing"
+}
+
+/**
+ * Base structure for all event types, containing common properties.
+ */
+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
+}
+
+declare interface CustomData {
+    DoNotCallMeStatus?: string,
+    DoNotCallMeStatusCode?: DoNotCallMeStatusCodeEnum,
+    DoNotCallMeTokenName?: string,
+    DoNotCallMetransactionId?: string,
+    IsDoNotCallMe?: string
+}
+
+declare interface Dialer {
+    campaignID: number,
+    name: string,
+    typeID: number,
+    type: DialerType,
+    code: string,
+    calls: unknown,
+    statistics: unknown
+}
+
+/**
+ * Data structure for dialer event.
+ */
+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
+}
+
+declare enum DialerType {
+    AUTOMATIC = "Automatic",
+    IVR = "IVR"
+}
+
+declare enum DirectionEnum {
+    INCOMING = "Incoming",
+    OUTGOING = "Outgoing",
+    SPY = "Spy",
+    CLICK2CALL = "Click2call"
+}
+
+declare enum DoNotCallMeStatusCodeEnum {
+    RESPONSE_FROM_API_VALID = "RESPONSE_FROM_API_VALID",
+    RESPONSE_FROM_API_INVALID = "RESPONSE_FROM_API_INVALID"
+}
+
+/**
+ * Defines a registry of callback functions for each event type.
+ * Each key is an event type name, and the value is a function that takes the specific event data type as an argument.
+ * This registry is used to manage and invoke event-specific callbacks.
+ */
+declare type EventCallbackRegistry = {
+    [K in EventTypeNames]: (data: EventDataMap[K]) => void
+}
+
+/**
+ * Mapping of event names to their respective data structures.
+ */
+declare interface EventDataMap {
+    [EventsEnum_2.ALL_EXTENSION_STATUS]: AllExtensionStatusEvent
+    [EventsEnum_2.ALL_DIALER_STATUS]: AllDialersStatusEvent
+    [EventsEnum_2.ALL_USERS_STATUS]: AllUsersStatusEvent
+    [EventsEnum_2.QUEUE_EVENT]: QueueEvent
+    [EventsEnum_2.EXTENSION_EVENT]: ExtensionEvent
+    [EventsEnum_2.DIALER_EVENT]: DialerEvent
+    [EventsEnum_2.LOGIN_SUCCESS]: LoginSuccessEvent
+    [EventsEnum_2.LOGIN_STATUS]: LoginStatusEvent
+    [EventsEnum_2.KEEP_ALIVE_RESPONSE]: KeepAliveResponseEvent
+    [EventsEnum_2.ONLINE_STATUS_EVENT]: OnlineStatusEvent
+}
+
+/**
+ * All the eventNames that can be received from the server. Exists only in EXTENSION_EVENT and QueueEvent
+ */
+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",
+    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"
+}
+
+/**
+ * All events that can be received from the server.
+ */
+declare enum EventsEnum_2 {
+    ALL_DIALER_STATUS = 'AllDialersStatus',
+    ALL_EXTENSION_STATUS = 'AllExtensionsStatus',
+    ALL_USERS_STATUS = 'AllUsersStatus',
+    CONNECT = 'connect',
+    DISCONNECT = 'disconnect',
+    EXTENSION_EVENT = 'ExtensionEvent',
+    KEEP_ALIVE = 'keepalive',
+    KEEP_ALIVE_RESPONSE = 'keepaliveResponse',
+    // This type of event will be sent only in case of a successful connection.
+    // The event describes the list of monitored queues on this active connection.
+    // The list of monitored queues will only be sent if the login connection was made with account credentials or account token.
+    // If the login connection type is by user credentials, only the user’s extension assigned queues will return.
+    LOGIN_STATUS = 'loginStatus',
+    // This type of event will be sent in the initial login connection request in case of a successful connection only.
+    // In case of wrong username or password or token, you will receive a 401 (“Unauthorized”) or 500 (“Unexpected token”) http error.
+    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.
+ */
+declare type EventSpecificCallback<T extends EventTypeNames> = (data: WrappedSocketEvent<T>) => void
+
+declare class EventsSdkClass {
+    constructor(options: EventsSdkOptions);
+    private argumentOptions;
+    readonly options: EventsSdkOptions;
+    servers: Server[];
+    server: Server;
+    socket: SocketTyped | undefined;
+    authClass: AuthClass;
+    socketIoClass: SocketIoClass;
+    reconnectOptions: ReconnectOptions;
+    retryConnection: DebouncedFuncLeading<(server?: ServerParameter, skipLogin?: boolean) => void>;
+    private listeners;
+    private allListeners;
+    on<T extends EventTypeNames>(event: T, callback: EventSpecificCallback<T>): void;
+    on(event: '*', callback: (data: GenericEventWrapper) => void): void;
+    off<T extends EventTypeNames>(event: T, callback: EventSpecificCallback<T>): void;
+    off(event: '*', callback: (data: GenericEventWrapper) => void): void;
+    emit<T extends EventTypeNames>(event: T, data: EventTypeData<T>): void;
+    connect(server?: ServerParameter, skipLogin?: boolean): void;
+    disconnect(): void;
+    clearKeepAliveInterval(): void;
+    private findCurrentServer;
+    private findNextAvailableServer;
+    private findMaxPriorityServer;
+    private findMinPriorityServer;
+    getServerWithHighestPriority(servers: Server[]): Server;
+    init(): Promise<boolean>;
+    private getServers;
+}
+export default EventsSdkClass;
+
+declare interface EventsSdkOptions {
+    isNewStack?: boolean;
+    servers: Server[];
+    loginUrl: string;
+    fallbackServer: Server;
+    refreshTokenUrl?: string;
+    refreshToken?: string;
+    token: string;
+    tokenExpiry?: Date;
+    loginType: LoginType;
+    forceNew?: boolean;
+    reconnectionDelay: number;
+    reconnectionDelayMax?: number;
+    maxReconnectAttempts: number;
+    timeout?: number;
+    keepAliveTimeout: number;
+    idleInterval?: number;
+    protocol: string;
+    transports?: string[];
+    upgrade?: boolean;
+    serverFetchStrategy?: string;
+    serverType?: number;
+    useLogger?: boolean;
+    loggerSocketConnection?: string;
+    loggerServer?: string;
+    loggerConfig?: LoggerConfig;
+    loggerConnectOptions?: LoggerConnectOptions;
+    email: string;
+    password: string;
+    username: string;
+}
+
+declare type EventTypeData<T extends EventsEnum_2> = EventDataMap[T]
+
+/**
+ * Represents the set of all possible event type names as keys from the EventDataMap.
+ * This type is used to define event listeners and handlers.
+ */
+declare type EventTypeNames = keyof EventDataMap
+
+/**
+ * This type represents a mapping of listener event names to their corresponding wrapped socket event data structures.
+ * Each key is an event name, and the value is the wrapped socket event data for that event
+ */
+declare type EventWrappedSocketDataMap = {
+    [K in EventTypeNames]: WrappedSocketEvent<K>
+}
+
+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,
+}
+
+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.
+ */
+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.
+ */
+declare enum ExtensionEventReasonEnum {
+    // A new call is ringing or dialing from an extension.
+    NEW_CALL = 'NEWCALL',
+    // A call was answered at an extension.
+    ANSWER = 'ANSWER',
+    // A call was placed on hold.
+    HOLD = 'HOLD',
+    // A call is no longer on hold.
+    UNHOLD = 'UNHOLD',
+    // When a call was ended. It is not necessarily means that the call was answered.
+    HANGUP = 'HANGUP',
+    // When the extension online user updated his\her user status(Login, Break, Logout, etc.)
+    USER_STATUS_UPDATE = 'userStatusUpdate',
+}
+
+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'
+}
+
+/**
+ * A generic type that represents the structure of any event data wrapped in a socket event format.
+ * This type is used in the handling of all event types, providing a consistent structure for event data processing.
+ */
+declare type GenericEventWrapper = EventWrappedSocketDataMap[EventTypeNames]
+
+/**
+ * Data structure for keep alive response event.
+ */
+declare interface KeepAliveResponseEvent extends CommonEventProperties {
+    isOk: boolean
+}
+
+declare interface LoggerConfig {
+    logToConsole?: boolean;
+    overloadGlobalConsole?: boolean;
+    namespace?: string;
+    socketEmitInterval?: number;
+}
+
+declare interface LoggerConnectOptions {
+    reconnection?: boolean;
+    reconnectionDelay?: number;
+    reconnectionAttempts?: number;
+    perMessageDeflate?: boolean;
+    upgrade?: boolean;
+    transports?: string[];
+    debug?: boolean;
+}
+
+/**
+ * Data structure for login status event.
+ */
+declare interface LoginStatusEvent extends CommonEventProperties {
+    // Array of Queue objects
+    queues: Queue[]
+}
+
+declare type LoginSuccessEvent = CommonEventProperties
+
+declare enum LoginType {
+    USER = "User",
+    TOKEN = "Token"
+}
+
+declare interface OnlineStatusEvent {
+    isSocketConnected: boolean
+}
+
+declare interface Queue {
+    QueueID: number,
+    QueueName: string,
+    Calls: QueueCall[],
+    UserId?: number,
+    DistributorID?: number,
+    IsDistributedQueue?: boolean,
+    AnsweredAgent?: string,
+}
+
+declare interface QueueCall {
+    CallerID: string,
+    CallerName: string,
+    IvrUniqueID: string,
+    JoinTimeStamp: number,
+    calldurationinterval: number,
+    ivrid: string,
+    isDistributedQueue?: boolean
+}
+
+/**
+ * Data structure for queue event.
+ */
+declare interface QueueEvent extends CommonEventProperties {
+    eventName: EventNameEnum.QUEUE,
+    reason: QueueEventReasonEnum,
+    telephonyServerTime: number,
+    ivrUniqueId: string,
+    data: Queue
+}
+
+declare enum QueueEventReasonEnum {
+    ANSWER = 'ANSWER',
+    ABANDONED = 'ABANDONED',
+    EXIT = 'EXIT',
+    JOIN = 'JOIN'
+}
+
+declare interface ReconnectOptions {
+    retryCount: number;
+    maxReconnectAttempts: number;
+    reconnectionDelay: number;
+    minReconnectionDelay: number;
+    maxReconnectionDelay: number;
+}
+
+declare interface Recording {
+    Filename: string,
+    Options: string,
+    ApproximateURL: string,
+    IsMuted: number
+}
+
+declare interface Server {
+    Priority: number;
+    Domain: string;
+    URLID: number;
+    Version: string;
+}
+
+declare enum ServerParameter {
+    DEFAULT = "default",
+    NEXT = "next",
+    PREVIOUS = "previous"
+}
+
+declare class SocketIoClass {
+    private readonly eventsSdkClass;
+    constructor(eventsSdkClass: EventsSdkClass);
+    io: SocketTyped | undefined;
+    ioFunction: TypedSocketIo | undefined;
+    lastEventTimestamp: number;
+    doReconnect: boolean;
+    private keepAliveInterval;
+    private keepReconnectInterval;
+    private connected;
+    getSocketIoFunction(Client: string): void;
+    initSocketConnection(): void;
+    initSocketEvents(): void;
+    clearKeepAliveInterval(): void;
+    initKeepAlive(): void;
+    closeAllConnections(): void;
+    private onKeepAliveResponse;
+    private onConnect;
+    private onDisconnect;
+}
+
+declare type SocketTyped = Socket<EventCallbackRegistry, Record<EventsEnum, any>>
+
+declare interface Summery {
+    representative: string
+}
+
+declare type TypedSocketIo = (...args: Parameters<typeof io>) => any;
+
+declare interface User {
+    userID: number,
+    userName: string,
+    accountID: number
+
+}
+
+declare type WrappedSocketEvent<T extends EventsEnum_2> = {
+    name: T
+    data: EventDataMap[T]
+}
+
+export { }