@voicenter-team/events-sdk 0.0.12 → 0.0.14

package/dist/index.d.ts

@@ -1,11 +1,689 @@
-import EventsSdkClass from './classes/events-sdk/events-sdk.class';
-import { EventsEnum } from './enum/events.enum';
-export type * from './types/auth';
-export type * from './types/events.common';
-export type * from './types/events';
-export type * from './types/listeners';
-export type * from './types/public-api';
-export type * from './types/socket';
-export type * from './classes/events-sdk/events-sdk.types';
-export { EventsEnum };
-export default EventsSdkClass;
+import { DebouncedFuncLeading } from 'lodash';
+import { EventsEnum as EventsEnum_3 } from 'enum/events.enum';
+import { io } from 'socket.io-client';
+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);
+    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;
+}
+
+export declare type CallAddingProgressListener = (callId: string | undefined) => void
+
+declare enum CallStatusEnum {
+    RINGING = "Ringing",
+    TALKING = "Talking",
+    DIALING = "Dialing",
+    HOLD = "Hold"
+}
+
+declare enum CallTypeEnum {
+    INCOMING = "Incoming",
+    OUTGOING = "Outgoing"
+}
+
+export declare type changeActiveCallsListener = (event: { [key: string]: string }) => void
+
+export declare type changeActiveInputMediaDeviceListener = (event: string) => void
+
+export declare type changeActiveOutputMediaDeviceListener = (event: string) => void
+
+export declare type changeCallStatusListener = (event: { [key: string]: number }) => void
+
+export declare type changeIsDNDListener = (value: boolean) => void
+
+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
+}
+
+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"
+}
+
+/**
+ * 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
+ */
+export declare type EventCallbackListenersMap = {
+    [K in EventTypeNames]: Array<EventSpecificCallback<K>>
+}
+
+/**
+ * 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.
+ */
+export declare type EventCallbackRegistry = {
+    [K in EventTypeNames]: (data: EventDataMap[K]) => void
+}
+
+/**
+ * Mapping of event names to their respective data structures.
+ */
+export 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.
+ */
+export 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;
+
+export 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;
+}
+
+export 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.
+ */
+export declare type EventTypeNames = keyof EventDataMap
+
+/**
+ * Represents Event Types in Enum
+ */
+export declare enum EventTypesEnum {
+    ALL_DIALERS_STATUS = 'AllDialersStatus',
+    ALL_EXTENSION_STATUS = 'AllExtensionsStatus',
+    CLOSE = 'closeme',
+    CONNECT = 'connect',
+    CONNECT_ERROR = 'connect_error',
+    CONNECT_TIMEOUT = 'connect_timeout',
+    DISCONNECT = 'disconnect',
+    DIALER_EVENT = 'DialerEvent',
+    DIALERS_UPDATED = 'DialersUpdated',
+    ERROR = 'error',
+    EXTENSION_EVENT = 'ExtensionEvent',
+    EXTENSION_UPDATED = 'ExtensionsUpdated',
+    KEEP_ALIVE = 'keepalive',
+    KEEP_ALIVE_RESPONSE = 'keepaliveResponse',
+    LOGIN = 'login',
+    LOGIN_ACCOUNT = 'loginAccount',
+    LOGIN_CODE = 'loginUserCode',
+    LOGIN_RESPONSE = 'loginResponse',
+    LOGIN_STATUS = 'loginStatus',
+    LOGIN_USER = 'loginUser',
+    PONG = 'pong',
+    QUEUE_EVENT = 'QueueEvent',
+    QUEUES_UPDATED = 'QueuesUpdated',
+    RECONNECT = 'reconnect',
+    RECONNECT_ATTEMPT = 'reconnect_attempt',
+    RECONNECT_ERROR = 'reconnect_error',
+    RECONNECT_FAILED = 'reconnect_failed',
+    RECONNECTING = 'reconnecting',
+    RESYNC = 'resync'
+}
+
+/**
+ * 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
+ */
+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.
+ */
+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'
+}
+
+export declare interface ExternalLoginNewStackResponseData {
+    AccessToken: string,
+    RefreshToken: string
+}
+
+export declare interface ExternalLoginOldStackResponseData {
+    Socket: Socket,
+}
+
+export declare interface ExternalLoginRequestBody {
+    identityType: LoginType,
+    username?: string,
+    password?: string,
+    token?: string
+}
+
+export declare interface ExternalLoginResponse<T> {
+    StatusCode: number,
+    Status: string,
+    Data: T
+}
+
+/**
+ * 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.
+ */
+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]
+
+export declare type ListenersKeyType = keyof OpenSIPSEventMap
+
+export declare interface LoggerConfig {
+    logToConsole?: boolean;
+    overloadGlobalConsole?: boolean;
+    namespace?: string;
+    socketEmitInterval?: number;
+}
+
+export declare interface LoggerConnectOptions {
+    reconnection?: boolean;
+    reconnectionDelay?: number;
+    reconnectionAttempts?: number;
+    perMessageDeflate?: boolean;
+    upgrade?: boolean;
+    transports?: string[];
+    debug?: boolean;
+}
+
+export declare interface LoginSessionData extends Settings, ExternalLoginNewStackResponseData, Socket {}
+
+export declare interface LoginSessionPayload {
+    token: string,
+    email: string,
+    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"
+}
+
+export declare interface OnlineStatusEvent {
+    isSocketConnected: boolean
+}
+
+export declare interface OpenSIPSEventMap {
+    ready: readyListener
+    changeActiveCalls: changeActiveCallsListener
+    callConfirmed: TestEventListener
+    currentActiveRoomChanged: ActiveRoomListener
+    callAddingInProgressChanged: CallAddingProgressListener
+    roomDeleted: RoomDeletedListener
+    changeActiveInputMediaDevice: changeActiveInputMediaDeviceListener
+    changeActiveOutputMediaDevice: changeActiveOutputMediaDeviceListener
+    changeMuteWhenJoin: changeMuteWhenJoinListener
+    changeIsDND: changeIsDNDListener
+    changeIsMuted: changeIsMutedListener
+    addRoom: addRoomListener
+    updateRoom: updateRoomListener
+    removeRoom: removeRoomListener
+    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
+}
+
+declare enum QueueEventReasonEnum {
+    ANSWER = 'ANSWER',
+    ABANDONED = 'ABANDONED',
+    EXIT = 'EXIT',
+    JOIN = 'JOIN'
+}
+
+export declare type readyListener = (value: boolean) => void
+
+export declare interface ReconnectOptions {
+    retryCount: number;
+    maxReconnectAttempts: number;
+    reconnectionDelay: number;
+    minReconnectionDelay: number;
+    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
+
+export declare interface Server {
+    Priority: number;
+    Domain: string;
+    URLID: number;
+    Version: string;
+}
+
+export declare enum ServerParameter {
+    DEFAULT = "default",
+    NEXT = "next",
+    PREVIOUS = "previous"
+}
+
+export declare enum ServerTypesEnum {
+    DEFAULT = 1,
+    CHROME_EXTENSION = 2
+}
+
+export declare interface Settings {
+    IdentityCode: string,
+    IdentityCodeExpiry: Date,
+    PersonID: number,
+    PersonType: number,
+    ExtensionMonitorID: number,
+    MonitorList: Server[]
+}
+
+export declare interface Socket {
+    Client: string,
+    PersonId: number,
+    RefreshToken: string,
+    RefreshTokenExpiry: Date,
+    Token: string,
+    TokenExpiry: Date,
+    URLList: string[],
+    Url: string,
+    Version: string
+}
+
+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;
+}
+
+export declare type SocketTyped = Socket_2<EventCallbackRegistry, Record<EventsEnum_3, 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_2> = {
+    name: T
+    data: EventDataMap[T]
+}
+
+export { }