@voicenter-team/events-sdk 0.0.66 → 0.0.67

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

@@ -1,82 +1,34 @@
+import { DebouncedFuncLeading } from 'lodash';
 import { io } from 'socket.io-client';
-import { LoggerDataPartial } from '@voicenter-team/socketio-storage-logger';
-import { LoggerOptions } from '@voicenter-team/socketio-storage-logger';
 import { Socket as Socket_2 } from 'socket.io-client';
-import StorageLogger from '@voicenter-team/socketio-storage-logger';
 
 export declare type ActiveRoomListener = (event: number | undefined) => void
 
 export declare type addRoomListener = (value: string) => void
 
-declare type AllDialersStatusEvent = {
-    dialers: Array<Dialer>;
-    /**
-     * 0 - Connection was establishing successfully.
-     */
-    errorCode?: number;
-    /**
-     * “Ok” - Connection was establishing successfully.
-     */
-    errorDesc?: string;
-    /**
-     * Server time at the moment of the event
-     */
-    serverTime: number;
-    /**
-     * Difference in time between server and client
-     */
-    serverTimeOffset: number;
-};
-
-export declare type AllDialersStatusEventSDK = EventTypeData<EventsEnum.ALL_DIALER_STATUS>
-
-declare type AllExtensionStatusEvent = {
-    /**
-     * 0 - Connection was establishing successfully.
-     */
-    errorCode?: number;
-    /**
-     * “Ok” - Connection was establishing successfully.
-     */
-    errorDesc?: string;
-    extensions: Array<Extension>;
-    /**
-     * Server time at the moment of the event
-     */
-    servertime: number;
-    /**
-     * Difference in time between server and client
-     */
-    servertimeoffset: number;
-};
-
-declare interface AllExtensionStatusEventExtended extends Omit<AllExtensionStatusEvent, 'extensions'> {
-    extensions: Array<ExtensionSDK>
+/**
+ * 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[]
 }
 
-export declare type AllExtensionStatusEventSDK = EventTypeData<EventsEnum.ALL_EXTENSION_STATUS>
-
-declare type AllUsersStatusEvent = {
-    users: Array<User>;
-    /**
-     * 0 - Connection was establishing successfully.
-     */
-    errorCode?: number;
-    /**
-     * “Ok” - Connection was establishing successfully.
-     */
-    errorDesc?: string;
-    /**
-     * Server time at the moment of the event
-     */
-    serverTime: number;
-    /**
-     * Difference in time between server and client
-     */
-    serverTimeOffset: number;
-};
-
-export declare type AllUsersStatusEventSDK = EventTypeData<EventsEnum.ALL_USERS_STATUS>
+/**
+ * Data structure for all users status event.
+ */
+declare interface AllUsersStatusEvent extends CommonEventProperties {
+    // Array of User objects
+    users: User[]
+}
 
 declare class AuthClass {
     private readonly eventsSdkClass;
@@ -84,33 +36,30 @@ declare class AuthClass {
     private delay;
     lastLoginTimestamp: number | undefined;
     token: string | undefined;
-    private refreshToken;
-    private tokenExpiry;
     private storageKey;
-    login(): Promise<Partial<LoginSessionData> | undefined>;
+    login(options: EventsSdkOptions): Promise<void>;
     updateLastLoginTimestamp(): void;
     private checkLoginStatus;
     private userLoginFunction;
-    onLoginResponse(loginSessionData: Partial<LoginSessionData>): void;
+    private onLoginResponse;
     handleTokenExpiry(): void;
     private externalLogin;
     private getSettings;
-    private externalRefreshToken;
-    private normalizeLoginType;
+    private refreshToken;
 }
 
 export declare type CallAddingProgressListener = (callId: string | undefined) => void
 
-export declare enum CallStatusEnum {
-    RINGING = 'Ringing',
-    TALKING = 'Talking',
-    DIALING = 'Dialing',
-    HOLD = 'Hold',
+declare enum CallStatusEnum {
+    RINGING = "Ringing",
+    TALKING = "Talking",
+    DIALING = "Dialing",
+    HOLD = "Hold"
 }
 
-export declare enum CallTypeEnum {
-    INCOMING = 'Incoming',
-    OUTGOING = 'Outgoing',
+declare enum CallTypeEnum {
+    INCOMING = "Incoming",
+    OUTGOING = "Outgoing"
 }
 
 export declare type changeActiveCallsListener = (event: { [key: string]: string }) => void
@@ -127,129 +76,67 @@ export declare type changeIsMutedListener = (value: boolean) => void
 
 export declare type changeMuteWhenJoinListener = (value: boolean) => void
 
-export declare enum ConnectionStatusEnum {
-    CONNECTED = 'connected',
-    DISCONNECTED = 'disconnected',
-    TRYING_TO_CONNECT = 'tryingToConnect',
-}
-
-declare interface CurrentCallEnded extends CurrentCallUTCExtended {
-    duration: number
-}
-
-declare interface CurrentCallUTCExtended extends ExtensionCall {
-    callStarted_UTC: number
-    callStarted_UTC_CLIENT: number
-    callAnswered_UTC: number
-    callAnswered_UTC_CLIENT: number
+/**
+ * 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
+}
+
+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
 }
 
-declare type CustomData = {
-    /**
-     * Is do not call me
-     */
-    IsDoNotCallMe?: string;
-    /**
-     * Do not call me status
-     */
-    DoNotCallMeStatus?: string;
-    /**
-     * Do not call me token name
-     */
-    DoNotCallMeTokenName?: string;
-    DoNotCallMeStatusCode?: DoNotCallMeStatusCodeEnum;
-    /**
-     * Do not call me transaction id
-     */
-    DoNotCallMetransactionId?: string;
-};
-
-export declare type CustomDataSDK = CustomData
-
-declare type Dialer = {
-    /**
-     * Code
-     */
-    code: string;
-    /**
-     * Name
-     */
-    name: string;
-    type: DialerTypeEnum;
-    /**
-     * Calls
-     */
-    calls: string;
-    /**
-     * Type id
-     */
-    typeID: number;
-    /**
-     * Campaign id
-     */
-    campaignID: number;
-    /**
-     * Statistics
-     */
-    statistics: string;
-};
-
-declare type DialerEvent = {
-    data: Dialer;
-    /**
-     * callerID
-     */
-    callerID?: string;
-    /**
-     * Event name (dialer)
-     */
-    eventName: string;
-    /**
-     * dialStatus
-     */
-    dialStatus?: string;
-    /**
-     * ivrUniqueId
-     */
-    ivrUniqueId?: string;
-    /**
-     * TelephonyServerTime
-     */
-    telephonyServerTime?: number;
-};
-
-export declare type DialerEventSDK = EventTypeData<EventsEnum.DIALER_EVENT>
-
-export declare type DialerSDK = Dialer
-
-export declare enum DialerTypeEnum {
-    AUTOMATIC = 'Automatic',
-    IVR = 'IVR',
+/**
+ * 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
 }
 
-export declare enum DirectionEnum {
-    INCOMINC = 'Incoming',
-    OUTGOING = 'Outgoing',
-    SPY = 'Spy',
-    CLICK2CALL = 'Click2Call',
+declare enum DialerType {
+    AUTOMATIC = "Automatic",
+    IVR = "IVR"
 }
 
-export declare enum DoNotCallMeStatusCodeEnum {
-    RESPONSE_FROM_API_VALID = 'RESPONSE_FROM_API_VALID',
-    RESPONSE_FROM_API_INVALID = 'RESPONSE_FROM_API_INVALID',
+declare enum DirectionEnum {
+    INCOMING = "Incoming",
+    OUTGOING = "Outgoing",
+    SPY = "Spy",
+    CLICK2CALL = "Click2call"
 }
 
-declare type Error_2 = {
-};
-
-export declare type ErrorSDK = Error_2
-
-/**
- * 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>>
+declare enum DoNotCallMeStatusCodeEnum {
+    RESPONSE_FROM_API_VALID = "RESPONSE_FROM_API_VALID",
+    RESPONSE_FROM_API_INVALID = "RESPONSE_FROM_API_INVALID"
 }
 
 /**
@@ -257,17 +144,14 @@ export declare type EventCallbackListenersMap = {
  * 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 = {
+declare type EventCallbackRegistry = {
     [K in EventTypeNames]: (data: EventDataMap[K]) => void
 }
 
-export declare type EventData = EventDataMapExtended[EventsEnum]
-
 /**
  * Mapping of event names to their respective data structures.
- * The data structures that socket io will send us
  */
-export declare interface EventDataMap {
+declare interface EventDataMap {
     [EventsEnum.ALL_EXTENSION_STATUS]: AllExtensionStatusEvent
     [EventsEnum.ALL_DIALER_STATUS]: AllDialersStatusEvent
     [EventsEnum.ALL_USERS_STATUS]: AllUsersStatusEvent
@@ -278,145 +162,112 @@ export declare interface EventDataMap {
     [EventsEnum.LOGIN_STATUS]: LoginStatusEvent
     [EventsEnum.KEEP_ALIVE_RESPONSE]: KeepAliveResponseEvent
     [EventsEnum.ONLINE_STATUS_EVENT]: OnlineStatusEvent
-    [EventsEnum.EXTENSIONS_UPDATED]: ExtensionsUpdated
 }
 
 /**
- * Mapping of event names to their respective data structures.
- * The data structures that we will send to the end user, here we can modify the type of events data
+ * All the eventNames that can be received from the server. Exists only in EXTENSION_EVENT and QueueEvent
  */
-export declare interface EventDataMapExtended extends EventDataMap {
-    [EventsEnum.EXTENSION_EVENT]: ExtensionEventExtended
-    [EventsEnum.ALL_EXTENSION_STATUS]: AllExtensionStatusEventExtended
-    [EventsEnum.QUEUE_EVENT]: QueueEventUTCExtended
-}
-
-declare class EventEmitterClass {
-    private readonly eventsSdkClass;
-    private listeners;
-    private allListeners;
-    constructor(eventsSdkClass: EventsSdkClass);
-    on(event: unknown, callback: unknown): 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;
+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',
-    EXTENSIONS_UPDATED = 'ExtensionsUpdated',
+    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"
 }
 
 /**
  * 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 type EventSpecificCallback<T extends EventTypeNames> = (data: WrappedSocketEvent<T>) => void
 
 declare class EventsSdkClass {
-    readonly options: EventsSdkOptionsMain & EventsSdkOptionsBase;
+    constructor(options: EventsSdkOptions);
+    private argumentOptions;
+    readonly options: EventsSdkOptions;
     servers: Server[];
-    URLList: string[];
-    server: Server | undefined;
-    URL: string | undefined;
-    socket: SocketTyped | undefined;
-    private mainServer;
-    private alreadyAttemptedOtherServers;
+    server: Server;
+    socket: any | undefined;
     authClass: AuthClass;
     socketIoClass: SocketIoClass;
-    loggerClass: LoggerClass;
-    eventEmitterClass: EventEmitterClass;
-    constructor(options: EventsSdkOptionsClient);
+    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;
-    emit<T extends ServerEmitEventTypeNames>(event: T, ...args: Parameters<ServerEmitEventCallbackRegistry[T]>): void;
-    connect(serverParameter: ServerParameter): 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 findMainServer;
-    private findNextServer;
+    private findCurrentServer;
+    private findNextAvailableServer;
+    private findMaxPriorityServer;
+    private findMinPriorityServer;
+    getServerWithHighestPriority(servers: Server[]): Server;
     init(): Promise<boolean>;
-    getCircularReplacer: () => (key: string, value: object) => object | undefined;
-    getCurrentMonitorServer(): Server | undefined;
+    private getServers;
 }
 export default EventsSdkClass;
 
-export declare interface EventsSdkOptionsBase {
-    loginType: LoginType;
+export declare interface EventsSdkOptions {
     isNewStack?: boolean;
+    servers: Server[];
+    loginUrl: string;
+    fallbackServer: Server;
+    refreshTokenUrl: string;
+    refreshToken?: string;
+    token: string;
+    tokenExpiry?: Date;
+    loginType: LoginType;
     forceNew?: boolean;
-    servers?: Server[];
-    reconnectionDelay?: number;
+    reconnectionDelay: number;
+    reconnectionDelayMax?: number;
+    maxReconnectAttempts: number;
     timeout?: number;
-    keepAliveTimeout?: number;
-    protocol?: string;
+    keepAliveTimeout: number;
+    idleInterval?: number;
+    protocol: string;
+    transports?: string[];
+    upgrade?: boolean;
+    serverFetchStrategy?: string;
+    serverType?: number;
     useLogger?: boolean;
-    loggerSocketConnection?: Socket_2;
+    loggerSocketConnection?: string;
     loggerServer?: string;
-    loggerConfig?: LoggerOptions;
-    loggerConnectOptions?: LoggerConnectOptions;
-    storageLoggerInstance?: StorageLogger;
-}
-
-export declare type EventsSdkOptionsClient = EventsSdkOptionsUserLogin | EventsSdkOptionsTokenLogin | EventsSdkOptionsOldStack | EventsSdkOptionsNewStack;
-
-export declare type EventsSdkOptionsMain = Required<Pick<EventsSdkOptionsOldStack | EventsSdkOptionsNewStack, 'isNewStack' | 'loginUrl' | 'refreshTokenUrl' | 'forceNew' | 'protocol' | 'timeout' | 'loggerConfig' | 'keepAliveTimeout' | 'reconnectionDelay' | 'loggerServer' | 'useLogger'>> & {
-    getSettingsUrl?: string;
-    token?: string;
-    email?: string;
-    password?: string;
-    storageLoggerInstance?: StorageLogger;
+    loggerConfig?: LoggerConfig;
     loggerConnectOptions?: LoggerConnectOptions;
-    loggerSocketConnection?: Socket_2;
-};
-
-declare type EventsSdkOptionsNewStack = EventsSdkOptionsBase & {
-    isNewStack: true;
-    loginUrl?: string;
-    refreshTokenUrl?: string;
-    getSettingsUrl: string;
-};
-
-declare type EventsSdkOptionsOldStack = EventsSdkOptionsBase & {
-    isNewStack?: false;
-    loginUrl?: string;
-    refreshTokenUrl?: string;
-};
-
-declare type EventsSdkOptionsTokenLogin = EventsSdkOptionsBase & {
-    loginType: LoginType.TOKEN;
-    token: string;
-};
-
-declare type EventsSdkOptionsUserLogin = EventsSdkOptionsBase & {
-    loginType: LoginType.USER;
     email: string;
     password: string;
-};
+    username: string;
+}
 
-/**
- * The structure of event data for a specific event type.
- */
-export declare type EventTypeData<T extends EventsEnum> = EventDataMapExtended[T]
+declare type EventTypeData<T extends EventsEnum> = 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
+declare type EventTypeNames = keyof EventDataMap
 
 /**
  * Represents Event Types in Enum
@@ -457,267 +308,96 @@ export declare enum EventTypesEnum {
  * 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 = {
+declare type EventWrappedSocketDataMap = {
     [K in EventTypeNames]: WrappedSocketEvent<K>
 }
 
-declare type Extension = {
-    calls: Array<ExtensionCall>;
-    /**
-     * Number
-     */
-    number: number;
-    /**
-     * User id
-     */
-    userID: number;
-    summery: Summery;
-    /**
-     * User name
-     */
-    userName: string;
-    /**
-     * Account id
-     */
-    accountID: number;
-    /**
-     * Exten user
-     */
-    extenUser: string;
-    /**
-     * Peer status
-     */
-    peerStatus: string;
-    currentCall?: ExtensionCall;
-    /**
-     * Online user id
-     */
-    onlineUserID: number;
-    /**
-     * Top account id
-     */
-    topAccountID: number;
-    /**
-     * Representative
-     */
-    representative: number;
-    /**
-     * Last call event epoch
-     */
-    lastCallEventEpoch: number;
-    /**
-     * Last hangup call epoch
-     */
-    lastHangupCallEpoch: number;
-    /**
-     * Representative status
-     */
-    representativeStatus: number;
-    /**
-     * Representative updated
-     */
-    representativeUpdated: number;
-    /**
-     * Last answered call event epoch
-     */
-    lastAnsweredCallEventEpoch: number;
-};
-
-declare type ExtensionCall = {
-    /**
-     * Ip
-     */
-    ip: string;
-    /**
-     * Did
-     */
-    did: string;
-    /**
-     * Ivr id
-     */
-    ivrid: string;
-    /**
-     * Channel
-     */
-    channel: string;
-    /**
-     * Is spyed
-     */
-    isSpyed?: boolean;
-    /**
-     * Queue id
-     */
-    queueID?: number;
-    /**
-     * Answered
-     */
-    answered: number;
-    callType?: CallTypeEnum;
-    /**
-     * Channel 2
-     */
-    'channel 2': string;
-    direction: DirectionEnum;
-    recording: Recording;
-    /**
-     * Caller name
-     */
-    callername: string;
-    callstatus: CallStatusEnum;
-    customdata: CustomData;
-    /**
-     * Is internal
-     */
-    isInternal: boolean;
-    /**
-     * Is opensips
-     */
-    isOpensips: boolean;
-    /**
-     * Blc server id
-     */
-    blcServerID: number;
-    /**
-     * Blc server id
-     */
-    blcServerId?: number;
-    /**
-     * Call started
-     */
-    callStarted: number;
-    /**
-     * Caller phone
-     */
-    callerphone: string;
-    /**
-     * Call answered
-     */
-    callAnswered: number;
-    /**
-     * Original caller id
-     */
-    originalCallerID?: string;
-    /**
-     * Actual dialed number
-     */
-    actualDialedNumber?: number;
-    /**
-     * Original caller name
-     */
-    originalCallerName?: string;
-    /**
-     * Outgoing caller name
-     */
-    outgoingcallername?: string;
-    /**
-     * Outgoing caller phone
-     */
-    outgoingcallerphone?: string;
-    /**
-     * Related ivr unique ids
-     */
-    relatedIvrUniqueIDs?: Array<string>;
-    /**
-     * Call duration interval
-     */
-    calldurationinterval: number;
-};
-
-export declare type ExtensionCallSDK = CurrentCallUTCExtended | CurrentCallEnded
-
-declare interface ExtensionCallsEnded extends ExtensionUTCExtended {
-    currentCall?: CurrentCallEnded
-    calls?: Array<CurrentCallUTCExtended>
-}
-
-declare interface ExtensionCallsUTCExtended extends ExtensionUTCExtended {
-    currentCall?: CurrentCallUTCExtended
-    calls?: Array<CurrentCallUTCExtended>
-}
-
-declare type ExtensionEvent = {
-    data: Extension;
-    cause?: ExtensionHangupCauseEnum;
-    reason: ExtensionEventReasonEnum;
-    /**
-     * Caller id
-     */
-    callerID?: string;
-    /**
-     * Event name (extension)
-     */
-    eventName: string;
-    /**
-     * Dial status
-     */
-    dialStatus?: string;
-    /**
-     * Server time
-     */
-    servertime: number;
-    /**
-     * Ivr unique id
-     */
-    ivrUniqueId?: string;
-    /**
-     * Server time offset
-     */
-    servertimeoffset: number;
-    /**
-     * Telephony server time
-     */
-    telephonyServerTime?: number;
-};
-
-declare interface ExtensionEventEnded extends Omit<ExtensionEvent, 'reason' | 'data'> {
-    reason: ExtensionEventReasonEnum.HANGUP
-    data: ExtensionCallsEnded
-}
-
-declare type ExtensionEventExtended = ExtensionEventUTCExtended | ExtensionEventEnded
-
-export declare enum ExtensionEventReasonEnum {
-    NEWCALL = 'NEWCALL',
-    ANSWER = 'ANSWER',
-    HOLD = 'HOLD',
-    UNHOLD = 'UNHOLD',
-    HANGUP = 'HANGUP',
-    USER_STATUS_UPDATE = 'userStatusUpdate',
-}
-
-export declare type ExtensionEventSDK = EventTypeData<EventsEnum.EXTENSION_EVENT>
-
-declare interface ExtensionEventUTCExtended extends Omit<ExtensionEvent, 'reason' | 'data'> {
-    reason: Exclude<ExtensionEventReasonEnum, ExtensionEventReasonEnum.HANGUP>
-    data: ExtensionCallsUTCExtended
+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
 }
 
-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',
+/**
+ * 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
 }
 
-export declare type ExtensionSDK = ExtensionCallsUTCExtended | ExtensionCallsEnded
-
-declare type ExtensionsUpdated = string;
-
-export declare type ExtensionsUpdatedSDK = EventTypeData<EventsEnum.EXTENSIONS_UPDATED>
-
-declare interface ExtensionUTCExtended extends Extension {
-    lastAnsweredCallEventEpoch_UTC: number
-    lastAnsweredCallEventEpoch_UTC_CLIENT: number
-    lastCallEventEpoch_UTC: number
-    lastCallEventEpoch_UTC_CLIENT: number
-    lastHangupCallEpoch_UTC: number
-    lastHangupCallEpoch_UTC_CLIENT: number
-    representativeUpdated_UTC: number
-    representativeUpdated_UTC_CLIENT: number
+/**
+ * All the reasons for the extension event, e.g. a new call is ringing or dialing from an extension.
+ */
+declare enum ExtensionEventReasonEnum {
+    NEW_CALL = "NEWCALL",
+    ANSWER = "ANSWER",
+    HOLD = "HOLD",
+    UNHOLD = "UNHOLD",
+    HANGUP = "HANGUP",
+    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 {
@@ -746,32 +426,14 @@ export declare interface ExternalLoginResponse<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]
-
-declare type KeepAliveResponseEvent = {
-    /**
-     * Is ok
-     */
-    isOk: boolean;
-    /**
-     * 0 - Connection was establishing successfully.
-     */
-    errorCode?: number;
-    /**
-     * “Ok” - Connection was establishing successfully.
-     */
-    errorDesc?: string;
-    /**
-     * Server time at the moment of the event
-     */
-    serverTime: number;
-    /**
-     * Difference in time between server and client
-     */
-    serverTimeOffset: number;
-};
-
-export declare type KeepAliveResponseEventSDK = EventTypeData<EventsEnum.KEEP_ALIVE_RESPONSE>
+declare type GenericEventWrapper = EventWrappedSocketDataMap[EventTypeNames]
+
+/**
+ * Data structure for keep alive response event.
+ */
+declare interface KeepAliveResponseEvent extends CommonEventProperties {
+    isOk: boolean
+}
 
 export declare type ListenerCallbackFnType<T extends ListenersKeyType> = OpenSIPSEventMap[T]
 
@@ -779,19 +441,10 @@ export declare type ListenersCallbackFnType = OpenSIPSEventMap[ListenersKeyType]
 
 export declare type ListenersKeyType = keyof OpenSIPSEventMap
 
-declare class LoggerClass {
-    private readonly eventsSdkClass;
-    constructor(eventsSdkClass: EventsSdkClass);
-    private storageLogger;
-    init(): void;
-    log(data: LoggerDataPartial): void;
-    sdkInitializedLog(): void;
-}
-
 export declare interface LoggerConfig {
     logToConsole?: boolean;
     overloadGlobalConsole?: boolean;
-    system: string;
+    namespace?: string;
     socketEmitInterval?: number;
 }
 
@@ -799,9 +452,7 @@ export declare interface LoggerConnectOptions {
     reconnection?: boolean;
     reconnectionDelay?: number;
     reconnectionAttempts?: number;
-    perMessageDeflate?: {
-        threshold: number;
-    };
+    perMessageDeflate?: boolean;
     upgrade?: boolean;
     transports?: string[];
     debug?: boolean;
@@ -810,68 +461,29 @@ export declare interface LoggerConnectOptions {
 export declare interface LoginSessionData extends Settings, ExternalLoginNewStackResponseData, Socket {}
 
 export declare interface LoginSessionPayload {
-    token?: string,
-    email?: string,
-    password?: string
+    token: string,
+    email: string,
+    password: string
+}
+
+/**
+ * Data structure for login status event.
+ */
+declare interface LoginStatusEvent extends CommonEventProperties {
+    // Array of Queue objects
+    queues: Queue[]
 }
 
-declare type LoginStatusEvent = {
-    queues: Array<Queue>;
-    /**
-     * 0 - Connection was establishing successfully.
-     */
-    errorCode?: number;
-    /**
-     * “Ok” - Connection was establishing successfully.
-     */
-    errorDesc?: string;
-    /**
-     * Server time at the moment of the event
-     */
-    serverTime: number;
-    /**
-     * Difference in time between server and client
-     */
-    serverTimeOffset: number;
-};
-
-export declare type LoginStatusEventSDK = EventTypeData<EventsEnum.LOGIN_STATUS>
-
-declare type LoginSuccessEvent = {
-    /**
-     * 0 - Connection was establishing successfully.
-     */
-    errorCode?: number;
-    /**
-     * “Ok” - Connection was establishing successfully.
-     */
-    errorDesc?: string;
-    /**
-     * Server time at the moment of the event
-     */
-    serverTime: number;
-    /**
-     * Difference in time between server and client
-     */
-    serverTimeOffset: number;
-};
-
-export declare type LoginSuccessEventSDK = EventTypeData<EventsEnum.LOGIN_SUCCESS>
-
-export declare enum LoginType {
+declare type LoginSuccessEvent = CommonEventProperties
+
+declare enum LoginType {
     USER = "User",
     TOKEN = "Token"
 }
 
-declare type OnlineStatusEvent = {
-    /**
-     * which server sdk trying to connect
-     */
-    attemptToConnect?: string;
-    connectionStatus: ConnectionStatusEnum;
-};
-
-export declare type OnlineStatusEventSDK = EventTypeData<EventsEnum.ONLINE_STATUS_EVENT>
+declare interface OnlineStatusEvent {
+    isSocketConnected: boolean
+}
 
 export declare interface OpenSIPSEventMap {
     ready: readyListener
@@ -891,141 +503,62 @@ export declare interface OpenSIPSEventMap {
     changeCallStatus: changeCallStatusListener
 }
 
-declare type Queue = {
-    Calls: Array<QueueCall>;
-    /**
-     * User id
-     */
-    UserId?: number;
-    /**
-     * Queue id
-     */
-    QueueID: number;
-    /**
-     * Queue name
-     */
-    QueueName: string;
-    /**
-     * Answered agent
-     */
-    AnsweredAgent?: string;
-    /**
-     * Distributor id
-     */
-    DistributorID?: number;
-    /**
-     * Is distributed queue
-     */
-    IsDistributedQueue?: boolean;
-};
-
-declare type QueueCall = {
-    /**
-     * Ivr id
-     */
-    ivrid: string;
-    /**
-     * Caller id
-     */
-    CallerId: string;
-    /**
-     * Caller name
-     */
-    CallerNme: string;
-    /**
-     * Ivr unique id
-     */
-    IvrUniqueID: string;
-    /**
-     * Join timestamp
-     */
-    JoinTimeStamp: number;
-    /**
-     * Is distributed queue
-     */
-    isDistributedQueue?: boolean;
-    /**
-     * Call duration interval
-     */
-    calldurationinterval: number;
-};
-
-export declare interface QueueCallSDK extends QueueCall {
-    JoinTimeStamp_UTC: number
-    JoinTimeStamp_UTC_CLIENT: number
+export declare interface Queue {
+    QueueID: number,
+    QueueName: string,
+    Calls: QueueCall[],
+    UserId?: number,
+    DistributorID?: number,
+    IsDistributedQueue?: boolean,
+    AnsweredAgent?: string,
 }
 
-declare type QueueEvent = {
-    data: Queue;
-    reason: QueueEventReasonEnum;
-    /**
-     * Event name (queue)
-     */
-    eventName: string;
-    /**
-     * Server time
-     */
-    servertime: number;
-    /**
-     * Ivr unique id
-     */
-    ivrUniqueId: string;
-    /**
-     * Server time offset
-     */
-    servertimeoffset: number;
-    /**
-     * Telephony server time
-     */
-    telephonyServerTime: number;
-};
-
-export declare enum QueueEventReasonEnum {
-    ANSWER = 'ANSWER',
-    ABANDONED = 'ABANDONED',
-    EXIT = 'EXIT',
-    JOIN = 'JOIN',
+export declare interface QueueCall {
+    CallerID: string,
+    CallerName: string,
+    IvrUniqueID: string,
+    JoinTimeStamp: number,
+    calldurationinterval: number,
+    ivrid: string,
+    isDistributedQueue?: boolean
 }
 
-export declare type QueueEventSDK = EventTypeData<EventsEnum.QUEUE_EVENT>
-
-declare interface QueueEventUTCExtended extends Omit<QueueEvent, 'data'> {
-    data: QueueSDK
+/**
+ * Data structure for queue event.
+ */
+declare interface QueueEvent extends CommonEventProperties {
+    eventName: EventNameEnum.QUEUE,
+    reason: QueueEventReasonEnum,
+    telephonyServerTime: number,
+    ivrUniqueId: string,
+    data: Queue
 }
 
-export declare interface QueueSDK extends Omit<Queue, 'Calls'> {
-    Calls?: Array<QueueCallSDK>
+declare enum QueueEventReasonEnum {
+    ANSWER = "ANSWER",
+    ABANDONED = "ABANDONED",
+    EXIT = "EXIT",
+    JOIN = "JOIN"
 }
 
 export declare type readyListener = (value: boolean) => void
 
-declare type Recording = {
-    /**
-     * Is muted
-     */
-    IsMuted: number;
-    /**
-     * Options
-     */
-    Options: string;
-    /**
-     * Filename
-     */
-    Filename: string;
-    /**
-     * Approximate url
-     */
-    ApproximateURL: string;
-};
-
-export declare type RecordingSDK = Recording
-
-export declare type removeRoomListener = (value: string) => void
+export declare interface ReconnectOptions {
+    retryCount: number;
+    maxReconnectAttempts: number;
+    reconnectionDelay: number;
+    minReconnectionDelay: number;
+    maxReconnectionDelay: number;
+}
 
-declare type Response_2 = {
-};
+export declare interface Recording {
+    Filename: string,
+    Options: string,
+    ApproximateURL: string,
+    IsMuted: number
+}
 
-export declare type ResponseSDK = Response_2
+export declare type removeRoomListener = (value: string) => void
 
 export declare type RoomDeletedListener = (roomId: number) => void
 
@@ -1036,33 +569,10 @@ export declare interface Server {
     Version: string;
 }
 
-export declare type ServerEmitEventCallbackRegistry = {
-    [K in ServerEmitEventTypeNames]: (data: ServerEmitEventDataMap[K]) => void
-}
-
-/**
- * Mapping of event names to their respective data structures.
- * The data structures that we can send to the server
- */
-export declare interface ServerEmitEventDataMap {
-    [ServerListenerEventsEnum.UPDATE_MONITORED_EXTENSIONS]: UpdateMonitoredExtensionsPayload
-    [ServerListenerEventsEnum.KEEP_ALIVE]: string
-}
-
-/**
- * Represents the set of all possible event type names as keys from the ServerEmitEventDataMap.
- * This type is used to define event emitters and data.
- */
-export declare type ServerEmitEventTypeNames = keyof ServerEmitEventDataMap
-
-export declare enum ServerListenerEventsEnum {
-    UPDATE_MONITORED_EXTENSIONS = "updateMonitoredExtensions",
-    KEEP_ALIVE = "keepAlive"
-}
-
 export declare enum ServerParameter {
-    MAIN = "main",
-    NEXT = "next"
+    DEFAULT = "default",
+    NEXT = "next",
+    PREVIOUS = "previous"
 }
 
 export declare enum ServerTypesEnum {
@@ -1103,68 +613,37 @@ declare class SocketIoClass {
     private connected;
     getSocketIoFunction(Client: string): void;
     initSocketConnection(): void;
+    initSocketEvents(): void;
     clearKeepAliveInterval(): void;
     initKeepAlive(): void;
     closeAllConnections(): void;
-    initSocketEvents(): void;
-    private onLoginSuccessEvent;
-    private onQueueEvent;
-    private onExtensionEvent;
-    private onDialerEvent;
-    private onLoginStatusEvent;
-    private onAllExtensionStatus;
-    private onAllDialerStatus;
     private onKeepAliveResponse;
-    private onExtensionsUpdatedEvent;
     private onConnect;
     private onDisconnect;
-    private onConnectError;
 }
 
-export declare type SocketTyped = Socket_2<EventCallbackRegistry, ServerEmitEventCallbackRegistry>
+export declare type SocketTyped = Socket_2<EventCallbackRegistry, Record<EventsEnum, any>>
 
-declare type Summery = {
-    /**
-     * Representative
-     */
-    representative: string;
-};
-
-export declare type SummerySDK = Summery
+export declare interface Summery {
+    representative: string
+}
 
 export declare type TestEventListener = (event: { test: string }) => void
 
 declare type TypedSocketIo = (...args: Parameters<typeof io>) => SocketTyped;
 
-export declare interface UpdateMonitoredExtensionsPayload {
-    extensionsString: string
-}
-
 export declare type updateRoomListener = (value: string) => void
 
-declare type User = {
-    /**
-     * User id
-     */
-    userID: number;
-    /**
-     * User name
-     */
-    userName: string;
-    /**
-     * Account id
-     */
-    accountID: number;
-};
-
-export declare type UserSDK = User
+export declare interface User {
+    userID: number,
+    userName: string,
+    accountID: number
 
-/**
- * The structure of received socket events.
- */
-export declare type WrappedSocketEvent<T extends EventsEnum> = {
+}
+
+declare type WrappedSocketEvent<T extends EventsEnum> = {
     name: T
-    data: EventDataMapExtended[T]
+    data: EventDataMap[T]
 }
 
 export { }