@voicenter-team/events-sdk 0.0.9 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voicenter-team/events-sdk",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "",
   "main": "dist/voicenter-events-sdk.cjs.js",
   "jsdelivr": "dist/voicenter-events-sdk.umd.js",

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

@@ -1,682 +0,0 @@
-import { DebouncedFuncLeading } from 'lodash';
-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;
-
-declare interface EventsSdkOptions {
-    fallbackServer: Server;
-    refreshTokenUrl?: string;
-    refreshToken?: string;
-    servers?: 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 ExternalLoginRequestBody {
-    identityType: LoginType,
-    username?: string,
-    password?: string,
-    token?: string
-}
-
-export declare interface ExternalLoginResponse {
-    StatusCode: number,
-    Status: string,
-    Data: ExternalLoginResponseData
-}
-
-export declare interface ExternalLoginResponseData {
-    AccessToken: string,
-    RefreshToken: string
-}
-
-/**
- * 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
-
-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;
-}
-
-export declare interface LoginSessionData extends Settings, ExternalLoginResponseData {}
-
-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
-
-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
-
-declare interface Server {
-    Priority: number;
-    Domain: string;
-    URLID: number;
-    Version: string;
-}
-
-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, 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 { }