Introduction

Rtd Library is a javascript library to build your own Real Time Display.

With real time Display you can monitor TVox Services, TVox Skillsets and Agent Production.

Initialize Rtd Client Instance

import { RTDClient, RTDClientConfig } from '@telenia/rtdclient';
const rtdConfig = new RTDClientConfig({ url: "https://<tvox_ip>" });
const client = new RTDClient(rtdConfig);

var rtdConfig = RTDClientConfig({ url: "https://<tvox_ip>" });
var client = RTDClient(rtdConfig);

change <tvox_ip> with the TVox Contact Center ip or domain

To create a real time application, need to create a new instance of RTDClient.

To use all library methods youn have to login to server before. There are two ways to login:

const loginResult = await client.login(username, password);

var loginResult = await client.login(username, password);

To Login to server with administrator credentials use this method:

login(username: string, password: string): Promise<TVoxRestClientModels.LoginProfileModel>

Parameter	Type	Description
username	String	Administrator/Supervisor username to login to server
password	String	Administrator/Supervisor password to login to server

const loginResult = await client.loginByAccessToken(accessToken);

var loginResult = await client.loginByAccessToken(accessToken);

To login to server with access token ( retrieve accesstoken after Login with username and password) use this method:

loginByAccessToken(accessToken: string): Promise<TVoxRestClientModels.LoginProfileModel>

Parameter	Type	Description
accessToken	String	Access token to login

Logout

await client.logout();

await client.logout();

To logout from client use the logout method

logout(): Promise<void>

Create Realtime Instance

const statsReference = client.panel.createPanel();

var statsReference = client.panel.createPanel();

Create a instance of indicators and statistics reference to PanelManager

createPanel(): Panel

Get Service Stats Subscription

import { Filter, Indicator } from "@telenia/rtdclient";

const serviceStatsFilter: Filter.ServiceStatsFilterData = {
  CALL: {
    services: ["service_code_1", "service_code_2"],
    customStatKeys: ["custom_1", "custom_2"],
    userSite : 1,
    activityCodes: ["activity_1","activity_2"]
  } as Filter.ServiceChannelStatFilter,
  VIDEO: {
    services: ["service_code_1", "service_code_2"],
    customStatKeys: ["custom_1", "custom_2"],
    userSite : 1,
    activityCodes: ["activity_1","activity_2"]
  } as Filter.ServiceChannelStatFilter,  
};

statsReference.serviceStats.filter = serviceStatsFilter;

const stats: Indicator.ServiceStatsIndicator = {
    channelStats: {
        answeredCalls: true,
        closedCalls: true,        
          call: {
              openTickets: true,
          } as Indicator.ServiceCallAtStatIndicator,
          video: {
              createdTickets: true,
          } as Indicator.ServiceVideoAtStatIndicator,        
    } as Indicator.ServiceChannelStatIndicator,
    userStats: {
        notReadyUsers: true,
        loggedUsers: true,        
          call: {
              busyOnDNCallInUsers: true,
          },        
    } as Indicator.ServiceUserStatsIndicator,
} as Indicator.ServiceStatsIndicator;

statsReference.serviceStats.indicator = stats;

statsReference.serviceStats.stats.subscribe((data) => {});


var serviceStatsFilter = {
  CALL: {
    services: ["service_code_1", "service_code_2"],
    customStatKeys: ["custom_1", "custom_2"],
    userSite : 1,
    activityCodes: ["activity_1","activity_2"]
  },
  VIDEO: {
    services: ["service_code_1", "service_code_2"],
    customStatKeys: ["custom_1", "custom_2"],
    userSite : 1,
    activityCodes: ["activity_1","activity_2"]
  } ,
};

statsReference.serviceStats.filter = serviceStatsFilter;

var stats = {
  channelStats:{
    answeredCalls: true,
    closedCalls: true,    
      call:{            
        openTickets: true,            
      },
      video:{            
        createdTickets: true,
      }      
  }, 
  userStats: { 
    notReadyUsers: true,
    loggedUsers: true,    
      call: {
        busyOnDNCallInUsers: true
      }    
  },
};

statsReference.serviceStats.indicator = stats;

statsReference.serviceStats.stats.subscribe((data) => {});

const statsReference = client.panel.createPanel() get the panel reference, then define a ServiceStatsFilterData and assign it to statsRefercence filter statsReference.serviceStats.filter = serviceStatsFilter, then define a ServiceStatsIndicator statsReference.serviceStats.indicator = stats and assign it to statsRefercence indicator.

The request is sent to server and start the monitor when subscribe to stats statsReference.serviceStats.stats.subscribe((data) => {}).

For details on statsReference.serviceStats go to ServiceStatPanel section

Update Service Stats Subscription

import { Filter, Indicator } from "@telenia/rtdclient";

const serviceStatsFilter: Filter.ServiceStatsFilterData = {
  CALL: {
    services: ["service_code_1", "service_code_2","service_code_3"],
  } as Filter.ServiceChannelStatFilter,
  VIDEO: {
    services: ["service_code_1", "service_code_2","service_code_3"],
  } as Filter.ServiceChannelStatFilter,  
};

statsReference.serviceStats.filter = serviceStatsFilter;

const stats: Indicator.ServiceStatsIndicator = {
    channelStats: {
        answeredCalls: true,
        closedCalls: true,
        hangupCalls: true,        
        call: {
            openTickets: true,
        } as Indicator.ServiceCallAtStatIndicator,
        video: {
            createdTickets: true,
        } as Indicator.ServiceVideoAtStatIndicator,        
    } as Indicator.ServiceChannelStatIndicator,
    userStats: {
        notReadyUsers: true,
        loggedUsers: true,
        busyUsers: true,        
        call: {
            busyOnDNCallInUsers: true,
        },        
    } as Indicator.ServiceUserStatsIndicator,
} as Indicator.ServiceStatsIndicator;

statsReference.serviceStats.indicator = stats;

statsReference.serviceStats.applyFilterOrIndicator();


var serviceStatsFilter = {
  CALL: {
    services: ["service_code_1", "service_code_2","service_code_3"],
  },
  VIDEO: {
    services: ["service_code_1", "service_code_2","service_code_3"],
  } ,
};

statsReference.serviceStats.filter = serviceStatsFilter;

var stats = {
  channelStats:{
    answeredCalls: true,
    closedCalls: true
    hangupCalls: true,    
      call:{            
        openTickets: true,            
      },
      video:{            
        createdTickets: true,
      }      
  }, 
  userStats: { 
    notReadyUsers: true,
    loggedUsers: true,
    busyUsers: true,    
    call: {
      busyOnDNCallInUsers: true
    }    
  },
};

statsReference.serviceStats.indicator = stats;

statsReference.serviceStats.applyFilterOrIndicator();

The request is updated then sent to server when launch the statsReference.serviceStats.applyFilterOrIndicator() method.

applyFilterOrIndicator() sends the request to the server only if it was subscribed first else only update fliter or indicator reference

For details on statsReference.serviceStats go to ServiceStatPanel section

Get Skillset Stats Subscription

import { Filter, Indicator } from "@telenia/rtdclient";

const skillsetsStatsFilter: Filter.GroupStatsFilterData = {
  CALL: {
    groups: ["skillset_code_1", "skillset_code_2"],
    customStatKeys: ["custom_1", "custom_2"],
    userSite : 1
  } as Filter.GroupChannelStatFilter,
  VIDEO: {
    groups: ["skillset_code_1", "skillset_code_2"],
    customStatKeys: ["custom_1", "custom_2"],
    userSite : 1
  } as Filter.GroupChannelStatFilter,  
};

statsReference.groupStats.filter = skillsetsStatsFilter;

const stats: Indicator.GroupStatsIndicator = {
    channelStats: {
        answeredCalls: true,
        queuedCalls: true,                     
    } as Indicator.GroupChannelStatFilter,
    userStats: { loggedUsers: true } as Indicator.GroupStatsUserIndicator,
} as Indicator.GroupStatsIndicator;

statsReference.groupStats.indicator = stats;

statsReference.groupStats.stats.subscribe((data) => {});


var skillsetsStatsFilter = {
  CALL: {
    groups: ["skillset_code_1", "skillset_code_2"],
    customStatKeys: ["custom_1", "custom_2"],
    userSite : 1
  },
  VIDEO: {
    groups: ["skillset_code_1", "skillset_code_2"],
    customStatKeys: ["custom_1", "custom_2"],
    userSite : 1
  } ,
};

statsReference.groupStats.filter = skillsetsStatsFilter;

var stats = {
 channelStats: {
        answeredCalls: true,
        queuedCalls: true,                     
    } as Indicator.GroupChannelStatFilter,
    userStats: { loggedUsers: true }
};

statsReference.groupStats.indicator = stats;

statsReference.groupStats.stats.subscribe((data) => {});

const statsReference = client.panel.createPanel() get the panel reference, then define a GroupStatsFilterData and assign it to statsRefercence filter statsReference.serviceStats.filter = serviceStatsFilter, then define a GroupStatsUserIndicator statsReference.serviceStats.indicator = stats and assign it to statsRefercence indicator.

The request is sent to server and start the monitor when subscribe to stats statsReference.serviceStats.stats.subscribe((data) => {}).

For details on statsReference.groupStats go to GroupStatPanel section

Update Skillset Stats Subscription

import { Filter, Indicator } from "@telenia/rtdclient";

const skillsetsStatsFilter: Filter.GroupStatsFilterData = {
  CALL: {
    groups: ["skillset_code_1", "skillset_code_2", "skillset_code_3"], 
  } as Filter.GroupChannelStatFilter,
  VIDEO: {
    groups: ["skillset_code_1", "skillset_code_2", "skillset_code_3"], 
  } as Filter.GroupChannelStatFilter,  
};

statsReference.groupStats.filter = skillsetsStatsFilter;

const stats: Indicator.GroupStatsIndicator = {
    channelStats: {
      answeredCalls: true,
      queuedCalls: true,
      hangupCalls: true,                    
    } as Indicator.GroupChannelStatFilter,
    userStats: { loggedUsers: true } as Indicator.GroupStatsUserIndicator,
} as Indicator.GroupStatsIndicator;

statsReference.groupStats.indicator = stats;

statsReference.groupStats.applyFilterOrIndicator();


var skillsetsStatsFilter = {
  CALL: {
    groups: ["skillset_code_1", "skillset_code_2", "skillset_code_3"], 
  },
  VIDEO: {
    groups: ["skillset_code_1", "skillset_code_2", "skillset_code_3"], 
  } ,
};

statsReference.groupStats.filter = skillsetsStatsFilter;

var stats = {
  channelStats: {
      answeredCalls: true,
      queuedCalls: true,
      hangupCalls: true,                 
  }
  userStats: { loggedUsers: true }
};

statsReference.groupStats.indicator = stats;

statsReference.groupStats.applyFilterOrIndicator();

The request is updated then sent to server when launch the statsReference.serviceStats.applyFilterOrIndicator() method.

applyFilterOrIndicator() sends the request to the server only if it was subscribed first else only update fliter or indicator reference

For details on statsReference.groupStats go to GroupStatPanel section

Get User Stats Subscription

import { Filter, Indicator } from "@telenia/rtdclient";


const usersStatsFilter: Filter.UserStatsFilterData = {
  CALL: { users: ["username_1", "username_2"] },
  VIDEO: { users: ["username_1", "username_2"] }
};

statsReference.userStats.filter = usersStatsFilter;

const stats: Indicator.UserStatsIndicator = {
  name: true,
  surname: true,
  channel: true,
  activityCode: true,
  call: {
    numberCallOut: true,
  }
} as Indicator.UserStatsIndicator;
statsReference.userStats.indicator = stats;

statsReference.userStats.subscribe((data) => {});


var usersStatsFilter = {
  CALL: { users: ["username_1", "username_2"] },
  VIDEO: { users: ["username_1", "username_2"] }
};

statsReference.userStats.filter = usersStatsFilter;

var stats = {
  name: true,
  surname: true,
  channel: true,
  activityCode: true,
  call: {
    numberCallOut: true,
  }
};
statsReference.userStats.indicator = stats;

statsReference.userStats.subscribe((data) => {});

const statsReference = client.panel.createPanel() get the panel reference, then define a UserStatsFilterData and assign it to statsRefercence filter statsReference.serviceStats.filter = serviceStatsFilter, then define a UserStatsIndicator statsReference.serviceStats.indicator = stats and assign it to statsRefercence indicator.

The request is sent to server and start the monitor when subscribe to stats statsReference.serviceStats.stats.subscribe((data) => {}).

For details on statsReference.userStats go to UserStatPanel section

Update User Stats Subscription

import { Filter, Indicator } from "@telenia/rtdclient";


const usersStatsFilter: Filter.UserStatsFilterData = {
  CALL: { users: ["username_1", "username_2", "username_3"] },
  VIDEO: { users: ["username_1", "username_2", "username_3"] },
};

statsReference.userStats.filter = usersStatsFilter;

const stats: Indicator.UserStatsIndicator = {
  name: true,
  surname: true,
  channel: true,
  activityCode: true,
  timeInState:true,
  call:{
    numberCallOutPrivate: true
  }
} as Indicator.UserStatsIndicator;
statsReference.userStats.indicator = stats;

statsReference.userStats.applyFilterOrIndicator();


var usersStatsFilter = {
  CALL: { users: ["username_1", "username_2", "username_3"] },
  VIDEO: { users: ["username_1", "username_2", "username_3"] },
};

statsReference.userStats.filter = usersStatsFilter;

var stats = {
  name: true,
  surname: true,
  channel: true,
  activityCode: true,
  timeInState:true,
  call:{
    numberCallOutPrivate: true
  }
};
statsReference.userStats.indicator = stats;

statsReference.userStats.applyFilterOrIndicator();

The request is updated then sent to server when launch the statsReference.serviceStats.applyFilterOrIndicator() method.

applyFilterOrIndicator() sends the request to the server only if it was subscribed first else only update fliter or indicator reference

For details on statsReference.userStats go to UserStatPanel section

Get User Profile Stats Subscription

import { Filter, Indicator } from "@telenia/rtdclient";


const usersStatsFilter: Filter.UserProfileStatFilter = {
  CALL: { userProfiles: [1, 2] },
  VIDEO: { userProfiles: [1, 2] },
};

statsReference.userProfileStats.filter = usersStatsFilter;

const stats: Indicator.UserProfileStatsIndicator = {
  name: true,
  surname: true,
  channel: true,
  activityCode: true,
  call: {
    numberCallOut: true,
  }
} as Indicator.UserProfileStatsIndicator;
statsReference.userProfileStats.indicator = stats;

statsReference.userProfileStats.subscribe((data) => {});


var usersStatsFilter = {
  CALL: { userProfiles: [1, 2] },
  VIDEO: { userProfiles: [1, 2] },
};

statsReference.userProfileStats.filter = usersStatsFilter;

var stats = {
  name: true,
  surname: true,
  channel: true,
  activityCode: true,
  call: {
    numberCallOut: true,
  }
};
statsReference.userProfileStats.indicator = stats;


statsReference.userProfileStats.subscribe((data) => {});

const statsReference = client.panel.createPanel() get the panel reference, then define a UserProfileStatFilter and assign it to statsRefercence filter statsReference.serviceStats.filter = serviceStatsFilter, then define a UserProfileStatsIndicator statsReference.serviceStats.indicator = stats and assign it to statsRefercence indicator.

The request is sent to server and start the monitor when subscribe to stats statsReference.serviceStats.stats.subscribe((data) => {}).

For details on statsReference.userProfileStats go to UserProfileStatPanel section

Update User Profile Stats Subscription

import { Filter, Indicator } from "@telenia/rtdclient";


const usersStatsFilter: Filter.UserProfileStatFilter = {
  CALL: { userProfiles: [1, 2, 3] },
  VIDEO: { userProfiles: [1, 2, 3] },
};

statsReference.userProfileStats.filter = usersStatsFilter;

const stats: Indicator.UserProfileStatsIndicator = {
  name: true,
  surname: true,
  channel: true,
  activityCode: true,
  timeInState: true,
  call:{
    numberCallOutPrivate: true
  }
} as Indicator.UserProfileStatsIndicator;
statsReference.userProfileStats.indicator = stats;

statsReference.userProfileStats.applyFilterOrIndicator();


var usersStatsFilter = {
  CALL: { userProfiles: [1, 2, 3] },
  VIDEO: { userProfiles: [1, 2, 3] },
};

statsReference.userProfileStats.filter = usersStatsFilter;

var stats = {
  name: true,
  surname: true,
  channel: true,
  activityCode: true,
  timeInState: true,
  call:{
    numberCallOutPrivate: true
  }
};
statsReference.userProfileStats.indicator = stats;

statsReference.userProfileStats.applyFilterOrIndicator();

The request is updated then sent to server when launch the statsReference.serviceStats.applyFilterOrIndicator() method.

applyFilterOrIndicator() sends the request to the server only if it was subscribed first else only update fliter or indicator reference

For details on statsReference.userProfileStats go to UserProfileStatPanel section

Search Services

import { TVoxRestClientModels } from "@telenia/rtdclient/rest";

const pageSize = 10;
const pageNumber = 1;

const limitRequest: TVoxRestClientModels.SearchLimitModel = {
  pageNumber,
  pageSize,
} as TVoxRestClientModels.SearchLimitModel;

const request: TVoxRestClientModels.SearchResultServiceBaseWithChannelsModel = {
  term: search_term,
  enabledChannels: [TVoxRestClientModels.MultiChannelIdTypeModel.CALL],
  types: [TVoxRestClientModels.ServiceTypeModel.CALLCENTER],
  limit: limitRequest,
  excludeServices: ['exclude_service_code_1', 'exclude_service_code_2'],
};

client.entity.service.search(request);


var pageSize = 10;
var pageNumber = 1;

var limitRequest = {
  pageNumber,
  pageSize,
};

var request = {
  term: search_term,
  enabledChannels: ['CALL'],
  types: ['CALLCENTER'],
  limit: limitRequest,
  excludeServices: ['exclude_service_code_1', 'exclude_service_code_2'],
};

client.entity.service.search(request);

search_term is the search string to filter the request. client is the RTDClient instance

Get the list of services filtered by the search criterias.

search(request:TVoxRestClientModels.SearchServiceLiteRequestModel): Promise<TVoxRestClientModels.SearchResultServiceBaseWithChannelsModel>

Search Skillsets

import { TVoxRestClientModels } from "@telenia/rtdclient/rest";

const pageSize = 10;
const pageNumber = 1;

const limitRequest: TVoxRestClientModels.SearchLimitModel = {
  pageNumber,
  pageSize,
} as TVoxRestClientModels.SearchLimitModel;

const request: TVoxRestClientModels.SearchSkillsetLiteRequestModel = {
  term: search_term,
  enabledChannels: [TVoxRestClientModels.MultiChannelIdTypeModel.CALL],
  types: [TVoxRestClientModels.SkillsetTypeModel.CALLCENTER],
  limit: limitRequest,
  excludeSkillsets: ['exclude_skillset_code_1', 'exclude_skillset_code_2'],
};
client.entity.group.search(request);

var pageSize = 10;
var pageNumber = 1;

var limitRequest = {
  pageNumber,
  pageSize,
};

var request = {
  term: search_term,
  enabledChannels: ['CALL'],
  types: ['CALLCENTER'],
  limit: limitRequest,
  excludeSkillsets: ['exclude_service_code_1', 'exclude_service_code_2'],
};

client.entity.group.search(request);

search_term is the search string to filter the request. client is the RTDClient instance

Get the list of skillsets filtered by the search criterias.

search(request:TVoxRestClientModels.SearchRequestSkillsetsSearchCriteriaSortFieldModel): Promise<TVoxRestClientModels.SearchResultSkillsetBaseWithChannelsModel>

Search Live Users

import { UserEntity } from "@telenia/rtdclient";

const filter: UserEntity.UserFilterData = {
  services: ['service_1', 'service_2'],
  skillsets: ['skillset_1', 'skillset_2'],
  channels: [TVoxRestClientModels.MultiChannelIdTypeModel.CALL],
  statuses: [
    UserEntity.UserStatusFilter.READY,
    UserEntity.UserStatusFilter.NOT_READY,
    UserEntity.UserStatusFilter.BUSY,
    UserEntity.UserStatusFilter.NOT_READY_BUSY,
    UserEntity.UserStatusFilter.BOOKED,
    UserEntity.UserStatusFilter.WNR,
  ],
};

const indicators: UserEntity.UserIndicator = {
  activeProfile: true,
  name: true,
  surname: true,
  statuses: { CALL: true },
};

client.entity.user.liveSearch(filter, indicators).subscribe((result)=>{});

var filter  = {
  services: [service_1, service_2],
  skillsets: [skillset_1, skillset_2],
  channels: ['CALL'],
  statuses: [ 
    'READY',
    'NOT_READY',
    'BUSY',
    'NOT_READY_BUSY',
    'BOOKED',
    'WNR',
  ],
};

var indicators = {
  activeProfile: true,
  name: true,
  surname: true,
  statuses: { CALL: true },
};

client.entity.user.liveSearch(filter, indicators).subscribe((result)=>{});

Get the list of users filtered by UserFilterData and UserIndicator, the result is an observable that return live result that match the filtered request.

liveSearch(request:UserFilterData, fields:UserIndicator): Observable<GraphResult<UserData[]>>

Get Channels List

const channelList = await client.entity.configuration.getChannelsList();

var channelList = await client.entity.configuration.getChannelsList();

Get the list of TVox channels, the result return an object that give some channel informations (enabled, id, etc...).

getChannelsList(): Promise<TVoxRestClientModels.MultiChannelModel[]>

Get User's Sites

const userSites = await client.entity.user.getUserSites();

var userSites = await client.entity.user.getUserSites();

Get the all user's sites configured on TVox system. getUserSites(): Promise<TVoxRestClientModels.UserSiteModel[]>

RTDClient

import { RTDClient } from '@telenia/rtdclient';
class RTDClient {
  readonly instanceId: string;
  readonly logConfigurator: RTDClientLogConfigurator;
  readonly options: RTDClientConfig;
  readonly panel: PanelManager;
  readonly entity: RTDEntityManager;
  readonly connectionState: Observable<ConnectionStateEvent<ConnectionStateData>>;
  constructor(options: RTDClientConfig);
}

class RTDClient {
  instanceId;
  logConfigurator;
  options;
  panel;
  entity;
  connectionState;
  constructor(options);
}

new RTDClient(options: RTDClientConfig)

Parameter	Type	Description
instanceId	string	Get the instance id of RTD Client
logConfigurator	RTDClientLogConfigurator	Change runtime log configuration
options	RTDClientConfig	Get RTD client configuration
panel	PanelManager	PanelManager allows you to manage different indicators groups (panels)
entity	RTDEntityManager	Allows you to retrieve Services, Skillsets and Users from the TVox system. This information will be used to request realtime indicators
connectionState	Observable`<`ConnectionStateEvent`<`ConnectionStateData`>>`	Event that represents the state of the connection

RTDClientLogConfigurator

import { RTDClientLogConfigurator } from '@telenia/rtdclient';
class RTDClientLogConfigurator {
  enabled: boolean;
  objectToJson: boolean;
  instanceIdLogged: boolean;
  logLevel: LogLevel;
}

class RTDClientLogConfigurator {
  enabled;
  objectToJson;
  instanceIdLogged;
  logLevel;
}

Prameter	Type	Description
enabled	boolean	Set to true/false to enable/disable log in realtime
objectToJson	boolean	Set to true/false to enable/disable object to JSon conversion in realtime
instanceIdLogged	boolean	Set to true/false to enable/disable log the instanceId in realtime
logLevel	LogLevel	Change the log level in realtime

RTDClientConfig

import {  RTDClientConfig} from '@telenia/rtdclient';
interface RTDClientConfig {
  url: string;
  logConfig?: RTDClientLogConfig;
  subscriptionConfig?: SubscriptionConfig;
}

interface RTDClientConfig {
  url;
  logConfig;
  subscriptionConfig;
}

Parameter	Type	Required	Description
url	String	true	Server url https://
logConfig	RTDClientLogConfig	false	Object to customize log configuration
subscriptionConfig	SubscriptionConfig	false	Object o customize subscription configuration

RTDClientLogConfig

import { RTDClientLogConfig} from '@telenia/rtdclient';
class RTDClientLogConfig {
  enabled?: boolean;
  objectToJson?: boolean;
  instanceIdLogged?: boolean;
  logLevel?: LogLevel;
}

class RTDClientLogConfig {
  enabled;
  objectToJson;
  instanceIdLogged;
  logLevel;
}

Parameter	Type	Required	Description
enabled	boolean	false	Set to true/false to enable/disable log
objectToJSon	boolean	false	Set to true/false to enable/disable object to JSon conversion
instanceIdLogged	boolean	false	Set to true/false to enable/disable log the instanceId
logLevel	LogLevel	false	Set the log level

LogLevel

enum LogLevel {
    Verbose,
    Debug,
    Info,
    Warn,
    Error,
    Fatal,
    None
}

enum LogLevel {
    Verbose,
    Debug,
    Info,
    Warn,
    Error,
    Fatal,
    None
}

Level	Description
Verbose	Highly detailed tracing messages. Produces the most voluminous output.
Debug	Relatively detailed tracing used by application developers.
Info	Informational messages that might make sense to end users and system administrators, and highlight the progress of the application.
Warn	Potentially harmful situations of interest to end users or system managers that indicate potential problems.
Error	Error events of considerable importance that will prevent normal program execution, but might still allow the application to continue running.
Fatal	Very severe error events that might cause the application to terminate.
None	No log written on console

SubscriptionConfig

import {  SubscriptionConfig} from '@telenia/rtdclient';
class SubscriptionConfig {
  timeout?: number;
  reconnect?: boolean;
  reconnectionAttempts?: number;
}

class SubscriptionConfig {
  timeout;
  reconnect;
  reconnectionAttempts;
}

Parameter	Type	Required	Default Value	Description
timeout	number	false	30000	The number of milliseconds of timeout
reconnect	boolean	false	true	Reconnect if the connection is lost
reconnectionAttempts	number	false	null	The maximum amount of times to retry the operation. If set to null, reconnection attemps are infinite

ConnectionStateEvent

import {ConnectionStateData,ConnectionStateEvent} from '@telenia/rtdclient';
interface ConnectionStateEvent<ConnectionStateData> {
    readonly state: ConnectionState;
    readonly payload: ConnectionStateData | null;
    readonly time: Date;
}

interface ConnectionStateEvent{
    state;
    payload;
    time;
}

Parameter	Type	Description
state	ConnectionState	The connection's state
payload	ConnectionStateData	Connection's object referenced by connection state
time	Date	Instant of state change

ConnectionStateData

import {ConnectionStateData} from '@telenia/rtdclient';
declare type ConnectionStateData = ConnectionStateConnecting | ConnectionStateConnected | ConnectionStateDisconnected;

ConnectionState	Type	Description
connecting	ConnectionStateConnecting	The connection is in connecting state
connected	ConnectionStateConnected	The connection is in connected state
disconnected	ConnectionStateDisconnected	The connection is in disconnected state

ConnectionStateConnecting

import {ConnectionStateConnecting, connectionStateEventIsConnecting} from '@telenia/rtdclient';
interface ConnectionStateConnecting {
}

connectionStateEventIsConnecting(connectionStateEvent: ConnectionStateEvent<ConnectionStateData>):  ConnectionStateEvent<ConnectionStateConnecting>

interface ConnectionStateConnecting {
}

To get ConnectionStateConnecting object use connectionStateEventIsConnecting(connectionStateEvent: ConnectionStateEvent) method.

ConnectionStateConnected

import {ConnectionStateConnected, connectionStateEventIsConnected} from '@telenia/rtdclient';
interface ConnectionStateConnected {
    readonly socket: WebSocket;
    readonly socketID: string;
}

connectionStateEventIsConnected(connectionStateEvent: ConnectionStateEvent<ConnectionStateData>): ConnectionStateEvent<ConnectionStateConnected>

interface ConnectionStateConnected {
    socket;
    socketID;
}

To get ConnectionStateConnected object, use connectionStateEventIsConnected(connectionStateEvent: ConnectionStateEvent) method

Attributes	Type	Description
socket	WebSocket	The WebSocket instance
socketID	string	The server socket instance

ConnectionStateDisconnected

import {ConnectionStateDisconnected,connectionStateEventIsDisconnected} from '@telenia/rtdclient';
interface ConnectionStateDisconnected {
    readonly closeEvent: CloseEvent;
    readonly reason: DisconnectedReason | null;
}

connectionStateEventIsDisconnected(connectionStateEvent: ConnectionStateEvent<ConnectionStateData>):  ConnectionStateEvent<ConnectionStateDisconnected>

interface ConnectionStateDisconnected {
    closeEvent;
    reason;
}

To get ConnectionStateDisconnected object, use connectionStateEventIsDisconnected(connectionStateEvent: ConnectionStateEvent) method

Attributes	Type	Description
closeEvent	CloseEvent	The WebSocket closed Event
reason	DisconnectedReason	The reason for the websocket closing event

DisconnectedReason

enum DisconnectedReason {
    TOKEN_EXPIRED = "EXPIRED_TOKEN",
    TOKEN_INVALID = "INVALID_TOKEN"
}

enum DisconnectedReason {
    TOKEN_EXPIRED,
    TOKEN_INVALID
}

DisconnectReason	Description
TOKEN_EXPIRED	The authentication token is expired
TOKEN_INVALID	The authenticationtoken is invalid

ConnectionState

import {  ConnectionState} from '@telenia/rtdclient';
enum ConnectionState {
    CONNECTING,
    CONNECTED,
    DISCONNECTED
}

enum ConnectionState {
    CONNECTING,
    CONNECTED,
    DISCONNECTED
}

State	Description
CONNECTING	The client is connecting to server
CONNECTED	The client is connected to server
DISCONNECTED	The lient is disconnected from server

PanelManager

import {PanelManager} from '@telenia/rtdclient';
class PanelManager {
  createPanel(): Panel;
  getPanel(panelId: string): Panel;
  closePanel(panelId: string): void;
}

class PanelManager {
  createPanel();
  getPanel(panelId);
  closePanel(panelId);
}

Create the insrance of panel. The panel is a instance that group realtime requests. Every panel can have own requests and indicators.

createPanel(): Panel

Get the panel instance by panelId. Get the panelId from Panel object.

Parameter	Type	Description>
panelId	string	Is the panel instance identifier

getPanel(panelId: string): Panel

Close the panel instance, when you call this method, all subcriptions are closed. Get the panelId from Panel object.

closePanel(panelId: string): void

Panel:

import {Panel} from '@telenia/rtdclient';
class Panel {
  readonly panelId: string;
  readonly userStats: UserStatPanel;
  readonly userProfileStats: UserProfileStatPanel;
  readonly groupStats: GroupStatPanel;
  readonly serviceStats: ServiceStatPanel;
  close(): void;
}

class Panel {
  panelId;
  userStats;
  userProfileStats;
  groupStats;
  serviceStats;
  close();
}

Use close() method to close the panel

Parameter	Type	Description
panelId	string	Is the panel unique instance identifier
userStats	UserStatPanel	Can set users indicator and filter to get users realtime statistics
userProfileStats	UserProfileStatPanel	Can set user profiles indicator and filter to get user profiles realtime statistics
groupStats	GroupStatPanel	Can set skillsets indicator and filter to get skillsets realtime statistics
serviceStats	ServiceStatPanel	Can set services indicator and filter to get services realtime statistics

UserStatPanel

import {UserStatPanel} from '@telenia/rtdclient';
class UserStatPanel {
  readonly stats: Observable<GraphResult<UserStats[]>> | null;
  readonly entity: Entity;
  filter: UserStatsFilterData;
  indicator: UserStatsIndicator;
  applyFilterOrIndicator(): void;
  close(): void;
}

class UserStatPanel {
  stats;
  entity;
  filter;
  indicator;
  applyFilterOrIndicator();
  close();
}

Use applyFilterOrIndicator() when change filter or indicator to send request to server

Use close() method to close the entity stats of panel, after call the object is invalid and cannot be reused to request entity stats

Parameter	Type	Description
stats	Observable`<`GraphResult`<`UserStats`[]>>`	Get realtime statistics for users
entity	Entity	Entity type of UserStatPanel
filter	UserStatsFilterData	Set the filter to monitoring statistics changes
indicator	UserStatsIndicator	Set the indicators to monitoring statistics changes

UserProfileStatPanel

import {UserProfileStatPanel} from '@telenia/rtdclient';
class UserProfileStatPanel {
  readonly stats: Observable<GraphResult<UserProfileStats[]>> | null;
  readonly entity: Entity;
  filter: UserProfileStatsFilterData;
  indicator: UserProfileStatsIndicator;
  applyFilterOrIndicator(): void;
  close(): void;
}

class UserStatPanel {
  stats;
  entity;
  filter;
  indicator;
  applyFilterOrIndicator();
  close();
}

Use applyFilterOrIndicator() when change filter or indicator to send request to server

Use close() method to close the entity stats of panel, after call the object is invalid and cannot be reused to request entity stats

Parameter	Type	Description
stats	Observable`<`GraphResult`<`UserProfileStats`[]>>`	Get realtime statistics for user profiles
entity	Entity	Entity type of UserStatPanel
filter	UserProfileStatsFilterData	Set the filter to monitoring statistics changes
indicator	UserProfileStatsIndicator	Set the indicators to monitoring statistics changes

GroupStatPanel

import {GroupStatPanel} from '@telenia/rtdclient';
class GroupStatPanel {
  readonly stats: Observable<GraphResult<GroupStats[]>> | null;
  readonly entity: Entity;
  filter: GroupStatsFilterData;
  indicator: GroupStatsIndicator;
  applyFilterOrIndicator(): void;
  close(): void;
}

class GroupStatPanel {
  stats;
  entity;
  filter;
  indicator;
  applyFilterOrIndicator();
  close();
}

Use applyFilterOrIndicator() when change filter or indicator to send request to server

Use close() method to close the entity stats of panel, after call the object is invalid and cannot be reused to request entity stats

Parameter	Type	Description
stats	Observable`<`GraphResult`<`GroupStats`[]>>`	Get realtime statistics for skillsets
entity	Entity	Entity type of UserStatPanel
filter	GroupStatsFilterData	Set the filter to monitoring statistics changes
indicator	GroupStatsIndicator	Set the indicators to monitoring statistics changes

ServiceStatPanel

import {ServiceStatPanel} from '@telenia/rtdclient';
class ServiceStatPanel {
  readonly stats: Observable<GraphResult<ServiceStats[]>> | null;
  readonly entity: Entity;
  filter: ServiceStatsFilterData;
  indicator: ServiceStatsIndicator;
  applyFilterOrIndicator(): void;
  close(): void;
}

class ServiceStatPanel {
  stats;
  entity;
  filter;
  indicator;
  applyFilterOrIndicator();
  close();
}

Use applyFilterOrIndicator() when change filter or indicator to send request to server

Use close() method to close the entity stats of panel, after call the object is invalid and cannot be reused to request entity stats

Parameter	Type	Description
stats	Observable`<`GraphResult`<`ServiceStats`[]>>`	Get realtime statistics for services
entity	Entity	Entity type of UserStatPanel
filter	ServiceStatsFilterData	Set the filter to monitoring statistics changes
indicator	ServiceStatsIndicator	Set the indicators to monitoring statistics changes

Entity

Entity	Description
service	Is a service entity
user	Is a user entity
userprofile	Is a user profile entity
group	Is a skillset entity

RTDEntityManager

import {RTDEntityManager} from '@telenia/rtdclient';
class RTDEntityManager {
  readonly service: ServiceEntityManager;
  readonly user: UserEntityManager;
  readonly group: GroupEntityManager;
}

class RTDEntityManager {
  service;
  user;
  group;
}

Parameter	Type	Description
service	ServiceEntityManager	Use to retrieve Services from the TVox system. The information will be used to request realtime indicators
user	UserEntityManager	Use to retrieve Users from the TVox system. The information will be used to request realtime indicators
group	GroupEntityManager	Use to retrieve Skillsets from the TVox system. The information will be used to request realtime indicators

ServiceEntityManager

import {ServiceEntity} from '@telenia/rtdclient';

class ServiceEntityManager {
  getServices(
    codes: string[]
  ): Promise<TVoxRestClientModels.ServiceBaseModel[]>;
  search(
    request: TVoxRestClientModels.SearchServiceLiteRequestModel
  ): Promise<TVoxRestClientModels.SearchResultServiceBaseWithChannelsModel>;
  searchByGroup(
    request: SearchServiceBySkillsetRequest
  ): Promise<TVoxRestClientModels.SearchResultServiceModel>;
}

class ServiceEntityManager {
  getServices(codes);
  search(request);
  searchByGroup(request);
}

To access this class use ServiceEntity.ServiceEntityManager

Get the services by the service codes. Is useful to get service information (for example description) if service code is known.

getServices(codes: string[]): Promise<TVoxRestClientModels.ServiceBaseModel[]>
Search services from server filtered by request.

search(request:TVoxRestClientModels.SearchServiceLiteRequestModel):Promise<TVoxRestClientModels.SearchResultServiceBaseWithChannelsModel>
Search services filtered by skillsets.

searchByGroup(request:SearchServiceBySkillsetRequest): Promise<TVoxRestClientModels.TVoxRestClientModels.SearchResultServiceModel>

UserEntityManager

import {UserEntity} from '@telenia/rtdclient';
class UserEntityManager {
  getUserSites(): Observable<TVoxRestClientModels.UserSiteModel>;
  getActivityCodes(): Observable<TVoxRestClientModels.ActivityCodeModel>;
  get(usernames: string[]): Promise<TVoxRestClientModels.UserBaseModel[]>;
  search(
    request: TVoxRestClientModels.SearchUserLiteRequestModel
    ): Promise<TVoxRestClientModels.SearchResultUserBaseModel>;
  searchByGroup(
    request: TVoxRestClientModels.SearchRequestSkillsetAgentsSearchCriteriaSortFieldModel
    ): Promise<TVoxRestClientModels.SearchResultTVoxUserModel>;
  liveSearch(
    request: UserFilterData, 
    fields: UserIndicator
    ):Observable<GraphResult<UserEntity.UserData[]>>;
}

class UserEntityManager {
  getUserSites();
  getActivityCodes();
  get(usernames);
  search(requestl);
  searchByGroup(request);
  liveSearch(request, fields);
}

To access this class use UserEntity.UserEntityManager

Get users sites lists

getUserSites(): Observable<TVoxRestClientModels.UserSiteModel>
Get Activity Codes List

getActivityCodes(): Observable<TVoxRestClientModels.ActivityCodeModel>
Get users details by usernames list

get(usernames: string[]): Promise<TVoxRestClientModels.UserBaseModel[]>
Search Users by filter

search(request:TVoxRestClientModels.SearchUserLiteRequestModel): Promise<TVoxRestClientModels.SearchResultUserBaseModel>
Search users by skillsets filter

searchByGroup(request:TVoxRestClientModels.SearchRequestSkillsetAgentsSearchCriteriaSortFieldModel): Promise<TVoxRestClientModels.SearchResultTVoxUserModel>;
Live Search to get realtime user by filter

liveSearch(request:UserFilterData, fields:UserIndicator): Observable<GraphResult<UserData[]>>

GroupEntityManager

import {GroupEntity} from '@telenia/rtdclient';
class GroupEntityManager {
  get(id: string): Promise<TVoxRestClientModels.SkillsetBaseWithChannelsModel>;
  search(request: TVoxRestClientModels.SearchRequestSkillsetsSearchCriteriaSortFieldModel): Promise<TVoxRestClientModels.SearchResultSkillsetBaseWithChannelsModel>;
}

class GroupEntityManager {
  get(id);
  search(request);
}

To access this class use GroupEntity.GroupEntityManager

Get skillset detail by skillset id

get(id: string): Promise<TVoxRestClientModels.SkillsetBaseWithChannelsModel>;
Search skillset filtered

search(request:TVoxRestClientModels.SearchRequestSkillsetsSearchCriteriaSortFieldModel): Promise<TVoxRestClientModels.SearchResultSkillsetBaseWithChannelsModel>;

Filter

ServiceStatsFilterData

import { Filter } from "@telenia/rtdclient";
interface ServiceStatsFilterData {
    CALL?: ServiceChannelStatFilter | null;       
    VIDEO?: ServiceChannelStatFilter | null;    
    CHAT?: ServiceChannelStatFilter | null;    
    MAIL_ACD?: ServiceChannelStatFilter | null;            
    CUSTOM_1?: ServiceChannelStatFilter | null;    
    CUSTOM_2?: ServiceChannelStatFilter | null;    
    CUSTOM_3?: ServiceChannelStatFilter | null; 
    LIVEHELP?: ServiceChannelStatFilter | null;    
}

interface ServiceStatsFilterData {
    CALL; 
    VIDEO; 
    CHAT; 
    MAIL_ACD;         
    CUSTOM_1; 
    CUSTOM_2; 
    CUSTOM_3; 
    LIVEHELP; 
}

To access this interface use Filter.ServiceStatsFilterData

Parameter	Type	Required	Description
CALL	ServiceChannelStatFilter	false	Filter service for channel Call
VIDEO	ServiceChannelStatFilter	false	Filter service for channel Video
CHAT	ServiceChannelStatFilter	false	Filter service for channel Chat
MAIL_ACD	ServiceChannelStatFilter	false	Filter service for channel Mail (ACD)
CUSTOM_1	ServiceChannelStatFilter	false	Filter service for channel Custom 1
CUSTOM_2	ServiceChannelStatFilter	false	Filter service for channel Custom 2
CUSTOM_3	ServiceChannelStatFilter	false	Filter service for channel Custom 2
LIVEHELP	ServiceChannelStatFilter	false	Filter service for channel Livehelp

ServiceChannelStatFilter

import { Filter } from "@telenia/rtdclient";
interface ServiceChannelStatFilter {
    services: String[];
    customStatKeys?: String[] | null;
    userSite?: Int | null;
    activityCodes?: String[] | null;
}

interface ServiceChannelStatFilter {
    services;
    customStatKeys;
    userSite;
    activityCodes;
}

To access this interface use Filter.ServiceChannelStatFilter

Parameter	Type	Required	Description
services	String[]	true	List of service codes to filter
customStatKeys	String[]	false	List of custom idicators keys
userSite	Int	false	User site to filter request
activityCodes	String[]	false	Activity codes to filter request

GroupStatsFilterData

import { Filter } from "@telenia/rtdclient";
interface GroupStatsFilterData {
    CALL?: GroupChannelStatFilter | null;
    VIDEO?: GroupChannelStatFilter | null;    
    CHAT?: GroupChannelStatFilter | null;    
    MAIL_ACD?: GroupChannelStatFilter | null;            
    CUSTOM_1?: GroupChannelStatFilter | null;    
    CUSTOM_2?: GroupChannelStatFilter | null;    
    CUSTOM_3?: GroupChannelStatFilter | null; 
    LIVEHELP?: GroupChannelStatFilter | null;    
}

interface GroupStatsFilterData {
    CALL; 
    VIDEO; 
    CHAT; 
    MAIL_ACD;         
    CUSTOM_1; 
    CUSTOM_2; 
    CUSTOM_3; 
    LIVEHELP; 
}

To access this interface use Filter.GroupStatsFilterData

Parameter	Type	Required	Description
CALL	GroupChannelStatFilter	false	Filter skillset for channel Call
VIDEO	GroupChannelStatFilter	false	Filter skillset for channel Video
CHAT	GroupChannelStatFilter	false	Filter skillset for channel Chat
MAIL_ACD	GroupChannelStatFilter	false	Filter skillset for channel Mail (ACD)
CUSTOM_1	GroupChannelStatFilter	false	Filter skillset for channel Custom 1
CUSTOM_2	GroupChannelStatFilter	false	Filter skillset for channel Custom 2
CUSTOM_3	GroupChannelStatFilter	false	Filter skillset for channel Custom 2
LIVEHELP	GroupChannelStatFilter	false	Filter skillset for channel Livehelp

GroupChannelStatFilter

import { Filter } from "@telenia/rtdclient";
interface GroupChannelStatFilter {
    groups: String[];
    customStatKeys?: String[] | null;
    userSite?: Int | null;
}

interface GroupChannelStatFilter {
    groups;
    customStatKeys;
    userSite;
}

To access this interface use Filter.GroupChannelStatFilter

Parameter	Type	Required	Description
groups	String[]	true	List of skillsets codes to filter
customStatKeys	String[]	false	List of custom idicators keys
userSite	Int	false	User site to filter request

UserProfileStatFilter

import { Filter } from "@telenia/rtdclient";
interface UserProfileStatFilter {
    CALL?: UserProfileStatChannelFilter | null;
    VIDEO?: UserProfileStatChannelFilter | null;    
    CHAT?: UserProfileStatChannelFilter | null;    
    MAIL_ACD?: UserProfileStatChannelFilter | null;            
    CUSTOM_1?: UserProfileStatChannelFilter | null;    
    CUSTOM_2?: UserProfileStatChannelFilter | null;    
    CUSTOM_3?: UserProfileStatChannelFilter | null; 
    LIVEHELP?: UserProfileStatChannelFilter | null;    
}

interface UserProfileStatFilter {
    CALL; 
    VIDEO; 
    CHAT; 
    MAIL_ACD;         
    CUSTOM_1; 
    CUSTOM_2; 
    CUSTOM_3; 
    LIVEHELP; 
}

To access this interface use Filter.UserProfileStatFilter

Parameter	Type	Required	Description
CALL	UserProfileStatChannelFilter	false	Filter users profiles ids for channel Call
VIDEO	UserProfileStatChannelFilter	false	Filter users for channel Video
CHAT	UserProfileStatChannelFilter	false	Filter users for channel Chat
MAIL_ACD	UserProfileStatChannelFilter	false	Filter users for channel Mail (ACD)
CUSTOM_1	UserProfileStatChannelFilter	false	Filter users for channel Custom 1
CUSTOM_2	UserProfileStatChannelFilter	false	Filter users for channel Custom 2
CUSTOM_3	UserProfileStatChannelFilter	false	Filter users for channel Custom 2
LIVEHELP	UserProfileStatChannelFilter	false	Filter users for channel Livehelp

UserProfileStatChannelFilter

import { Filter } from "@telenia/rtdclient";
interface UserProfileStatChannelFilter {
    userProfiles: Int[];
    activityCodes?: String[] | null;
}

interface UserProfileStatChannelFilter {
    userProfiles;
    activityCodes;
}

To access this interface use Filter.UserProfileStatChannelFilter

Parameter	Type	Required	Description
userProfiles	Int[]	true	List of profiles id to filter
activityCodes	String[]	false	List of code of activity codes to fitler

UserStatsFilterData

import { Filter } from "@telenia/rtdclient";
interface UserStatsFilterData {
    CALL?: UserStatChannelFilter | null;
    VIDEO?: UserStatChannelFilter | null;    
    CHAT?: UserStatChannelFilter | null;    
    MAIL_ACD?: UserStatChannelFilter | null;            
    CUSTOM_1?: UserStatChannelFilter | null;    
    CUSTOM_2?: UserStatChannelFilter | null;    
    CUSTOM_3?: UserStatChannelFilter | null; 
    LIVEHELP?: UserStatChannelFilter | null;    
}

interface UserStatsFilterData {
    CALL; 
    VIDEO; 
    CHAT; 
    MAIL_ACD;         
    CUSTOM_1; 
    CUSTOM_2; 
    CUSTOM_3; 
    LIVEHELP; 
}

To access this interface use Filter.UserStatsFilterData

Parameter	Type	Required	Description
CALL	UserStatChannelFilter	false	Filter users by usernames for channel Call
VIDEO	UserStatChannelFilter	false	Filter users for channel Video
CHAT	UserStatChannelFilter	false	Filter users for channel Chat
MAIL_ACD	UserStatChannelFilter	false	Filter users for channel Mail (ACD)
CUSTOM_1	UserStatChannelFilter	false	Filter users for channel Custom 1
CUSTOM_2	UserStatChannelFilter	false	Filter users for channel Custom 2
CUSTOM_3	UserStatChannelFilter	false	Filter users for channel Custom 2
LIVEHELP	UserStatChannelFilter	false	Filter users for channel Livehelp

UserStatChannelFilter

import { Filter } from "@telenia/rtdclient";
interface UserStatChannelFilter {
    users: String[];
    activityCodes?: String[] | null;
}

interface UserStatChannelFilter {
    users;
    activityCodes;
}

To access this interface use Filter.UserStatChannelFilter

Parameter	Type	Required	Description
users	String[]	true	List of usernames to filter
activityCodes	String[]	false	List of code of activity codes to fitler

Indicator

ServiceStatsIndicator

import { Indicator } from "@telenia/rtdclient";
interface ServiceStatsIndicator {
  userStats?: ServiceStatsUserIndicator;
  channelStats?: ServiceChannelStatIndicator;
}

interface ServiceStatsIndicator {
  userStats;
  channelStats;
}

To access this interface use Indicator.ServiceStatsIndicator

Parameter	Type	Required	Description
userStats	ServiceStatsUserIndicator	false	Indicator for Services's users statistics
channelStats	ServiceChannelStatIndicator	false	Indicators for services's channels statistics

ServiceStatsUserIndicator

import { Indicator } from "@telenia/rtdclient";
interface ServiceChannelStatIndicator {
  channel?:ServiceUserStatsChannelIndicator;
  loggedUsers?: UserProfileInStatusRequest;
  notReadyUsers?: UserProfileInStatusRequest;
  notReadyUsersOnActivityCode?: UserProfileInStatusRequest;
  postCallUsers?: UserProfileInStatusRequest;
  readyUsers?: UserProfileInStatusRequest;
  busyOnServUsers?: UserProfileInStatusRequest;
  busyUsers?: UserProfileInStatusRequest;
  activityCodeIndicators?: UserProfileInStatusRequest;  
}

interface ServiceChannelStatIndicator {
  channel;
  loggedUsers;
  notReadyUsers;
  notReadyUsersOnActivityCode;
  postCallUsers;
  readyUsers;
  busyOnServUsers;
  busyUsers;
  activityCodeIndicators;
}

Parameter	Type	Required	Description
channel	ServiceUserStatsChannelIndicator	false	Indicator for services's contact center call statistics
busyOnServUsers	UserProfileInStatusRequest	false	Number of agents engaged in a service call conversation
busyUsers	UserProfileInStatusRequest	false	Total number of agents engaged in a telephone conversation
loggedUsers	UserProfileInStatusRequest	false	Number of logged in agents
notReadyUsers	UserProfileInStatusRequest	false	Number of agents in Not Ready state
notReadyUsersOnActivityCode	UserProfileInStatusRequest	false	Number of agents in Not Ready state who have specified an activity code
postCallUsers	UserProfileInStatusRequest	false	Number of agents in "Post Call Processing" state. It is the timeout configured on each operator to allow the closing of the activities related to the previous service conversation.
readyUsers	UserProfileInStatusRequest	false	Number of agents in Ready state

ServiceUserStatsChannelIndicator

import { Indicator } from "@telenia/rtdclient";
interface ServiceUserStatsChannelIndicator {
  call?: ServiceUserStatsCallIndicator;
  video?: ServiceUserStatsMultichannelIndicator;
  chat?: ServiceUserStatsMultichannelIndicator;
  mailAcd?: ServiceUserStatsMultichannelIndicator;
  livehelp?: ServiceUserStatsMultichannelIndicator;  
  custom1?: ServiceUserStatsMultichannelIndicator;
  custom2?: ServiceUserStatsMultichannelIndicator;
  custom3?: ServiceUserStatsMultichannelIndicator;
}

interface ServiceUserStatsChannelIndicator {
  call;
  video;
  chat;
  mailAcd;
  livehelp;  
  custom1;
  custom2;
  custom3; 
}

To access this interface use Indicator.ServiceUserStatsChannelIndicator

Parameter	Type	Required	Description
call	ServiceUserStatsCallIndicator	false	Indicator for Services's call statistics
video	ServiceUserStatsMultichannelIndicator	false	Indicators for services's video statistics
chat	ServiceUserStatsMultichannelIndicator	false	Indicator for Services's chat statistics
mailAcd	ServiceUserStatsMultichannelIndicator	false	Indicators for services's mail ACD statistics
livehelp	ServiceUserStatsMultichannelIndicator	false	Indicator for Services's Live Help statistics
custom1	ServiceUserStatsMultichannelIndicator	false	Indicators for services's channel Custom 01 statistics
custom2	ServiceUserStatsMultichannelIndicator	false	Indicator for Services's channel Custom 02 statistics
custom3	ServiceUserStatsMultichannelIndicator	false	Indicators for services's channel Custom 03 statistics

ServiceUserStatsCallIndicator

import { Indicator } from "@telenia/rtdclient";
interface ServiceUserStatsCallIndicator {
  busyOnDNCallInUsers?: UserProfileInStatusRequest;
  busyOnDNCallOutUsers?: UserProfileInStatusRequest;
  busyOnDNCallOutUsersPrivate?: UserProfileInStatusRequest;
  busyOnDNCallUsers?: UserProfileInStatusRequest;
}

interface ServiceUserStatsCallIndicator {
  busyOnDNCallInUsers;
  busyOnDNCallOutUsers;
  busyOnDNCallOutUsersPrivate;
  busyOnDNCallUsers;
}

To access this interface use Indicator.ServiceUserStatsCallIndicator

Parameter	Type	Required	Description
busyOnDNCallInUsers	UserProfileInStatusRequest	false	Number of agents engaged in a direct incoming call conversation (DN-Call IN)
busyOnDNCallOutUsers	UserProfileInStatusRequest	false	Number of agents engaged in conversation for direct outgoing calls (DN-Call OUT)
busyOnDNCallOutUsersPrivate	UserProfileInStatusRequest	false	Number of agents engaged in a private outgoing call conversation
busyOnDNCallUsers	UserProfileInStatusRequest	false	Number of agents in conversation for direct calls (DN-Call)

ServiceChannelStatIndicator

import { Indicator } from "@telenia/rtdclient";
interface ServiceChannelStatIndicator {
  channel?: ServiceChannelIndicator;  
  answeredCalls?: boolean;
  closedCalls?: boolean;
  hangupCalls?: boolean; 
  queuedCalls?: boolean;
  receivedCalls?: boolean;
  shortCalls?: boolean;
  answeredCallsUnderSpeedLimit?: boolean, 
  connectedCall?: boolean;
  currentCalls?: boolean;
  maxTimeCallOnQueue?: boolean;
  receivedCallsInAccessList?: boolean;
  averageTimeOnQueue?: boolean;  
}

interface ServiceChannelStatIndicator {
  channel;
  answeredCalls;
  closedCalls;
  hangupCalls;
  queuedCalls;
  receivedCalls;
  shortCalls;
  answeredCallsUnderSpeedLimit;
  connectedCall;
  currentCalls;
  maxTimeCallOnQueue;
  receivedCallsInAccessList;
  averageTimeOnQueue;  
}

To access this interface use Indicator.ServiceChannelStatIndicator

Parameter	Type	Required	Description
channel	ServiceChannelIndicator	false	Indicator for services's contact center call statistics
answeredCalls	boolean	false	Operator's calls answered
closedCalls	boolean	false	Number of calls closed on the service in the 'active' context
hangupCalls	boolean	false	Number of abandoned calls (hung up by the caller) in the "active" context
queuedCalls	boolean	false	Number of queued calls
receivedCalls	boolean	false	Number of calls received by the service in an "active" context
shortCalls	boolean	false	Number of short abandoned calls. A short call is an abandoned call that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)
answeredCallsUnderSpeedLimit	boolean	false	Calls answered by the operator within the 'response speed' threshold in the active context configured in the TVox-> General settings-> Miscellaneous menu
connectedCall	boolean	false	Number of conversation calls on agents
currentCalls	boolean	false	Number of calls in progress on the service in the 'active' context
maxTimeCallOnQueue	boolean	false	Maximum waiting time in queue for calls queued to the service
receivedCallsInAccessList	boolean	false	Number of calls received by the service in the 'active' context filtered from the access list (blacklist or whitelist)
averageTimeOnQueue	boolean	false	Average waiting time in queue for calls queued to the service

ServiceChannelIndicator

import { Indicator } from "@telenia/rtdclient";
interface ServiceChannelIndicator {
  call:ServiceCallAtStatIndicator;
  video: ServiceVideoAtStatIndicator;
  chat: ServiceChatAtStatIndicator;
  mailAcd: ServiceMultichannelAtStatIndicator;
  livehelp: ServiceLivehelpAtStatIndicator;  
  custom1: ServiceMultichannelAtStatIndicator;
  custom2: ServiceMultichannelAtStatIndicator;
  custom3: ServiceMultichannelAtStatIndicator;
}

interface ServiceChannelIndicator {
  call;
  video;
  chat;
  mailAcd;
  livehelp;  
  custom1;
  custom2;
  custom3; 
}

Parameter	Type	Required	Description
call	ServiceCallAtStatIndicator	false	Indicator for Services's call statistics
video	ServiceVideoAtStatIndicator	false	Indicators for services's video statistics
chat	ServiceChatAtStatIndicator	false	Indicator for Services's chat statistics
mailAcd	ServiceMultichannelAtStatIndicator	false	Indicators for services's mail ACD statistics
livehelp	ServiceLivehelpAtStatIndicator	false	Indicator for Services's Live Help statistics
custom1	ServiceMultichannelAtStatIndicator	false	Indicators for services's channel Custom 01 statistics
custom2	ServiceMultichannelAtStatIndicator	false	Indicator for Services's channel Custom 02 statistics
custom3	ServiceMultichannelAtStatIndicator	false	Indicators for services's channel Custom 03 statistics

ServiceCallAtStatIndicator

import { Indicator } from "@telenia/rtdclient";
interface ServiceCallAtStatIndicator {        
  closedCallsCallBack?: boolean;      
  outboundAnsweredCalls?: boolean;
  outboundClosedCallsGenericCause?: boolean;
  outboundHangupCalls?: boolean;
  outboundReceivedCalls?: boolean;            
  receivedCallsWithT4you?: boolean;
  receivedCallsWithT4youAnonymous?: boolean;
  receivedCallsWithT4youMultiple?: boolean;
  receivedCallsWithT4youSingle?: boolean;
  openTickets?: boolean;
  createdTickets?: boolean;
  callsToTicketsPercentage?: boolean;  
}

interface ServiceCallAtStatIndicator {
  closedCallsCallBack;      
  outboundAnsweredCalls;
  outboundClosedCallsGenericCause;
  outboundHangupCalls;
  outboundReceivedCalls;            
  receivedCallsWithT4you;
  receivedCallsWithT4youAnonymous;
  receivedCallsWithT4youMultiple;
  receivedCallsWithT4youSingle;
  openTickets;
  createdTickets;
  callsToTicketsPercentage;  
}

To access this interface use Indicator.ServiceCallAtStatIndicator

Parameter	Type	Required	Description
closedCallsCallBack	boolean	false	Number of callback requests in 'active' context
outboundAnsweredCalls	boolean	false	Number of outgoing calls answered by the called contact
outboundClosedCallsGenericCause	boolean	false	Number of outgoing calls that could not be made due to an error, e.g.: Congestion, ChannelUnavailable, other...
outboundHangupCalls	boolean	false	Number of outgoing calls not answered
outboundReceivedCalls	boolean	false	Outgoing call attempts made
receivedCallsWithT4you	boolean	false	Percentage value of calls received that were answered positively in the directory in an "active" context
receivedCallsWithT4youAnonymous	boolean	false	Percentage of calls received that received an anonymous response in the directory in an "active" context
receivedCallsWithT4youMultiple	boolean	false	Percentage value of calls received that have had more than one answer in the directory in an "active" context
receivedCallsWithT4youSingle	boolean	false	Percentage of calls received that were exactly matched in the directory in an "active" context
openTickets	boolean	false	Number of open tickets of call type
createdTickets	boolean	false	Number of tickets created of call type
callsToTicketsPercentage	boolean	false	Percentage of answered calls that have been converted to tickets

ServiceVideoAtStatIndicator

import { Indicator } from "@telenia/rtdclient";
interface ServiceVideoAtStatIndicator {              
  receivedCallsWithT4you?: boolean;
  receivedCallsWithT4youAnonymous?: boolean;
  receivedCallsWithT4youMultiple?: boolean;
  receivedCallsWithT4youSingle?: boolean;
  openTickets?: boolean;
  createdTickets?: boolean;
  callsToTicketsPercentage?: boolean;  
}

interface ServiceVideoAtStatIndicator {         
  receivedCallsWithT4you;
  receivedCallsWithT4youAnonymous;
  receivedCallsWithT4youMultiple;
  receivedCallsWithT4youSingle;
  openTickets;
  createdTickets;
  callsToTicketsPercentage;  
}

To access this interface use Indicator.ServiceVideoAtStatIndicator

Parameter	Type	Required	Description
receivedCallsWithT4you	boolean	false	Percentage value of video calls received that were answered positively in the directory in an "active" context
receivedCallsWithT4youAnonymous	boolean	false	Percentage of video calls received that received an anonymous response in the directory in an "active" context
receivedCallsWithT4youMultiple	boolean	false	Percentage value of video calls received that have had more than one answer in the directory in an "active" context
receivedCallsWithT4youSingle	boolean	false	Percentage of video calls received that were exactly matched in the directory in an "active" context
openTickets	boolean	false	Number of open tickets of video call type
createdTickets	boolean	false	Number of tickets created of video call type
callsToTicketsPercentage	boolean	false	Percentage of answered video calls that have been converted to tickets

ServiceChatAtStatIndicator

import { Indicator } from "@telenia/rtdclient";
interface ServiceChatAtStatIndicator {              
  receivedCallsWithT4you?: boolean;
  receivedCallsWithT4youAnonymous?: boolean;
  receivedCallsWithT4youMultiple?: boolean;
  receivedCallsWithT4youSingle?: boolean;
  openTickets?: boolean;
  createdTickets?: boolean;
  callsToTicketsPercentage?: boolean;  
}

interface ServiceChatAtStatIndicator {         
  receivedCallsWithT4you;
  receivedCallsWithT4youAnonymous;
  receivedCallsWithT4youMultiple;
  receivedCallsWithT4youSingle;
  openTickets;
  createdTickets;
  callsToTicketsPercentage;  
}

To access this interface use Indicator.ServiceChatAtStatIndicator

Parameter	Type	Required	Description
receivedCallsWithT4you	boolean	false	Percentage value of chat received that were answered positively in the directory in an "active" context
receivedCallsWithT4youAnonymous	boolean	false	Percentage of chat received that received an anonymous response in the directory in an "active" context
receivedCallsWithT4youMultiple	boolean	false	Percentage value of chat received that have had more than one answer in the directory in an "active" context
receivedCallsWithT4youSingle	boolean	false	Percentage of chat received that were exactly matched in the directory in an "active" context
openTickets	boolean	false	Number of open tickets of chat type
createdTickets	boolean	false	Number of tickets created of chat type
callsToTicketsPercentage	boolean	false	Percentage of answered chat that have been converted to tickets

ServiceMultichannelAtStatIndicator

import { Indicator } from "@telenia/rtdclient";
interface ServiceMultichannelAtStatIndicator {              
  receivedCallsWithT4you?: boolean;
  receivedCallsWithT4youAnonymous?: boolean;
  receivedCallsWithT4youMultiple?: boolean;
  receivedCallsWithT4youSingle?: boolean;
}

interface ServiceMultichannelAtStatIndicator {         
  receivedCallsWithT4you;
  receivedCallsWithT4youAnonymous;
  receivedCallsWithT4youMultiple;
  receivedCallsWithT4youSingle;
}

To access this interface use Indicator.ServiceMultichannelAtStatIndicator

Parameter	Type	Required	Description
receivedCallsWithT4you	boolean	false	Percentage value of iterations received that were answered positively in the directory in an "active" context
receivedCallsWithT4youAnonymous	boolean	false	Percentage of iterations received that received an anonymous response in the directory in an "active" context
receivedCallsWithT4youMultiple	boolean	false	Percentage value of iterations received that have had more than one answer in the directory in an "active" context
receivedCallsWithT4youSingle	boolean	false	Percentage of iterations received that were exactly matched in the directory in an "active" context

ServiceLivehelpAtStatIndicator

import { Indicator } from "@telenia/rtdclient";
interface ServiceLivehelpAtStatIndicator {              
  receivedCallsWithT4you?: boolean;
  receivedCallsWithT4youAnonymous?: boolean;
  receivedCallsWithT4youMultiple?: UserProfileInStatusRequest;
  receivedCallsWithT4youSingle?: boolean;
}

interface ServiceLivehelpAtStatIndicator {         
  receivedCallsWithT4you;
  receivedCallsWithT4youAnonymous;
  receivedCallsWithT4youMultiple;
  receivedCallsWithT4youSingle; 
}

To access this interface use Indicator.ServiceLivehelpAtStatIndicator

Parameter	Type	Required	Description
receivedCallsWithT4you	boolean	false	Percentage value of iterations received that were answered positively in the directory in an "active" context
receivedCallsWithT4youAnonymous	boolean	false	Percentage of iterations received that received an anonymous response in the directory in an "active" context
receivedCallsWithT4youMultiple	boolean	false	Percentage value of iterations received that have had more than one answer in the directory in an "active" context
receivedCallsWithT4youSingle	boolean	false	Percentage of iterations received that were exactly matched in the directory in an "active" context

GroupStatsIndicator

import { Indicator } from "@telenia/rtdclient";
interface GroupStatsIndicator {
  userStats?: GroupStatsUserIndicator;
  channelStats?: GroupStatsIndicator;
}

interface GroupStatsIndicator {
  userStats;
  channelStats;
}

To access this interface use Indicator.GroupStatsIndicator

Parameter	Type	Required	Description
userStats	GroupStatsUserIndicator	false	Indicator for skillets's users statistics
channelStats	GroupStatsIndicator	false	Indicators for skillsets's channels statistics

GroupStatsIndicator

import { Indicator } from "@telenia/rtdclient";
interface GroupStatsIndicator {
  channelStats?: GroupChannelStatIndicator;  
}

interface GroupStatsIndicator {
  channelStats;
}

To access this interface use Indicator.GroupStatsIndicator

Parameter	Type	Required	Description
channelStats	GroupChannelStatIndicator	false	Indicator for services's contact center call statistics

GroupChannelStatIndicator

import { Indicator } from "@telenia/rtdclient";
interface GroupStatsIndicator {  
  answeredCalls?: boolean; 
  closedCalls?: boolean;
  hangupCalls?: boolean;
  queuedCalls?: boolean;
  receivedCalls?: boolean;
  shortCalls?: boolean;
}

interface GroupStatsIndicator {  
  answeredCalls; 
  closedCalls; 
  hangupCalls; 
  queuedCalls; 
  receivedCalls; 
  shortCalls; 
}

To access this interface use Indicator.GroupCcCallStatRequest

Parameter	Type	Required	Description
answeredCalls	boolean	false	Operator's calls answered
closedCalls	boolean	false	Number of calls closed on the service in the 'active' context
hangupCalls	boolean	false	Number of abandoned calls (hung up by the caller) in the "active" context
queuedCalls	boolean	false	Number of queued calls
receivedCalls	boolean	false	Number of calls received by the service in an "active" context
shortCalls	boolean	false	Number of short abandoned calls. A short call is an abandoned call that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)

GroupStatsUserIndicator

import { Indicator } from "@telenia/rtdclient";
interface GroupStatsUserIndicator {
  loggedUsers?: UserProfileInStatusRequest;
  notReadyUsers?: UserProfileInStatusRequest;
  notReadyUsersOnActivityCode?: UserProfileInStatusRequest;
  postCallUsers?: UserProfileInStatusRequest;
  readyUsers?: UserProfileInStatusRequest;
}

interface GroupStatsUserIndicator {
  loggedUsers;
  notReadyUsers;
  notReadyUsersOnActivityCode;
  postCallUsers;
  readyUsers;
}

To access this interface use Indicator.GroupStatsUserIndicator

Parameter	Type	Required	Description
loggedUsers	UserProfileInStatusRequest	false	Number of logged in agents
notReadyUsers	UserProfileInStatusRequest	false	Number of agents in Not Ready state
notReadyUsersOnActivityCode	UserProfileInStatusRequest	false	Number of agents in Not Ready state who have specified an activity code
postCallUsers	UserProfileInStatusRequest	false	Number of agents in "Post Call Processing" state. It is the timeout configured on each operator to allow the closing of the activities related to the previous service conversation.
readyUsers	UserProfileInStatusRequest	false	Number of agents in Ready state

UserProfileInStatusRequest

import { Indicator } from "@telenia/rtdclient";
interface UserProfileInStatusRequest {
    count?: boolean;
    profileIds?: boolean;
}

interface UserProfileInStatusRequest {
    count;
    profileIds;
}

To access this interface use Indicator.UserProfileInStatusRequest

Parameter	Type	Required	Description
count	boolean	false	Current number of users in filtered state
profileIds	boolean	false	List of profiles id in filteres state

UserStatsIndicator

import { Indicator } from "@telenia/rtdclient";
interface UserStatsIndicator {  
  username?: boolean; 
  name?: boolean; 
  surname?: boolean; 
  userSite?: boolean; 
  loggedProfileId?: boolean; 
  channel?: boolean;
  activityCode?: boolean; 
  activityCode2?: boolean; 
  currentGroup?: boolean; 
  currentService?: boolean; 
  numberCallFromService?: boolean; 
  numberCallFromServiceAnswered?: boolean; 
  numberCallFromServiceNotAnswered?: boolean; 
  numberCallIn?: boolean; 
  numberCallServiceOverSpeedAnswer?: boolean; 
  status?: boolean; 
  timeInState?: boolean; 
  timeInStateBooked?: boolean; 
  timeInStateBusy?: boolean; 
  timeInStateBusyOnService?: boolean; 
  timeInStateNotReady?: boolean; 
  timeInStateReady?: boolean; 
  timeInStateWNR?: boolean; 
  timeInActivityCode?: boolean;
  timeInActivityCodeStateBusy?: boolean;
  timeInActivityCodeStateNotReady?: boolean;
  channelStats?: UserStatsChannelIndicator;
  timeInActivityCodeStateNotReady?: boolean; 
}

interface UserStatsIndicator {  
  username; 
  name; 
  surname; 
  userSite; 
  loggedProfileId; 
  channel;
  activityCode; 
  activityCode2; 
  currentGroup; 
  currentService; 
  numberCallFromService; 
  numberCallFromServiceAnswered; 
  numberCallFromServiceNotAnswered; 
  numberCallIn; 
  numberCallServiceOverSpeedAnswer; 
  status; 
  timeInState; 
  timeInStateBooked; 
  timeInStateBusy; 
  timeInStateBusyOnService; 
  timeInStateNotReady; 
  timeInStateReady; 
  timeInStateWNR; 
  timeInActivityCode;
  timeInActivityCodeStateBusy;
  timeInActivityCodeStateNotReady;
  channelStats;
  timeInActivityCodeStateNotReady; 
}

To access this interface use Indicator.UserStatsIndicator

Parameter	Type	Required	Description
username	boolean	false	Username of logged user
channelStats	UserStatsChannelIndicator	false	Specific channel indicators
userSite	boolean	false	Profile user site
channel	boolean	false	User channel
activityCode	boolean	false	User activity code
activityCode2	boolean	false	User sendo level activity code
currentGroup	boolean	false	Current call's skillset
currentService	boolean	false	Current call's service
numberCallFromService	boolean	false	Number of service calls received by the agent
numberCallFromServiceAnswered	boolean	false	Number of service calls answered by the agent
numberCallFromServiceNotAnswered	boolean	false	Number of service calls that the operator did not answer
numberCallIn	boolean	false	Total number of calls received by the agent
status	boolean	false	Current Agent state
timeInActivityCode	boolean	false	Total time elapsed on activity code
timeInActivityCodeStateBusy	boolean	false	Total time wlapsed on activity code
timeInActivityCodeStateNotReady	boolean	false	Total time elapsed on activity code in state not ready
timeInState	boolean	false	Time spent by the operator in the current state
timeInStateBooked	boolean	false	Total time (expressed in seconds) that the operator has been in the Reserved state. This is the time when the phone rings
timeInStateBusy	boolean	false	Total time (expressed in seconds) that the operator has remained in the busy state (Busy)
timeInStateBusyOnService	boolean	false	Total time (in seconds) that the operator has been in the busy state for service calls
timeInStateNotReady	boolean	false	Total time (in seconds) that the operator was in the Not Ready state
timeInStateReady	boolean	false	Total time (in seconds) that the operator was in the Ready state
timeInStateWNR	boolean	false	Total time (in seconds) that the operator was in the "Post Call Processing" state

UserStatsChannelIndicator

import { Indicator } from "@telenia/rtdclient";
interface UserStatsChannelIndicator {
  call?: UserStatsCallIndicator;
}

interface UserStatsChannelIndicator {
  call;
}

To access this interface use Indicator.ServiceUserStatsChannelIndicator

Parameter	Type	Required	Description
call	UserStatsChannelIndicator	false	Indicator for Services's call statistics

UserStatsCallIndicator

import { Indicator } from "@telenia/rtdclient";
interface UserStatsCallIndicator {
  numberCallOut?: boolean;
  numberCallOutPrivate?: boolean;
  timeInStateBusyDnCallIn?: boolean;
  timeInStateBusyDnCallOut?: boolean;
  timeInStateBusyDnCallOutPrivate?: boolean;
}

interface UserStatsCallIndicator {
  numberCallOut;
  numberCallOutPrivate;
  timeInStateBusyDnCallIn;
  timeInStateBusyDnCallOut;
  timeInStateBusyDnCallOutPrivate;
}

To access this interface use Indicator.UserStatsIndicator

Parameter	Type	Required	Description
numberCallOut	boolean	false	Total number of calls made by the agent
numberCallOutPrivate	boolean	false	Total number of private calls made
numberCallServiceOverSpeedAnswer	boolean	false	Number of calls answered by the service beyond the 'response speed' threshold configured in the TVox-> General settings-> Miscellaneous menu
timeInStateBusyDnCallIn	boolean	false	Total time (in seconds) that the attendant was on busy for incoming calls
timeInStateBusyDnCallOut	boolean	false	Total time (in seconds) that the attendant was busy for outgoing calls
timeInStateBusyDnCallOutPrivate	boolean	false	Total time (in seconds) that the operator has been in busy state for private outgoing calls

UserProfileStatsIndicator

import { Indicator } from "@telenia/rtdclient";
interface UserProfileStatsIndicator {
  id?: boolean;  
  timeInActivityCode?: boolean;
  timeInActivityCodeStateBusy?: boolean;
  timeInActivityCodeStateNotReady?: boolean;
  channelStats?: UserProfileStatsChannelIndicator;
  channel?: boolean;
  userSite?: boolean;
  activityCode?: boolean;
  activityCode2?: boolean;
  numberCallFromService?: boolean;
  numberCallFromServiceAnswered?: boolean;
  numberCallFromServiceNotAnswered?: boolean;
  numberCallIn?: boolean;
  numberCallServiceOverSpeedAnswer?: boolean;
  status?: boolean;
  timeInState?: boolean;
  timeInStateBooked?: boolean;
  timeInStateBusy?: boolean;
  timeInStateBusyOnService?: boolean;
  timeInStateNotReady?: boolean;
  timeInStateReady?: boolean;
  timeInStateWNR?: boolean;
}

interface UserProfileStatsIndicator {
  id;
  timeInActivityCode;
  timeInActivityCodeStateBusy;
  timeInActivityCodeStateNotReady;
  channelStats;
  channel;
  userSite;
  activityCode;
  activityCode2;
  numberCallFromService;
  numberCallFromServiceAnswered;
  numberCallFromServiceNotAnswered;
  numberCallIn;
  numberCallServiceOverSpeedAnswer;
  status;
  timeInState;
  timeInStateBooked;
  timeInStateBusy;
  timeInStateBusyOnService;
  timeInStateNotReady;
  timeInStateReady;
  timeInStateWNR;
}

To access this interface use Indicator.UserProfileStatsIndicator

Parameter	Type	Required	Description
id	boolean	false	Profile id
channel	boolean	false	User channel
channelStats	UserProfileStatsChannelIndicator	false	User channel
activityCode	boolean	false	User activity code
activityCode2	boolean	false	User sendo level activity code
currentGroup	boolean	false	Current call's skillset
currentService	boolean	false	Current call's service
numberCallFromService	boolean	false	Number of service calls received by the agent
numberCallFromServiceAnswered	boolean	false	Number of service calls answered by the agent
numberCallFromServiceNotAnswered	boolean	false	Number of service calls that the operator did not answer
numberCallIn	boolean	false	Total number of calls received by the agent
numberCallServiceOverSpeedAnswer	boolean	false	Number of calls answered by the service beyond the 'response speed' threshold configured in the TVox-> General settings-> Miscellaneous menu
status	boolean	false	Current Agent state
timeInActivityCode	boolean	false	Total time elapsed on activity code
timeInActivityCodeStateBusy	boolean	false	Total time wlapsed on activity code
timeInActivityCodeStateNotReady	boolean	false	Total time elapsed on activity code in state not ready
timeInState	boolean	false	Time spent by the operator in the current state
timeInStateBooked	boolean	false	Total time (expressed in seconds) that the operator has been in the Reserved state. This is the time when the phone rings
timeInStateBusy	boolean	false	Total time (expressed in seconds) that the operator has remained in the busy state (Busy)
timeInStateBusyOnService	boolean	false	Total time (in seconds) that the operator has been in the busy state for service calls
timeInStateNotReady	boolean	false	Total time (in seconds) that the operator was in the Not Ready state
timeInStateReady	boolean	false	Total time (in seconds) that the operator was in the Ready state
timeInStateWNR	boolean	false	Total time (in seconds) that the operator was in the "Post Call Processing" state

UserProfileStatsChannelIndicator

import { Indicator } from "@telenia/rtdclient";
interface UserProfileStatsChannelIndicator {
  call?: UserProfileStatsCallIndicator;
}

interface UserProfileStatsChannelIndicator {
  call;
}

To access this interface use Indicator.UserProfileStatsChannelIndicator

Parameter	Type	Required	Description
call	UserProfileStatsCallIndicator	false	Indicator for Services's call statistics

UserProfileStatsCallIndicator

import { Indicator } from "@telenia/rtdclient";
interface UserProfileStatsCallIndicator {
  numberCallOut?: boolean;
  numberCallOutPrivate?: boolean;
  timeInStateBusyDnCallIn?: boolean;
  timeInStateBusyDnCallOut?: boolean;
  timeInStateBusyDnCallOutPrivate?: boolean;
  timeInHold?: boolean;
}

interface UserProfileStatsCallIndicator {
  numberCallOut;
  numberCallOutPrivate;
  timeInStateBusyDnCallIn;
  timeInStateBusyDnCallOut;
  timeInStateBusyDnCallOutPrivate;
  timeInHold;
}

To access this interface use Indicator.UserProfileStatsCallIndicator

Parameter	Type	Required	Description
numberCallOut	boolean	false	Total number of calls made by the agent
numberCallOutPrivate	boolean	false	Total number of private calls made
timeInStateBusyDnCallIn	boolean	false	Total time (in seconds) that the attendant was on busy for incoming calls
timeInStateBusyDnCallOut	boolean	false	Total time (in seconds) that the attendant was busy for outgoing calls
timeInStateBusyDnCallOutPrivate	boolean	false	Total time (in seconds) that the operator has been in busy state for private outgoing calls
timeInHold	boolean	false	Hold time for service calls

TVoxRestClientModels

MultiChannelIdTypeModel

import { TVoxRestClientModels } from "@telenia/rtdclient/rest";
enum MultiChannelIdTypeModel {
    CALL,
    MC_1,
    MC_2,
    MC_3,
    CALLBACK,
    MC_VIDEO,
    MC_MAIL,
    MC_LIVEHELP,
    MC_CHAT,
    MC_WHATSAPP_TWILIO
}

enum MultiChannelIdTypeModel {
    CALL,
    MC_1,
    MC_2,
    MC_3,
    CALLBACK,
    MC_VIDEO,
    MC_MAIL,
    MC_LIVEHELP,
    MC_CHAT,
    MC_WHATSAPP_TWILIO
}

To access this enum use TVoxRestClientModels.MultiChannelIdTypeModel

Channel	Description
CALL	Call channel
MC_1	Channel custom 1
MC_2	Channel custom 2
MC_3	Channel custom 3
MC_VIDEO	Video Channel
MC_MAIL	Support channel
MC_CHAT	Chat channel
MC_WHATSAPP_TWILIO	Chat Channel

ServiceTypeModel

import { TVoxRestClientModels } from "@telenia/rtdclient/rest";
enum ServiceTypeModel {
  IVR,
  HUNT,
  CALLCENTER,
  POWER_DIALER,
  TQM,
}

enum ServiceTypeModel {
  IVR,
  HUNT,
  CALLCENTER,
  POWER_DIALER,
  TQM,
}

To access this enum use TVoxRestClientModels.ServiceTypeModel

Channel	Description
IVR	Ivr services
HUNT	Normal services
CALLCENTER	Contact center Services
POWER_DIALER	Power Dialer services
TQM	Telenia queue manager Services

LoginProfileModel

import { TVoxRestClientModels } from "@telenia/rtdclient/rest";
interface LoginProfileModel {
  username?: string;
  surname?: string;
  name?: string;
  publicUsername?: string;
  accessToken?: string;
  sessionId?: string;
  language?: LanguageModel;
  anonymous?: boolean;
  pwdChangeable?: boolean;
  profileRoles?: Array<string>;
  userPermissions?: Array<UserPermissionModel>;
  logged?: boolean;
}

interface LoginProfileModel {
  username;
  surname;
  name;
  publicUsername;
  accessToken;
  sessionId;
  language;
  anonymous;
  pwdChangeable;
  profileRoles;
  userPermissions;
}

To access this interface use TVoxRestClientModels.LoginProfileModel

Parameter	Type	Optional	Description
username	string	true	Username of logged user
surname	string	true	Surname of logged user
name	string	true	Name of logged user
publicUsername	string	true	Username of logged user used in multi domain configurations
accessToken	string	true	The access token of the registered user. It is useful to store it in a cookie and use it later to log in
sessionId	string	true	Current logged user's session Id
language	LanguageModel	true	User language configured in the system
userPermissions	Array<UserPermissionModel>	true	List of user permissions for RTD need check if user have SUPERUSER and GRTD permissions
logged	boolean	true	Returns information if the user is logged in

UserPermissionModel

import { TVoxRestClientModels } from "@telenia/rtdclient/rest";
enum UserPermissionModel {
    SUPERUSER = "SUPERUSER",    
    SUPERVISOR = "SUPERVISOR",    
    GRTD = "GRTD",
}

enum UserPermissionModel {
    SUPERUSER,    
    SUPERVISOR,    
    GRTD,
}

Permission Model	Description
SUPERUSER	Profile that can access to all TVox Omnichannel Contact Center services, skillsets and users
SUPERVISOR	Profile that can access to TVox Omnichannel Contact Center services, skillsets and users supervised
GRTD	Profile that can access to GRTD monitor

LanguageModel

import { ConfigurationEntity } from "@telenia/rtdclient";
enum LanguageModel {
    IT,
    it_IT,
    EN,
    en_US
}

enum LanguageModel {
    IT,
    it_IT,
    EN,
    en_US
}

To access this enum use ConfigurationEntity.LanguageModel

Language	Description
IT	Italian language
it_IT	Italian language
EN	English language
en_US	English language

MultiChannelModel

import { TVoxRestClientModels } from "@telenia/rtdclient/rest";
interface MultiChannelModel {
  id?: number;
  idType?: MultiChannelIdTypeModel;
  name?: string;
  status?: MultiChannelModelStatusModelEnum;
}

interface MultiChannelModel {
  id;
  idType;
  name;
  status;
}

To access this interface use TVoxRestClientModels.MultiChannelModel

Parameter	Type	Optional	Description
id	number	true	Channel Id
idType	MultiChannelIdTypeModel	true	Channel Type
name	string	true	Channel Name
status	MultiChannelModelStatusModelEnum	true	Return ENABLED if channel is enabled!

MultiChannelModelStatusModelEnum

import { TVoxRestClientModels } from "@telenia/rtdclient/rest";
enum MultiChannelModelStatusModelEnum {
  ENABLED,
  DISABLED
}

enum MultiChannelModelStatusModelEnum {
  ENABLED,
  DISABLED
}

To access this enum use TVoxRestClientModels.MultiChannelModel

Type	Description
ENABLED	Channel is enabled
DISABLED	Channel is disabled

SearchLimitModel

import { TVoxRestClientModels } from "@telenia/rtdclient/rest";
interface SearchLimitModel {
  pageNumber?: number;
  pageSize?: number;
}

interface SearchLimitModel {
  pageNumber;
  pageSize;
}

To access this interface use TVoxRestClientModels.SearchLimitModel

Parameter	Type	Optional	Description
pageNumber	number	true	Page number for pagination search
pageSize	number	true	Page size for pagination search

SearchServiceLiteRequestModel

import { TVoxRestClientModels } from "@telenia/rtdclient/rest";
interface SearchServiceLiteRequestModel {
  term?: string;
  types?: Array<ServiceTypeModel>;
  enabledChannels?: Array<MultiChannelIdTypeModel>;
  excludeServices?: Array<string>;
  excludeSkillsets?: Array<string>;
  limit?: SearchLimitModel;
}

interface SearchServiceLiteRequestModel {
  term;
  types;
  enabledChannels;
  excludeServices;
  excludeSkillsets;
  limit;
}

To access this interface use TVoxRestClientModels.SearchServiceLiteRequestModel

Parameter	Type	Optional	Description
term	string	true	value to server search
types	ServiceTypeModel	true	Service type for search
enabledChannels	MultiChannelIdTypeModel	true	Search among the enabled channels
excludeServices	Array	true	Search excluding this service codes
limit	SearchLimitModel	true	Search with pagination

SearchCriteriaStringModel

import { TVoxRestClientModels } from "@telenia/rtdclient/rest";
interface SearchCriteriaStringModel {
  operation?: SearchCriteriaStringModelOperationModelEnum;
  value?: string;
}

interface SearchCriteriaStringModel {
  operation;
  value;
}

To access this interface use TVoxRestClientModels.SearchCriteriaStringModel

Parameter	Type	Optional	Description
operation	SearchCriteriaStringModelOperationModelEnum	true	Search criteria for example EQUAL, CONTAINS etc...
value	string	true	Value to search

SearchCriteriaStringModelOperationModelEnum

import { TVoxRestClientModels } from "@telenia/rtdclient/rest";
enum SearchCriteriaStringModelOperationModelEnum {
  EQUAL,
  NOT_EQUAL,
  CONTAINS,
  GT,
  GE,
  LT,
  LE,
  NOT_NULL,
  BETWEEN
}

enum SearchCriteriaStringModelOperationModelEnum {
  EQUAL,
  NOT_EQUAL,
  CONTAINS,
  GT,
  GE,
  LT,
  LE,
  NOT_NULL,
  BETWEEN
}

To access this enum use TVoxRestClientModels.SearchCriteriaStringModelOperationModelEnum

Operation	Description
EQUAL	Search with value equal then passed
NOT_EQUAL	Search with value not equal then passed
CONTAINS	Search return element thah contains passed value
GT	Search with value greather than passed
GE	Search with value greather or equal then passed
LT	Search with value less than passed
LE	Search with value less equal then passed
NOT_NULL	Search with value not null
BETWEEN	Search with value betweeen then passed

SearchCriteriaSkillsetTypeModel

interface SearchCriteriaSkillsetTypeModel {
  operation?: SearchCriteriaSkillsetTypeModelOperationModelEnum;
  value?: SkillsetTypeModel;
}

interface SearchCriteriaSkillsetTypeModel {
  operation;
  value;
}

Parameter	Type	Optional	Description
operation	SearchCriteriaSkillsetTypeModelOperationModelEnum	true	Search criteria for example EQUAL, CONTAINS etc...
value	SkillsetTypeModel	true	Type of skillset search

SearchCriteriaSkillsetTypeModelOperationModelEnum

enum SearchCriteriaSkillsetTypeModelOperationModelEnum {
  EQUAL,
  NOT_EQUAL,
  CONTAINS,
  GT,
  GE,
  LT,
  LE,
  NOT_NULL,
  BETWEEN
}

enum SearchCriteriaSkillsetTypeModelOperationModelEnum {
  EQUAL,
  NOT_EQUAL,
  CONTAINS,
  GT,
  GE,
  LT,
  LE,
  NOT_NULL,
  BETWEEN
}

Operation	Description
EQUAL	Search with value equal then passed
NOT_EQUAL	Search with value not equal then passed
CONTAINS	Search return element thah contains passed value
GT	Search with value greather than passed
GE	Search with value greather or equal then passed
LT	Search with value less than passed
LE	Search with value less equal then passed
NOT_NULL	Search with value not null
BETWEEN	Search with value betweeen then passed

SkillsetTypeModel

enum SkillsetTypeModel {
  IVR,
  HUNT,
  CALLCENTER,
  POWER_DIALER,
  TQM,
}

enum SkillsetTypeModel {
  IVR,
  HUNT,
  CALLCENTER,
  POWER_DIALER,
  TQM,
}

Channel	Description
HUNT	Normal skillsets
CALLCENTER	Contact center skillsets
TQM	Telenia queue manager skillset

SkillsetBaseWithChannelsModel

interface SkillsetBaseWithChannelsModel {
    code?: string;
    descrizione?: string;
    type?: SkillsetTypeModel;
    enabledChannels?: Array<MultiChannelIdTypeModel>;
    hasMailAcd?: boolean;
}

interface SkillsetBaseWithChannelsModel {
    skillset;
    descrizione;
    type;
    enabledChannels;
    hasMailAcd;
}

Parameter	Type	Optional	Description
skillset	string	true	Skillset code
descrizione	string	true	Skillset Description
type	SkillsetTypeModel	true	Skillset Type
enabledChannels	MultiChannelIdTypeModel	true	Skillset Type
hasMailAcd	boolean	true	Include services with mail acd enabled

ServiceBaseWithChannelsModel

interface ServiceBaseModel {
    code?: string;
    name?: string;
    exten?: string;
    type?: ServiceTypeModel;
    enabledChannels?: Array<MultiChannelIdTypeModel>;
    hasMailAcd?: boolean;
}

interface ServiceBaseModel {
    code;
    name;
    exten;
    type;
    enabledChannels;
    hasMailAcd;    
}

Parameter	Type	Optional	Description
code	string	true	Service code
name	string	true	Service Description
exten	string	true	Service extension
type	ServiceTypeModel	true	Service Type
enabledChannels	MultiChannelIdTypeModel	true	Skillset Type
hasMailAcd	boolean	true	Include services with mail acd enabled

ServiceBaseModel

interface ServiceBaseModel {
    code?: string;
    name?: string;
    exten?: string;
    type?: ServiceTypeModel;
}

interface ServiceBaseModel {
    code;
    name;
    exten;
    type;
}

Parameter	Type	Optional	Description
code	string	true	Service code
name	string	true	Service Description
exten	string	true	Service extension
type	ServiceTypeModel	true	Service Type

SearchResultServiceBaseWithChannelsModel

interface SearchResultServiceBaseWithChannelsModel {
    tot?: number;
    result?: Array<ServiceBaseWithChannelsModel>;
}

interface SearchResultServiceBaseWithChannelsModel {
    tot;
    result;
}

Parameter	Type	Optional	Description
tot	number	true	Total number of services
result	Array<ServiceBaseWithChannelsModel>	true	Services List

SearchResultServiceModel

interface SearchResultServiceModel {
    tot?: number;
    result?: Array<ServiceBaseModel>;
}

interface SearchResultServiceModel {
    tot;
    result;
}

Parameter	Type	Optional	Description
tot	number	true	Total number of services
result	Array<ServiceBaseModel>	true	Services List

UserSiteModel

interface UserSiteModel {
    id?: number;
    name?: string;
}

interface UserSiteModel {
    id;
    name;
}

Parameter	Type	Optional	Description
id	number	true	Site id
name	string	true	Site name

ActivityCodeModel

interface ActivityCodeModel {
{
  id?: string;
  description?: string;
}

interface ActivityCodeModel {
  id;
  description;
}

Parameter	Type	Optional	Description
id	string	true	Activity code id
description	string	true	Activity code description

UserBaseModel

interface UserBaseModel {
  username?: string;
  name?: string;
  surname?: string;
  exten?: string;
  email?: string;
}

interface UserBaseModel {
  username;
  name;
  surname;
  exten;
  email;
}

Parameter	Type	Optional	Description
username	string	true	Username of result user
name	string	true	Name of result user
surname	string	true	Surname of result user
exten	string	true	Extension of result user
email	string	true	Email of result user

SearchUserLiteRequestModel

interface SearchUserLiteRequestModel {
  term?: string;
  types?: Array<SearchUserLiteRequestModelTypesModelEnum>;  
  logged?: boolean;
  hasEmail?: boolean;
  excludeUsers?: Array<string>;
  limit?: SearchLimitModel;    
}

interface SearchUserLiteRequestModel {
  term;
  types;  
  logged;
  hasEmail;
  excludeUsers;
  limit;
}

Parameter	Type	Optional	Description
term	string	true	value to server search
types	Array<SearchUserLiteRequestModelTypesModelEnum>	true	Type to search
logged	boolean	true	Search logged users
hasEmail	boolean	true	Search users with email
excludeUsers	Array	true	Exclude users by username
limit	SearchLimitModel	true	Search with pagination

SearchUserLiteRequestModelTypesModelEnum

enum SearchUserLiteRequestModelTypesModelEnum {
  UC,
  AG,
  AG_EXTERNAL,
  AG_REMOTE,
  TQM,
  NONE
}

enum SearchUserLiteRequestModelTypesModelEnum {
  UC,
  AG,
  AG_EXTERNAL,
  AG_REMOTE,
  TQM,
  NONE
}

Agent Type	Description
UC	Normal user
AG	Contact center Agent
AG_EXTERNAL	External agent
AG_REMOTE	Remote agent
TQM	Telenia queue manager Agent
NONE	No user type

SearchResultUserBaseModel

interface SearchResultUserBaseModel {
  tot?: number;
  result?: Array<UserBaseModel>;
}

interface SearchResultUserBaseModel {
  tot;
  result;
}

Parameter	Type	Optional	Description
tot	number	true	Total number of user
result	Array<UserBaseModel>	true	Users List

SearchResultTVoxUserModel

interface SearchResultTVoxUserModel {
  tot?: number;
  result?: Array<TVoxUserModel>;
}

interface SearchResultTVoxUserModel {
  tot;
  result;
}

Parameter	Type	Optional	Description
tot	number	true	Total number of user
result	Array<TVoxUserModel>	true	Users List

SkillsetBaseWithChannelsModel## TVoxUserModel

interface TVoxUserModel {
  username?: string;
  surname?: string;
  name?: string;
}

interface SearchResultTVoxUserModel {
  username;
  surname;
  name;
}

Parameter	Type	Optional	Description
username	string	true	Username of result user
name	string	true	Name of result user
surname	string	true	Surname of result user

SkillsetsSearchCriteriaModel

interface SkillsetsSearchCriteriaModel {
  skillset?: SearchCriteriaStringModel;
  type?: SearchCriteriaSkillsetTypeModel;
  description?: SearchCriteriaStringModel;
}

interface SkillsetsSearchCriteriaModel {
  skillset;
  type;
  description;
}

Parameter	Type	Optional	Description
skillset	SearchCriteriaStringModel	true	Search by skillset
type	SearchCriteriaStringModel	true	Search by type
description	SearchCriteriaStringModel	true	Surname by description

SearchRequestSkillsetsSearchCriteriaSortFieldModel

interface SkillsetsSearchCriteriaModel {
  criterias?: SkillsetsSearchCriteriaModel;
  page?: number;
  size?: number;
  exclusions?: Array<string>;
}

interface SkillsetsSearchCriteriaModel {
  criterias;
  page;
  size;
  exclusions;
}

Parameter	Type	Optional	Description
criterias	SkillsetsSearchCriteriaModel	true	Search skillset by specific criterias
page	number	true	Search with page number
size	number	true	Search with page size
exclusions	Array	true	List of skilslet code ot exclude

SearchResultSkillsetBaseWithChannelsModel

interface SearchResultSkillsetBaseWithChannelsModel {
  tot?: number;
  result?: Array<SkillsetBaseWithChannelsModel>;
}

interface SearchResultSkillsetBaseWithChannelsModel {
  tot;
  result;
}

Parameter	Type	Optional	Description
tot	number	true	Total number of skillsets
result	Array<SkillsetBaseWithChannelsModel>	true	Skillsets List

UserEntity

UserStatusFilter

import {  UserEntity } from '@telenia/rtdclient';
enum UserStatusFilter {
  READY,
  NOT_READY,
  BOOKED,
  BUSY,
  NOTLOGGED,
  NOT_READY_BUSY,
  WNR
}

enum UserStatusFilter {
  READY,
  NOT_READY,
  BOOKED,
  BUSY,
  NOTLOGGED,
  NOT_READY_BUSY,
  WNR
}

To access this enum use UserEntity.UserStatusFilter

Agent State	Description
READY	Ready State
NOT_READY	Not ready State
BOOKED	Booked state
BUSY	Busy State
NOTLOGGED	Not logged state
NOT_READY_BUSY	Busy in state not ready
WNR	Work not ready

UserFilterData

import {  UserEntity } from '@telenia/rtdclient';
interface UserFilterData {
  surname?: String;
  name?: String;
  sites?: Int[];
  statuses?: UserStatusFilter[];
  skillsets?: String[];
  services?: String[];
  activityCodes?: String[];
  channels?: MultiChannel[];
}

interface UserFilterData {
  surname;
  name;
  sites;
  statuses;
  skillsets;
  services;
  activityCodes;
  channels;
}

To access this interface use UserEntity.UserFilterData

Parameter	Type	Optional	Description
surname	String	true	Filter by surname
name	String	true	Filter by name
sites	Int[]	true	Filter by sites
statuses	UserStatusFilter[]	true	Filter by statuses
skillsets	String[]	true	Filter by skillsets codes
services	String[]	true	Filter by service codes
activityCodes	String[]	true	Filter by activity code ids
channels	MultiChannel[]	true	Filter by channels

MultiChannel

import {  UserEntity } from '@telenia/rtdclient';
enum MultiChannel {
  CALL,
  VIDEO,    
  CHAT
}

enum MultiChannel {
  CALL,
  VIDEO,    
  CHAT
}

To access this enum use UserEntity.MultiChannel

Agent State	Description
CALL	Call channel
VIDEO	Video channel
CHAT	Chat channel

UserIndicator

import {  UserEntity } from '@telenia/rtdclient';
interface UserIndicator {
    activeProfile?: boolean;
    surname?: boolean;
    name?: boolean;
    activityCodes?: UserActivityCodeMapIndicator;
    services?: boolean;
    site?: boolean;
    skillsets?: boolean;
    statuses?: UserStatusMultiChannelMapIndicator;
}

interface UserIndicator {
    activeProfile;
    surname;
    name;
    activityCodes;
    services;
    site;
    skillsets;
    statuses;
}

To access this interface use UserEntity.UserIndicator

Parameter	Type	Optional	Description
activeProfile	boolean	true	Request active profile stats
surname	boolean	true	Request surname stats
name	boolean	true	Request name stats
activityCodes	UserActivityCodeMapIndicator[]	true	Request activity codes stats
services	boolean	true	Request service stats
site	boolean	true	Request site stats
skillsets	boolean	true	Request skillsets stats
statuses	UserStatusMultiChannelMapIndicator	true	Request statuses stats

UserStatusMultiChannelMapIndicator

import {  UserEntity } from '@telenia/rtdclient';
interface UserStatusMultiChannelMapIndicator {
  CALL?: boolean;
  VIDEO?: boolean;
  CHAT?: boolean;
}

interface UserStatusMultiChannelMapIndicator {
  CALL,
  VIDEO,    
  CHAT
}

To access this interface use UserEntity.UserStatusMultiChannelMapIndicator

Agent State	Type	Optional	Description
CALL	boolean	true	Request Call channel
VIDEO	boolean	true	Request Video channel
CHAT	boolean	true	Request Chat channel

UserActivityCodeMapIndicator

import {  UserEntity } from '@telenia/rtdclient';
interface UserActivityCodeMapIndicator {
  CALL?: boolean;
  VIDEO?: boolean;
  CHAT?: boolean;
}

interface UserActivityCodeMapIndicator {
  CALL,
  VIDEO,    
  CHAT
}

To access this interface use UserEntity.UserActivityCodeMapIndicator

Agent State	Type	Optional	Description
CALL	boolean	true	Request Call channel
VIDEO	boolean	true	Request Video channel
CHAT	boolean	true	Request Chat channel

UserData

import {  UserEntity } from '@telenia/rtdclient';
interface UserData {
  mutation: MutationType;
  username: String;
  activeProfile: Int | null;
  surname: String | null;
  name: String | null;
  activityCodes: UserActivityCodeMap | null;
  services: String[] | null;
  site: Int | null;
  skillsets: String[] | null;
  statuses: UserStatusMultiChannelMap | null;
}

interface UserData {
  mutation;
  username;
  activeProfile;
  surname;
  name;
  activityCodes;
  services;
  site;
  skillsets;
  statuses;
}

To access this interface use UserEntity.UserData

Agent State	Type	Nullable	Description
mutation	MutationType	no	Return state of user in applied filter
username	String	no	Username of user
activeProfile	Int	yes	Current Active Profile
surname	String	yes	User's surname
name	String	yes	User's name
activityCodes	UserActivityCodeMap	yes	User Activity Codes
services	String[]	yes	User's services
site	Int	yes	Current user site
skillsets	String[]	yes	User's skillsets
statuses	UserStatusMultiChannelMap	yes	Current user statuses

MutationType

import {  UserEntity } from '@telenia/rtdclient';
enum MutationType {
  CREATED,
  UPDATED,
  DELETED
}

enum MutationType {
  CREATED,
  UPDATED,
  DELETED
}

To access this enum use UserEntity.MutationType

Mutation	Description
CREATED	User has been added on filter
UPDATED	The user in the filter has had updates
DELETED	User has been deleted on filter

UserActivityCodeMap

import {  UserEntity } from '@telenia/rtdclient';
interface UserActivityCodeMap {
  CALL: String | null;
  VIDEO: String | null;  
  CHAT: String | null;
}

interface UserActivityCodeMap {
  CALL;
  VIDEO;
  CHAT;
}

To access this interface use UserEntity.UserActivityCodeMap

Agent State	Type	Nullable	Description
CALL	String	yes	Return the id of activityCode
VIDEO	String	yes	Return the id of activityCode
CHAT	String	yes	Return the id of activityCode

UserStatusMultiChannelMap

import {  UserEntity } from '@telenia/rtdclient';
interface UserStatusMultiChannelMap {
  CALL: UserStatus | null;
  VIDEO: UserStatus | null;  
  CHAT: UserStatus | null;
}

interface UserStatusMultiChannelMap {
  CALL;
  VIDEO;
  CHAT;
}

To access this interface use UserEntity.UserStatusMultiChannelMap

Agent State	Type	Nullable	Description
CALL	UserStatus	yes	Return the status for call channel
VIDEO	UserStatus	yes	Return the status for video channel
CHAT	UserStatus	yes	Return the status for chat channel

UserMultiChannelMap

import {  UserEntity } from '@telenia/rtdclient';
interface UserMultiChannelMap {
  CALL: UserStatus | null;
  VIDEO: UserStatus | null;  
  CHAT: UserStatus | null;
}

interface UserMultiChannelMap {
  CALL;
  VIDEO;
  CHAT;
}

To access this interface use UserEntity.UserMultiChannelMap

Agent State	Type	Nullable	Description
CALL	UserStatus	yes	Return the status for call channel
VIDEO	UserStatus	yes	Return the status for video channel
CHAT	UserStatus	yes	Return the status for chat channel

UserStatus

import {  UserEntity } from '@telenia/rtdclient';
enum UserStatus {
  READY,
  NOT_READY,
  BOOKED,
  BUSY,
  NOTLOGGED,
  NOT_READY_BUSY,
  WNR,
  BUSY_dn_call_in,
  BUSY_dn_call_out,
  BUSY_dn_call_out_private,
  BUSY_service,
  NR_BUSY_dn_call_in",
  NR_BUSY_dn_call_out,
  NR_BUSY_dn_call_out_private
}

enum UserStatus {
  READY,
  NOT_READY,
  BOOKED,
  BUSY,
  NOTLOGGED,
  NOT_READY_BUSY,
  WNR,
  BUSY_dn_call_in,
  BUSY_dn_call_out,
  BUSY_dn_call_out_private,
  BUSY_service,
  NR_BUSY_dn_call_in",
  NR_BUSY_dn_call_out,
  NR_BUSY_dn_call_out_private
}

To access this enum use UserEntity.UserStatus

Agent State	Description
READY	Ready State
NOT_READY	Not ready State
BOOKED	Booked state
BUSY	Busy State
NOTLOGGED	Not logged state
NOT_READY_BUSY	Busy in state not ready
BUSY_dn_call_in	Busy on inbound call
BUSY_dn_call_out	Busy on outbound call
BUSY_dn_call_out_private	Busy on private outbound call
BUSY_service	Busy on service call
NR_BUSY_dn_call_in	Busy on inbound call in state not ready
NR_BUSY_dn_call_out	Busy on outbound call in state not ready
NR_BUSY_dn_call_out_private	Busy on outbound private call in state not ready

GraphResult

import {  GraphResult } from '@telenia/rtdclient';
 interface GraphResult<T> {
    type: GraphResultType;
    data: T;
}

 interface GraphResult{
    type;
    data;
}

Parameter	Type	Nullable	Description
type	GraphResultType	no	It exposes the type of result obtained by the server which can be the current state or an update state
data	T	no	is the server's object , can be one of follow types : ServiceStats, GroupStats, UserStats, UserProfileStats, UserData

GraphResultType

enum GraphResultType {
    CURRENT,
    UPDATED
}

enum GraphResultType {
    CURRENT,
    UPDATED
}

Type	Description
CURRENT	Is the current statistics states. When arrive this type all stats informations are sent
UPDATED	Update values from last state. When this type arrives, only statistics changed from the previous state are sent

Result

UserStats

import {  Result } from '@telenia/rtdclient';
interface UserStats {
  username: String;
  name: String | null;
  surname: String | null;
  userSite: Int | null;
  loggedProfileId: Int;
  channelStats?: UserStatsChannelStats;
  channel: MultiChannel;
  activityCode: String | null;
  activityCode2: String | null;
  currentGroup: String | null;
  currentService: String | null;
  numberCallFromService: Int | null;
  numberCallFromServiceAnswered: Int | null;
  numberCallFromServiceNotAnswered: Int | null;
  numberCallIn: Int | null;
  numberCallServiceOverSpeedAnswer: Int | null;
  status: UserStatus | null;
  timeInActivityCode: TimeInActivityCode[] | null;
  timeInActivityCodeStateBusy: TimeInActivityCode[] | null;
  timeInActivityCodeStateNotReady: TimeInActivityCode[] | null;
  timeInState: Date | null;
  timeInStateBooked: Int | null;
  timeInStateBusy: Int | null;
  timeInStateBusyOnService: Int | null;
  timeInStateNotReady: Int | null;
  timeInStateReady: Int | null;
  timeInStateWNR: Int | null;
}

interface UserStats {
  username;
  name;
  surname;
  userSite;
  loggedProfileId;
  channelStats;
  channel;
  activityCode;
  activityCode2;
  currentGroup;
  currentService;
  numberCallFromService;
  numberCallFromServiceAnswered;
  numberCallFromServiceNotAnswered;
  numberCallIn;  
  numberCallServiceOverSpeedAnswer;
  status;
  timeInActivityCode;
  timeInActivityCodeStateBusy;
  timeInActivityCodeStateNotReady;
  timeInState;
  timeInStateBooked;
  timeInStateBusy;  
  timeInStateBusyOnService;
  timeInStateNotReady;
  timeInStateReady;
  timeInStateWNR;
}

To access this interface use Result.UserStats

Parameter	Type	Nullable	Description
username	String	no	User's username
name	String	yes	User's name
surname	String	yes	User's surname
userSite	Int	yes	Profile user site
channelStats	UserStatsChannelStats	no	User channel
loggedProfileId	Int	no	User logged profile id
channel	MultiChannel	no	User channel
activityCode	String	yes	User activity code
activityCode2	String	yes	User sendo level activity code
currentGroup	String	yes	Current call's skillset
currentService	String	yes	Current call's service
numberCallFromService	Int	yes	Number of service calls received by the agent
numberCallFromServiceAnswered	Int	yes	Number of service calls answered by the agent
numberCallFromServiceNotAnswered	Int	yes	Number of service calls that the operator did not answer
numberCallIn	Int	yes	Total number of calls received by the agent
numberCallServiceOverSpeedAnswer	Int	yes	Number of calls answered by the service beyond the 'response speed' threshold configured in the TVox-> General settings-> Miscellaneous menu
status	UserStatus	yes	Current Agent state
timeInActivityCode	TimeInActivityCode or boolean	yes	Total time elapsed on activity code
timeInActivityCodeStateBusy	TimeInActivityCode or boolean	yes	Total time wlapsed on activity code
timeInActivityCodeStateNotReady	TimeInActivityCode or boolean	yes	Total time elapsed on activity code in state not ready
timeInState	Date	yes	Time spent by the operator in the current state
timeInStateBooked	Int	yes	Total time (expressed in seconds) that the operator has been in the Reserved state. This is the time when the phone rings
timeInStateBusy	Int	yes	Total time (expressed in seconds) that the operator has remained in the busy state (Busy)
timeInStateBusyOnService	Int	yes	Total time (in seconds) that the operator has been in the busy state for service calls
timeInStateNotReady	Int	yes	Total time (in seconds) that the operator was in the Not Ready state
timeInStateReady	Int	yes	Total time (in seconds) that the operator was in the Ready state
timeInStateWNR	Int	yes	Total time (in seconds) that the operator was in the "Post Call Processing" state

UserStatsChannelStats

import { Indicator } from "@telenia/rtdclient";
interface UserStatsChannelStats {
  call?: UserStatsCallIndicator;
}

interface UserStatsChannelStats {
  call;
}

To access this interface use Indicator.UserStatsChannelStats

Parameter	Type	Required	Description
call	UserStatsCallIndicator	false	Indicator for Services's call statistics

UserStatsCallIndicator

import {  Result } from '@telenia/rtdclient';
interface UserStats {
  numberCallOut: Int | null;
  numberCallOutPrivate: Int | null;
  timeInStateBusyDnCallIn: Int | null;
  timeInStateBusyDnCallOut: Int | null;
  timeInStateBusyDnCallOutPrivate: Int | null;
}

interface UserStats {
  numberCallOut;
  numberCallOutPrivate;
  timeInStateBusyDnCallIn;
  timeInStateBusyDnCallOut;
  timeInStateBusyDnCallOutPrivate;
}

Parameter	Type	Nullable	Description
numberCallOut	Int	yes	Total number of calls made by the agent
numberCallOutPrivate	Int	yes	Total number of private calls made
timeInStateBusyDnCallIn	Int	yes	Total time (in seconds) that the attendant was on busy for incoming calls
timeInStateBusyDnCallOut	Int	yes	Total time (in seconds) that the attendant was busy for outgoing calls
timeInStateBusyDnCallOutPrivate	Int	yes	Total time (in seconds) that the operator has been in busy state for private outgoing calls

UserProfileStats

import {  Result } from '@telenia/rtdclient';
interface UserProfileStats {
  id: Int;
  userSite: Int | null;
  channel: MultiChannel;
  activityCode: String | null;
  activityCode2: String | null;
  currentGroup: String | null;
  currentService: String | null;
  channelStats?: UserProfileStatsChanneStats;
  numberCallFromService: Int | null;
  numberCallFromServiceAnswered: Int | null;
  numberCallFromServiceNotAnswered: Int | null;
  numberCallIn: Int | null;
  numberCallServiceOverSpeedAnswer: Int | null;
  status: UserStatus | null;
  timeInActivityCode: TimeInActivityCode[] | null;
  timeInActivityCodeStateBusy: TimeInActivityCode[] | null;
  timeInActivityCodeStateNotReady: TimeInActivityCode[] | null;
  timeInState: Date | null;
  timeInStateBooked: Int | null;
  timeInStateBusy: Int | null;
  timeInStateBusyOnService: Int | null;
  timeInStateNotReady: Int | null;
  timeInStateReady: Int | null;
  timeInStateWNR: Int | null;
}

interface UserProfileStats {
  id;
  userSite;
  channel;
  activityCode;
  activityCode2;
  currentGroup;
  currentService;
  channelStats;
  numberCallFromService;
  numberCallFromServiceAnswered;
  numberCallFromServiceNotAnswered;
  numberCallIn;  
  numberCallServiceOverSpeedAnswer;
  status;
  timeInActivityCode;
  timeInActivityCodeStateBusy;
  timeInActivityCodeStateNotReady;
  timeInState;
  timeInStateBooked;
  timeInStateBusy;
  timeInStateBusyOnService;
  timeInStateNotReady;
  timeInStateReady;
  timeInStateWNR;
  timeInHold;
}

To access this interface use Result.UserProfileStats

Parameter	Type	Nullable	Description
id	String	no	User's profile id
userSite	Int	yes	Profile user site
channel	MultiChannel	no	User channel
activityCode	String	yes	User activity code
activityCode2	String	yes	User sendo level activity code
currentGroup	String	yes	Current call's skillset
currentService	String	yes	Current call's service
channelStats	UserProfileStatsChanneStats	no	User channel
numberCallFromService	Int	yes	Number of service calls received by the agent
numberCallFromServiceAnswered	Int	yes	Number of service calls answered by the agent
numberCallFromServiceNotAnswered	Int	yes	Number of service calls that the operator did not answer
numberCallIn	Int	yes	Total number of calls received by the agent
numberCallServiceOverSpeedAnswer	Int	yes	Number of calls answered by the service beyond the 'response speed' threshold configured in the TVox-> General settings-> Miscellaneous menu
status	UserStatus	yes	Current Agent state
timeInActivityCode	TimeInActivityCode or boolean	yes	Total time elapsed on activity code
timeInActivityCodeStateBusy	TimeInActivityCode or boolean	yes	Total time wlapsed on activity code
timeInActivityCodeStateNotReady	TimeInActivityCode or boolean	yes	Total time elapsed on activity code in state not ready
timeInState	Date	yes	Time spent by the operator in the current state
timeInStateBooked	Int	yes	Total time (expressed in seconds) that the operator has been in the Reserved state. This is the time when the phone rings
timeInStateBusy	Int	yes	Total time (expressed in seconds) that the operator has remained in the busy state (Busy)
timeInStateBusyOnService	Int	yes	Total time (in seconds) that the operator has been in the busy state for service calls
timeInStateNotReady	Int	yes	Total time (in seconds) that the operator was in the Not Ready state
timeInStateReady	Int	yes	Total time (in seconds) that the operator was in the Ready state
timeInStateWNR	Int	yes	Total time (in seconds) that the operator was in the "Post Call Processing" state

UserProfileStatsChanneStats

import { Indicator } from "@telenia/rtdclient";
interface UserProfileStatsChanneStats {
  call?: UserProfileStatsCallIndicator;
}

interface UserProfileStatsCallIndicator {
  call;
}

To access this interface use Indicator.UserProfileStatsChanneStats

Parameter	Type	Required	Description
call	UserProfileStatsCallIndicator	false	Indicator for Services's call statistics

UserProfileStatsCallIndicator

import {  Result } from '@telenia/rtdclient';
interface UserProfileStatsCallIndicator {
  numberCallOut: Int | null;
  numberCallOutPrivate: Int | null;
  timeInStateBusyDnCallIn: Int | null;
  timeInStateBusyDnCallOut: Int | null;
  timeInStateBusyDnCallOutPrivate: Int | null;
  timeInHold: TimeInHold | null;
}

interface UserProfileStatsCallIndicator {
  numberCallOut;
  numberCallOutPrivate;
  timeInStateBusyDnCallIn;
  timeInStateBusyDnCallOut;
  timeInStateBusyDnCallOutPrivate;
  timeInHold;
}

To access this interface use Result.UserProfileStatsCallIndicator

Parameter	Type	Nullable	Description
numberCallOut	Int	yes	Total number of calls made by the agent
numberCallOutPrivate	Int	yes	Total number of private calls made
timeInStateBusyDnCallIn	Int	yes	Total time (in seconds) that the attendant was on busy for incoming calls
timeInStateBusyDnCallOut	Int	yes	Total time (in seconds) that the attendant was busy for outgoing calls
timeInStateBusyDnCallOutPrivate	Int	yes	Total time (in seconds) that the operator has been in busy state for private outgoing calls
timeInHold	TimeInHold	yes	Hold time for service calls

TimeInHold

interface TimeInHold {
    time: Date | null;
    timeInState: Int | null;    
}

interface TimeInHold {
    time;
    timeInState;    
}

Current time in state is the sum of time and timeInState, if time is null, time in state hold is only the timeInState

Parameter	Type	Nullable	Description
time	Date	yes	Time in state after call become hold
timeInState	Int	yes	(Seconds) Total time in state hold (sum of all time in state)

GroupStats

import {  Result } from '@telenia/rtdclient';
interface GroupStats {
  userStats?: GroupUserStat;
  channelStats?: GroupChannelStats
  customStats: CustomStat[];
}

interface GroupStats {
  userStats;
  channelStats;
  customStats;
}

To access this interface use Result.GroupStats

Parameter	Type	Nullable	Description
userStats	GroupUserStat	no	Skillset user statistics
channelStats	GroupChannelStats	no	Skillset channels statistics
customStats	CustomStat[]	no	Skillset custom indicator statistics

GroupChannelStats

import { Indicator } from "@telenia/rtdclient";
interface GroupChannelStats {
  call?: GroupCcCallStat;
  video?: GroupCcVideoStat;
  chat?: GroupCcChatStat;
  mailAcd?: GroupCcMailAcdStat;
  livehelp?: GroupCcLivehelpStat;  
  custom1?: GroupCcCustom1Stat;
  custom2?: GroupCcCustom2Stat;
  custom3?: GroupCcCustom3Stat;
}

interface GroupChannelStats {
  call;
  video;
  chat;
  mailAcd;
  livehelp;  
  custom1;
  custom2;
  custom3; 
}

To access this interface use Indicator.GroupChannelStats

Parameter	Type	Required	Description
call	GroupCcCallStat	false	Indicator for Skillsets's call statistics
video	GroupCcVideoStat	false	Indicators for Skillsets's video statistics
chat	GroupCcChatStat	false	Indicator for Skillsets's chat statistics
mailAcd	GroupCcMailAcdStat	false	Indicators for Skillsets's mail ACD statistics
livehelp	GroupCcLivehelpStat	false	Indicator for Skillsets's Live Help statistics
custom1	GroupCcCustom1Stat	false	Indicators for Skillsets's channel Custom 01 statistics
custom2	GroupCcCustom2Stat	false	Indicator for Skillsets's channel Custom 02 statistics
custom3	GroupCcCustom3Stat	false	Indicators for Skillsets's channel Custom 03 statistics

GroupCcCallStat

import {  Result } from '@telenia/rtdclient';
interface GroupCcCallStat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  hangupCalls: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  shortCalls: Int | null;
}

interface GroupCcCallStat {
  answeredCalls;
  closedCalls;
  hangupCalls;
  queuedCalls;
  receivedCalls;
  shortCalls;
}

To access this interface use Result.GroupCcCallStat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's calls answered
closedCalls	Int	yes	Number of calls closed on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned calls (hung up by the caller) in the "active" context
queuedCalls	Int	yes	Number of queued calls
receivedCalls	Int	yes	Number of calls received by the service in an "active" context
shortCalls	Int	yes	Number of short abandoned calls. A short call is an abandoned call that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)

GroupCcVideoStat

import {  Result } from '@telenia/rtdclient';
interface GroupCcVideoStat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  hangupCalls: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  shortCalls: Int | null;
}

interface GroupCcVideoStat {
  answeredCalls;
  closedCalls;
  hangupCalls;
  queuedCalls;
  receivedCalls;
  shortCalls;
}

To access this interface use Result.GroupCcVideoStat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's video calls answered
closedCalls	Int	yes	Number of video calls closed on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned video calls (hung up by the caller) in the "active" context
queuedCalls	Int	yes	Number of queued video calls
receivedCalls	Int	yes	Number of video calls received by the service in an "active" context
shortCalls	Int	yes	Number of short abandoned video calls. A short video call is an abandoned video call that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)

GroupCcChatStat

import {  Result } from '@telenia/rtdclient';
interface GroupCcChatStat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  hangupCalls: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  shortCalls: Int | null;
}

interface GroupCcChatStat {
  answeredCalls;
  closedCalls;
  hangupCalls;
  queuedCalls;
  receivedCalls;
  shortCalls;
}

To access this interface use Result.GroupCcChatStat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's chats answered
closedCalls	Int	yes	Number of chats closed on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned chats (hung up by the caller) in the "active" context
queuedCalls	Int	yes	Number of queued chats
receivedCalls	Int	yes	Number of chats received by the service in an "active" context
shortCalls	Int	yes	Number of short abandoned chats. A short chat is an abandoned chat that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)

GroupCcMailAcdStat

import {  Result } from '@telenia/rtdclient';
interface GroupCcMailAcdStat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  hangupCalls: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  shortCalls: Int | null;
}

interface GroupCcMailAcdStat {
  answeredCalls;
  closedCalls;
  hangupCalls;
  queuedCalls;
  receivedCalls;
  shortCalls;
}

To access this interface use Result.GroupCcMailAcdStat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's mails answered
closedCalls	Int	yes	Number of mails closed on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned mails (hung up by the caller) in the "active" context
queuedCalls	Int	yes	Number of queued mails
receivedCalls	Int	yes	Number of mails received by the service in an "active" context
shortCalls	Int	yes	Number of short abandoned mails. A short mail is an abandoned call that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)

GroupCcLivehelpStat

import {  Result } from '@telenia/rtdclient';
interface GroupCcLivehelpStat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  hangupCalls: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  shortCalls: Int | null;
}

interface GroupCcLivehelpStat {
  answeredCalls;
  closedCalls;
  hangupCalls;
  queuedCalls;
  receivedCalls;
  shortCalls;
}

To access this interface use Result.GroupCcLivehelpStat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's livehelp iteractions answered
closedCalls	Int	yes	Number of livehelp iteractions closed on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned livehelp iteractions (hung up by the caller) in the "active" context
queuedCalls	Int	yes	Number of queued livehelp iteractions
receivedCalls	Int	yes	Number of livehelp iteractions received by the service in an "active" context
shortCalls	Int	yes	Number of short abandoned livehelp iteractions. A short livehelp iteraction is an abandoned livehelp iteraction that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)

GroupCcCustom1Stat

import {  Result } from '@telenia/rtdclient';
interface GroupCcCustom1Stat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  hangupCalls: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  shortCalls: Int | null;
}

interface GroupCcCustom1Stat {
  answeredCalls;
  closedCalls;
  hangupCalls;
  queuedCalls;
  receivedCalls;
  shortCalls;
}

To access this interface use Result.GroupCcCustom1Stat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's iterations answered
closedCalls	Int	yes	Number of iterations closed on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned iterations (hung up by the caller) in the "active" context
queuedCalls	Int	yes	Number of queued iterations
receivedCalls	Int	yes	Number of iterations received by the service in an "active" context
shortCalls	Int	yes	Number of short abandoned iterations. A short iteration is an abandoned iteration that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)

GroupCcCustom2Stat

import {  Result } from '@telenia/rtdclient';
interface GroupCcCustom2Stat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  hangupCalls: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  shortCalls: Int | null;
}

interface GroupCcCustom2Stat {
  answeredCalls;
  closedCalls;
  hangupCalls;
  queuedCalls;
  receivedCalls;
  shortCalls;
}

To access this interface use Result.GroupCcCustom12Stat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's iterations answered
closedCalls	Int	yes	Number of iterations closed on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned iterations (hung up by the caller) in the "active" context
queuedCalls	Int	yes	Number of queued iterations
receivedCalls	Int	yes	Number of iterations received by the service in an "active" context
shortCalls	Int	yes	Number of short abandoned iterations. A short iteration is an abandoned iteration that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)

GroupCcCustom3Stat

import {  Result } from '@telenia/rtdclient';
interface GroupCcCustom3Stat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  hangupCalls: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  shortCalls: Int | null;
}

interface GroupCcCustom3Stat {
  answeredCalls;
  closedCalls;
  hangupCalls;
  queuedCalls;
  receivedCalls;
  shortCalls;
}

To access this interface use Result.GroupCcCustom3Stat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's iterations answered
closedCalls	Int	yes	Number of iterations closed on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned iterations (hung up by the caller) in the "active" context
queuedCalls	Int	yes	Number of queued iterations
receivedCalls	Int	yes	Number of iterations received by the service in an "active" context
shortCalls	Int	yes	Number of short abandoned iterations. A short iteration is an abandoned iteration that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)

GroupUserStat

import {  Result } from '@telenia/rtdclient';
interface GroupUserStat {
  loggedUsers: UserProfileInStatus | null;
  notReadyUsers: UserProfileInStatus | null;
  notReadyUsersOnActivityCode: UserProfileInStatus | null;
  postCallUsers: UserProfileInStatus | null;
  readyUsers: UserProfileInStatus | null;
}

interface GroupUserStat {
  loggedUsers;
  notReadyUsers;
  notReadyUsersOnActivityCode;
  postCallUsers;
  readyUsers;
}

To access this interface use Result.GroupUserStat

Parameter	Type	Nullable	Description
busyOnDNCallInUsers	UserProfileInStatus	yes	Number of agents engaged in a direct incoming call conversation (DN-Call IN)
busyOnDNCallOutUsers	UserProfileInStatus	yes	Number of agents engaged in conversation for direct outgoing calls (DN-Call OUT)
busyOnDNCallOutUsersPrivate	UserProfileInStatus	yes	Number of agents engaged in a private outgoing call conversation
busyOnDNCallUsers	UserProfileInStatus	yes	Number of agents in conversation for direct calls (DN-Call)
busyOnServUsers	UserProfileInStatus	yes	Number of agents engaged in a service call conversation
busyUsers	UserProfileInStatus	yes	Total number of agents engaged in a telephone conversation
loggedUsers	UserProfileInStatus	yes	Number of logged in agents
notReadyUsers	UserProfileInStatus	yes	Number of agents in Not Ready state
notReadyUsersOnActivityCode	UserProfileInStatus	yes	Number of agents in Not Ready state who have specified an activity code
postCallUsers	UserProfileInStatus	yes	Number of agents in "Post Call Processing" state. It is the timeout configured on each operator to allow the closing of the activities related to the previous service conversation.
readyUsers	UserProfileInStatus	yes	Number of agents in Ready state

UserProfileInStatus

import {  Result } from '@telenia/rtdclient';
interface UserProfileInStatus {
  count: Int | null;
  profileIds: Int[] | null;
}

interface UserProfileInStatus {
  count;
  profileIds;
}

To access this interface use Result.UserProfileInStatus

Parameter	Type	Nullable	Description
count	Int	yes	Current number of users
profileIds	Int[]	yes	List of profiles id

ServiceStats

import {  Result } from '@telenia/rtdclient';
interface ServiceStats {
  userStats: ServiceUserStat;
  channelStats: ServiceChannelStats;    
  customStats: CustomStat[];
}

interface ServiceStats {
  userStats;
  channelStats;
  customStats;
}

To access this interface use Result.ServiceStats

Parameter	Type	Nullable	Description
userStats	ServiceUserStat	no	Services user statistics
serviceCcCallAtStat	ServiceChannelStats	no	Services statistics
customStats	CustomStat[]	no	Services custom indicator statistics

ServiceChannelStats

import { Indicator } from "@telenia/rtdclient";
interface ServiceChannelStats {
  call?: ServiceCcCallATStat;
  video?: ServiceCcVideoAtStat;
  chat?: ServiceCcChatAtStat;
  mailAcd?: ServiceCcMailAcdAtStat;
  livehelp?: ServiceCcLivehelpAtStat;  
  custom1?: ServiceCcCustom1AtStat;
  custom2?: ServiceCcCustom2AtStat;
  custom3?: ServiceCcCustom3AtStat;
}

interface ServiceChannelStats {
  call;
  video;
  chat;
  mailAcd;
  livehelp;  
  custom1;
  custom2;
  custom3; 
}

To access this interface use Indicator.ServiceChannelStats

Parameter	Type	Required	Description
call	ServiceCcCallATStat	false	Indicator for Services's call statistics
video	ServiceCcVideoAtStat	false	Indicators for Services's video statistics
chat	ServiceCcChatAtStat	false	Indicator for Services's chat statistics
mailAcd	ServiceCcMailAcdAtStat	false	Indicators for Services's mail ACD statistics
livehelp	ServiceCcLivehelpAtStat	false	Indicator for Services's Live Help statistics
custom1	ServiceCcCustom1AtStat	false	Indicators for Services's channel Custom 01 statistics
custom2	ServiceCcCustom2AtStat	false	Indicator for Services's channel Custom 02 statistics
custom3	ServiceCcCustom3AtStat	false	Indicators for Services's channel Custom 03 statistics

ServiceCcCallATStat

import {  Result } from '@telenia/rtdclient';
interface ServiceCcCallATStat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  closedCallsCallBack: Int | null;
  connectedCall: Int | null;
  currentCalls: Int | null;
  hangupCalls: Int | null;
  maxTimeCallOnQueue: Int | null;
  outboundAnsweredCalls: Int | null;
  outboundClosedCallsGenericCause: Int | null;
  outboundHangupCalls: Int | null;
  outboundReceivedCalls: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  receivedCallsInAccessList: Int | null;
  receivedCallsWithT4you: Float | null;
  receivedCallsWithT4youAnonymous: Float | null;
  receivedCallsWithT4youMultiple: Float | null;
  receivedCallsWithT4youSingle: Float | null;  
  shortCalls: Int | null;
  averageTimeOnQueue: Int | null;
  openTickets: Int | null;
  createdTickets: Int | null;
  callsToTicketsPercentage: Int | null;
}

interface ServiceCcCallATStat {
  answeredCalls;
  closedCalls;
  closedCallsCallBack;
  connectedCall;
  currentCalls;
  hangupCalls;
  maxTimeCallOnQueue;
  outboundAnsweredCalls;
  outboundClosedCallsGenericCause;
  outboundHangupCalls;
  outboundReceivedCalls;
  queuedCalls;
  receivedCalls;
  receivedCallsInAccessList;
  receivedCallsWithT4you;
  receivedCallsWithT4youAnonymous;
  receivedCallsWithT4youMultiple;
  receivedCallsWithT4youSingle;
  remotelyAnsweredCalls;
  remotelyAnsweredCallsOverSpeedLimit;
  remotelyAnsweredCallsUnderSpeedLimit;
  remotelyConnectedCalls;
  remotelyQueuedCalls;
  shortCalls;
  averageTimeOnQueue;
  openTickets;
  createdTickets;
  callsToTicketsPercentage;
}

To access this interface use Result.ServiceCcCallATStat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's calls answered
closedCalls	Int	yes	Number of calls closed on the service in the 'active' context
closedCallsCallBack	Int	yes	Number of callback requests in 'active' context
connectedCall	Int	yes	Number of conversation calls on agents
currentCalls	Int	yes	Number of calls in progress on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned calls (hung up by the caller) in the "active" context
maxTimeCallOnQueue	Int	yes	Maximum waiting time in queue for calls queued to the service
outboundAnsweredCalls	Int	yes	Number of outgoing calls answered by the called contact
outboundClosedCallsGenericCause	Int	yes	Number of outgoing calls that could not be made due to an error, e.g.: Congestion, ChannelUnavailable, other...
outboundHangupCalls	Int	yes	Number of outgoing calls not answered
outboundReceivedCalls	Int	yes	Outgoing call attempts made
queuedCalls	Int	yes	Number of queued calls
receivedCalls	Int	yes	Number of calls received by the service in an "active" context
receivedCallsInAccessList	Int	yes	Number of calls received by the service in the 'active' context filtered from the access list (blacklist or whitelist)
receivedCallsWithT4you	Float	yes	Percentage value of calls received that were answered positively in the directory in an "active" context
receivedCallsWithT4youAnonymous	Float	yes	Percentage of calls received that received an anonymous response in the directory in an "active" context
receivedCallsWithT4youMultiple	Float	yes	Percentage value of calls received that have had more than one answer in the directory in an "active" context
receivedCallsWithT4youSingle	Float	yes	Percentage of calls received that were exactly matched in the directory in an "active" context
remotelyAnsweredCalls	Int	yes	Number of remote calls (from the Network Contact Center site) that the agent answered
remotelyAnsweredCallsOverSpeedLimit	Int	yes	Number of remote calls (from the Network Contact Center site) answered by the operator beyond the 'response speed' threshold configured in the TVox-> General settings-> Miscellaneous menu
remotelyAnsweredCallsUnderSpeedLimit	Int	yes	Number of remote calls (from the Network Contact Center site) answered by the operator within the 'response speed' threshold in the active context configured in the TVox-> General settings-> Miscellaneous menu
remotelyConnectedCalls	Int	yes	Number of conversational calls from the Network Contact Center remote site
remotelyQueuedCalls	Int	yes	Number of remote calls (from the Network Contact Center site) in queue
shortCalls	Int	yes	Number of short abandoned calls. A short call is an abandoned call that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)
averageTimeOnQueue	Int	yes	Average waiting time in queue for calls queued to the service
openTickets	Int	yes	Number of open tickets of call type
createdTickets	Int	yes	Number of tickets created of call type
callsToTicketsPercentage	Int	yes	Percentage of answered call that have been converted to tickets

ServiceCcVideoATStat

import {  Result } from '@telenia/rtdclient';
interface ServiceCcVideoATStat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  closedCallsCallBack: Int | null;
  connectedCall: Int | null;
  currentCalls: Int | null;
  hangupCalls: Int | null;
  maxTimeCallOnQueue: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  receivedCallsInAccessList: Int | null;
  receivedCallsWithT4you: Float | null;
  receivedCallsWithT4youAnonymous: Float | null;
  receivedCallsWithT4youMultiple: Float | null;
  receivedCallsWithT4youSingle: Float | null;  
  shortCalls: Int | null;
  averageTimeOnQueue: Int | null;
  openTickets: Int | null;
  createdTickets: Int | null;
  callsToTicketsPercentage: Int | null;
}

interface ServiceCcVideoATStat {
  answeredCalls;
  closedCalls;
  closedCallsCallBack;
  connectedCall;
  currentCalls;
  hangupCalls;
  maxTimeCallOnQueue;
  queuedCalls;
  receivedCalls;
  receivedCallsInAccessList;
  receivedCallsWithT4you;
  receivedCallsWithT4youAnonymous;
  receivedCallsWithT4youMultiple;
  receivedCallsWithT4youSingle;
  remotelyAnsweredCalls;
  remotelyAnsweredCallsOverSpeedLimit;
  remotelyAnsweredCallsUnderSpeedLimit;
  remotelyConnectedCalls;
  remotelyQueuedCalls;
  shortCalls;
  averageTimeOnQueue;
  openTickets;
  createdTickets;
  callsToTicketsPercentage;
}

To access this interface use Result.ServiceCcVideoATStat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's video calls answered
closedCalls	Int	yes	Number of video calls closed on the service in the 'active' context
closedCallsCallBack	Int	yes	Number of callback requests in 'active' context
connectedCall	Int	yes	Number of conversation video calls on agents
currentCalls	Int	yes	Number of video calls in progress on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned video calls (hung up by the caller) in the "active" context
maxTimeCallOnQueue	Int	yes	Maximum waiting time in queue for video calls queued to the service
queuedCalls	Int	yes	Number of queued calls
receivedCalls	Int	yes	Number of video calls received by the service in an "active" context
receivedCallsInAccessList	Int	yes	Number of video calls received by the service in the 'active' context filtered from the access list (blacklist or whitelist)
receivedCallsWithT4you	Float	yes	Percentage value of video calls received that were answered positively in the directory in an "active" context
receivedCallsWithT4youAnonymous	Float	yes	Percentage of video calls received that received an anonymous response in the directory in an "active" context
receivedCallsWithT4youMultiple	Float	yes	Percentage value of video calls received that have had more than one answer in the directory in an "active" context
receivedCallsWithT4youSingle	Float	yes	Percentage of video calls received that were exactly matched in the directory in an "active" context
remotelyAnsweredCalls	Int	yes	Number of remote video calls (from the Network Contact Center site) that the agent answered
remotelyAnsweredCallsOverSpeedLimit	Int	yes	Number of remote video calls (from the Network Contact Center site) answered by the operator beyond the 'response speed' threshold configured in the TVox-> General settings-> Miscellaneous menu
remotelyAnsweredCallsUnderSpeedLimit	Int	yes	Number of remote video calls (from the Network Contact Center site) answered by the operator within the 'response speed' threshold in the active context configured in the TVox-> General settings-> Miscellaneous menu
remotelyConnectedCalls	Int	yes	Number of conversational video calls from the Network Contact Center remote site
remotelyQueuedCalls	Int	yes	Number of remote video calls (from the Network Contact Center site) in queue
shortCalls	Int	yes	Number of short abandoned calls. A short call is an abandoned call that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)
averageTimeOnQueue	Int	yes	Average waiting time in queue for video calls queued to the service
openTickets	Int	yes	Number of open tickets of call type
createdTickets	Int	yes	Number of tickets created of call type
callsToTicketsPercentage	Int	yes	Percentage of answered call that have been converted to tickets

ServiceCcChatATStat

import {  Result } from '@telenia/rtdclient';
interface ServiceCcChatATStat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  closedCallsCallBack: Int | null;
  connectedCall: Int | null;
  currentCalls: Int | null;
  hangupCalls: Int | null;
  maxTimeCallOnQueue: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  receivedCallsInAccessList: Int | null;
  receivedCallsWithT4you: Float | null;
  receivedCallsWithT4youAnonymous: Float | null;
  receivedCallsWithT4youMultiple: Float | null;
  receivedCallsWithT4youSingle: Float | null;  
  shortCalls: Int | null;
  averageTimeOnQueue: Int | null;
  openTickets: Int | null;
  createdTickets: Int | null;
  callsToTicketsPercentage: Int | null;
}

interface ServiceCcChatATStat {
  answeredCalls;
  closedCalls;
  closedCallsCallBack;
  connectedCall;
  currentCalls;
  hangupCalls;
  maxTimeCallOnQueue;
  queuedCalls;
  receivedCalls;
  receivedCallsInAccessList;
  receivedCallsWithT4you;
  receivedCallsWithT4youAnonymous;
  receivedCallsWithT4youMultiple;
  receivedCallsWithT4youSingle;
  remotelyAnsweredCalls;
  remotelyAnsweredCallsOverSpeedLimit;
  remotelyAnsweredCallsUnderSpeedLimit;
  remotelyConnectedCalls;
  remotelyQueuedCalls;
  shortCalls;
  averageTimeOnQueue;
  openTickets;
  createdTickets;
  callsToTicketsPercentage;
}

To access this interface use Result.ServiceCcChatATStat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's chats answered
closedCalls	Int	yes	Number of chats closed on the service in the 'active' context
closedCallsCallBack	Int	yes	Number of callback requests in 'active' context
connectedCall	Int	yes	Number of conversation chats on agents
currentCalls	Int	yes	Number of chats in progress on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned chats (hung up by the caller) in the "active" context
maxTimeCallOnQueue	Int	yes	Maximum waiting time in queue for chats queued to the service
queuedCalls	Int	yes	Number of queued calls
receivedCalls	Int	yes	Number of chats received by the service in an "active" context
receivedCallsInAccessList	Int	yes	Number of chats received by the service in the 'active' context filtered from the access list (blacklist or whitelist)
receivedCallsWithT4you	Float	yes	Percentage value of chats received that were answered positively in the directory in an "active" context
receivedCallsWithT4youAnonymous	Float	yes	Percentage of chats received that received an anonymous response in the directory in an "active" context
receivedCallsWithT4youMultiple	Float	yes	Percentage value of chats received that have had more than one answer in the directory in an "active" context
receivedCallsWithT4youSingle	Float	yes	Percentage of chats received that were exactly matched in the directory in an "active" context
remotelyAnsweredCalls	Int	yes	Number of remote chats (from the Network Contact Center site) that the agent answered
remotelyAnsweredCallsOverSpeedLimit	Int	yes	Number of remote chats (from the Network Contact Center site) answered by the operator beyond the 'response speed' threshold configured in the TVox-> General settings-> Miscellaneous menu
remotelyAnsweredCallsUnderSpeedLimit	Int	yes	Number of remote chats (from the Network Contact Center site) answered by the operator within the 'response speed' threshold in the active context configured in the TVox-> General settings-> Miscellaneous menu
remotelyConnectedCalls	Int	yes	Number of conversational chats from the Network Contact Center remote site
remotelyQueuedCalls	Int	yes	Number of remote chats (from the Network Contact Center site) in queue
shortCalls	Int	yes	Number of short abandoned calls. A short call is an abandoned call that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)
averageTimeOnQueue	Int	yes	Average waiting time in queue for chats queued to the service
openTickets	Int	yes	Number of open tickets of call type
createdTickets	Int	yes	Number of tickets created of call type
callsToTicketsPercentage	Int	yes	Percentage of answered call that have been converted to tickets

ServiceCcLivehelpAtStat

import {  Result } from '@telenia/rtdclient';
interface ServiceCcLivehelpAtStat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  closedCallsCallBack: Int | null;
  connectedCall: Int | null;
  currentCalls: Int | null;
  hangupCalls: Int | null;
  maxTimeCallOnQueue: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  receivedCallsInAccessList: Int | null;
  receivedCallsWithT4you: Float | null;
  receivedCallsWithT4youAnonymous: Float | null;
  receivedCallsWithT4youMultiple: Float | null;
  receivedCallsWithT4youSingle: Float | null;  
  shortCalls: Int | null;
  averageTimeOnQueue: Int | null;
  openTickets: Int | null;
  createdTickets: Int | null;
  callsToTicketsPercentage: Int | null;
}

interface ServiceCcLivehelpAtStat {
  answeredCalls;
  closedCalls;
  closedCallsCallBack;
  connectedCall;
  currentCalls;
  hangupCalls;
  maxTimeCallOnQueue;
  queuedCalls;
  receivedCalls;
  receivedCallsInAccessList;
  receivedCallsWithT4you;
  receivedCallsWithT4youAnonymous;
  receivedCallsWithT4youMultiple;
  receivedCallsWithT4youSingle;
  remotelyAnsweredCalls;
  remotelyAnsweredCallsOverSpeedLimit;
  remotelyAnsweredCallsUnderSpeedLimit;
  remotelyConnectedCalls;
  remotelyQueuedCalls;
  shortCalls;
  averageTimeOnQueue;
  openTickets;
  createdTickets;
  callsToTicketsPercentage;
}

To access this interface use Result.ServiceCcLivehelpAtStat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's livehelp interactions answered
closedCalls	Int	yes	Number of livehelp interactions closed on the service in the 'active' context
closedCallsCallBack	Int	yes	Number of callback requests in 'active' context
connectedCall	Int	yes	Number of conversation livehelp interactions on agents
currentCalls	Int	yes	Number of livehelp interactions in progress on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned livehelp interactions (hung up by the caller) in the "active" context
maxTimeCallOnQueue	Int	yes	Maximum waiting time in queue for livehelp interactions queued to the service
queuedCalls	Int	yes	Number of queued calls
receivedCalls	Int	yes	Number of livehelp interactions received by the service in an "active" context
receivedCallsInAccessList	Int	yes	Number of livehelp interactions received by the service in the 'active' context filtered from the access list (blacklist or whitelist)
receivedCallsWithT4you	Float	yes	Percentage value of livehelp interactions received that were answered positively in the directory in an "active" context
receivedCallsWithT4youAnonymous	Float	yes	Percentage of livehelp interactions received that received an anonymous response in the directory in an "active" context
receivedCallsWithT4youMultiple	Float	yes	Percentage value of livehelp interactions received that have had more than one answer in the directory in an "active" context
receivedCallsWithT4youSingle	Float	yes	Percentage of livehelp interactions received that were exactly matched in the directory in an "active" context
remotelyAnsweredCalls	Int	yes	Number of remote livehelp interactions (from the Network Contact Center site) that the agent answered
remotelyAnsweredCallsOverSpeedLimit	Int	yes	Number of remote livehelp interactions (from the Network Contact Center site) answered by the operator beyond the 'response speed' threshold configured in the TVox-> General settings-> Miscellaneous menu
remotelyAnsweredCallsUnderSpeedLimit	Int	yes	Number of remote livehelp interactions (from the Network Contact Center site) answered by the operator within the 'response speed' threshold in the active context configured in the TVox-> General settings-> Miscellaneous menu
remotelyConnectedCalls	Int	yes	Number of conversational livehelp interactions from the Network Contact Center remote site
remotelyQueuedCalls	Int	yes	Number of remote livehelp interactions (from the Network Contact Center site) in queue
shortCalls	Int	yes	Number of short abandoned calls. A short call is an abandoned call that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)
averageTimeOnQueue	Int	yes	Average waiting time in queue for livehelp interactions queued to the service
openTickets	Int	yes	Number of open tickets of call type
createdTickets	Int	yes	Number of tickets created of call type
callsToTicketsPercentage	Int	yes	Percentage of answered call that have been converted to tickets

ServiceCcMailAcdAtStat

import {  Result } from '@telenia/rtdclient';
interface ServiceCcMailAcdAtStat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  closedCallsCallBack: Int | null;
  connectedCall: Int | null;
  currentCalls: Int | null;
  hangupCalls: Int | null;
  maxTimeCallOnQueue: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  receivedCallsInAccessList: Int | null;
  receivedCallsWithT4you: Float | null;
  receivedCallsWithT4youAnonymous: Float | null;
  receivedCallsWithT4youMultiple: Float | null;
  receivedCallsWithT4youSingle: Float | null;  
  shortCalls: Int | null;
  averageTimeOnQueue: Int | null;
}

interface ServiceCcMailAcdAtStat {
  answeredCalls;
  closedCalls;
  closedCallsCallBack;
  connectedCall;
  currentCalls;
  hangupCalls;
  maxTimeCallOnQueue;
  queuedCalls;
  receivedCalls;
  receivedCallsInAccessList;
  receivedCallsWithT4you;
  receivedCallsWithT4youAnonymous;
  receivedCallsWithT4youMultiple;
  receivedCallsWithT4youSingle;
  remotelyAnsweredCalls;
  remotelyAnsweredCallsOverSpeedLimit;
  remotelyAnsweredCallsUnderSpeedLimit;
  remotelyConnectedCalls;
  remotelyQueuedCalls;
  shortCalls;
  averageTimeOnQueue;
}

To access this interface use Result.ServiceCcMailAcdAtStat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's mails answered
closedCalls	Int	yes	Number of mails closed on the service in the 'active' context
closedCallsCallBack	Int	yes	Number of callback requests in 'active' context
connectedCall	Int	yes	Number of conversation mails on agents
currentCalls	Int	yes	Number of mails in progress on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned mails (hung up by the caller) in the "active" context
maxTimeCallOnQueue	Int	yes	Maximum waiting time in queue for mails queued to the service
queuedCalls	Int	yes	Number of queued calls
receivedCalls	Int	yes	Number of mails received by the service in an "active" context
receivedCallsInAccessList	Int	yes	Number of mails received by the service in the 'active' context filtered from the access list (blacklist or whitelist)
receivedCallsWithT4you	Float	yes	Percentage value of mails received that were answered positively in the directory in an "active" context
receivedCallsWithT4youAnonymous	Float	yes	Percentage of mails received that received an anonymous response in the directory in an "active" context
receivedCallsWithT4youMultiple	Float	yes	Percentage value of mails received that have had more than one answer in the directory in an "active" context
receivedCallsWithT4youSingle	Float	yes	Percentage of mails received that were exactly matched in the directory in an "active" context
remotelyAnsweredCalls	Int	yes	Number of remote mails (from the Network Contact Center site) that the agent answered
remotelyAnsweredCallsOverSpeedLimit	Int	yes	Number of remote mails (from the Network Contact Center site) answered by the operator beyond the 'response speed' threshold configured in the TVox-> General settings-> Miscellaneous menu
remotelyAnsweredCallsUnderSpeedLimit	Int	yes	Number of remote mails (from the Network Contact Center site) answered by the operator within the 'response speed' threshold in the active context configured in the TVox-> General settings-> Miscellaneous menu
remotelyConnectedCalls	Int	yes	Number of conversational mails from the Network Contact Center remote site
remotelyQueuedCalls	Int	yes	Number of remote mails (from the Network Contact Center site) in queue
shortCalls	Int	yes	Number of short abandoned calls. A short call is an abandoned call that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)
averageTimeOnQueue	Int	yes	Average waiting time in queue for mails queued to the service

ServiceCcCustom1AtStat

import {  Result } from '@telenia/rtdclient';
interface ServiceCcCustom1AtStat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  closedCallsCallBack: Int | null;
  connectedCall: Int | null;
  currentCalls: Int | null;
  hangupCalls: Int | null;
  maxTimeCallOnQueue: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  receivedCallsInAccessList: Int | null;
  receivedCallsWithT4you: Float | null;
  receivedCallsWithT4youAnonymous: Float | null;
  receivedCallsWithT4youMultiple: Float | null;
  receivedCallsWithT4youSingle: Float | null;  
  shortCalls: Int | null;
  averageTimeOnQueue: Int | null;
}

interface ServiceCcCustom1AtStat {
  answeredCalls;
  closedCalls;
  closedCallsCallBack;
  connectedCall;
  currentCalls;
  hangupCalls;
  maxTimeCallOnQueue;
  queuedCalls;
  receivedCalls;
  receivedCallsInAccessList;
  receivedCallsWithT4you;
  receivedCallsWithT4youAnonymous;
  receivedCallsWithT4youMultiple;
  receivedCallsWithT4youSingle;
  remotelyAnsweredCalls;
  remotelyAnsweredCallsOverSpeedLimit;
  remotelyAnsweredCallsUnderSpeedLimit;
  remotelyConnectedCalls;
  remotelyQueuedCalls;
  shortCalls;
  averageTimeOnQueue;
}

To access this interface use Result.ServiceCcCustom1AtStat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's interactions answered
closedCalls	Int	yes	Number of interactions closed on the service in the 'active' context
closedCallsCallBack	Int	yes	Number of callback requests in 'active' context
connectedCall	Int	yes	Number of conversation interactions on agents
currentCalls	Int	yes	Number of interactions in progress on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned interactions (hung up by the caller) in the "active" context
maxTimeCallOnQueue	Int	yes	Maximum waiting time in queue for interactions queued to the service
queuedCalls	Int	yes	Number of queued calls
receivedCalls	Int	yes	Number of interactions received by the service in an "active" context
receivedCallsInAccessList	Int	yes	Number of interactions received by the service in the 'active' context filtered from the access list (blacklist or whitelist)
receivedCallsWithT4you	Float	yes	Percentage value of interactions received that were answered positively in the directory in an "active" context
receivedCallsWithT4youAnonymous	Float	yes	Percentage of interactions received that received an anonymous response in the directory in an "active" context
receivedCallsWithT4youMultiple	Float	yes	Percentage value of interactions received that have had more than one answer in the directory in an "active" context
receivedCallsWithT4youSingle	Float	yes	Percentage of interactions received that were exactly matched in the directory in an "active" context
remotelyAnsweredCalls	Int	yes	Number of remote interactions (from the Network Contact Center site) that the agent answered
remotelyAnsweredCallsOverSpeedLimit	Int	yes	Number of remote interactions (from the Network Contact Center site) answered by the operator beyond the 'response speed' threshold configured in the TVox-> General settings-> Miscellaneous menu
remotelyAnsweredCallsUnderSpeedLimit	Int	yes	Number of remote interactions (from the Network Contact Center site) answered by the operator within the 'response speed' threshold in the active context configured in the TVox-> General settings-> Miscellaneous menu
remotelyConnectedCalls	Int	yes	Number of conversational interactions from the Network Contact Center remote site
remotelyQueuedCalls	Int	yes	Number of remote interactions (from the Network Contact Center site) in queue
shortCalls	Int	yes	Number of short abandoned calls. A short call is an abandoned call that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)
averageTimeOnQueue	Int	yes	Average waiting time in queue for interactions queued to the service

ServiceCcCustom2AtStat

import {  Result } from '@telenia/rtdclient';
interface ServiceCcCustom1AtStat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  closedCallsCallBack: Int | null;
  connectedCall: Int | null;
  currentCalls: Int | null;
  hangupCalls: Int | null;
  maxTimeCallOnQueue: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  receivedCallsInAccessList: Int | null;
  receivedCallsWithT4you: Float | null;
  receivedCallsWithT4youAnonymous: Float | null;
  receivedCallsWithT4youMultiple: Float | null;
  receivedCallsWithT4youSingle: Float | null;  
  shortCalls: Int | null;
  averageTimeOnQueue: Int | null;
}

interface ServiceCcCustom2AtStat {
  answeredCalls;
  closedCalls;
  closedCallsCallBack;
  connectedCall;
  currentCalls;
  hangupCalls;
  maxTimeCallOnQueue;
  queuedCalls;
  receivedCalls;
  receivedCallsInAccessList;
  receivedCallsWithT4you;
  receivedCallsWithT4youAnonymous;
  receivedCallsWithT4youMultiple;
  receivedCallsWithT4youSingle;
  remotelyAnsweredCalls;
  remotelyAnsweredCallsOverSpeedLimit;
  remotelyAnsweredCallsUnderSpeedLimit;
  remotelyConnectedCalls;
  remotelyQueuedCalls;
  shortCalls;
  averageTimeOnQueue;
}

To access this interface use Result.ServiceCcCustom2AtStat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's interactions answered
closedCalls	Int	yes	Number of interactions closed on the service in the 'active' context
closedCallsCallBack	Int	yes	Number of callback requests in 'active' context
connectedCall	Int	yes	Number of conversation interactions on agents
currentCalls	Int	yes	Number of interactions in progress on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned interactions (hung up by the caller) in the "active" context
maxTimeCallOnQueue	Int	yes	Maximum waiting time in queue for interactions queued to the service
queuedCalls	Int	yes	Number of queued calls
receivedCalls	Int	yes	Number of interactions received by the service in an "active" context
receivedCallsInAccessList	Int	yes	Number of interactions received by the service in the 'active' context filtered from the access list (blacklist or whitelist)
receivedCallsWithT4you	Float	yes	Percentage value of interactions received that were answered positively in the directory in an "active" context
receivedCallsWithT4youAnonymous	Float	yes	Percentage of interactions received that received an anonymous response in the directory in an "active" context
receivedCallsWithT4youMultiple	Float	yes	Percentage value of interactions received that have had more than one answer in the directory in an "active" context
receivedCallsWithT4youSingle	Float	yes	Percentage of interactions received that were exactly matched in the directory in an "active" context
remotelyAnsweredCalls	Int	yes	Number of remote interactions (from the Network Contact Center site) that the agent answered
remotelyAnsweredCallsOverSpeedLimit	Int	yes	Number of remote interactions (from the Network Contact Center site) answered by the operator beyond the 'response speed' threshold configured in the TVox-> General settings-> Miscellaneous menu
remotelyAnsweredCallsUnderSpeedLimit	Int	yes	Number of remote interactions (from the Network Contact Center site) answered by the operator within the 'response speed' threshold in the active context configured in the TVox-> General settings-> Miscellaneous menu
remotelyConnectedCalls	Int	yes	Number of conversational interactions from the Network Contact Center remote site
remotelyQueuedCalls	Int	yes	Number of remote interactions (from the Network Contact Center site) in queue
shortCalls	Int	yes	Number of short abandoned calls. A short call is an abandoned call that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)
averageTimeOnQueue	Int	yes	Average waiting time in queue for interactions queued to the service

ServiceCcCustom3AtStat

import {  Result } from '@telenia/rtdclient';
interface ServiceCcCustom1AtStat {
  answeredCalls: Int | null;
  closedCalls: Int | null;
  closedCallsCallBack: Int | null;
  connectedCall: Int | null;
  currentCalls: Int | null;
  hangupCalls: Int | null;
  maxTimeCallOnQueue: Int | null;
  queuedCalls: Int | null;
  receivedCalls: Int | null;
  receivedCallsInAccessList: Int | null;
  receivedCallsWithT4you: Float | null;
  receivedCallsWithT4youAnonymous: Float | null;
  receivedCallsWithT4youMultiple: Float | null;
  receivedCallsWithT4youSingle: Float | null;  
  shortCalls: Int | null;
  averageTimeOnQueue: Int | null;
}

interface ServiceCcCustom3AtStat {
  answeredCalls;
  closedCalls;
  closedCallsCallBack;
  connectedCall;
  currentCalls;
  hangupCalls;
  maxTimeCallOnQueue;
  queuedCalls;
  receivedCalls;
  receivedCallsInAccessList;
  receivedCallsWithT4you;
  receivedCallsWithT4youAnonymous;
  receivedCallsWithT4youMultiple;
  receivedCallsWithT4youSingle;
  remotelyAnsweredCalls;
  remotelyAnsweredCallsOverSpeedLimit;
  remotelyAnsweredCallsUnderSpeedLimit;
  remotelyConnectedCalls;
  remotelyQueuedCalls;
  shortCalls;
  averageTimeOnQueue;
}

To access this interface use Result.ServiceCcCustom3AtStat

Parameter	Type	Nullable	Description
answeredCalls	Int	yes	Operator's interactions answered
closedCalls	Int	yes	Number of interactions closed on the service in the 'active' context
closedCallsCallBack	Int	yes	Number of callback requests in 'active' context
connectedCall	Int	yes	Number of conversation interactions on agents
currentCalls	Int	yes	Number of interactions in progress on the service in the 'active' context
hangupCalls	Int	yes	Number of abandoned interactions (hung up by the caller) in the "active" context
maxTimeCallOnQueue	Int	yes	Maximum waiting time in queue for interactions queued to the service
queuedCalls	Int	yes	Number of queued calls
receivedCalls	Int	yes	Number of interactions received by the service in an "active" context
receivedCallsInAccessList	Int	yes	Number of interactions received by the service in the 'active' context filtered from the access list (blacklist or whitelist)
receivedCallsWithT4you	Float	yes	Percentage value of interactions received that were answered positively in the directory in an "active" context
receivedCallsWithT4youAnonymous	Float	yes	Percentage of interactions received that received an anonymous response in the directory in an "active" context
receivedCallsWithT4youMultiple	Float	yes	Percentage value of interactions received that have had more than one answer in the directory in an "active" context
receivedCallsWithT4youSingle	Float	yes	Percentage of interactions received that were exactly matched in the directory in an "active" context
remotelyAnsweredCalls	Int	yes	Number of remote interactions (from the Network Contact Center site) that the agent answered
remotelyAnsweredCallsOverSpeedLimit	Int	yes	Number of remote interactions (from the Network Contact Center site) answered by the operator beyond the 'response speed' threshold configured in the TVox-> General settings-> Miscellaneous menu
remotelyAnsweredCallsUnderSpeedLimit	Int	yes	Number of remote interactions (from the Network Contact Center site) answered by the operator within the 'response speed' threshold in the active context configured in the TVox-> General settings-> Miscellaneous menu
remotelyConnectedCalls	Int	yes	Number of conversational interactions from the Network Contact Center remote site
remotelyQueuedCalls	Int	yes	Number of remote interactions (from the Network Contact Center site) in queue
shortCalls	Int	yes	Number of short abandoned calls. A short call is an abandoned call that does not exceed a predetermined duration (e.g. Users who realize they have the wrong number and hang up almost immediately)
averageTimeOnQueue	Int	yes	Average waiting time in queue for interactions queued to the service

ServiceUserStat

import { Indicator } from "@telenia/rtdclient";
interface ServiceUserStat {
  call?: ServiceUserCallStat;
  video?: ServiceUserMultichannelStat;
  chat?: ServiceUserMultichannelStat;
  mailAcd?: ServiceUserMultichannelStat;
  livehelp?: ServiceUserMultichannelStat;  
  custom1?: ServiceUserMultichannelStat;
  custom2?: ServiceUserMultichannelStat;
  custom3?: ServiceUserMultichannelStat;
}

interface ServiceUserStat {
  call;
  video;
  chat;
  mailAcd;
  livehelp;  
  custom1;
  custom2;
  custom3; 
}

To access this interface use Indicator.ServiceUserStat

Parameter	Type	Required	Description
call	ServiceUserCallStat	false	Indicator for Services's call statistics
video	ServiceUserMultichannelStat	false	Indicators for Services's video statistics
chat	ServiceUserMultichannelStat	false	Indicator for Services's chat statistics
mailAcd	ServiceUserMultichannelStat	false	Indicators for Services's mail ACD statistics
livehelp	ServiceUserMultichannelStat	false	Indicator for Services's Live Help statistics
custom1	ServiceUserMultichannelStat	false	Indicators for Services's channel Custom 01 statistics
custom2	ServiceUserMultichannelStat	false	Indicator for Services's channel Custom 02 statistics
custom3	ServiceUserMultichannelStat	false	Indicators for Services's channel Custom 03 statistics

ServiceUserCallStat

import {  Result } from '@telenia/rtdclient';
interface ServiceUserCallStat {
  busyOnDNCallInUsers: UserProfileInStatus | null;
  busyOnDNCallOutUsers: UserProfileInStatus | null;
  busyOnDNCallOutUsersPrivate: UserProfileInStatus | null;
  busyOnDNCallUsers: UserProfileInStatus | null;
  busyOnServUsers: UserProfileInStatus | null;
  busyUsers: UserProfileInStatus | null;
  loggedUsers: UserProfileInStatus | null;
  notReadyUsers: UserProfileInStatus | null;
  notReadyUsersOnActivityCode: UserProfileInStatus | null;
  postCallUsers: UserProfileInStatus | null;
  readyUsers: UserProfileInStatus | null;
}

interface ServiceUserCallStat {
  busyOnDNCallInUsers;
  busyOnDNCallOutUsers;
  busyOnDNCallOutUsersPrivate;
  busyOnDNCallUsers;
  busyOnServUsers;
  busyUsers;
  loggedUsers;
  notReadyUsers;
  notReadyUsersOnActivityCode;
  postCallUsers;
  readyUsers;
}

To access this interface use Result.ServiceUserCallStat

Parameter	Type	Nullable	Description
busyOnDNCallInUsers	UserProfileInStatus	yes	Number of agents engaged in a direct incoming call conversation (DN-Call IN)
busyOnDNCallOutUsers	UserProfileInStatus	yes	Number of agents engaged in conversation for direct outgoing calls (DN-Call OUT)
busyOnDNCallOutUsersPrivate	UserProfileInStatus	yes	Number of agents engaged in a private outgoing call conversation
busyOnDNCallUsers	UserProfileInStatus	yes	Number of agents in conversation for direct calls (DN-Call)
busyOnServUsers	UserProfileInStatus	yes	Number of agents engaged in a service call conversation
busyUsers	UserProfileInStatus	yes	Total number of agents engaged in a telephone conversation
loggedUsers	UserProfileInStatus	yes	Number of logged in agents
notReadyUsers	UserProfileInStatus	yes	Number of agents in Not Ready state
notReadyUsersOnActivityCode	UserProfileInStatus	yes	Number of agents in Not Ready state who have specified an activity code
postCallUsers	UserProfileInStatus	yes	Number of agents in "Post Call Processing" state. It is the timeout configured on each operator to allow the closing of the activities related to the previous service conversation.
readyUsers	UserProfileInStatus	yes	Number of agents in Ready state

ServiceUserMultichannelStat

import {  Result } from '@telenia/rtdclient';
interface ServiceUserMultichannelStat {
  busyOnServUsers: UserProfileInStatus | null;
  busyUsers: UserProfileInStatus | null;
  loggedUsers: UserProfileInStatus | null;
  notReadyUsers: UserProfileInStatus | null;
  notReadyUsersOnActivityCode: UserProfileInStatus | null;
  postCallUsers: UserProfileInStatus | null;
  readyUsers: UserProfileInStatus | null;
}

interface ServiceUserMultichannelStat {
  busyOnServUsers;
  busyUsers;
  loggedUsers;
  notReadyUsers;
  notReadyUsersOnActivityCode;
  postCallUsers;
  readyUsers;
}

To access this interface use Result.ServiceUserMultichannelStat

Parameter	Type	Nullable	Description
busyOnServUsers	UserProfileInStatus	yes	Number of agents engaged in a service interaction conversation
busyUsers	UserProfileInStatus	yes	Total number of agents engaged in a interaction
loggedUsers	UserProfileInStatus	yes	Number of logged in agents
notReadyUsers	UserProfileInStatus	yes	Number of agents in Not Ready state
notReadyUsersOnActivityCode	UserProfileInStatus	yes	Number of agents in Not Ready state who have specified an activity code
postCallUsers	UserProfileInStatus	yes	Number of agents in "Post Call Processing" state. It is the timeout configured on each operator to allow the closing of the activities related to the previous service interaction.
readyUsers	UserProfileInStatus	yes	Number of agents in Ready state

CustomStat

import {  Result } from '@telenia/rtdclient';
interface CustomStat {
  key: String;
  value?: CustomStatValue;
}

interface CustomStat {
  key;
  value;
}

To access this interface use Result.CustomStat

Parameter	Type	Nullable	Description
key	String	no	Custom indicator key
value	CustomStatValue	yes	Custom idicator value

CustomStatValue

import {  Result } from '@telenia/rtdclient';

interface CustomStatValue {
  aggregatedValue?: String;
  value?: String;
}

interface CustomStatValue {
  aggregatedValue;
  value;
}

To access this interface use Result.CustomStatValue

Parameter	Type	Nullable	Description
aggregatedValue	String	yes	Value calculated by aggregating (e.g. sum, average, etc.) the data of the filtered services / skillsets, the calculation logic depends on the custom indicator requested
value	String	yes	Custom idicator stats

Example

Download the example Test here.

After logging in, you can search for services or get users (the default for testing is all registered users).

If you want to search for a specific service, enter the name of the service in the input box to filter it, if you want to have a list of all services, click directly on search

From list, select services to monitor than click generate statistics.

The result of the click Generate statistics is the list of services with the values of its indicators, if you click the Retrieve users button, get the list of users with their statistics.

Download

Download the library here.

Changelog

2.0.0

Added multichannel to RTD, some objects are changed:

Attribute serviceCcCallAtStat of Indicator.ServiceStatsIndicator become specific channel for example call, video, etc..

From:

const stats: Indicator.ServiceStatsIndicator = { channelStats: { serviceCcCallAtStat: { answeredCalls: true, queuedCalls: true, } as Indicator.ServiceCCCallATStatIndicator, } as Indicator.ServiceChannelStatIndicator, userStats: { loggedUsers: true } as Indicator.ServiceStatsUserIndicator, } as Indicator.ServiceStatsIndicator;

To:

const stats: Indicator.ServiceStatsIndicator = { channelStats: { answeredCalls: true, closedCalls: true, call: { openTickets: true, } as Indicator.ServiceCallAtStatIndicator, video: { createdTickets: true, } as Indicator.ServiceVideoAtStatIndicator, } as Indicator.ServiceChannelStatIndicator, userStats: { notReadyUsers: true, loggedUsers: true, call: { busyOnDNCallInUsers: true, }, } as Indicator.ServiceUserStatsIndicator, } as Indicator.ServiceStatsIndicator;

Attribute serviceCcCallAtStat of Result.ServiceStats become specific channel for example call, video, etc..

From:

interface ServiceStats { userStats: ServiceUserStat; channelStats: { serviceCcCallAtStat?: ServiceCcCallATStat; }; customStats: CustomStat[]; }

To:

interface ServiceStats { userStats: ServiceUserStat; channelStats: ServiceChannelStats; customStats: CustomStat[]; }

the same is for skillsets and user objects.

1.0.2

Changed CustomStat indicator interface from

interface CustomStat { key: String; value: String | null; }

interface CustomStat { key: String; value?: CustomStatValue; }

1.0.1

Added the ability to filter sites by skillsets

1.0.0

Added javascript library for Real Time Display for the telephone channel

Introduction

Initialize Rtd Client Instance

Login

Login by Username and Password

Login by AccessToken

Logout

Create Realtime Instance

Get Service Stats Subscription

Update Service Stats Subscription

Get Skillset Stats Subscription

Update Skillset Stats Subscription

Get User Stats Subscription

Update User Stats Subscription

Get User Profile Stats Subscription

Update User Profile Stats Subscription

Search Services

Search Skillsets

Search Live Users

Get Channels List

Get User's Sites

RTDClient

RTDClientLogConfigurator

RTDClientConfig

RTDClientLogConfig

LogLevel

SubscriptionConfig

ConnectionStateEvent

ConnectionStateData

ConnectionStateConnecting

ConnectionStateConnected

ConnectionStateDisconnected

DisconnectedReason

ConnectionState

PanelManager

Panel:

UserStatPanel

UserProfileStatPanel

GroupStatPanel

ServiceStatPanel

Entity

RTDEntityManager

ServiceEntityManager

UserEntityManager

GroupEntityManager

Filter

ServiceStatsFilterData

ServiceChannelStatFilter

GroupStatsFilterData

GroupChannelStatFilter

UserProfileStatFilter

UserProfileStatChannelFilter

UserStatsFilterData

UserStatChannelFilter

Indicator

ServiceStatsIndicator

ServiceStatsUserIndicator

ServiceUserStatsChannelIndicator

ServiceUserStatsCallIndicator

ServiceChannelStatIndicator

ServiceChannelIndicator

ServiceCallAtStatIndicator

ServiceVideoAtStatIndicator

ServiceChatAtStatIndicator

ServiceMultichannelAtStatIndicator

ServiceLivehelpAtStatIndicator

GroupStatsIndicator

GroupStatsIndicator

GroupChannelStatIndicator

GroupStatsUserIndicator

UserProfileInStatusRequest

UserStatsIndicator

UserStatsChannelIndicator

UserStatsCallIndicator

UserProfileStatsIndicator

UserProfileStatsChannelIndicator

UserProfileStatsCallIndicator

TVoxRestClientModels

MultiChannelIdTypeModel

ServiceTypeModel

LoginProfileModel