NAV
Version: 1.0.0
Typescript Javascript
Versions
2.0.0 , 1.0.3 , 1.0.2 , 1.0.1 , 1.0.0

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.

Login

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

Login by Username and Password

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

Login by AccessToken

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"],
  } as Filter.ServiceChannelStatFilter,
};

statsReference.serviceStats.filter = serviceStatsFilter;

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;

statsReference.serviceStats.indicator = stats;

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


var serviceStatsFilter = {
  CALL: {
    services: ["service_code_1", "service_code_2"],
    customStatKeys: ["custom_1", "custom_2"],
  },
};

statsReference.serviceStats.filter = serviceStatsFilter;

var stats = {
  channelStats: {
    serviceCcCallAtStat: {
      answeredCalls: true,
      queuedCalls: true,
    } ,
  } ,
  userStats: { loggedUsers: 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,
};

statsReference.serviceStats.filter = serviceStatsFilter;

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

statsReference.serviceStats.indicator = stats;

statsReference.serviceStats.applyFilterOrIndicator();



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

statsReference.serviceStats.filter = serviceStatsFilter;

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

statsReference.serviceStats.indicator = stats;

statsReference.serviceStats.applyFilterOrIndicator();

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 updated then sent to server when launch the statsReference.serviceStats.applyFilterOrIndicator() method.

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"],
  },
};

statsReference.groupStats.filter = skillsetsStatsFilter;

const stats: Indicator.GroupStatsIndicator = {
  channelStats: {
    groupCcCallStat: {
      answeredCalls: true,
      queuedCalls: true,
    } as Indicator.GroupCcCallStatIndicator,
  } as Indicator.GroupChannelStatIndicator,
  userStats: { loggedUsers: true } as Indicator.GroupStatsUserIndicator,
} as Indicator.GroupStatsIndicator;
statsReference.groupStats.indicator = stats;

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


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

statsReference.groupStats.filter = skillsetsStatsFilter;

var stats = {
  channelStats: {
    groupCcCallStat: {
      answeredCalls: true,
      queuedCalls: true,
    },
  },
  userStats: { loggedUsers: true },
};
statsReference.groupStats.indicator = stats;

statsReference.groupStats.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"],    
  },
};

statsReference.groupStats.filter = skillsetsStatsFilter;

const stats: Indicator.GroupStatsIndicator = {
  channelStats: {
    groupCcCallStat: {
      answeredCalls: true,
      queuedCalls: true,
      hangupCalls: true,
    } as Indicator.GroupCcCallStatIndicator,
  } as Indicator.GroupChannelStatIndicator,
  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"],      
  },
};

statsReference.groupStats.filter = skillsetsStatsFilter;

var stats = {
  channelStats: {
    groupCcCallStat: {
      answeredCalls: true,
      queuedCalls: true,
      hangupCalls: true,
    },
  },
  userStats: { loggedUsers: true },
};
statsReference.groupStats.indicator = stats;

statsReference.groupStats.applyFilterOrIndicator();

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 updated then sent to server when launch the statsReference.serviceStats.applyFilterOrIndicator() method.

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"] },
};

statsReference.userStats.filter = usersStatsFilter;

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

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


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

statsReference.userStats.filter = usersStatsFilter;

var stats = {
  name: true,
  surname: true,
  channel: true,
  activityCode: 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"] },
};

statsReference.userStats.filter = usersStatsFilter;

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

statsReference.userStats.applyFilterOrIndicator();


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

statsReference.userStats.filter = usersStatsFilter;

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

statsReference.userStats.applyFilterOrIndicator();

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 updated then sent to server when launch the statsReference.serviceStats.applyFilterOrIndicator() method.

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] },
};

statsReference.userProfileStats.filter = usersStatsFilter;

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

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



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

statsReference.userProfileStats.filter = usersStatsFilter;

var stats = {
  name: true,
  surname: true,
  channel: true,
  activityCode: 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] },
};

statsReference.userProfileStats.filter = usersStatsFilter;

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

statsReference.userProfileStats.applyFilterOrIndicator();



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

statsReference.userProfileStats.filter = usersStatsFilter;

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

statsReference.userProfileStats.applyFilterOrIndicator();

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 updated then sent to server when launch the statsReference.serviceStats.applyFilterOrIndicator() method.

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.SearchServiceLiteRequestModel = {
  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.SearchResultServiceBaseModel>

Search Skillsets

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

const pageSize = 10;
const pageNumber = 1;

const criteriaModel: TVoxRestClientModels.SearchCriteriaStringModel = {
  operation:
    TVoxRestClientModels.SearchCriteriaStringModelOperationModelEnum.CONTAINS,
  value: search_term,
};

const criteriaType: TVoxRestClientModels.SearchCriteriaSkillsetTypeModel = {
  operation:
    TVoxRestClientModels.SearchCriteriaSkillsetTypeModelOperationModelEnum
      .CONTAINS,
  value: TVoxRestClientModels.SkillsetTypeModel.CALLCENTER,
};
const skillsetCriterias: TVoxRestClientModels.SkillsetsSearchCriteriaModel = {
  skillset: criteriaModel,
  description: criteriaModel,
  type: criteriaType,
};
const request: TVoxRestClientModels.SearchRequestSkillsetsSearchCriteriaSortFieldModel = {
  exclusions: [skillset_1, skillset_2],
  criterias: skillsetCriterias,
  size: pageSize,
  page: pageNumber,
};
client.entity.group.search(request);

var pageSize = 10;
var pageNumber = 1;

var criteriaModel = {
  operation:'CONTAINS',
  value: search_term,
};

var criteriaType = {
  operation: 'CONTAINS',
  value: 'CALLCENTER',
};
var skillsetCriterias = {
  skillset: criteriaModel,
  description: criteriaModel,
  type: criteriaType,
};
var request:  = {
  exclusions: [skillset_1, skillset_2],
  criterias: skillsetCriterias,
  size: pageSize,
  page: pageNumber,
};
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.SearchResultSkillsetModel>

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.SearchResultServiceBaseModel>;
  searchByGroup(
    request: SearchServiceBySkillsetRequest
  ): Promise<TVoxRestClientModels.SearchResultServiceModel>;
}

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

To access this class use ServiceEntity.ServiceEntityManager

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

GroupEntityManager

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

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

To access this class use GroupEntity.GroupEntityManager

Filter

ServiceStatsFilterData

import { Filter } from "@telenia/rtdclient";
interface ServiceStatsFilterData {
    CALL?: ServiceChannelStatFilter | null;
}

interface ServiceStatsFilterData {
    CALL;
}

To access this interface use Filter.ServiceStatsFilterData

Parameter Type Required Description
CALL ServiceChannelStatFilter false Filter service for channel Call

ServiceChannelStatFilter

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

interface ServiceChannelStatFilter {
    services;
    customStatKeys;
    userSite;
}

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

GroupStatsFilterData

import { Filter } from "@telenia/rtdclient";
interface GroupStatsFilterData {
    CALL?: GroupChannelStatFilter | null;
}

interface GroupStatsFilterData {
    CALL;
}

To access this interface use Filter.GroupStatsFilterData

Parameter Type Required Description
CALL GroupChannelStatFilter false Filter skillset for channel Call

GroupChannelStatFilter

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

interface GroupChannelStatFilter {
    groups;
    customStatKeys?;
}

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

UserProfileStatFilter

import { Filter } from "@telenia/rtdclient";
interface UserProfileStatFilter {
    CALL?: UserProfileStatChannelFilter | null;
}

interface UserProfileStatFilter {
    CALL;
}

To access this interface use Filter.UserProfileStatFilter

Parameter Type Required Description
CALL UserProfileStatChannelFilter false Filter users profiles ids for channel Call

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;
}

interface UserStatsFilterData {
     CALL;
}

To access this interface use Filter.UserStatsFilterData

Parameter Type Required Description
CALL UserStatChannelFilter false Filter users by usernames for channel Call

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

ServiceChannelStatIndicator

import { Indicator } from "@telenia/rtdclient";
interface ServiceChannelStatIndicator {
  serviceCcCallAtStat?: ServiceCCCallATStatIndicator;
}

interface ServiceChannelStatIndicator {
  serviceCcCallAtStat;
}

To access this interface use Indicator.ServiceChannelStatIndicator

Parameter Type Required Description
serviceCcCallAtStat ServiceCCCallATStatIndicator false Indicator for services's contact center call statistics

ServiceCCCallATStatIndicator

import { Indicator } from "@telenia/rtdclient";
interface ServiceCCCallATStatIndicator {
    answeredCalls?: boolean;
    closedCalls?: boolean;
    closedCallsCallBack?: boolean;
    connectedCall?: boolean;
    currentCalls?: boolean;
    hangupCalls?: boolean;
    maxTimeCallOnQueue?: boolean;
    outboundAnsweredCalls?: boolean;
    outboundClosedCallsGenericCause?: boolean;
    outboundHangupCalls?: boolean;
    outboundReceivedCalls?: boolean;
    queuedCalls?: boolean;
    receivedCalls?: boolean;
    receivedCallsInAccessList?: boolean;
    receivedCallsWithT4you?: boolean;
    receivedCallsWithT4youAnonymous?: boolean;
    receivedCallsWithT4youMultiple?: boolean;
    receivedCallsWithT4youSingle?: boolean;
    remotelyAnsweredCalls?: boolean;
    remotelyAnsweredCallsOverSpeedLimit?: boolean;
    remotelyAnsweredCallsUnderSpeedLimit?: boolean;
    remotelyConnectedCalls?: boolean;
    remotelyQueuedCalls?: boolean;
    shortCalls?: boolean;
}

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

To access this interface use Indicator.ServiceCCCallATStatIndicator

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
closedCallsCallBack boolean false Number of callback requests in 'active' context
connectedCall boolean false Number of conversation calls on agents
currentCalls boolean false Number of calls in progress on the service in the 'active' context
hangupCalls boolean false Number of abandoned calls (hung up by the caller) in the "active" context
maxTimeCallOnQueue boolean false Maximum waiting time in queue for calls queued to the service
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
queuedCalls boolean false Number of queued calls
receivedCalls boolean false Number of calls received by the service in an "active" context
receivedCallsInAccessList boolean false Number of calls received by the service in the 'active' context filtered from the access list (blacklist or whitelist)
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
remotelyAnsweredCalls boolean false Number of remote calls (from the Network Contact Center site) that the agent answered
remotelyAnsweredCallsOverSpeedLimit boolean false 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 boolean false 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 boolean false Number of conversational calls from the Network Contact Center remote site
remotelyQueuedCalls boolean false Number of remote calls (from the Network Contact Center site) in queue
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)

ServiceStatsUserIndicator

import { Indicator } from "@telenia/rtdclient";
interface ServiceUserStatRequest {
    busyOnDNCallInUsers?: UserProfileInStatusRequest;
    busyOnDNCallOutUsers?: UserProfileInStatusRequest;
    busyOnDNCallOutUsersPrivate?: UserProfileInStatusRequest;
    busyOnDNCallUsers?: UserProfileInStatusRequest;
    busyOnServUsers?: UserProfileInStatusRequest;
    busyUsers?: UserProfileInStatusRequest;
    loggedUsers?: UserProfileInStatusRequest;
    notReadyUsers?: UserProfileInStatusRequest;
    notReadyUsersOnActivityCode?: UserProfileInStatusRequest;
    postCallUsers?: UserProfileInStatusRequest;
    readyUsers?: UserProfileInStatusRequest;
}

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

To access this interface use Indicator.ServiceUserStatRequest

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)
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

GroupStatsIndicator

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

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 GroupChannelStatIndicator false Indicators for skillsets's channels statistics

GroupChannelStatIndicator

import { Indicator } from "@telenia/rtdclient";
interface GroupChannelStatIndicator {
  groupCcCallStat?: GroupCcCallStatIndicator;  
}

interface GroupChannelStatIndicator {
  groupCcCallStat;
}

To access this interface use Indicator.GroupChannelStatIndicator

Parameter Type Required Description
groupCcCallStat GroupCcCallStatIndicator false Indicator for services's contact center call statistics

GroupCcCallStatIndicator

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

interface GroupCcCallStatIndicator {
  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 {
  id?: boolean;
  userSite?: boolean;
  channel?: boolean;
  activityCode?: boolean;
  activityCode2?: boolean;
  currentGroup?: boolean;
  currentService?: boolean;
  numberCallFromService?: boolean;
  numberCallFromServiceAnswered?: boolean;
  numberCallFromServiceNotAnswered?: boolean;
  numberCallIn?: boolean;
  numberCallOut?: boolean;
  numberCallOutPrivate?: boolean;
  numberCallServiceOverSpeedAnswer?: boolean;
  status?: boolean;
  timeInActivityCode?: boolean;
  timeInActivityCodeStateBusy?: boolean;
  timeInActivityCodeStateNotReady?: boolean;
  timeInState?: boolean;
  timeInStateBooked?: boolean;
  timeInStateBusy?: boolean;
  timeInStateBusyDnCallIn?: boolean;
  timeInStateBusyDnCallOut?: boolean;
  timeInStateBusyDnCallOutPrivate?: boolean;
  timeInStateBusyOnService?: boolean;
  timeInStateNotReady?: boolean;
  timeInStateReady?: boolean;
  timeInStateWNR?: boolean;  
  timeInHold?: boolean;
  timeInActivityCode?: boolean;
  timeInActivityCodeStateBusy?: boolean;
  timeInActivityCodeStateNotReady?: boolean;
}

interface UserStatsIndicator {
  id;
  userSite;
  channel;
  activityCode;
  activityCode2;
  currentGroup;
  currentService;
  numberCallFromService;
  numberCallFromServiceAnswered;
  numberCallFromServiceNotAnswered;
  numberCallIn;
  numberCallOut;
  numberCallOutPrivate;
  numberCallServiceOverSpeedAnswer;
  status;
  timeInActivityCode;
  timeInActivityCodeStateBusy;
  timeInActivityCodeStateNotReady;
  timeInState;
  timeInStateBooked;
  timeInStateBusy;
  timeInStateBusyDnCallIn;
  timeInStateBusyDnCallOut;
  timeInStateBusyDnCallOutPrivate;
  timeInStateBusyOnService;
  timeInStateNotReady;
  timeInStateReady;
  timeInStateWNR;
  timeInHold;  
  timeInActivityCode;
  timeInActivityCodeStateBusy;
  timeInActivityCodeStateNotReady;
}

To access this interface use Indicator.UserStatsIndicator

Parameter Type Required Description
id boolean false Profile id
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
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
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)
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
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
timeInHold boolean false Hold time for service calls

UserProfileStatsIndicator

import { Indicator } from "@telenia/rtdclient";
interface UserProfileStatsIndicator {
  id?: boolean;
  userSite?: boolean;
  channel?: boolean;
  activityCode?: boolean;
  activityCode2?: boolean;
  currentGroup?: boolean;
  currentService?: boolean;
  numberCallFromService?: boolean;
  numberCallFromServiceAnswered?: boolean;
  numberCallFromServiceNotAnswered?: boolean;
  numberCallIn?: boolean;
  numberCallOut?: boolean;
  numberCallOutPrivate?: boolean;
  numberCallServiceOverSpeedAnswer?: boolean;
  status?: boolean;
  timeInActivityCode?: boolean;
  timeInActivityCodeStateBusy?: boolean;
  timeInActivityCodeStateNotReady?: boolean;
  timeInState?: boolean;
  timeInStateBooked?: boolean;
  timeInStateBusy?: boolean;
  timeInStateBusyDnCallIn?: boolean;
  timeInStateBusyDnCallOut?: boolean;
  timeInStateBusyDnCallOutPrivate?: boolean;
  timeInStateBusyOnService?: boolean;
  timeInStateNotReady?: boolean;
  timeInStateReady?: boolean;
  timeInStateWNR?: boolean;  
  timeInHold?: boolean;
  timeInActivityCode?: boolean;
  timeInActivityCodeStateBusy?: boolean;
  timeInActivityCodeStateNotReady?: boolean;
}

interface UserProfileStatsIndicator {
  id;
  userSite;
  channel;
  activityCode;
  activityCode2;
  currentGroup;
  currentService;
  numberCallFromService;
  numberCallFromServiceAnswered;
  numberCallFromServiceNotAnswered;
  numberCallIn;
  numberCallOut;
  numberCallOutPrivate;
  numberCallServiceOverSpeedAnswer;
  status;
  timeInActivityCode;
  timeInActivityCodeStateBusy;
  timeInActivityCodeStateNotReady;
  timeInState;
  timeInStateBooked;
  timeInStateBusy;
  timeInStateBusyDnCallIn;
  timeInStateBusyDnCallOut;
  timeInStateBusyDnCallOutPrivate;
  timeInStateBusyOnService;
  timeInStateNotReady;
  timeInStateReady;
  timeInStateWNR;  
  timeInHold;
  timeInActivityCode;
  timeInActivityCodeStateBusy;
  timeInActivityCodeStateNotReady;
}

To access this interface use Indicator.UserProfileStatsIndicator

Parameter Type Required Description
id boolean false Profile id
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
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
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)
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
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
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

SkillsetModel

interface SkillsetModel {
    skillset?: string;
    descrizione?: string;
    type?: SkillsetTypeModel;
}

interface SkillsetModel {
    skillset;
    descrizione;
    type;
}
Parameter Type Optional Description
skillset string true Skillset code
descrizione string true Skillset Description
type SkillsetTypeModel true Skillset Type

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

SearchResultServiceBaseModel

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

interface SearchResultServiceBaseModel {
    tot;
    result;
}
Parameter Type Optional Description
tot number true Total number of services
result Array<ServiceBaseModel> 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 SearchResultServiceModel {
    id?: number;
    name?: string;
}

interface SearchResultServiceModel {
    id;
    name;
}
Parameter Type Optional Description
id number true Site id
name string true Site name

ActivityCodeModel

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

interface SearchResultServiceModel {
  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 SearchResultServiceModel {
  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 SearchResultServiceModel {
  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

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

SearchResultSkillsetModel

interface SearchResultSkillsetModel {
  tot?: number;
  result?: Array<SkillsetModel>;
}

interface SearchResultSkillsetModel {
  tot;
  result;
}
Parameter Type Optional Description
tot number true Total number of skillsets
result Array<TVoxUserModel> 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;
  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;
  numberCallOut: Int | null;
  numberCallOutPrivate: 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;
  timeInStateBusyDnCallIn: Int | null;
  timeInStateBusyDnCallOut: Int | null;
  timeInStateBusyDnCallOutPrivate: Int | null;
  timeInStateBusyOnService: Int | null;
  timeInStateNotReady: Int | null;
  timeInStateReady: Int | null;
  timeInStateWNR: Int | null;
}

interface UserStats {
  username;
  name;
  surname;
  userSite;
  loggedProfileId;
  channel;
  activityCode;
  activityCode2;
  currentGroup;
  currentService;
  numberCallFromService;
  numberCallFromServiceAnswered;
  numberCallFromServiceNotAnswered;
  numberCallIn;
  numberCallOut;
  numberCallOutPrivate;
  numberCallServiceOverSpeedAnswer;
  status;
  timeInActivityCode;
  timeInActivityCodeStateBusy;
  timeInActivityCodeStateNotReady;
  timeInState;
  timeInStateBooked;
  timeInStateBusy;
  timeInStateBusyDnCallIn;
  timeInStateBusyDnCallOut;
  timeInStateBusyDnCallOutPrivate;
  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
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
numberCallOut Int yes Total number of calls made by the agent
numberCallOutPrivate Int yes Total number of private calls made
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)
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
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

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;
  numberCallFromService: Int | null;
  numberCallFromServiceAnswered: Int | null;
  numberCallFromServiceNotAnswered: Int | null;
  numberCallIn: Int | null;
  numberCallOut: Int | null;
  numberCallOutPrivate: 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;
  timeInStateBusyDnCallIn: Int | null;
  timeInStateBusyDnCallOut: Int | null;
  timeInStateBusyDnCallOutPrivate: Int | null;
  timeInStateBusyOnService: Int | null;
  timeInStateNotReady: Int | null;
  timeInStateReady: Int | null;
  timeInStateWNR: Int | null;
  timeInHold: TimeInHold | null;
}

interface UserProfileStats {
  id;
  userSite;
  channel;
  activityCode;
  activityCode2;
  currentGroup;
  currentService;
  numberCallFromService;
  numberCallFromServiceAnswered;
  numberCallFromServiceNotAnswered;
  numberCallIn;
  numberCallOut;
  numberCallOutPrivate;
  numberCallServiceOverSpeedAnswer;
  status;
  timeInActivityCode;
  timeInActivityCodeStateBusy;
  timeInActivityCodeStateNotReady;
  timeInState;
  timeInStateBooked;
  timeInStateBusy;
  timeInStateBusyDnCallIn;
  timeInStateBusyDnCallOut;
  timeInStateBusyDnCallOutPrivate;
  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
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
numberCallOut Int yes Total number of calls made by the agent
numberCallOutPrivate Int yes Total number of private calls made
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)
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
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
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: {
    groupCcCallStat?: GroupCcCallStat;
  }
  customStats: CustomStat[];
}

interface GroupStats {
  userStats: GroupUserStat;
  channelStats: {
    groupCcCallStat?: GroupCcCallStat;
  }
  customStats: CustomStat[];
}

To access this interface use Result.GroupStats

Parameter Type Nullable Description
userStats GroupUserStat no Skillset user statistics
groupCcCallStat GroupCcCallStat no Skillset statistics
customStats CustomStat[] no Skillset custom indicator 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)

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: {
    serviceCcCallAtStat?: ServiceCcCallATStat;
  };
  customStats: CustomStat[];
}

interface ServiceStats {
  userStats;
  channelStats: {
    serviceCcCallAtStat;
  };
  customStats;
}

To access this interface use Result.ServiceStats

Parameter Type Nullable Description
userStats ServiceUserStat no Services user statistics
serviceCcCallAtStat ServiceCcCallATStat no Services statistics
customStats CustomStat[] no Services custom indicator 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;
  remotelyAnsweredCalls: Int | null;
  remotelyAnsweredCallsOverSpeedLimit: Int | null;
  remotelyAnsweredCallsUnderSpeedLimit: Int | null;
  remotelyConnectedCalls: Int | null;
  remotelyQueuedCalls: Int | null;
  shortCalls: 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;
}

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)

ServiceUserStat

import {  Result } from '@telenia/rtdclient';
interface ServiceUserStat {
  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 ServiceUserStat {
  busyOnDNCallInUsers;
  busyOnDNCallOutUsers;
  busyOnDNCallOutUsersPrivate;
  busyOnDNCallUsers;
  busyOnServUsers;
  busyUsers;
  loggedUsers;
  notReadyUsers;
  notReadyUsersOnActivityCode;
  postCallUsers;
  readyUsers;
}

To access this interface use Result.ServiceUserStat

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

CustomStat

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

interface CustomStat {
  key;
  value;
}

To access this interface use Result.CustomStat

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

Example

Download the example Test here.

Login with TVox credentials to start monitor the system with correct permissions UserPermissionModel.

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; }

to

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

Typescript Javascript