@voicenter-team/events-sdk 0.0.67 → 0.0.69

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

@@ -1,34 +1,82 @@
-import { DebouncedFuncLeading } from 'lodash';
 import { io } from 'socket.io-client';
+import type { 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
 
-/**
- * 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[]
+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 users status event.
- */
-declare interface AllUsersStatusEvent extends CommonEventProperties {
-    // Array of User objects
-    users: User[]
-}
+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>
 
 declare class AuthClass {
     private readonly eventsSdkClass;
@@ -36,30 +84,33 @@ declare class AuthClass {
     private delay;
     lastLoginTimestamp: number | undefined;
     token: string | undefined;
+    private refreshToken;
+    private tokenExpiry;
     private storageKey;
-    login(options: EventsSdkOptions): Promise<void>;
+    login(): Promise<Partial<LoginSessionData> | undefined>;
     updateLastLoginTimestamp(): void;
     private checkLoginStatus;
     private userLoginFunction;
-    private onLoginResponse;
+    onLoginResponse(loginSessionData: Partial<LoginSessionData>): void;
     handleTokenExpiry(): void;
     private externalLogin;
     private getSettings;
-    private refreshToken;
+    private externalRefreshToken;
+    private normalizeLoginType;
 }
 
 export declare type CallAddingProgressListener = (callId: string | undefined) => void
 
-declare enum CallStatusEnum {
-    RINGING = "Ringing",
-    TALKING = "Talking",
-    DIALING = "Dialing",
-    HOLD = "Hold"
+export declare enum CallStatusEnum {
+    RINGING = 'Ringing',
+    TALKING = 'Talking',
+    DIALING = 'Dialing',
+    HOLD = 'Hold',
 }
 
-declare enum CallTypeEnum {
-    INCOMING = "Incoming",
-    OUTGOING = "Outgoing"
+export declare enum CallTypeEnum {
+    INCOMING = 'Incoming',
+    OUTGOING = 'Outgoing',
 }
 
 export declare type changeActiveCallsListener = (event: { [key: string]: string }) => void
@@ -76,67 +127,129 @@ export declare type changeIsMutedListener = (value: boolean) => void
 
 export declare type changeMuteWhenJoinListener = (value: boolean) => void
 
-/**
- * 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
+export declare enum ConnectionStatusEnum {
+    CONNECTED = 'connected',
+    DISCONNECTED = 'disconnected',
+    TRYING_TO_CONNECT = 'tryingToConnect',
 }
 
-/**
- * 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 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
+}
+
+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',
 }
 
-declare enum DialerType {
-    AUTOMATIC = "Automatic",
-    IVR = "IVR"
+export declare enum DirectionEnum {
+    INCOMINC = 'Incoming',
+    OUTGOING = 'Outgoing',
+    SPY = 'Spy',
+    CLICK2CALL = 'Click2Call',
 }
 
-declare enum DirectionEnum {
-    INCOMING = "Incoming",
-    OUTGOING = "Outgoing",
-    SPY = "Spy",
-    CLICK2CALL = "Click2call"
+export declare enum DoNotCallMeStatusCodeEnum {
+    RESPONSE_FROM_API_VALID = 'RESPONSE_FROM_API_VALID',
+    RESPONSE_FROM_API_INVALID = 'RESPONSE_FROM_API_INVALID',
 }
 
-declare enum DoNotCallMeStatusCodeEnum {
-    RESPONSE_FROM_API_VALID = "RESPONSE_FROM_API_VALID",
-    RESPONSE_FROM_API_INVALID = "RESPONSE_FROM_API_INVALID"
+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>>
 }
 
 /**
@@ -144,14 +257,17 @@ declare enum DoNotCallMeStatusCodeEnum {
  * 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 = {
+export 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
  */
-declare interface EventDataMap {
+export declare interface EventDataMap {
     [EventsEnum.ALL_EXTENSION_STATUS]: AllExtensionStatusEvent
     [EventsEnum.ALL_DIALER_STATUS]: AllDialersStatusEvent
     [EventsEnum.ALL_USERS_STATUS]: AllUsersStatusEvent
@@ -162,112 +278,145 @@ declare interface EventDataMap {
     [EventsEnum.LOGIN_STATUS]: LoginStatusEvent
     [EventsEnum.KEEP_ALIVE_RESPONSE]: KeepAliveResponseEvent
     [EventsEnum.ONLINE_STATUS_EVENT]: OnlineStatusEvent
+    [EventsEnum.EXTENSIONS_UPDATED]: ExtensionsUpdated
 }
 
 /**
- * All the eventNames that can be received from the server. Exists only in EXTENSION_EVENT and QueueEvent
+ * 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
  */
-declare enum EventNameEnum {
-    EXTENSION = "extension",
-    QUEUE = "queue",
-    DIALER = "dialer"
+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;
 }
 
-/**
- * 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_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',
 }
 
 /**
  * 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
+export declare type EventSpecificCallback<T extends EventTypeNames> = (data: WrappedSocketEvent<T>) => void
 
 declare class EventsSdkClass {
-    constructor(options: EventsSdkOptions);
-    private argumentOptions;
-    readonly options: EventsSdkOptions;
+    readonly options: EventsSdkOptionsMain & EventsSdkOptionsBase;
     servers: Server[];
-    server: Server;
-    socket: any | undefined;
+    URLList: string[];
+    server: Server | undefined;
+    URL: string | undefined;
+    socket: SocketTyped | undefined;
+    private mainServer;
+    private alreadyAttemptedOtherServers;
     authClass: AuthClass;
     socketIoClass: SocketIoClass;
-    reconnectOptions: ReconnectOptions;
-    retryConnection: DebouncedFuncLeading<(server?: ServerParameter, skipLogin?: boolean) => void>;
-    private listeners;
-    private allListeners;
+    loggerClass: LoggerClass;
+    eventEmitterClass: EventEmitterClass;
+    constructor(options: EventsSdkOptionsClient);
     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;
+    emit<T extends ServerEmitEventTypeNames>(event: T, ...args: Parameters<ServerEmitEventCallbackRegistry[T]>): void;
+    connect(serverParameter: ServerParameter): void;
     disconnect(): void;
     clearKeepAliveInterval(): void;
-    private findCurrentServer;
-    private findNextAvailableServer;
-    private findMaxPriorityServer;
-    private findMinPriorityServer;
-    getServerWithHighestPriority(servers: Server[]): Server;
+    private findMainServer;
+    private findNextServer;
     init(): Promise<boolean>;
-    private getServers;
+    getCircularReplacer: () => (key: string, value: object) => object | undefined;
+    getCurrentMonitorServer(): Server | undefined;
 }
 export default EventsSdkClass;
 
-export declare interface EventsSdkOptions {
-    isNewStack?: boolean;
-    servers: Server[];
-    loginUrl: string;
-    fallbackServer: Server;
-    refreshTokenUrl: string;
-    refreshToken?: string;
-    token: string;
-    tokenExpiry?: Date;
+export declare interface EventsSdkOptionsBase {
     loginType: LoginType;
+    isNewStack?: boolean;
     forceNew?: boolean;
-    reconnectionDelay: number;
-    reconnectionDelayMax?: number;
-    maxReconnectAttempts: number;
+    servers?: Server[];
+    reconnectionDelay?: number;
     timeout?: number;
-    keepAliveTimeout: number;
-    idleInterval?: number;
-    protocol: string;
-    transports?: string[];
-    upgrade?: boolean;
-    serverFetchStrategy?: string;
-    serverType?: number;
+    keepAliveTimeout?: number;
+    protocol?: string;
     useLogger?: boolean;
-    loggerSocketConnection?: string;
+    loggerSocketConnection?: Socket_2;
     loggerServer?: string;
-    loggerConfig?: LoggerConfig;
+    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;
     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;
-}
+};
 
-declare type EventTypeData<T extends EventsEnum> = EventDataMap[T]
+/**
+ * The structure of event data for a specific event type.
+ */
+export declare type EventTypeData<T extends EventsEnum> = EventDataMapExtended[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
+export declare type EventTypeNames = keyof EventDataMap
 
 /**
  * Represents Event Types in Enum
@@ -308,96 +457,267 @@ 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
  */
-declare type EventWrappedSocketDataMap = {
+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
+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>
 }
 
-/**
- * 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
+declare interface ExtensionCallsUTCExtended extends ExtensionUTCExtended {
+    currentCall?: CurrentCallUTCExtended
+    calls?: Array<CurrentCallUTCExtended>
 }
 
-/**
- * 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"
+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 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 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
 }
 
 export declare interface ExternalLoginNewStackResponseData {
@@ -426,14 +746,32 @@ 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.
  */
-declare type GenericEventWrapper = EventWrappedSocketDataMap[EventTypeNames]
-
-/**
- * Data structure for keep alive response event.
- */
-declare interface KeepAliveResponseEvent extends CommonEventProperties {
-    isOk: boolean
-}
+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>
 
 export declare type ListenerCallbackFnType<T extends ListenersKeyType> = OpenSIPSEventMap[T]
 
@@ -441,10 +779,20 @@ 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;
+    stop(): void;
+    log(data: LoggerDataPartial): void;
+    sdkInitializedLog(): void;
+}
+
 export declare interface LoggerConfig {
     logToConsole?: boolean;
     overloadGlobalConsole?: boolean;
-    namespace?: string;
+    system: string;
     socketEmitInterval?: number;
 }
 
@@ -452,7 +800,9 @@ export declare interface LoggerConnectOptions {
     reconnection?: boolean;
     reconnectionDelay?: number;
     reconnectionAttempts?: number;
-    perMessageDeflate?: boolean;
+    perMessageDeflate?: {
+        threshold: number;
+    };
     upgrade?: boolean;
     transports?: string[];
     debug?: boolean;
@@ -461,29 +811,68 @@ export declare interface LoggerConnectOptions {
 export declare interface LoginSessionData extends Settings, ExternalLoginNewStackResponseData, Socket {}
 
 export declare interface LoginSessionPayload {
-    token: string,
-    email: string,
-    password: string
-}
-
-/**
- * Data structure for login status event.
- */
-declare interface LoginStatusEvent extends CommonEventProperties {
-    // Array of Queue objects
-    queues: Queue[]
+    token?: string,
+    email?: string,
+    password?: string
 }
 
-declare type LoginSuccessEvent = CommonEventProperties
-
-declare enum LoginType {
+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 {
     USER = "User",
     TOKEN = "Token"
 }
 
-declare interface OnlineStatusEvent {
-    isSocketConnected: boolean
-}
+declare type OnlineStatusEvent = {
+    /**
+     * which server sdk trying to connect
+     */
+    attemptToConnect?: string;
+    connectionStatus: ConnectionStatusEnum;
+};
+
+export declare type OnlineStatusEventSDK = EventTypeData<EventsEnum.ONLINE_STATUS_EVENT>
 
 export declare interface OpenSIPSEventMap {
     ready: readyListener
@@ -503,63 +892,142 @@ export declare interface OpenSIPSEventMap {
     changeCallStatus: changeCallStatusListener
 }
 
-export declare interface Queue {
-    QueueID: number,
-    QueueName: string,
-    Calls: QueueCall[],
-    UserId?: number,
-    DistributorID?: number,
-    IsDistributedQueue?: boolean,
-    AnsweredAgent?: string,
+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 QueueCall {
-    CallerID: string,
-    CallerName: string,
-    IvrUniqueID: string,
-    JoinTimeStamp: number,
-    calldurationinterval: number,
-    ivrid: string,
-    isDistributedQueue?: boolean
+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',
 }
 
-/**
- * Data structure for queue event.
- */
-declare interface QueueEvent extends CommonEventProperties {
-    eventName: EventNameEnum.QUEUE,
-    reason: QueueEventReasonEnum,
-    telephonyServerTime: number,
-    ivrUniqueId: string,
-    data: Queue
+export declare type QueueEventSDK = EventTypeData<EventsEnum.QUEUE_EVENT>
+
+declare interface QueueEventUTCExtended extends Omit<QueueEvent, 'data'> {
+    data: QueueSDK
 }
 
-declare enum QueueEventReasonEnum {
-    ANSWER = "ANSWER",
-    ABANDONED = "ABANDONED",
-    EXIT = "EXIT",
-    JOIN = "JOIN"
+export declare interface QueueSDK extends Omit<Queue, 'Calls'> {
+    Calls?: Array<QueueCallSDK>
 }
 
 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
-}
+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
 
+declare type Response_2 = {
+};
+
+export declare type ResponseSDK = Response_2
+
 export declare type RoomDeletedListener = (roomId: number) => void
 
 export declare interface Server {
@@ -569,10 +1037,33 @@ 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 {
-    DEFAULT = "default",
-    NEXT = "next",
-    PREVIOUS = "previous"
+    MAIN = "main",
+    NEXT = "next"
 }
 
 export declare enum ServerTypesEnum {
@@ -613,37 +1104,68 @@ 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, Record<EventsEnum, any>>
+export declare type SocketTyped = Socket_2<EventCallbackRegistry, ServerEmitEventCallbackRegistry>
 
-export declare interface Summery {
-    representative: string
-}
+declare type Summery = {
+    /**
+     * Representative
+     */
+    representative: string;
+};
+
+export declare type SummerySDK = Summery
 
 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 UpdateMonitoredExtensionsPayload {
+    extensionsString: string
+}
 
-export declare interface User {
-    userID: number,
-    userName: string,
-    accountID: number
+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
 
-declare type WrappedSocketEvent<T extends EventsEnum> = {
+/**
+ * The structure of received socket events.
+ */
+export declare type WrappedSocketEvent<T extends EventsEnum> = {
     name: T
-    data: EventDataMap[T]
+    data: EventDataMapExtended[T]
 }
 
 export { }