www.pudn.com > lucent_softphone.rar > tlibrary.h

/*  
 * $Id: tlibrary.h,v 2.38 1999/09/15 19:50:40 epi Exp $ 
 */ 
 
#ifndef _TLIBRARY_H 
#define _TLIBRARY_H 
 
#ifdef BACKUP_SYNC 
#ifndef WIN32 
#include  
#include  
#include  
#ifdef _AIX 
#include  
#endif 
#else 
#include  
#include  
#include  
#include  
#endif 
#endif 
 
#include "cmntypes.h" 
#include "gkvlist.h" 
 
#define T_PROTOCOL_VERSION "tserver protocol 4.2" 
 
#define T_MASK_LENGTH 64 
 
#define ISCC_TRACKING_NUMBER "_ISCC_TRACKING_NUMBER_"   
 
typedef int TServer; 
typedef char *TDirectoryNumber; 
typedef char *TAgentID; 
typedef char *TAgentPassword; 
typedef unsigned long TCallID; 
typedef unsigned long TFile; 
typedef unsigned long TTime; 
typedef unsigned char TMask[T_MASK_LENGTH]; 
typedef unsigned int TReferenceID; 
 
typedef enum { 
  SyncMode, 
  AsyncMode 
} TOpenMode; 
 
typedef enum { 
  RoleUnknown, 
  RoleOrigination, 
  RoleDestination, 
  RoleConferenceMember, 
  RoleNewParty, 
  RoleAddedBy, 
  RoleDeletedBy, 
  RoleTransferredBy, 
  RoleDeletedParty, 
  RoleConferencedBy, 
  RoleObserver 
} TDNRole; 
 
typedef enum { 
  CallStateOk, 
  CallStateTransferred, 
  CallStateConferenced, 
  CallStateGeneralError, 
  CallStateSystemError, 
  CallStateRemoteRelease, 
  CallStateBusy, 
  CallStateNoAnswer, 
  CallStateSitDetected, 
  CallStateAnsweringMachineDetected, 
  CallStateAllTrunksBusy, 
  CallStateSitInvalidnum, 
  CallStateSitVacant, 
  CallStateSitIntercept, 
  CallStateSitUnknown, 
  CallStateSitNocircuit, 
  CallStateSitReorder, 
  CallStateFaxDetected, 
  CallStateQueueFull, 
  CallStateCleared, 
  CallStateOverflowed, 
  CallStateAbandoned, 
  CallStateRedirected, 
  CallStateForwarded, 
  CallStateConsult, 
  CallStatePickedup, 
  CallStateDropped, 
  CallStateDroppednoanswer, 
  CallStateUnknown, 
  CallStateCovered, /* 5/5/98 */ 
  CallStateConverseOn, 
  CallStateBridged, 
 
  CallStateDeafened = 49, /* added 9/15/99 by epi */ 
  CallStateHeld     = 50  /* (see common/gcti.h)  */ 
 
} TCallState; 
 
typedef enum { 
  AddressTypeUnknown, 
  AddressTypeDN, 
  AddressTypePosition, 
  AddressTypeQueue, 
  AddressTypeRouteDN, 
  AddressTypeTrunk, 
  AddressTypeVoiceChannel, 
  AddressTypeDataChannel, 
  AddressTypeAnnouncement, 
  AddressTypeASAI, 
  AddressTypeACDGroup, 
  AddressTypeVSP, 
  AddressTypeRouteQueue, /* RouteDN + Queue    */ 
  AddressTypeAgentID,    /* not a real address */ 
  AddressTypeOther = 99  /* other/unspecified  */ 
} TAddressType; 
 
typedef enum { 
  ModeShare, 
  ModePrivate, 
  ModeMonitor 
} TRegisterMode; 
 
typedef enum { 
  RegisterDefault, 
  RegisterForce, 
  RegisterLocal 
} TControlMode; 
 
typedef enum { 
  CallTypeUnknown, 
  CallTypeInternal, 
  CallTypeInbound, 
  CallTypeOutbound, 
  CallTypeConsult 
} TCallType; 
 
typedef enum { 
  AgentWorkModeUnknown, 
  AgentManualIn, 
  AgentAutoIn, 
  AgentAfterCallWork, 
  AgentAuxWork, 
  AgentNoCallDisconnect 
} TAgentWorkMode; 
 
enum _TRouteType { 
  RouteTypeUnknown, 
  RouteTypeDefault, 
  RouteTypeLabel, 
  RouteTypeOverwriteDNIS, 
  RouteTypeDDD, 
  RouteTypeIDDD, 
  RouteTypeDirect, 
  RouteTypeReject, 
  RouteTypeAnnouncement, 
  RouteTypePostFeature, 
  RouteTypeDirectAgent, 
  RouteTypePriority, 
  RouteTypeDirectPriority, 
 
  RouteTypeAgentID, /* OtherDN = AgentID; added 8/10/99 */ 
 
  RouteTypeIDMAX 
}; 
typedef enum _TRouteType TRouteType; 
 
typedef enum { 
  XRouteTypeRoute, 
  XRouteTypeDirect, 
  XRouteTypeDirectWToken 
} TXRouteType; 
 
typedef enum { 
  MakeCallRegular, 
  MakeCallDirectAgent, 
  MakeCallSupervisorAssist, 
  MakeCallPriority, 
  MakeCallDirectPriority 
} TMakeCallType; 
 
typedef enum { 
  AddressStatusIdle, 
  AddressStatusOrigination, 
  AddressStatusDialing, 
  AddressStatusTalking, 
  AddressStatusRinging, 
  AddressStatusHeld, 
  AddressStatusTreatment, 
  AddressStatusLockedOut, 
  AddressStatusMaintenance, 
  AddressStatusAvailable, 
  AddressStatusVacant 
} AddressStatusInfoType; 
 
typedef enum { 
  MsgWaitingActivated, 
  MsgWaitingDeactivated, 
  ExecMsgWaitingActivated, 
  ExecMsgWaitingDeactivated, 
  MsgWaitingNotAllowed 
} MsgWaitingInfoType; 
 
typedef enum { 
  ForwardModeNone, 
  ForwardModeUnconditional, 
  ForwardModeOnBusy, 
  ForwardModeOnNoAnswer, 
  ForwardModeOnBusyAndNoAnswer, 
  ForwardModeSendAllCalls 
} TForwardMode; 
 
typedef enum { 
  AssociatedToThisSession, 
  AssociatedToAnotherSession, 
  NotAssociated, 
  AssociationNotAllowed 
} AssociationInfoType; 
 
typedef enum { 
  AddressInfoAddressStatus, 
  AddressInfoMessageWaitingStatus, 
  AddressInfoAssociationStatus, 
  AddressInfoCallForwardingStatus, 
  AddressInfoAgentStatus, 
  AddressInfoNumberOfAgentsInQueue, 
  AddressInfoNumberOfAvailableAgentsInQueue, 
  AddressInfoNumberOfCallsInQueue, 
  AddressInfoAddressType, 
  AddressInfoCallsQuery, 
  AddressInfoSendAllCallsStatus, 
  AddressInfoQueueLoginAudit, 
  AddressInfoNumberOfIdleClassifiers,  /* obsolete, use TSwitchQuery instead */ 
  AddressInfoNumberOfClassifiersInUse, /* obsolete, use TSwitchQuery instead */ 
  AddressInfoNumberOfIdleTrunks, 
  AddressInfoNumberOfTrunksInUse, 
  AddressInfoDatabaseValue, 
  AddressInfoDNStatus, 
  AddressInfoQueueStatus 
} TAddressInfoType; 
 
typedef enum { 
  CallInfoPartiesQuery, 
  CallInfoStatusQuery 
} TCallInfoType; 
 
typedef enum { 
  SwitchInfoDateTime       = 1, 
  SwitchInfoClassifierStat = 2 
} TSwitchInfoType; 
 
 
typedef enum { 
  LocationInfoAllLocations, 
  LocationInfoLocationData, 
  LocationInfoMonitorLocation, 
  LocationInfoCancelMonitorLocation, 
  LocationInfoMonitorAllLocations, 
  LocationInfoCancellMonitorAllLocations, 
  LocationInfoLocationMonitorCanceled, 
  LocationInfoAllLocationsMonitorCanceled 
} TLocationInfoType; 
 
 
typedef union { 
  AssociationInfoType AssociationStatus; 
  AddressStatusInfoType AddressStatus; 
  MsgWaitingInfoType MsgWaitingStatus; 
  TForwardMode CallForwardingStatus; 
  TAgentWorkMode AgentStatus; 
  int NumberOfAgentsInQueue; 
  int NumberOfAvailableAgentsInQueue; 
  int NumberOfCallsInQueue; 
  TAddressType AddressType; 
  TForwardMode SendAllCallsStatus; 
  int NumberOfIdleClassifiers;  /* obsolete */ 
  int NumberOfClassifiersInUse; /* obsolete */ 
  int NumberOfIdleTrunks; 
  int NumberOfTrunksInUse; 
  int NumberOfListElements; /* value passed in AttributeExtensions */ 
} TAddressInfoStatus; 
 
typedef enum { 
  ServerRolePrimary, 
  ServerRoleBackup 
} TServerRole; 
 
typedef enum { 
  MergeForTransfer, 
  MergeForConference 
} TMergeType; 
 
typedef enum { 
  AgentTypeAgent, 
  AgentTypeSupervisor 
} TAgentType; 
 
typedef enum { 
  Uninterruptable = 1, 
  Interruptable = 2 
} TInterruptFlag; 
 
typedef enum { 
  Clear = 1, 
  NotClear = 2 
} TClearFlag; 
 
typedef struct { 
  char 	*HomeLocation; 
  TDirectoryNumber OrigDN; 
} TRemoteParty; 
 
typedef struct { 
  TRemoteParty FirstTransfer; 
  TRemoteParty LastTransfer; 
} TCallHistoryInfo; 
 
typedef enum { 
  CreateCallInfo, 
  SetCallInfo, 
  DeleteCallInfo, 
  AddParty, 
  DeleteParty, 
  CallInfoUpdate 
} TSetOpType; 
 
typedef struct { 
  unsigned long seconds; 
  unsigned long useconds; 
} TTimeStamp; 
 
enum _TTreatmentType { 
  TreatmentUnknown, 
  TreatmentIVR, 
  TreatmentMusic, 
  TreatmentRingBack, 
  TreatmentSilence, 
  TreatmentBusy, 
  TreatmentCollectDigits, 
  TreatmentPlayAnnouncement, 
  TreatmentPlayAnnouncementAndDigits, 
  TreatmentVerifyDigits, 
  TreatmentRecordUserAnnouncement, 
  TreatmentDeleteUserAnnouncement, 
  TreatmentCancelCall, 
  TreatmentPlayApplication, 
  TreatmentSetDefaultRoute, 
  TreatmentTextToSpeech, 
  TreatmentTextToSpeechAndDigits, 
 
  TreatmentFastBusy, /* added for DMS-100 */ 
  TreatmentRAN,      /* Sep 21, 1998      */ 
 
  TreatmentIDMAX 
}; 
 
typedef enum _TTreatmentType TTreatmentType; 
 
enum TMessageType { 
  RequestRegisterClient, 
  RequestQueryServer, 
  RequestQueryAddress, 
  RequestRegisterAddress, 
  RequestUnregisterAddress, 
  RequestRegisterAll, 
  RequestUnregisterAll, 
  RequestSetInputMask, 
  RequestAgentLogin, 
  RequestAgentLogout, 
  RequestAgentReady, 
  RequestAgentNotReady, 
  RequestSetDNDOn, 
  RequestSetDNDOff, 
  RequestMakeCall, 
  RequestMakePredictiveCall, 
  RequestAnswerCall, 
  RequestReleaseCall, 
  RequestHoldCall, 
  RequestRetrieveCall, 
  RequestInitiateConference, 
  RequestCompleteConference, 
  RequestDeleteFromConference, 
  RequestInitiateTransfer, 
  RequestMuteTransfer, 
  RequestSingleStepTransfer, 
  RequestCompleteTransfer, 
  RequestMergeCalls, 
  RequestAlternateCall, 
  RequestReconnectCall, 
  RequestAttachUserData, 
  RequestUpdateUserData, 
  RequestDeleteUserData, 
  RequestDeletePair, 
  RequestCallForwardSet, 
  RequestCallForwardCancel, 
  RequestRouteCall, 
  RequestGiveMusicTreatment, 
  RequestGiveSilenceTreatment, 
  RequestGiveRingBackTreatment, 
  RequestLoginMailBox, 
  RequestLogoutMailBox, 
  RequestOpenVoiceFile, 
  RequestCloseVoiceFile, 
  RequestPlayVoiceFile, 
  RequestCollectDigits, 
  RequestSetMessageWaitingOn, 
  RequestSetMessageWaitingOff, 
  RequestDistributeUserEvent, 
  RequestDistributeEvent, 
 
  EventServerConnected, 
  EventServerDisconnected, 
  EventError, 
  EventRegistered, 
  EventUnregistered, 
  EventRegisteredAll, 
  EventUnregisteredAll, 
  EventQueued, 
  EventDiverted, 
  EventAbandoned, 
  EventRinging, 
  EventDialing, 
  EventNetworkReached, 
  EventDestinationBusy, 
  EventEstablished, 
  EventReleased, 
  EventHeld, 
  EventRetrieved, 
  EventPartyChanged, 
  EventPartyAdded, 
  EventPartyDeleted, 
  EventRouteRequest, 
  EventRouteUsed, 
  EventAgentLogin, 
  EventAgentLogout, 
  EventAgentReady, 
  EventAgentNotReady, 
  EventDNDOn, 
  EventDNDOff, 
  EventMailBoxLogin, 
  EventMailBoxLogout, 
  EventVoiceFileOpened, 
  EventVoiceFileClosed, 
  EventVoiceFileEndPlay, 
  EventDigitsCollected, 
  EventAttachedDataChanged, 
  EventOffHook, 
  EventOnHook, 
  EventForwardSet, 
  EventForwardCancel, 
  EventMessageWaitingOn, 
  EventMessageWaitingOff, 
  EventAddressInfo, 
  EventServerInfo, 
  EventLinkDisconnected, 
  EventLinkConnected, 
  EventUserEvent, 
 
  RequestSendDTMF, 
  EventDTMFSent, 
 
  EventResourceAllocated, 
  EventResourceFreed, 
 
  EventRemoteConnectionSuccess, 
  EventRemoteConnectionFailed, 
 
  RequestRedirectCall, 
  RequestListenDisconnect, 
  RequestListenReconnect, 
  EventListenDisconnected, 
  EventListenReconnected, 
  RequestQueryCall, 
  EventPartyInfo, 
  RequestClearCall, 
 
  RequestSetCallInfo, 
  EventCallInfoChanged, 
 
  RequestApplyTreatment, 
  EventTreatmentApplied, 
  EventTreatmentNotApplied, 
  EventTreatmentEnd, 
 
  EventHardwareError, 
  EventAgentAfterCallWork, 
  EventTreatmentRequired, 
 
  RequestSingleStepConference, 
  RequestQuerySwitch, 
  EventSwitchInfo, 
 
  RequestGetAccessNumber, 
  RequestCancelReqGetAccessNumber, 
  EventAnswerAccessNumber, 
  EventReqGetAccessNumberCanceled, 
 
  RequestReserveAgent, 
  EventAgentReserved, 
  RequestReserveAgentAndGetAccessNumber, 
 
  RequestAgentSetIdleReason, 
  EventAgentIdleReasonSet, 
 
  EventRestoreConnection, 
  EventPrimaryChanged, 
  RequestLostBackupConnection, 
  RequestSetDNInfo, 
 
  RequestQueryLocation, 
  EventLocationInfo, 
 
  EventACK, 
 
  MessageIDMAX 
};  
 
enum TAttribute { 
  AttributeProtocolVersion, 
  AttributeErrorMessage, 
  AttributeReferenceID, 
  AttributeCallID, 
  AttributeNodeID, 
  AttributeNetworkCallID, 
  AttributeNetworkNodeID, 
  AttributeTransferredNetworkCallID, 
  AttributeTransferredNetworkNodeID, 
  AttributeConnID, 
  AttributePreviousConnID, 
  AttributeTransferConnID, 
  AttributeConferenceConnID, 
  AttributeCallState, 
  AttributeAgentID, 
  AttributeAgentStateReasonUnused, 
  AttributeAgentWorkMode, 
  AttributeReason, 
  AttributeDNIS, 
  AttributeANI, 
  AttributeThisDN, 
  AttributeThisQueue, 
  AttributeThisTrunk, 
  AttributeThisDNRole, 
  AttributeOtherDN, 
  AttributeOtherQueue, 
  AttributeOtherTrunk, 
  AttributeOtherDNRole, 
  AttributeThirdPartyDN, 
  AttributeThirdPartyQueue, 
  AttributeThirdPartyTrunk, 
  AttributeThirdPartyDNRole, 
  AttributeMusicPath, 
  AttributeVoiceFileName, 
  AttributeFileHandle, 
  AttributeUserID, 
  AttributePassword, 
  AttributeVoiceSegment, 
  AttributeVoiceIFlag, 
  AttributeVoiceCFlag, 
  AttributeNumberOfDigits, 
  AttributeTerminateDigits, 
  AttributeTimeout, 
  AttributeCollectedDigits, 
  AttributeLastDigit, 
  AttributeInputMask, 
  AttributeErrorCode, 
  AttributeAddressType, 
  AttributeAddressMode, 
  AttributeRegisterMode, 
  AttributeControlMode, 
  AttributeUserData, 
  AttributeDataKey, 
  AttributeExtensions, 
  AttributeCallType, 
  AttributeCallingLineName, 
  AttributeAddressInfoType, 
  AttributeAddressInfoStatus, 
  AttributeUserEvent, 
  AttributeCommunicationDN, 
  AttributeRouteType, 
  AttributeServerVersion, 
  AttributeServerRole, 
  AttributeServerCapabilityMask, 
  AttributeApplicationName, 
  AttributeApplicationPassword, 
  AttributeMergeType, 
  AttributeForwardMode, 
  AttributeDTMFDigits, 
  AttributeLocation, 
 
  AttributeRemoteLocation, 
  AttributeRemoteConnID, 
  AttributeRemoteDN, 
 
  AttributeMakeCallType, 
  AttributeCallInfoType, 
 
  AttributeHomeLocation, 
  AttributeCustomerID, 
 
  AttributeFirstTransferHomeLocation, 
  AttributeFirstTransferOrigDN, 
  AttributeLastTransferHomeLocation, 
  AttributeLastTransferOrigDN, 
 
  AttributeSetOperation, 
  AttributeNewConnID, 
 
  AttributeTreatmentType, 
  AttributeTreatmentParms, 
 
  AttributeCLID, 
 
  AttributeTimeinSecs, 
  AttributeTimeinuSecs, 
 
  AttributeSwitchInfoType, 
   
  AttributeXRouteType, 
  AttributeAccessNumber, 
  AttributeXReferenceID,   
 
  AttributePlace, 
  AttributePriority, 
 
  AttributeAgentIdleReason, 
 
  AttributeRegistrationCode, 
  AttributeDNSyncInfo, 
 
  AttributeMediaType, /* TMediaType enumeration */ 
 
  AttributeLocationInfoType, 
 
  AttributeIDMAX 
}; 
 
enum TSockInfoReason{ 
  TSocketCreated, 
  TSocketDeleted, 
  TSocketChanged 
}; 
 
typedef struct { 
  int socket; 
  int sync_id; 
  int reason; 
  void *ptr; 
 
} TSockInfo; 
 
typedef enum { 
  TMediaVoice      =   0,  /* Voice (PSTN) call   */ 
  TMediaVoIP       =   1,  /* Voice over IP       */ 
  TMediaEMail      =   2, 
  TMediaVMail      =   3,  /* Voice Mail          */ 
  TMediaSMail      =   4,  /* Scanned Mail        */ 
  TMediaChat       =   5, 
  TMediaVideo      =   6, 
  TMediaCobrowsing =   7, 
  TMediaWhiteboard =   8, 
  TMediaAppSharing =   9,  /* Application Sharing */ 
  TMediaWebForm    =  10, 
  TMediaWorkItem   =  11,  /* work item (generic) */ 
 
  TMediaCustom0    = 100   /*<- all values above this one are */ 
}                          /* reserved for custom media types */ 
TMediaType; 
 
/*---------------------------------------------------------------------------*/ 
 
typedef struct { 
  enum TMessageType	Event; 
  TServer		Server; 
  int			ReferenceID; 
 
  char			*HomeLocation; 
  char			*CustomerID; 
 
  TConnectionID		ConnID; 
  TConnectionID		PreviousConnID; 
  TCallID		CallID; 
  int			NodeID; 
  TCallID		NetworkCallID; 
  int			NetworkNodeID; 
 
  TCallHistoryInfo	CallHistory; 
 
  TCallType		CallType; 
  TCallState		CallState; 
 
  TAgentID		AgentID; 
  TAgentWorkMode	WorkMode; 
 
  long			ErrorCode; 
  char			*ErrorMessage; 
 
  TFile			FileHandle; 
  char			*CollectedDigits; 
  char			LastCollectedDigit; 
 
  TDirectoryNumber	ThisDN; 
  TDirectoryNumber	ThisQueue; 
  unsigned long		ThisTrunk; 
  TDNRole		ThisDNRole; 
  TDirectoryNumber	OtherDN; 
  TDirectoryNumber	OtherQueue; 
  unsigned long		OtherTrunk; 
  TDNRole		OtherDNRole; 
  TDirectoryNumber	ThirdPartyDN;      
  TDirectoryNumber	ThirdPartyQueue; 
  unsigned long		ThirdPartyTrunk; 
  TDNRole		ThirdPartyDNRole; 
 
  TDirectoryNumber	DNIS; 
  TDirectoryNumber	ANI; 
  char			*CallingLineName; 
  TDirectoryNumber	CLID; 
 
  TAddressInfoType	InfoType; 
  TAddressInfoStatus	InfoStatus; 
 
  TTreatmentType	TreatmentType; 
  TRouteType            RouteType; 
 
  char			*ServerVersion; 
  TServerRole		ServerRole; 
  TMask			Capabilities; 
 
  TKVList		*UserData; 
  TKVList		*Reasons; 
 
  TKVList		*Extensions; 
 
  TTimeStamp		Time; 
 
  void 			*RawData; 
 
  TDirectoryNumber	AccessNumber; 
  TXRouteType		XRouteType; 
  TReferenceID		XReferenceID; 
  TKVList               *TreatmentParameters; 
 
  char                  *Place; 
  int                    Timeout; 
  TMediaType            MediaType; /* added 7/15/99 ER#9462 */ 
 
  TLocationInfoType	LocationInfo; 
} TEvent; 
 
#define TMaskSetAll(M)		memset((M), 0xff, T_MASK_LENGTH) 
#define TMaskClearAll(M)	memset((M), 0, T_MASK_LENGTH) 
#define TMaskSet(E, M)		((M)[(E) / 8] |= (1 << ((E) % 8))) 
#define TMaskClear(E, M)	((M)[(E) / 8] &= ~(1 << ((E) % 8))) 
#define TMaskIsSet(E, M)	((M)[(E) / 8] & (1 << ((E) % 8))) 
 
#ifdef __cplusplus 
extern "C" { 
#endif 
 
void TDispatch( 
	TServer server 
); 
 
TServer TOpenServer( 
	char *server_name, 
	void (*dispatch_function)(TEvent *event), 
	char *application_name, 
	char *application_password, 
	TOpenMode open_mode 
); 
 
TServer TOpenServerEx( 
	char *server_host_name, 
	int server_port, 
	void (*dispatch_function)(TEvent *event), 
	char *application_name, 
	char *application_password, 
	TOpenMode open_mode 
); 
 
int TCloseServer( 
	TServer server 
); 
 
int TScanServer( 
	TServer server, 
	int timeout 
); 
 
int TSetInputMask( 
	TServer server, 
	TMask mask 
); 
 
int TGetReferenceID(void); 
int TSetReferenceID( 
	int reference_id_for_next_req 
); 
int TSetRefIDLimit( 
        int new_limit 
); 
 
int TRegisterAddress( 
	TServer server, 
	TDirectoryNumber dn, 
	TRegisterMode mode, 
	TControlMode ctrmode, 
	TAddressType type, 
	TKVList *extensions 
); 
 
int TUnregisterAddress( 
	TServer server, 
	TDirectoryNumber dn, 
	TControlMode ctrmode, 
	TKVList *extensions 
); 
 
int TRegisterAll( 
	TServer server, 
	TKVList *extensions 
); 
 
int TUnregisterAll( 
	TServer server, 
	TKVList *extensions 
); 
 
int TMakeCall( 
	TServer server, 
	TDirectoryNumber dn, 
	TDirectoryNumber destination, 
	char *location, 
	TMakeCallType call_type, 
	TKVList *user_data, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TMakePredictiveCall( 
	TServer server, 
	TDirectoryNumber dn, 
	TDirectoryNumber destination, 
	int ring_timeout, 
	TKVList *user_data, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TAnswerCall( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TRedirectCall( 
	TServer server, 
	TDirectoryNumber dn, 
	TDirectoryNumber destination, 
	TConnectionID conn_id, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TReleaseCall( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TClearCall( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int THoldCall( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TRetrieveCall( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TAlternateCall( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID held_conn_id, 
	TConnectionID current_conn_id, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TReconnectCall( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID held_conn_id, 
	TConnectionID current_conn_id, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TInitiateTransfer( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TDirectoryNumber destination, 
	char *location, 
	TKVList *user_data, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TMuteTransfer( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TDirectoryNumber destination, 
	char *location, 
	TKVList *user_data, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TSingleStepTransfer( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TDirectoryNumber destination, 
	char *location, 
	TKVList *user_data, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TCompleteTransfer( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID held_conn_id, 
	TConnectionID current_conn_id, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TInitiateConference( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TDirectoryNumber destination, 
	char *location, 
	TKVList *user_data, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TSingleStepConference( 
        TServer server,  
        TDirectoryNumber dn, 
        TConnectionID conn_id,  
        TDirectoryNumber destination, 
        char *location,  
        TKVList *user_data,  
        TKVList *reasons, 
        TKVList *extensions 
); 
 
int TCompleteConference( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID held_conn_id, 
	TConnectionID current_conn_id, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TDeleteFromConference( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TDirectoryNumber dn_to_drop, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TListenDisconnect( 
	TServer server, 
	TDirectoryNumber dn, 
	TDirectoryNumber listener_dn, 
	TConnectionID conn_id, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TListenReconnect( 
	TServer server, 
	TDirectoryNumber dn, 
	TDirectoryNumber listener_dn, 
	TConnectionID conn_id, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TMergeCalls( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID held_conn_id, 
	TConnectionID current_conn_id, 
	TMergeType merge_type, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TAgentLogin( 
	TServer server, 
	TDirectoryNumber queue, 
	TDirectoryNumber dn, 
	TAgentType agent_type, 
	TAgentID agent_id, 
	TAgentPassword passwd, 
	TAgentWorkMode workmode, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TAgentLogout( 
	TServer server, 
	TDirectoryNumber queue, 
	TDirectoryNumber dn, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TAgentSetReady( 
	TServer server, 
	TDirectoryNumber queue, 
	TDirectoryNumber dn, 
	TAgentWorkMode workmode, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TAgentSetNotReady( 
	TServer server, 
	TDirectoryNumber queue, 
	TDirectoryNumber dn, 
	TAgentWorkMode workmode, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TAgentSetIdleReason( 
	TServer server, 
	TDirectoryNumber queue, 
	TDirectoryNumber dn, 
	char *idle_reason, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TSetDNDOn( 
	TServer server, 
	TDirectoryNumber dn, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TSetDNDOff( 
	TServer server, 
	TDirectoryNumber dn, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TCallSetForward( 
	TServer server, 
	TDirectoryNumber dn, 
	TDirectoryNumber destination, 
	TForwardMode forward_mode, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TCallCancelForward( 
	TServer server, 
	TDirectoryNumber dn, 
	TForwardMode forward_mode, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TSetMessageWaitingOn( 
	TServer server, 
	TDirectoryNumber dn, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TSetMessageWaitingOff( 
	TServer server, 
	TDirectoryNumber dn, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TRouteCall( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TDirectoryNumber destination, 
	char *location, 
	TRouteType route_type, 
	TDirectoryNumber dnis, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TGetAccessNumber( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TDirectoryNumber destination, 
	char *location, 
	TXRouteType xroute_type,      
	TKVList *user_data, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TCancelReqGetAccessNumber( 
        TServer server, 
	TReferenceID xref_id 
); 
 
int TGiveMusicTreatment( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TDirectoryNumber music_dn, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TGiveSilenceTreatment( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TGiveRingBackTreatment( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TLoginMailBox( 
	TServer server, 
	TDirectoryNumber dn, 
	char *mbox_number, 
	char *mbox_passwd, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TLogoutMailBox( 
	TServer server, 
	TDirectoryNumber dn, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TOpenVoiceFile( 
	TServer server, 
	TDirectoryNumber dn, 
	char *file_name, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TCloseVoiceFile( 
	TServer server, 
	TDirectoryNumber dn, 
	TFile file_handle, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TPlayVoice( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TFile file_handle, 
	char *segments, 
	TInterruptFlag iflag, 
	TClearFlag cflag, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TCollectDigits( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	int num_digits, 
	char *term_digits, 
	TClearFlag cflag, 
	TTime timeout, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TQueryAddress( 
	TServer server, 
	TDirectoryNumber queue, 
	TDirectoryNumber dn, 
	TAddressType addr_type, 
	TAddressInfoType info_type, 
	TKVList *extensions 
); 
 
int TQueryCall( 
	TServer server, 
	TDirectoryNumber dn, /* reserved for access control */ 
	TConnectionID conn_id, 
	TCallInfoType info_type, 
	TKVList *extensions 
); 
 
int TQuerySwitch( 
	TServer server, 
	TSwitchInfoType info_type, 
	TKVList *extensions 
); 
 
int TQueryServer( 
	TServer server, 
	TKVList *extensions 
); 
 
int TQueryLocation( 
	TServer server, 
	char *location, 
	TLocationInfoType info_type, 
	TKVList *extensions 
); 
 
int TSendDTMF( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	char *digits, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TAttachUserData( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TKVList *user_data 
); 
 
int TDeleteUserData( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	char *key 
); 
 
int TDeleteAllUserData( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id 
); 
 
int TUpdateUserData( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TKVList *user_data 
); 
 
TEvent *TCopyEvent( 
	TEvent *event 
); 
 
void TFreeEvent( 
	TEvent *event 
); 
 
int TSendUserEvent( 
	TServer server, 
	TDirectoryNumber dn, 
	TEvent *event 
); 
 
int TSendEvent( 
	TServer server, 
	TEvent *event 
); 
 
int TSetCallAttributes( 
	TServer server, 
	TSetOpType    op, 
	TConnectionID conn_id, 
	TConnectionID new_conn_id, 
	TDirectoryNumber origination, 
	TDirectoryNumber destination, 
	TKVList *extensions 
); 
 
int TApplyTreatment( 
	TServer server, 
	TDirectoryNumber dn, 
	TConnectionID conn_id, 
	TTreatmentType treatment, 
	TKVList *parameters, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
int TReserveAgent( 
        TServer server, 
        TDirectoryNumber agent_dn, 
	TAgentID agent_id, 
        char *agent_place, 
        int duration, 
        int priority, 
	TKVList *reasons, 
	TKVList *extensions 
); 
         
int TReserveAgentAndGetAccessNumber( 
	TServer server, 
	TDirectoryNumber agent_dn, 
	TAgentID agent_id, 
        char *agent_place, 
        int duration, 
        int priority, 
	TConnectionID conn_id, 
	TXRouteType xroute_type,      
	TKVList *user_data, 
	TKVList *reasons, 
	TKVList *extensions 
); 
 
#ifdef BACKUP_SYNC 
 
int TSyncSetSelectMask(  
	int sync_id,  
	fd_set *pfd 
); 
 
int TSyncIsSet(  
	int sync_id,  
	fd_set *pfd 
); 
 
void TSyncClear(  
        int sync_id,  
	fd_set *pfd 
); 
 
void TSetSocketChangeCallback(  
        void (*client_callback)(TSockInfo *p) 
); 
 
void TSetReconnectParams( 
	int attempts,  
	int timeout 
); 
 
#endif 
 
#ifdef __cplusplus 
} 
#endif 
 
#endif /* _TLIBRARY_H */