From 3f4bb659f764bf2b4520fd9cd2cd8e97a5c8d2b9 Mon Sep 17 00:00:00 2001 From: Anders Broman Date: Wed, 22 Jun 2005 16:17:18 +0000 Subject: Add the IDL doc's needed to build the Parlay dissector. svn path=/trunk/; revision=14732 --- idl/parlay/Parlay.idl | 24 + idl/parlay/README.parlay | 6 + idl/parlay/am.idl | 313 +++++++++ idl/parlay/cccs.idl | 264 ++++++++ idl/parlay/cm.idl | 544 +++++++++++++++ idl/parlay/common_cc_data.idl | 289 ++++++++ idl/parlay/cs.idl | 550 +++++++++++++++ idl/parlay/dsc.idl | 342 ++++++++++ idl/parlay/fw_data.idl | 820 +++++++++++++++++++++++ idl/parlay/fw_if.idl | 1361 ++++++++++++++++++++++++++++++++++++++ idl/parlay/fw_if_access.idl | 164 +++++ idl/parlay/fw_if_app.idl | 465 +++++++++++++ idl/parlay/fw_if_entop.idl | 248 +++++++ idl/parlay/fw_if_service.idl | 519 +++++++++++++++ idl/parlay/gcc_data.idl | 207 ++++++ idl/parlay/gcc_interfaces.idl | 225 +++++++ idl/parlay/gms.idl | 464 +++++++++++++ idl/parlay/mm.idl | 842 +++++++++++++++++++++++ idl/parlay/mmccs.idl | 320 +++++++++ idl/parlay/mmm.idl | 1085 ++++++++++++++++++++++++++++++ idl/parlay/mpcc_data.idl | 259 ++++++++ idl/parlay/mpcc_interfaces.idl | 414 ++++++++++++ idl/parlay/osa.idl | 441 ++++++++++++ idl/parlay/pam_data.idl | 550 +++++++++++++++ idl/parlay/pam_interfaces.idl | 842 +++++++++++++++++++++++ idl/parlay/policy_data.idl | 146 ++++ idl/parlay/policy_interfaces.idl | 725 ++++++++++++++++++++ idl/parlay/termcap.idl | 113 ++++ idl/parlay/ui_data.idl | 295 +++++++++ idl/parlay/ui_interfaces.idl | 361 ++++++++++ 30 files changed, 13198 insertions(+) create mode 100644 idl/parlay/Parlay.idl create mode 100644 idl/parlay/README.parlay create mode 100644 idl/parlay/am.idl create mode 100644 idl/parlay/cccs.idl create mode 100644 idl/parlay/cm.idl create mode 100644 idl/parlay/common_cc_data.idl create mode 100644 idl/parlay/cs.idl create mode 100644 idl/parlay/dsc.idl create mode 100644 idl/parlay/fw_data.idl create mode 100644 idl/parlay/fw_if.idl create mode 100644 idl/parlay/fw_if_access.idl create mode 100644 idl/parlay/fw_if_app.idl create mode 100644 idl/parlay/fw_if_entop.idl create mode 100644 idl/parlay/fw_if_service.idl create mode 100644 idl/parlay/gcc_data.idl create mode 100644 idl/parlay/gcc_interfaces.idl create mode 100644 idl/parlay/gms.idl create mode 100644 idl/parlay/mm.idl create mode 100644 idl/parlay/mmccs.idl create mode 100644 idl/parlay/mmm.idl create mode 100644 idl/parlay/mpcc_data.idl create mode 100644 idl/parlay/mpcc_interfaces.idl create mode 100644 idl/parlay/osa.idl create mode 100644 idl/parlay/pam_data.idl create mode 100644 idl/parlay/pam_interfaces.idl create mode 100644 idl/parlay/policy_data.idl create mode 100644 idl/parlay/policy_interfaces.idl create mode 100644 idl/parlay/termcap.idl create mode 100644 idl/parlay/ui_data.idl create mode 100644 idl/parlay/ui_interfaces.idl (limited to 'idl') diff --git a/idl/parlay/Parlay.idl b/idl/parlay/Parlay.idl new file mode 100644 index 0000000000..f73632b684 --- /dev/null +++ b/idl/parlay/Parlay.idl @@ -0,0 +1,24 @@ +//Source file: fw_if_access.idl +//Date: 13 October 2004 +//Framework Access Interfaces for ES 203 915-03 V1.1.1, DES/TISPAN-01005-03-OSA, Parlay 5.0 + +#include "fw_if_access.idl" +#include "fw_if_app.idl" +#include "fw_if_entop.idl" +#include "fw_if_service.idl" +#include "gcc_interfaces.idl" +#include "mpcc_interfaces.idl" +#include "mmccs.idl" +#include "cccs.idl" +#include "ui_interfaces.idl" +#include "mm.idl" +#include "termcap.idl" +#include "dsc.idl" +#include "gms.idl" +#include "cm.idl" +#include "am.idl" +#include "cs.idl" +#include "policy_interfaces.idl" +#include "pam_interfaces.idl" +#include "mmm.idl" + diff --git a/idl/parlay/README.parlay b/idl/parlay/README.parlay new file mode 100644 index 0000000000..4f360a7aed --- /dev/null +++ b/idl/parlay/README.parlay @@ -0,0 +1,6 @@ +To generate the parlay dissector from the .idl dockuments do: + +omniidl -p ./ -b ethereal_be parlay.idl + +The parlay.idl file is is doing include on all the other .idl files to create one +dissector for Parlay. diff --git a/idl/parlay/am.idl b/idl/parlay/am.idl new file mode 100644 index 0000000000..d725935ab4 --- /dev/null +++ b/idl/parlay/am.idl @@ -0,0 +1,313 @@ +//Source file: am.idl +//Date: 12 October 2004 +//Account Manager Interfaces and Data Types for ETSI ES 203 915-11 V1.1.1, DES/TISPAN-01005-11-OSA, Parlay 5.0 + + +#ifndef __AM_DEFINED +#define __AM_DEFINED + + +#include "osa.idl" + +module org { + + module csapi { + + module am { + + + enum TpChargingEventName { + + P_AM_CHARGING, + P_AM_RECHARGING, + P_AM_ACCOUNT_LOW, + P_AM_ACCOUNT_ZERO, + P_AM_ACCOUNT_DISABLED + }; + + + enum TpBalanceQueryError { + + P_BALANCE_QUERY_OK, + P_BALANCE_QUERY_ERROR_UNDEFINED, + P_BALANCE_QUERY_UNKNOWN_SUBSCRIBER, + P_BALANCE_QUERY_UNAUTHORIZED_APPLICATION, + P_BALANCE_QUERY_SYSTEM_FAILURE + }; + + + struct TpBalanceInfo { + TpString Currency; + TpInt32 ValuePartA; + TpInt32 ValuePartB; + TpInt32 Exponent; + TpString AdditionalInfo; + }; + + + struct TpChargingEventInfo { + TpChargingEventName ChargingEventName; + TpBalanceInfo CurrentBalanceInfo; + TpTime ChargingEventTime; + }; + + + struct TpBalance { + TpAddress UserID; + TpBalanceQueryError StatusCode; + TpBalanceInfo BalanceInfo; + }; + + + typedef sequence TpBalanceSet; + + + struct TpTransactionHistory { + TpAssignmentID TransactionID; + TpDateAndTime TimeStamp; + TpString AdditionalInfo; + }; + + + typedef sequence TpTransactionHistorySet; + + + enum TpTransactionHistoryStatus { + + P_AM_TRANSACTION_ERROR_UNSPECIFIED, + P_AM_TRANSACTION_INVALID_INTERVAL, + P_AM_TRANSACTION_UNKNOWN_ACCOUNT, + P_AM_TRANSACTION_UNAUTHORIZED_APPLICATION, + P_AM_TRANSACTION_PROCESSING_ERROR, + P_AM_TRANSACTION_SYSTEM_FAILURE + }; + + + typedef sequence TpChargingEventNameSet; + + + struct TpChargingEventCriteria { + TpChargingEventNameSet ChargingEvents; + TpAddressSet Users; + }; + + + struct TpChargingEventCriteriaResult { + TpChargingEventCriteria ChargingEventCriteria; + TpAssignmentID AssignmentID; + }; + + + exception P_UNAUTHORIZED_APPLICATION { + TpString ExtraInformation; + }; + + + typedef sequence TpChargingEventCriteriaResultSet; + + + struct TpBalanceExpiryDate { + TpAddress UserID; + TpBalanceQueryError StatusCode; + TpDateAndTime ExpiryDate; + }; + + + typedef sequence TpBalanceExpiryDateSet; + + + enum TpVoucherError { + + P_VOUCHER_OK, + P_VOUCHER_UNDEFINED, + P_VOUCHER_UNKNOWN_SUBSCRIBER, + P_VOUCHER_UNAUTHORIZED_APPLICATION, + P_VOUCHER_SYSTEM_FAILURE + }; + + + struct TpVoucher { + TpAssignmentID VoucherID; + TpAddress UserID; + TpBalanceInfo BalanceInfo; + }; + + + typedef sequence TpVoucherSet; + + + + interface IpAppAccountManager : IpInterface { + void reportNotification ( + in TpChargingEventInfo chargingEventInfo, + in TpAssignmentID assignmentId + ); + + void queryBalanceRes ( + in TpAssignmentID queryId, + in TpBalanceSet balances + ); + + void queryBalanceErr ( + in TpAssignmentID queryId, + in TpBalanceQueryError cause + ); + + void retrieveTransactionHistoryRes ( + in TpAssignmentID retrievalID, + in TpTransactionHistorySet transactionHistory + ); + + void retrieveTransactionHistoryErr ( + in TpAssignmentID retrievalID, + in TpTransactionHistoryStatus transactionHistoryError + ); + + void queryBalanceExpiryDateRes ( + in TpAssignmentID queryId, + in TpBalanceExpiryDateSet dates + ); + + void queryBalanceExpiryDateErr ( + in TpAssignmentID queryId, + in TpBalanceQueryError cause + ); + + void updateBalanceRes ( + in TpAssignmentID requestId, + in TpBalance balance + ); + + void updateBalanceErr ( + in TpAssignmentID requestId, + in TpBalanceQueryError cause + ); + + void createVoucherRes ( + in TpAssignmentID requestId, + in TpAssignmentID voucherId + ); + + void createVoucherErr ( + in TpAssignmentID requestId, + in TpVoucherError cause + ); + + void destroyVoucherRes ( + in TpAssignmentID requestId, + in TpAssignmentID voucherId + ); + + void destroyVoucherErr ( + in TpAssignmentID requestId, + in TpAssignmentID voucherId, + in TpVoucherError cause + ); + + void queryVoucherRes ( + in TpAssignmentID queryId, + in TpVoucher voucher + ); + + void queryVoucherErr ( + in TpAssignmentID queryId, + in TpAssignmentID voucherId, + in TpVoucherError cause + ); + + void queryUserVouchersRes ( + in TpAssignmentID queryId, + in TpVoucherSet vouchers + ); + + void queryUserVouchersErr ( + in TpAssignmentID queryId, + in TpVoucherError cause + ); + + }; + + + interface IpAccountManager : IpService { + TpAssignmentID createNotification ( + in IpAppAccountManager appAccountManager, + in TpChargingEventCriteria chargingEventCriteria + ) + raises (TpCommonExceptions,P_INVALID_ADDRESS,P_INVALID_CRITERIA,P_INVALID_EVENT_TYPE,P_UNKNOWN_SUBSCRIBER); + + void destroyNotification ( + in TpAssignmentID assignmentId + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + TpAssignmentID queryBalanceReq ( + in TpAddressSet users + ) + raises (TpCommonExceptions,P_UNKNOWN_SUBSCRIBER,P_UNAUTHORIZED_APPLICATION); + + void changeNotification ( + in TpAssignmentID assignmentID, + in TpChargingEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID,P_INVALID_CRITERIA,P_INVALID_EVENT_TYPE,P_UNKNOWN_SUBSCRIBER,P_INVALID_ADDRESS); + + TpChargingEventCriteriaResultSet getNotification () + raises (TpCommonExceptions); + + TpAssignmentID retrieveTransactionHistoryReq ( + in TpAddress user, + in TpTimeInterval transactionInterval + ) + raises (TpCommonExceptions,P_UNKNOWN_SUBSCRIBER,P_UNAUTHORIZED_APPLICATION,P_INVALID_TIME_AND_DATE_FORMAT); + + TpAssignmentID enableNotifications ( + in IpAppAccountManager appAccountManager + ) + raises (TpCommonExceptions); + + void disableNotifications () + raises (TpCommonExceptions); + + TpAssignmentID queryBalanceExpiryDateReq ( + in TpAddressSet users + ) + raises (TpCommonExceptions,P_UNKNOWN_SUBSCRIBER,P_UNAUTHORIZED_APPLICATION); + + TpAssignmentID updateBalanceReq ( + in TpAddress user, + in TpBoolean debit, + in TpBalanceInfo amount, + in TpInt32 period + ) + raises (TpCommonExceptions, P_UNKNOWN_SUBSCRIBER, P_UNAUTHORIZED_APPLICATION); + + TpAssignmentID createVoucherReq ( + in TpAddress user, + in TpBalanceInfo amount + ) + raises (TpCommonExceptions, P_UNKNOWN_SUBSCRIBER, P_UNAUTHORIZED_APPLICATION); + + TpAssignmentID destroyVoucherReq ( + in TpAssignmentID voucherId + ) + raises (TpCommonExceptions, P_UNAUTHORIZED_APPLICATION, P_INVALID_ASSIGNMENT_ID); + + TpAssignmentID queryVoucherReq ( + in TpAssignmentID voucherId + ) + raises (TpCommonExceptions, P_UNAUTHORIZED_APPLICATION, P_INVALID_ASSIGNMENT_ID); + + TpAssignmentID queryUserVouchersReq ( + in TpAddress user + ) + raises (TpCommonExceptions, P_UNKNOWN_SUBSCRIBER, P_UNAUTHORIZED_APPLICATION, P_INVALID_ASSIGNMENT_ID); + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/cccs.idl b/idl/parlay/cccs.idl new file mode 100644 index 0000000000..c79756fce7 --- /dev/null +++ b/idl/parlay/cccs.idl @@ -0,0 +1,264 @@ +//Source file:cccs.idl +//Date: 7 October 2004 +//Conference Call Control for ES 203 915-4-5 V1.1.1, DES/TISPAN-01005-04-5-OSA, Parlay 5.0 + + +#ifndef __CCCS_DEFINED +#define __CCCS_DEFINED + + +#include "osa.idl" +#include "mpcc_data.idl" +#include "mmccs.idl" +#include "common_cc_data.idl" + + +module org { + + module csapi { + + module cc { + + module cccs { + interface IpAppConfCallControlManager ; + interface IpConfCall ; + interface IpSubConfCall ; + + + enum TpConfPolicyType { + + P_CONFERENCE_POLICY_UNDEFINED, + P_CONFERENCE_POLICY_MONOMEDIA, + P_CONFERENCE_POLICY_MULTIMEDIA + }; + + + struct TpMonoMediaConfPolicy { + TpBoolean JoinAllowed; + }; + + + struct TpJoinEventInfo { + TpAddress DestinationAddress; + TpAddress OriginatingAddress; + TpCallAppInfoSet CallAppInfo; + }; + + + struct TpConfSearchCriteria { + TpDateAndTime StartSearch; + TpDateAndTime StopSearch; + TpInt32 RequestedResources; + TpDuration RequestedDuration; + }; + + + struct TpConfSearchResult { + TpBoolean MatchFound; + TpDateAndTime ActualStartTime; + TpInt32 ActualResources; + TpDuration ActualDuration; + }; + + + enum TpVideoHandlingType { + + P_MIXED_VIDEO, + P_SWITCHED_VIDEO_CHAIR_CONTROLLED, + P_SWITCHED_VIDEO_VOICE_CONTROLLED + }; + + + struct TpMultiMediaConfPolicy { + TpBoolean JoinAllowed; + TpMediaType MediaAllowed; + TpBoolean Chaired; + TpVideoHandlingType VideoHandling; + }; + + + union TpConfPolicy switch(TpConfPolicyType) { + case P_CONFERENCE_POLICY_MONOMEDIA: TpMonoMediaConfPolicy MonoMedia; + case P_CONFERENCE_POLICY_MULTIMEDIA: TpMultiMediaConfPolicy MultiMedia; + default: short Dummy; + }; + + + struct TpResourceReservation { + TpAddress ResourceID; + TpInt32 ReservationID; + }; + + + struct TpConfCallIdentifier { + IpConfCall ConfCallReference; + TpSessionID ConfCallSessionID; + }; + + + struct TpSubConfCallIdentifier { + IpSubConfCall SubConfCallReference; + TpSessionID SubConfCallSessionID; + }; + + + typedef sequence TpSubConfCallIdentifierSet; + + + + interface IpAppSubConfCall : mmccs::IpAppMultiMediaCall { + void chairSelection ( + in TpSessionID subConferenceSessionID, + in TpSessionID callLegSessionID + ); + + void floorRequest ( + in TpSessionID subConferenceSessionID, + in TpSessionID callLegSessionID + ); + + }; + + + interface IpAppConfCall : mmccs::IpAppMultiMediaCall { + mpccs::IpAppCallLeg partyJoined ( + in TpSessionID conferenceSessionID, + in mpccs::TpCallLegIdentifier callLeg, + in TpJoinEventInfo eventInfo + ); + + void leaveMonitorRes ( + in TpSessionID conferenceSessionID, + in TpSessionID callLeg + ); + + }; + + + interface IpConfCallControlManager : mmccs::IpMultiMediaCallControlManager { + TpConfCallIdentifier createConference ( + in IpAppConfCall appConferenceCall, + in TpInt32 numberOfSubConferences, + in TpConfPolicy conferencePolicy, + in TpInt32 numberOfParticipants, + in TpDuration duration + ) + raises (TpCommonExceptions); + + TpConfSearchResult checkResources ( + in TpConfSearchCriteria searchCriteria + ) + raises (TpCommonExceptions); + + TpResourceReservation reserveResources ( + in IpAppConfCallControlManager appInterface, + in TpDateAndTime startTime, + in TpInt32 numberOfParticipants, + in TpDuration duration, + in TpConfPolicy conferencePolicy + ) + raises (TpCommonExceptions); + + void freeResources ( + in TpResourceReservation resourceReservation + ) + raises (TpCommonExceptions); + + }; + + + interface IpAppConfCallControlManager : mmccs::IpAppMultiMediaCallControlManager { + IpAppConfCall conferenceCreated ( + in TpConfCallIdentifier conferenceCall + ); + + }; + + + interface IpSubConfCall : mmccs::IpMultiMediaCall { + TpSubConfCallIdentifier splitSubConference ( + in TpSessionID subConferenceSessionID, + in TpSessionIDSet callLegList, + in IpAppSubConfCall appSubConferenceCall + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void mergeSubConference ( + in TpSessionID subConferenceCallSessionID, + in TpSessionID targetSubConferenceCall + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void moveCallLeg ( + in TpSessionID subConferenceCallSessionID, + in TpSessionID targetSubConferenceCall, + in TpSessionID callLeg + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void inspectVideo ( + in TpSessionID subConferenceSessionID, + in TpSessionID inspectedCallLeg + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void inspectVideoCancel ( + in TpSessionID subConferenceSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void appointSpeaker ( + in TpSessionID subConferenceSessionID, + in TpSessionID speakerCallLeg + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void chairSelection ( + in TpSessionID subConferenceSessionID, + in TpSessionID chairCallLeg + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void changeConferencePolicy ( + in TpSessionID subConferenceSessionID, + in TpConfPolicy conferencePolicy + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + }; + + + interface IpConfCall : mmccs::IpMultiMediaCall { + TpSubConfCallIdentifierSet getSubConferences ( + in TpSessionID conferenceSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + TpSubConfCallIdentifier createSubConference ( + in TpSessionID conferenceSessionID, + in IpAppSubConfCall appSubConference, + in TpConfPolicy conferencePolicy + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void leaveMonitorReq ( + in TpSessionID conferenceSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + TpAddress getConferenceAddress ( + in TpSessionID conferenceSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + }; + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/cm.idl b/idl/parlay/cm.idl new file mode 100644 index 0000000000..51bfee3ca5 --- /dev/null +++ b/idl/parlay/cm.idl @@ -0,0 +1,544 @@ +//Source file: cm.idl +//Date: 11 October 2004 +//Connectivity Manager Interfaces and Data Types for ETSI ES 203 915-10 V1.1.1, DES/TISPAN-01005-10-OSA, Parlay 5.0 + +#ifndef __CM_DEFINED +#define __CM_DEFINED + + +#include "osa.idl" + +module org { + + module csapi { + + module cm { + interface IpVPrN ; + interface IpEnterpriseNetwork ; + interface IpConnectivityManager ; + interface IpQoSTemplate ; + interface IpEnterpriseNetworkSite ; + + + enum TpTrafficDirection { + + UNIDIRECTIONAL, + BIDIRECTIONAL + }; + + + enum TpTagValue { + + PROVIDER_SPECIFIED, + OPERATOR_SPECIFIED, + UNSPECIFIED + }; + + enum TpSiteOrSap { + + SITE, + SAP + }; + + + struct TpNameDescrpTagTimePeriod { + TpInt32 duration; + }; + + + struct TpNameDescrpTagTimeOfDay { + TpString name; + TpString description; + TpTagValue tag; + TpString value; + }; + + struct TpNameDescrpTagString { + TpString name; + TpString description; + TpTagValue tag; + TpString value; + }; + + + struct TpNameDescrpTagMonth { + TpString name; + TpString description; + TpTagValue tag; + TpInt32 value; + }; + + struct TpNameDescrpTagInt { + TpString name; + TpString description; + TpTagValue tag; + TpInt32 value; + }; + + struct TpNameDescrpTagDir { + TpString name; + TpString description; + TpTagValue tag; + TpTrafficDirection value; + }; + + + struct TpNameDescrpTagDayOfWeek { + TpString name; + TpString description; + TpTagValue tag; + TpInt32 value; + }; + + + struct TpNameDescrpTagDateTime { + TpString name; + TpString description; + TpTagValue tag; + TpDateAndTime value; + }; + + + struct TpLossDescriptor { + TpNameDescrpTagInt meanLoss; + TpNameDescrpTagInt measurementPeriod; + TpNameDescrpTagInt maxLoss; + TpNameDescrpTagInt minLoss; + TpNameDescrpTagInt lossPriority; + TpNameDescrpTagString description; + }; + + + struct TpLoadDescriptor { + TpNameDescrpTagInt meanBandwidth; + TpNameDescrpTagInt measurementInterval; + TpNameDescrpTagInt maxBandwidth; + TpNameDescrpTagInt minBandwidth; + TpNameDescrpTagInt bandwidthShare; + TpNameDescrpTagInt bandwidthWeight; + TpNameDescrpTagInt burstSize; + TpNameDescrpTagString description; + }; + + + struct TpJitterDescriptor { + TpNameDescrpTagInt meanJitter; + TpNameDescrpTagInt measurementPeriod; + TpNameDescrpTagInt maxJitter; + TpNameDescrpTagInt minJitter; + TpNameDescrpTagInt jitterPriority; + TpNameDescrpTagString description; + }; + + enum TpIPVersion { + + VERSION_UNKNOWN, + VERSION_IPV4, + VERSION_IPV6 + }; + + enum TpIPv4AddType { + + IPV4_ADD_CLASS_A, + IPV4_ADD_CLASS_B, + IPV4_ADD_CLASS_C, + IPV4_ADD_CLASS_D, + IPV4_ADD_CLASS_E + }; + + struct TpEndpoint { + TpSiteOrSap type; + TpString id; + }; + + + struct TpDelayDescriptor { + TpNameDescrpTagInt meanDelay; + TpNameDescrpTagInt measurementPeriod; + TpNameDescrpTagInt maxDelay; + TpNameDescrpTagInt minDelay; + TpNameDescrpTagInt delayPriority; + TpNameDescrpTagString description; + }; + + + enum TpAction { + + DROP, + TRANSMIT, + RESHAPE, + REMARK + }; + + + struct TpNameDescrpTagExcessLoadAction { + TpString name; + TpString description; + TpTagValue tag; + TpAction value; + }; + + + exception P_UNKNOWN_VPRP_ID { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_SLA_ID { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_STATUS { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_QOS_INFO { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_VALIDITY_INFO { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_PIPEQOSINFO { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_DSCODEPOINT { + TpString ExtraInformation; + }; + + + exception P_ILLEGAL_VPRPID { + TpString ExtraInformation; + }; + + + exception P_ILLEGAL_REF_VALUE { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_INTERFACE { + TpString ExtraInformation; + }; + + + exception P_CANT_DELETE_VPRP { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_TEMPLATES { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_MENU { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_ENTERPRISE_NETWORK { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_TEMPLATE_TYPE { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_DESCRIPTION { + TpString ExtraInformation; + }; + + + exception P_ILLEGAL_SLA_ID { + TpString ExtraInformation; + }; + + + exception P_ILLEGAL_TAG { + TpString ExtraInformation; + }; + + + exception P_ILLEGAL_VALUE { + TpString ExtraInformation; + }; + + + exception P_ILLEGAL_COMBINATION { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_SITES { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_VPRN { + TpString ExtraInformation; + }; + + + exception P_ILLEGAL_SITE_ID { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_SITE_ID { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_SAPS { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_SITE_LOCATION { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_SITE_DESCRIPTION { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_IPSUBNET { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_SAP { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_VPRP { + TpString ExtraInformation; + }; + + + enum TpVprpStatus { + + ACTIVE, + PENDING, + DISALLOWED + }; + + + struct TpValidityInfo { + TpNameDescrpTagDateTime validFrom; + TpNameDescrpTagTimePeriod validPeriod; + TpNameDescrpTagTimeOfDay validDailyFrom; + TpNameDescrpTagTimePeriod validDailyPeriod; + TpNameDescrpTagDayOfWeek validDayOfWeek; + TpNameDescrpTagMonth validMonth; + TpNameDescrpTagString description; + }; + + struct TpProvisionedQoSInfo { + TpDelayDescriptor delayDescriptor; + TpLossDescriptor lossDescriptor; + TpJitterDescriptor jitterDescriptor; + TpNameDescrpTagExcessLoadAction excessLoadAction; + TpNameDescrpTagString description; + }; + + struct TpPipeQoSInfo { + TpNameDescrpTagDir directionality; + TpEndpoint serviceOrigin; + TpEndpoint serviceDestination; + TpLoadDescriptor forwardLoad; + TpLoadDescriptor reverseLoad; + TpNameDescrpTagString description; + }; + + + struct TpDsCodepoint { + TpString match; + TpString mask; + }; + + + struct TpIPSubnet { + TpString subnetNumber; + TpString subnetMask; + TpIPv4AddType addressType; + TpIPVersion IPVersionSupport; + }; + + + interface IpVPrP : IpService { + + TpString getVPrPID () + raises (TpCommonExceptions,P_UNKNOWN_VPRP_ID); + + TpString getSlaID () + raises (TpCommonExceptions,P_UNKNOWN_SLA_ID); + + TpVprpStatus getStatus () + raises (TpCommonExceptions,P_UNKNOWN_STATUS); + + TpProvisionedQoSInfo getProvisionedQoSInfo () + raises (TpCommonExceptions,P_UNKNOWN_QOS_INFO); + + TpValidityInfo getValidityInfo () + raises (TpCommonExceptions,P_UNKNOWN_VALIDITY_INFO); + + TpPipeQoSInfo getPipeQoSInfo () + raises (TpCommonExceptions,P_UNKNOWN_PIPEQOSINFO); + + TpDsCodepoint getDsCodepoint () + raises (TpCommonExceptions,P_UNKNOWN_DSCODEPOINT); + + }; + + + interface IpVPrN : IpService { + + TpStringList getVPrPList () + raises (TpCommonExceptions,P_UNKNOWN_VPRP); + + IpInterface getVPrP ( + in TpString vPrPID + ) + raises (TpCommonExceptions,P_ILLEGAL_VPRPID,P_UNKNOWN_VPRP_ID); + + IpInterface createVPrP ( + in IpInterface templateRef + ) + raises (TpCommonExceptions,P_ILLEGAL_REF_VALUE,P_UNKNOWN_INTERFACE); + + void deleteVPrP ( + in TpString vPrPID + ) + raises (TpCommonExceptions,P_CANT_DELETE_VPRP,P_UNKNOWN_VPRP_ID); + + }; + + + interface IpQoSMenu : IpService { + + IpInterface getTemplate ( + in TpString templateType + ) + raises (TpCommonExceptions); + + TpStringList getTemplateList () + raises (TpCommonExceptions,P_UNKNOWN_TEMPLATES); + + }; + + + interface IpConnectivityManager : IpService { + + IpInterface getQoSMenu () + raises (TpCommonExceptions,P_UNKNOWN_MENU); + + IpInterface getEnterpriseNetwork () + raises (TpCommonExceptions,P_UNKNOWN_ENTERPRISE_NETWORK); + + }; + + + interface IpQoSTemplate : IpService { + + TpString getTemplateType () + raises (TpCommonExceptions,P_UNKNOWN_TEMPLATE_TYPE); + + TpString getDescription () + raises (TpCommonExceptions,P_UNKNOWN_DESCRIPTION); + + void setSlaID ( + in TpString slaID + ) + raises (TpCommonExceptions,P_ILLEGAL_SLA_ID); + + TpPipeQoSInfo getPipeQoSInfo () + raises (TpCommonExceptions,P_UNKNOWN_PIPEQOSINFO); + + void setPipeQoSInfo ( + in TpPipeQoSInfo pipeQoSInfo + ) + raises (TpCommonExceptions,P_ILLEGAL_TAG,P_ILLEGAL_VALUE,P_ILLEGAL_COMBINATION); + + TpValidityInfo getValidityInfo () + raises (TpCommonExceptions,P_UNKNOWN_VALIDITY_INFO); + + void setValidityInfo ( + in TpValidityInfo validityInfo + ) + raises (TpCommonExceptions,P_ILLEGAL_TAG,P_ILLEGAL_VALUE,P_ILLEGAL_COMBINATION); + + void setProvisionedQoSInfo ( + in TpProvisionedQoSInfo provisionedQoSInfo + ) + raises (TpCommonExceptions,P_ILLEGAL_TAG,P_ILLEGAL_VALUE,P_ILLEGAL_COMBINATION); + + TpProvisionedQoSInfo getProvisionedQoSInfo () + raises (TpCommonExceptions,P_UNKNOWN_QOS_INFO); + + TpDsCodepoint getDsCodepoint () + raises (TpCommonExceptions,P_UNKNOWN_DSCODEPOINT); + + }; + + + interface IpEnterpriseNetwork : IpService { + + TpStringList getSiteList () + raises (TpCommonExceptions,P_UNKNOWN_SITES); + + IpInterface getVPrN () + raises (TpCommonExceptions,P_UNKNOWN_VPRN); + + IpInterface getSite ( + in TpString siteID + ) + raises (TpCommonExceptions,P_ILLEGAL_SITE_ID,P_UNKNOWN_SITE_ID); + + }; + + + interface IpEnterpriseNetworkSite : IpEnterpriseNetwork { + + TpStringList getSAPList () + raises (TpCommonExceptions,P_UNKNOWN_SAPS); + + TpString getSiteID () + raises (TpCommonExceptions,P_UNKNOWN_SITE_ID); + + TpString getSiteLocation () + raises (TpCommonExceptions,P_UNKNOWN_SITE_LOCATION); + + TpString getSiteDescription () + raises (TpCommonExceptions,P_UNKNOWN_SITE_DESCRIPTION); + + TpIPSubnet getIPSubnet () + raises (TpCommonExceptions,P_UNKNOWN_IPSUBNET); + + TpIPSubnet getSAPIPSubnet ( + in TpString sapID + ) + raises (TpCommonExceptions,P_ILLEGAL_SITE_ID,P_UNKNOWN_SAP,P_UNKNOWN_IPSUBNET); + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/common_cc_data.idl b/idl/parlay/common_cc_data.idl new file mode 100644 index 0000000000..bd7b507543 --- /dev/null +++ b/idl/parlay/common_cc_data.idl @@ -0,0 +1,289 @@ +//Source file: common_cc_data.idl +//Date: 6 October 2004 +//Common Call Control Data Types for ES 203 915-4-1 V1.1.1, DES/TISPAN-01005-04-2-OSA, Parlay 5.0 + +#ifndef __COMMON_CC_DATA_DEFINED +#define __COMMON_CC_DATA_DEFINED + + +#include "ui_data.idl" +#include "osa.idl" + +module org { + + module csapi { + + module cc { + + enum TpReleaseCause { + + P_UNDEFINED, + P_USER_NOT_AVAILABLE, + P_BUSY, + P_NO_ANSWER, + P_NOT_REACHABLE, + P_ROUTING_FAILURE, + P_PREMATURE_DISCONNECT, + P_DISCONNECTED, + P_CALL_RESTRICTED, + P_UNAVAILABLE_RESOURCE, + P_GENERAL_FAILURE, + P_TIMER_EXPIRY, + P_UNSUPPORTED_MEDIA + }; + + + enum TpCallMonitorMode { + + P_CALL_MONITOR_MODE_INTERRUPT, + P_CALL_MONITOR_MODE_NOTIFY, + P_CALL_MONITOR_MODE_DO_NOT_MONITOR + }; + + + typedef TpInt32 TpCallAlertingMechanism; + + + enum TpCallBearerService { + + P_CALL_BEARER_SERVICE_UNKNOWN, + P_CALL_BEARER_SERVICE_SPEECH, + P_CALL_BEARER_SERVICE_DIGITALUNRESTRICTED, + P_CALL_BEARER_SERVICE_DIGITALRESTRICTED, + P_CALL_BEARER_SERVICE_AUDIO, + P_CALL_BEARER_SERVICE_DIGITALUNRESTRICTEDTONES, + P_CALL_BEARER_SERVICE_VIDEO + }; + + + enum TpCallChargeOrderCategory { + + P_CALL_CHARGE_TRANSPARENT, + P_CALL_CHARGE_PREDEFINED_SET + }; + + + enum TpCallErrorType { + + P_CALL_ERROR_UNDEFINED, + P_CALL_ERROR_INVALID_ADDRESS, + P_CALL_ERROR_INVALID_STATE, + P_CALL_ERROR_RESOURCE_UNAVAILABLE + }; + + + union TpCallAdditionalErrorInfo switch(TpCallErrorType) { + case P_CALL_ERROR_INVALID_ADDRESS: TpAddressError CallErrorInvalidAddress; + default: short Dummy; + }; + + + struct TpCallError { + TpDateAndTime ErrorTime; + TpCallErrorType ErrorType; + TpCallAdditionalErrorInfo AdditionalErorInfo; + }; + + + struct TpCallEndedReport { + TpSessionID CallLegSessionID; + TpReleaseCause Cause; + }; + + + const TpInt32 P_CALL_INFO_UNDEFINED = 0; + + const TpInt32 P_CALL_INFO_TIMES = 1; + + const TpInt32 P_CALL_INFO_RELEASE_CAUSE = 2; + + typedef TpInt32 TpCallInfoType; + + + struct TpCallInfoReport { + TpCallInfoType CallInfoType; + TpDateAndTime CallInitiationStartTime; + TpDateAndTime CallConnectedToResourceTime; + TpDateAndTime CallConnectedToDestinationTime; + TpDateAndTime CallEndTime; + TpReleaseCause Cause; + }; + + + const TpInt32 P_CALL_LOAD_CONTROL_ADMIT_NO_CALLS = 0; + + enum TpCallLoadControlMechanismType { + + P_CALL_LOAD_CONTROL_PER_INTERVAL + }; + + + typedef TpInt32 TpCallLoadControlIntervalRate; + + + union TpCallLoadControlMechanism switch(TpCallLoadControlMechanismType) { + case P_CALL_LOAD_CONTROL_PER_INTERVAL: TpCallLoadControlIntervalRate CallLoadControlPerInterval; + }; + + + enum TpCallNetworkAccessType { + + P_CALL_NETWORK_ACCESS_TYPE_UNKNOWN, + P_CALL_NETWORK_ACCESS_TYPE_POT, + P_CALL_NETWORK_ACCESS_TYPE_ISDN, + P_CALL_NETWORK_ACCESS_TYPE_DIALUPINTERNET, + P_CALL_NETWORK_ACCESS_TYPE_XDSL, + P_CALL_NETWORK_ACCESS_TYPE_WIRELESS + }; + + + enum TpCallPartyCategory { + + P_CALL_PARTY_CATEGORY_UNKNOWN, + P_CALL_PARTY_CATEGORY_OPERATOR_F, + P_CALL_PARTY_CATEGORY_OPERATOR_E, + P_CALL_PARTY_CATEGORY_OPERATOR_G, + P_CALL_PARTY_CATEGORY_OPERATOR_R, + P_CALL_PARTY_CATEGORY_OPERATOR_S, + P_CALL_PARTY_CATEGORY_ORDINARY_SUB, + P_CALL_PARTY_CATEGORY_PRIORITY_SUB, + P_CALL_PARTY_CATEGORY_DATA_CALL, + P_CALL_PARTY_CATEGORY_TEST_CALL, + P_CALL_PARTY_CATEGORY_PAYPHONE + }; + + + enum TpCallServiceCodeType { + + P_CALL_SERVICE_CODE_UNDEFINED, + P_CALL_SERVICE_CODE_DIGITS, + P_CALL_SERVICE_CODE_FACILITY, + P_CALL_SERVICE_CODE_U2U, + P_CALL_SERVICE_CODE_HOOKFLASH, + P_CALL_SERVICE_CODE_RECALL + }; + + + struct TpCallServiceCode { + TpCallServiceCodeType CallServiceCodeType; + TpString ServiceCodeValue; + }; + + + enum TpCallTeleService { + + P_CALL_TELE_SERVICE_UNKNOWN, + P_CALL_TELE_SERVICE_TELEPHONY, + P_CALL_TELE_SERVICE_FAX_2_3, + P_CALL_TELE_SERVICE_FAX_4_I, + P_CALL_TELE_SERVICE_FAX_4_II_III, + P_CALL_TELE_SERVICE_VIDEOTEX_SYN, + P_CALL_TELE_SERVICE_VIDEOTEX_INT, + P_CALL_TELE_SERVICE_TELEX, + P_CALL_TELE_SERVICE_MHS, + P_CALL_TELE_SERVICE_OSI, + P_CALL_TELE_SERVICE_FTAM, + P_CALL_TELE_SERVICE_VIDEO, + P_CALL_TELE_SERVICE_VIDEO_CONF, + P_CALL_TELE_SERVICE_AUDIOGRAPH_CONF, + P_CALL_TELE_SERVICE_MULTIMEDIA, + P_CALL_TELE_SERVICE_CS_INI_H221, + P_CALL_TELE_SERVICE_CS_SUB_H221, + P_CALL_TELE_SERVICE_CS_INI_CALL, + P_CALL_TELE_SERVICE_DATATRAFFIC, + P_CALL_TELE_SERVICE_EMERGENCY_CALLS, + P_CALL_TELE_SERVICE_SMS_MT_PP, + P_CALL_TELE_SERVICE_SMS_MO_PP, + P_CALL_TELE_SERVICE_CELL_BROADCAST, + P_CALL_TELE_SERVICE_ALT_SPEECH_FAX_3, + P_CALL_TELE_SERVICE_AUTOMATIC_FAX_3, + P_CALL_TELE_SERVICE_VOICE_GROUP_CALL, + P_CALL_TELE_SERVICE_VOICE_BROADCAST + }; + + + const TpInt32 P_CALL_SUPERVISE_TIMEOUT = 1; + + const TpInt32 P_CALL_SUPERVISE_CALL_ENDED = 2; + + const TpInt32 P_CALL_SUPERVISE_TONE_APPLIED = 4; + + const TpInt32 P_CALL_SUPERVISE_UI_FINISHED = 8; + + typedef TpInt32 TpCallSuperviseReport; + + + const TpInt32 P_CALL_SUPERVISE_RELEASE = 1; + + const TpInt32 P_CALL_SUPERVISE_RESPOND = 2; + + const TpInt32 P_CALL_SUPERVISE_APPLY_TONE = 4; + + typedef TpInt32 TpCallSuperviseTreatment; + + + enum TpCallTreatmentType { + + P_CALL_TREATMENT_DEFAULT, + P_CALL_TREATMENT_RELEASE, + P_CALL_TREATMENT_SIAR + }; + + + union TpCallAdditionalTreatmentInfo switch(TpCallTreatmentType) { + case P_CALL_TREATMENT_SIAR: ui::TpUIInfo InformationToSend; + default: short Dummy; + }; + + + struct TpCallTreatment { + TpCallTreatmentType CallTreatmentType; + TpReleaseCause ReleaseCause; + TpCallAdditionalTreatmentInfo AdditionalTreatmentInfo; + }; + + + enum TpCallPartyToChargeType { + + P_CALL_PARTY_ORIGINATING, + P_CALL_PARTY_DESTINATION, + P_CALL_PARTY_SPECIAL + }; + + + typedef TpInt32 TpMediaType; + + + union TpCallPartyToChargeAdditionalInfo switch(TpCallPartyToChargeType) { + case P_CALL_PARTY_SPECIAL: TpAddress CallPartySpecial; + default: short Dummy; + }; + + + struct TpCallChargePlan { + TpCallChargeOrderCategory ChargeOrderType; + TpOctetSet TransparentCharge; + TpInt32 ChargePlan; + TpOctetSet AdditionalInfo; + TpCallPartyToChargeType PartyToCharge; + TpCallPartyToChargeAdditionalInfo PartyToChargeAdditionalInfo; + }; + + + typedef sequence TpCallServiceCodeSet; + + + const TpInt32 P_AUDIO = 1; + + const TpInt32 P_DATA = 4; + + const TpInt32 P_VIDEO = 2; + + const TpInt32 P_CALL_SUPERVISE_QOS_PARAM_CHANGE = 16; + }; + + }; + +}; + +#endif diff --git a/idl/parlay/cs.idl b/idl/parlay/cs.idl new file mode 100644 index 0000000000..98364159be --- /dev/null +++ b/idl/parlay/cs.idl @@ -0,0 +1,550 @@ +//Source file: cs.idl +//Date: 12 October 2004 +//Charging Interfaces and Data Types for ETSI ES 203 915-12 v.1.1.1, DES/TISPAN-01005-12-OSA, Parlay 5.0 + + +#ifndef __CS_DEFINED +#define __CS_DEFINED + + +#include "osa.idl" + +module org { + + module csapi { + + + module cs { + + interface IpChargingSession; + + + + + struct TpMerchantAccountID { + TpString MerchantID; + TpInt32 AccountID; + }; + + + typedef TpInt32 TpCorrelationType; + + + struct TpCorrelationID { + TpSessionID CorrelationID; + TpCorrelationType CorrelationType; + }; + + + struct TpAmount { + TpInt32 Number; + TpInt32 Exponent; + }; + + + struct TpChargingPrice { + TpString Currency; + TpAmount Amount; + }; + + + typedef TpInt32 TpChargingParameterID; + + + enum TpChargingParameterValueType { + + P_CHS_PARAMETER_INT32, + P_CHS_PARAMETER_FLOAT, + P_CHS_PARAMETER_STRING, + P_CHS_PARAMETER_BOOLEAN, + P_CHS_PARAMETER_OCTETSET + }; + + + union TpChargingParameterValue switch(TpChargingParameterValueType) { + case P_CHS_PARAMETER_INT32: TpInt32 IntValue; + case P_CHS_PARAMETER_FLOAT: TpFloat FloatValue; + case P_CHS_PARAMETER_STRING: TpString StringValue; + case P_CHS_PARAMETER_BOOLEAN: TpBoolean BooleanValue; + case P_CHS_PARAMETER_OCTETSET: TpOctetSet OctetValue; + }; + + + typedef TpInt32 TpUnitID; + + + struct TpVolume { + TpAmount Amount; + TpUnitID Unit; + }; + + + typedef sequence TpVolumeSet; + + + struct TpChargingSessionID { + IpChargingSession ChargingSessionReference; + TpSessionID ChargingSessionID; + TpInt32 RequestNumberFirstRequest; + }; + + + struct TpPriceVolume { + TpChargingPrice Price; + TpVolume Volume; + }; + + + typedef sequence TpPriceVolumeSet; + + + enum TpChargingError { + + P_CHS_ERR_UNDEFINED, + P_CHS_ERR_ACCOUNT, + P_CHS_ERR_USER, + P_CHS_ERR_PARAMETER, + P_CHS_ERR_NO_DEBIT, + P_CHS_ERR_NO_CREDIT, + P_CHS_ERR_VOLUMES, + P_CHS_ERR_CURRENCY, + P_CHS_ERR_NO_EXTEND, + P_CHS_ERR_RESERVATION_LIMIT, + P_CHS_ERR_CONFIRMATION_REQUIRED + }; + + + enum TpSessionEndedCause { + + P_CHS_CAUSE_UNDEFINED, + P_CHS_CAUSE_TIMER_EXPIRED + }; + + + enum TpAppInformationType { + + P_APP_INF_TIMESTAMP + }; + + + union TpAppInformation switch(TpAppInformationType) { + case P_APP_INF_TIMESTAMP: TpDateAndTime Timestamp; + }; + + + typedef sequence TpAppInformationSet; + + + struct TpApplicationDescription { + TpString Text; + TpAppInformationSet AppInformation; + }; + + + struct TpChargingParameter { + TpChargingParameterID ParameterID; + TpChargingParameterValue ParameterValue; + }; + + + typedef sequence TpChargingParameterSet; + + + const TpChargingParameterID P_CHS_PARAM_UNDEFINED = 0; + + const TpChargingParameterID P_CHS_PARAM_ITEM = 1; + + const TpChargingParameterID P_CHS_PARAM_SUBTYPE = 2; + + const TpCorrelationType P_CHS_CORRELATION_UNDEFINED = 0; + + const TpCorrelationType P_CHS_CORRELATION_VOICE = 1; + + const TpCorrelationType P_CHS_CORRELATION_DATA = 2; + + const TpCorrelationType P_CHS_CORRELATION_MM = 3; + + const TpUnitID P_CHS_UNIT_UNDEFINED = 0; + + const TpUnitID P_CHS_UNIT_NUMBER = 1; + + const TpUnitID P_CHS_UNIT_OCTETS = 2; + + const TpUnitID P_CHS_UNIT_SECONDS = 3; + + const TpUnitID P_CHS_UNIT_MINUTES = 4; + + const TpUnitID P_CHS_UNIT_HOURS = 5; + + const TpUnitID P_CHS_UNIT_DAYS = 6; + + exception P_INVALID_USER { + TpString ExtraInformation; + }; + + + exception P_INVALID_ACCOUNT { + TpString ExtraInformation; + }; + + + exception P_INVALID_REQUEST_NUMBER { + TpString ExtraInformation; + }; + + + exception P_INVALID_VOLUME { + TpString ExtraInformation; + }; + + + const TpChargingParameterID P_CHS_PARAM_CONFIRMATION_ID = 3; + + const TpChargingParameterID P_CHS_PARAM_CONTRACT = 4; + + + + + interface IpAppChargingSession : IpInterface { + void creditAmountErr ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingError error, + in TpInt32 requestNumberNextRequest + ); + + void creditAmountRes ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingPrice creditedAmount, + in TpChargingPrice reservedAmountLeft, + in TpInt32 requestNumberNextRequest + ); + + void creditUnitErr ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingError error, + in TpInt32 requestNumberNextRequest + ); + + void creditUnitRes ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpVolumeSet creditedVolumes, + in TpVolumeSet reservedUnitsLeft, + in TpInt32 requestNumberNextRequest + ); + + void debitAmountErr ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingError error, + in TpInt32 requestNumberNextRequest + ); + + void debitAmountRes ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingPrice debitedAmount, + in TpChargingPrice reservedAmountLeft, + in TpInt32 requestNumberNextRequest + ); + + void debitUnitErr ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingError error, + in TpInt32 requestNumberNextRequest + ); + + void debitUnitRes ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpVolumeSet debitedVolumes, + in TpVolumeSet reservedUnitsLeft, + in TpInt32 requestNumberNextRequest + ); + + void directCreditAmountErr ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingError error, + in TpInt32 requestNumberNextRequest + ); + + void directCreditAmountRes ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingPrice creditedAmount, + in TpInt32 requestNumberNextRequest + ); + + void directCreditUnitErr ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingError error, + in TpInt32 requestNumberNextRequest + ); + + void directCreditUnitRes ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpVolumeSet creditedVolumes, + in TpInt32 requestNumberNextRequest + ); + + void directDebitAmountErr ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingError error, + in TpInt32 requestNumberNextRequest + ); + + void directDebitAmountRes ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingPrice debitedAmount, + in TpInt32 requestNumberNextRequest + ); + + void directDebitUnitErr ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingError error, + in TpInt32 requestNumberNextRequest + ); + + void directDebitUnitRes ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpVolumeSet debitedVolumes, + in TpInt32 requestNumberNextRequest + ); + + void extendLifeTimeErr ( + in TpSessionID sessionID, + in TpChargingError error + ); + + void extendLifeTimeRes ( + in TpSessionID sessionID, + in TpInt32 sessionTimeLeft + ); + + void rateErr ( + in TpSessionID sessionID, + in TpChargingError error + ); + + void rateRes ( + in TpSessionID sessionID, + in TpPriceVolumeSet rates, + in TpDuration validityTimeLeft + ); + + void reserveAmountErr ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingError error, + in TpInt32 requestNumberNextRequest + ); + + void reserveAmountRes ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingPrice reservedAmount, + in TpInt32 sessionTimeLeft, + in TpInt32 requestNumberNextRequest + ); + + void reserveUnitErr ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpChargingError error, + in TpInt32 requestNumberNextRequest + ); + + void reserveUnitRes ( + in TpSessionID sessionID, + in TpInt32 requestNumber, + in TpVolumeSet reservedUnits, + in TpInt32 sessionTimeLeft, + in TpInt32 requestNumberNextRequest + ); + + void sessionEnded ( + in TpSessionID sessionID, + in TpSessionEndedCause report + ); + + }; + + + interface IpChargingSession : IpService { + void creditAmountReq ( + in TpSessionID sessionID, + in TpApplicationDescription applicationDescription, + in TpChargingPrice amount, + in TpBoolean closeReservation, + in TpInt32 requestNumber + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_AMOUNT,P_INVALID_CURRENCY,P_INVALID_REQUEST_NUMBER); + + void creditUnitReq ( + in TpSessionID sessionID, + in TpApplicationDescription applicationDescription, + in TpVolumeSet volumes, + in TpBoolean closeReservation, + in TpInt32 requestNumber + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_VOLUME,P_INVALID_REQUEST_NUMBER); + + void debitAmountReq ( + in TpSessionID sessionID, + in TpApplicationDescription applicationDescription, + in TpChargingPrice amount, + in TpBoolean closeReservation, + in TpInt32 requestNumber + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_AMOUNT,P_INVALID_CURRENCY,P_INVALID_REQUEST_NUMBER); + + void debitUnitReq ( + in TpSessionID sessionID, + in TpApplicationDescription applicationDescription, + in TpVolumeSet volumes, + in TpBoolean closeReservation, + in TpInt32 requestNumber + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_VOLUME,P_INVALID_REQUEST_NUMBER); + + void directCreditAmountReq ( + in TpSessionID sessionID, + in TpApplicationDescription applicationDescription, + in TpChargingParameterSet chargingParameters, + in TpChargingPrice amount, + in TpInt32 requestNumber + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_AMOUNT,P_INVALID_CURRENCY,P_INVALID_REQUEST_NUMBER); + + void directCreditUnitReq ( + in TpSessionID sessionID, + in TpApplicationDescription applicationDescription, + in TpChargingParameterSet chargingParameters, + in TpVolumeSet volumes, + in TpInt32 requestNumber + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_VOLUME,P_INVALID_REQUEST_NUMBER); + + void directDebitAmountReq ( + in TpSessionID sessionID, + in TpApplicationDescription applicationDescription, + in TpChargingParameterSet chargingParameters, + in TpChargingPrice amount, + in TpInt32 requestNumber + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_AMOUNT,P_INVALID_CURRENCY,P_INVALID_REQUEST_NUMBER); + + void directDebitUnitReq ( + in TpSessionID sessionID, + in TpApplicationDescription applicationDescription, + in TpChargingParameterSet chargingParameters, + in TpVolumeSet volumes, + in TpInt32 requestNumber + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_VOLUME,P_INVALID_REQUEST_NUMBER); + + void extendLifeTimeReq ( + in TpSessionID sessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + TpChargingPrice getAmountLeft ( + in TpSessionID sessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + TpInt32 getLifeTimeLeft ( + in TpSessionID sessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + TpVolumeSet getUnitLeft ( + in TpSessionID sessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void rateReq ( + in TpSessionID sessionID, + in TpChargingParameterSet chargingParameters + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void release ( + in TpSessionID sessionID, + in TpInt32 requestNumber + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_REQUEST_NUMBER); + + void reserveAmountReq ( + in TpSessionID sessionID, + in TpApplicationDescription applicationDescription, + in TpChargingParameterSet chargingParameters, + in TpChargingPrice preferredAmount, + in TpChargingPrice minimumAmount, + in TpInt32 requestNumber + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_AMOUNT,P_INVALID_CURRENCY,P_INVALID_REQUEST_NUMBER); + + void reserveUnitReq ( + in TpSessionID sessionID, + in TpApplicationDescription applicationDescription, + in TpChargingParameterSet chargingParameters, + in TpVolumeSet volumes, + in TpInt32 requestNumber + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_VOLUME,P_INVALID_REQUEST_NUMBER); + + }; + + + interface IpAppChargingManager : IpInterface { + void sessionAborted ( + in TpSessionID sessionID + ); + + void abortMultipleChargingSessions ( + in TpSessionIDSet chargingSessionSet + ); + + }; + + + interface IpChargingManager : IpService { + TpChargingSessionID createChargingSession ( + in IpAppChargingSession appChargingSession, + in TpString sessionDescription, + in TpMerchantAccountID merchantAccount, + in TpAddress user, + in TpCorrelationID correlationID + ) + raises (TpCommonExceptions,P_INVALID_USER,P_INVALID_ACCOUNT); + + TpChargingSessionID createSplitChargingSession ( + in IpAppChargingSession appChargingSession, + in TpString sessionDescription, + in TpMerchantAccountID merchantAccount, + in TpAddressSet users, + in TpCorrelationID correlationID + ) + raises (TpCommonExceptions,P_INVALID_USER,P_INVALID_ACCOUNT); + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/dsc.idl b/idl/parlay/dsc.idl new file mode 100644 index 0000000000..a04934f993 --- /dev/null +++ b/idl/parlay/dsc.idl @@ -0,0 +1,342 @@ +//Source file: dsc.idl +//Date: 11 October 2004 +//Data Session Control Interfaces and Data Types for ETSI ES 203 915-08 V1.1.1, DES/TISPAN-01005-08-OSA, Parlay 5.0 + + +#ifndef __DSC_DEFINED +#define __DSC_DEFINED + + +#include "osa.idl" + +module org { + + module csapi { + + + module dsc { + interface IpAppDataSessionControlManager ; + interface IpDataSessionControlManager ; + interface IpDataSession; + + + const TpInt32 P_DATA_SESSION_SUPERVISE_INFORM = 4; + + const TpInt32 P_DATA_SESSION_SUPERVISE_DATA_SESSION_ENDED = 2; + + const TpInt32 P_DATA_SESSION_SUPERVISE_MESSAGE_SENT = 4; + + const TpInt32 P_DATA_SESSION_SUPERVISE_RELEASE = 1; + + const TpInt32 P_DATA_SESSION_SUPERVISE_RESPOND = 2; + + const TpInt32 P_DATA_SESSION_SUPERVISE_VOLUME_REACHED = 1; + + + struct TpChargePerVolume { + TpInt32 InitialCharge; + TpInt32 CurrentChargePerKilobyte; + TpInt32 NextChargePerKilobyte; + }; + + enum TpDataSessionChargeOrderCategory { + + P_DATA_SESSION_CHARGE_PER_VOLUME, + P_DATA_SESSION_CHARGE_NETWORK + }; + + + union TpDataSessionChargeOrder switch(TpDataSessionChargeOrderCategory) { + case P_DATA_SESSION_CHARGE_PER_VOLUME: TpChargePerVolume ChargePerVolume; + case P_DATA_SESSION_CHARGE_NETWORK: TpString NetworkCharge; + }; + + + struct TpDataSessionChargePlan { + TpDataSessionChargeOrder ChargeOrderType; + TpString Currency; + TpString AdditionalInfo; + }; + + + enum TpDataSessionErrorType { + + P_DATA_SESSION_ERROR_UNDEFINED, + P_DATA_SESSION_ERROR_INVALID_ADDRESS, + P_DATA_SESSION_ERROR_INVALID_STATE + }; + + + union TpDataSessionAdditionalErrorInfo switch(TpDataSessionErrorType) { + case P_DATA_SESSION_ERROR_INVALID_ADDRESS: TpAddressError DataSessionErrorInvalidAddress; + default: short Dummy; + }; + + + struct TpDataSessionError { + TpDateAndTime ErrorTime; + TpDataSessionErrorType ErrorType; + TpDataSessionAdditionalErrorInfo AdditionalErrorInfo; + }; + + + typedef TpInt32 TpDataSessionEventName; + + + enum TpDataSessionFault { + + P_DATA_SESSION_FAULT_UNDEFINED, + P_DATA_SESSION_FAULT_USER_ABORTED, + P_DATA_SESSION_TIMEOUT_ON_RELEASE, + P_DATA_SESSION_TIMEOUT_ON_INTERRUPT + }; + + + enum TpDataSessionMonitorMode { + + P_DATA_SESSION_MONITOR_MODE_INTERRUPT, + P_DATA_SESSION_MONITOR_MODE_NOTIFY, + P_DATA_SESSION_MONITOR_MODE_DO_NOT_MONITOR + }; + + + struct TpDataSessionEventCriteria { + TpAddressRange DestinationAddress; + TpAddressRange OriginationAddress; + TpDataSessionEventName DataSessionEventName; + TpDataSessionMonitorMode MonitorMode; + }; + + + struct TpDataSessionEventInfo { + TpAddress DestinationAddress; + TpAddress OriginatingAddress; + TpDataSessionEventName DataSessionEventName; + TpDataSessionMonitorMode MonitorMode; + TpDataSessionQosClass QoSClass; + }; + + + struct TpDataSessionReleaseCause { + TpInt32 Value; + TpInt32 Location; + }; + + + enum TpDataSessionReportType { + + P_DATA_SESSION_REPORT_UNDEFINED, + P_DATA_SESSION_REPORT_CONNECTED, + P_DATA_SESSION_REPORT_DISCONNECT + }; + + + union TpDataSessionAdditionalReportInfo switch(TpDataSessionReportType) { + case P_DATA_SESSION_REPORT_DISCONNECT: TpDataSessionReleaseCause DataSessionDisconnect; + default: short Dummy; + }; + + + struct TpDataSessionReport { + TpDataSessionMonitorMode MonitorMode; + TpDateAndTime DataSessionEventTime; + TpDataSessionReportType DataSessionReportType; + TpDataSessionAdditionalReportInfo AdditionalReportInfo; + }; + + + struct TpDataSessionReportRequest { + TpDataSessionMonitorMode MonitorMode; + TpDataSessionReportType DataSessionReportType; + }; + + + typedef sequence TpDataSessionReportRequestSet; + + + typedef TpInt32 TpDataSessionSuperviseReport; + + + typedef TpInt32 TpDataSessionSuperviseTreatment; + + + struct TpDataSessionSuperviseVolume { + TpInt32 VolumeQuantity; + TpInt32 VolumeUnit; + }; + + + const TpInt32 P_EVENT_NAME_UNDEFINED = 0; + + const TpInt32 P_EVENT_DSCS_SETUP = 1; + + const TpInt32 P_EVENT_DSCS_ESTABLISHED = 2; + const TpInt32 P_EVENT_NAME_QOD_CHANGED = 4; + + struct TpDataSessionEventCriteriaResult { + TpDataSessionEventCriteria EventCriteria; + TpAssignmentID AssignmentID; + }; + + + typedef sequence TpDataSessionEventCriteriaResultSet; + + + const TpInt32 P_EVENT_DSCS_QOS_CHANGED = 4; + + struct TpDataSessionIdentifier { + IpDataSession DataSessionReference; + TpSessionID DataSessionID; + }; + + + interface IpAppDataSession : IpInterface { + + void connectRes ( + in TpSessionID dataSessionID, + in TpDataSessionReport eventReport, + in TpAssignmentID assignmentID + ); + + void connectErr ( + in TpSessionID dataSessionID, + in TpDataSessionError errorIndication, + in TpAssignmentID assignmentID + ); + + void superviseDataSessionRes ( + in TpSessionID dataSessionID, + in TpDataSessionSuperviseReport report, + in TpDataSessionSuperviseVolume usedVolume, + in TpDataSessionQosClass qualityOfService + ); + + void superviseDataSessionErr ( + in TpSessionID dataSessionID, + in TpDataSessionError errorIndication + ); + + void dataSessionFaultDetected ( + in TpSessionID dataSessionID, + in TpDataSessionFault fault + ); + + }; + + + interface IpAppDataSessionControlManager : IpInterface { + + void dataSessionAborted ( + in TpSessionID dataSession + ); + + IpAppDataSession reportNotification ( + in TpDataSessionIdentifier dataSessionReference, + in TpDataSessionEventInfo eventInfo, + in TpAssignmentID assignmentID + ); + + void dataSessionNotificationContinued (); + + void dataSessionNotificationInterrupted (); + + void abortMultipleDataSessions ( + in TpSessionIDSet dataSessionSet + ); + + }; + + + interface IpDataSession : IpService { + + TpAssignmentID connectReq ( + in TpSessionID dataSessionID, + in TpDataSessionReportRequestSet responseRequested, + in TpAddress targetAddress + ) + raises (TpCommonExceptions,P_INVALID_NETWORK_STATE,P_INVALID_ADDRESS,P_INVALID_SESSION_ID); + + void release ( + in TpSessionID dataSessionID, + in TpDataSessionReleaseCause cause + ) + raises (TpCommonExceptions,P_INVALID_NETWORK_STATE,P_INVALID_SESSION_ID); + + void superviseDataSessionReq ( + in TpSessionID dataSessionID, + in TpDataSessionSuperviseTreatment treatment, + in TpDataSessionSuperviseVolume bytes + ) + raises (TpCommonExceptions,P_INVALID_NETWORK_STATE,P_INVALID_SESSION_ID); + + void setDataSessionChargePlan ( + in TpSessionID dataSessionID, + in TpDataSessionChargePlan dataSessionChargePlan + ) + raises (TpCommonExceptions,P_INVALID_NETWORK_STATE,P_INVALID_SESSION_ID); + + void setAdviceOfCharge ( + in TpSessionID dataSessionID, + in TpAoCInfo aoCInfo, + in TpDuration tariffSwitch + ) + raises (TpCommonExceptions,P_INVALID_NETWORK_STATE,P_INVALID_TIME_AND_DATE_FORMAT); + + void deassignDataSession ( + in TpSessionID dataSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void continueProcessing ( + in TpSessionID dataSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE); + + }; + + + interface IpDataSessionControlManager : IpService { + + TpAssignmentID createNotification ( + in IpAppDataSessionControlManager appDataSessionControlManager, + in TpDataSessionEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_INVALID_NETWORK_STATE,P_INVALID_CRITERIA,P_INVALID_EVENT_TYPE); + + void destroyNotification ( + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_INVALID_NETWORK_STATE,P_INVALID_ASSIGNMENT_ID); + + void changeNotification ( + in TpAssignmentID assignmentID, + in TpDataSessionEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_INVALID_NETWORK_STATE,P_INVALID_ASSIGNMENT_ID,P_INVALID_CRITERIA,P_INVALID_EVENT_TYPE); + + TpAssignmentID enableNotifications ( + in IpAppDataSessionControlManager appDataSessionControlManager + ) + raises (TpCommonExceptions); + + void disableNotifications () + raises (TpCommonExceptions); + + TpDataSessionEventCriteriaResultSet getNotifications () + raises (TpCommonExceptions,P_INVALID_NETWORK_STATE); + + TpAssignmentID createNotifications ( + in IpAppDataSessionControlManager appDataSessionControlManager, + in TpDataSessionEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_INVALID_NETWORK_STATE,P_INVALID_CRITERIA,P_INVALID_EVENT_TYPE,P_INVALID_INTERFACE_TYPE); + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/fw_data.idl b/idl/parlay/fw_data.idl new file mode 100644 index 0000000000..605e101dc8 --- /dev/null +++ b/idl/parlay/fw_data.idl @@ -0,0 +1,820 @@ +//Source file: fw_data.idl +//Date: 13 October 2004 +//Framework Data Types for ES 203 915-03 V1.1.1, DES/TISPAN-01005-03-OSA, Parlay 5.0 + +#ifndef __FW_DATA_DEFINED +#define __FW_DATA_DEFINED + +#include "osa.idl" + +module org { + + module csapi { + + module fw { + + + typedef TpString TpAccessType; + + + typedef TpInt32 TpActivityTestID; + + + typedef TpString TpActivityTestRes; + + + enum TpAPIUnavailReason { + + API_UNAVAILABLE_UNDEFINED, + API_UNAVAILABLE_LOCAL_FAILURE, + API_UNAVAILABLE_GATEWAY_FAILURE, + API_UNAVAILABLE_OVERLOADED, + API_UNAVAILABLE_CLOSED, + API_UNAVAILABLE_PROTOCOL_FAILURE + }; + + + typedef TpString TpEncryptionCapability; + + + typedef TpString TpEncryptionCapabilityList; + + + typedef TpString TpAuthType; + + + typedef TpString TpClientAppID; + + + typedef sequence TpClientAppIDList; + + + enum TpDomainIDType { + + P_FW, + P_CLIENT_APPLICATION, + P_ENT_OP, + P_SERVICE_INSTANCE, + P_SERVICE_SUPPLIER + }; + + + typedef TpString TpEmail; + + + typedef TpString TpEntOpID; + + + typedef sequence TpEntOpIDList; + + + enum TpFwEventName { + + P_EVENT_FW_NAME_UNDEFINED, + P_EVENT_FW_SERVICE_AVAILABLE, + P_EVENT_FW_SERVICE_UNAVAILABLE, + P_EVENT_FW_MIGRATION_SERVICE_AVAILABLE, + P_EVENT_FW_APP_SESSION_CREATED, + P_EVENT_FW_APP_SESSION_TERMINATED, + P_EVENT_FW_APP_AGREEMENT_SIGNED, + P_EVENT_FW_APP_AGREEMENT_ENDED + }; + + + enum TpFWExceptionType { + + P_FW_DUMMY + }; + + + typedef TpString TpFwID; + + + enum TpFwUnavailReason { + + FW_UNAVAILABLE_UNDEFINED, + FW_UNAVAILABLE_LOCAL_FAILURE, + FW_UNAVAILABLE_GATEWAY_FAILURE, + FW_UNAVAILABLE_OVERLOADED, + FW_UNAVAILABLE_CLOSED, + FW_UNAVAILABLE_PROTOCOL_FAILURE + }; + + + typedef TpString TpHomePage; + + + enum TpInterfaceFault { + + INTERFACE_FAULT_UNDEFINED, + INTERFACE_FAULT_LOCAL_FAILURE, + INTERFACE_FAULT_GATEWAY_FAILURE, + INTERFACE_FAULT_PROTOCOL_ERROR + }; + + + struct TpFaultStats { + TpInterfaceFault Fault; + TpInt32 Occurrences; + TpInt32 MaxDuration; + TpInt32 TotalDuration; + TpInt32 NumberOfClientsAffected; + }; + + + typedef sequence TpFaultStatsSet; + + + struct TpFaultStatsRecord { + TpTimeInterval Period; + TpFaultStatsSet FaultStatsSet; + }; + + + typedef TpString TpInterfaceName; + + + enum TpLoadLevel { + + LOAD_LEVEL_NORMAL, + LOAD_LEVEL_OVERLOAD, + LOAD_LEVEL_SEVERE_OVERLOAD + }; + + + struct TpLoadPolicy { + TpString LoadPolicy; + }; + + + struct TpLoadStatisticData { + TpFloat LoadValue; + TpLoadLevel LoadLevel; + }; + + + enum TpLoadStatisticEntityType { + + P_LOAD_STATISTICS_FW_TYPE, + P_LOAD_STATISTICS_SVC_TYPE, + P_LOAD_STATISTICS_APP_TYPE + }; + + + enum TpLoadStatisticInfoType { + + P_LOAD_STATISTICS_VALID, + P_LOAD_STATISTICS_INVALID + }; + + + enum TpLoadStatusError { + + LOAD_STATUS_ERROR_UNDEFINED, + LOAD_STATUS_ERROR_UNAVAILABLE + }; + + + struct TpLoadThreshold { + TpFloat LoadThreshold; + }; + + + struct TpLoadInitVal { + TpLoadLevel LoadLevel; + TpLoadThreshold LoadThreshold; + }; + + + typedef TpString TpPersonName; + + + typedef TpString TpPostalAddress; + + + typedef TpString TpPropertyName; + + + typedef TpString TpPropertyValue; + + + struct TpProperty { + TpPropertyName PropertyName; + TpPropertyValue PropertyValue; + }; + + + typedef sequence TpPropertyList; + + + typedef TpPropertyList TpClientAppProperties; + + + struct TpClientAppDescription { + TpClientAppID ClientAppID; + TpClientAppProperties ClientAppProperties; + TpBoolean HasAccessSession; + TpBoolean HasServiceInstances; + }; + + + typedef TpPropertyList TpEndAccessProperties; + + + typedef TpPropertyList TpEntOpProperties; + + + struct TpEntOp { + TpEntOpID EntOpID; + TpEntOpProperties EntOpProperties; + }; + + + typedef TpPropertyList TpPersonProperties; + + + typedef TpString TpSagDescription; + + + typedef TpString TpSagID; + + + struct TpSag { + TpSagID SagID; + TpSagDescription SagDescription; + }; + + + typedef sequence TpSagIDList; + + + typedef TpString TpServiceContractID; + + + typedef TpDateAndTime TpServiceEndDate; + + + typedef TpString TpServiceID; + + + typedef sequence TpServiceIDList; + + + typedef TpString TpServiceProfileID; + + + typedef sequence TpServiceProfileIDList; + + + enum TpServiceTypePropertyMode { + + NORMAL, + MANDATORY, + _READONLY, + MANDATORY_READONLY + }; + + + typedef TpString TpServicePropertyName; + + + typedef sequence TpServicePropertyNameList; + + + typedef TpString TpServicePropertyTypeName; + + + typedef TpString TpServicePropertyValue; + + + typedef sequence TpServicePropertyValueList; + + + struct TpServiceProperty { + TpServicePropertyName ServicePropertyName; + TpServicePropertyValueList ServicePropertyValueList; + }; + + + typedef sequence TpServicePropertyList; + + + typedef TpDateAndTime TpServiceStartDate; + + + typedef TpServicePropertyList TpServiceSubscriptionProperties; + + + typedef TpString TpServiceSupplierID; + + + typedef TpString TpServiceToken; + + + typedef TpString TpServiceTypeName; + + + struct TpServiceDescription { + TpServiceTypeName ServiceTypeName; + TpServicePropertyList ServicePropertyList; + }; + + + struct TpService { + TpServiceID ServiceID; + TpServiceDescription ServiceDescription; + }; + + + typedef sequence TpServiceList; + + + struct TpServiceProfileDescription { + TpServiceContractID ServiceContractID; + TpServiceStartDate ServiceStartDate; + TpServiceEndDate ServiceEndDate; + TpServiceTypeName ServiceTypeName; + TpServiceSubscriptionProperties ServiceSubscriptionProperties; + TpBoolean InUse; + TpServiceID ServiceID; + }; + + + typedef sequence TpServiceTypeNameList; + + + union TpFwEventCriteria switch(TpFwEventName) { + case P_EVENT_FW_NAME_UNDEFINED: TpString EventNameUndefined; + case P_EVENT_FW_SERVICE_AVAILABLE: TpServiceTypeNameList ServiceTypeNameList; + case P_EVENT_FW_SERVICE_UNAVAILABLE: TpServiceTypeNameList UnavailableServiceTypeNameList; + case P_EVENT_FW_MIGRATION_SERVICE_AVAILABLE: TpServiceTypeNameList CompatibleServiceTypeNameList; + case P_EVENT_FW_APP_SESSION_CREATED: TpClientAppIDList SessionCreatedList; + case P_EVENT_FW_APP_SESSION_TERMINATED: TpClientAppIDList SessionTerminatedList; + case P_EVENT_FW_APP_AGREEMENT_SIGNED: TpClientAppIDList AgreementSignedList; + case P_EVENT_FW_APP_AGREEMENT_ENDED: TpClientAppIDList AgreementEndedList; + }; + + + struct TpServiceTypeProperty { + TpServicePropertyName ServicePropertyName; + TpServiceTypePropertyMode ServiceTypePropertyMode; + TpServicePropertyTypeName ServicePropertyTypeName; + }; + + + typedef sequence TpServiceTypePropertyList; + + + struct TpServiceTypeDescription { + TpServiceTypePropertyList ServiceTypePropertyList; + TpServiceTypeNameList ServiceTypeNameList; + TpBoolean AvailableOrUnavailable; + }; + + + struct TpSignatureAndServiceMgr { + TpOctetSet DigitalSignature; + IpService ServiceMgrInterface; + }; + + + typedef TpString TpSigningAlgorithm; + + + enum TpSvcUnavailReason { + + SERVICE_UNAVAILABLE_UNDEFINED, + SERVICE_UNAVAILABLE_LOCAL_FAILURE, + SERVICE_UNAVAILABLE_GATEWAY_FAILURE, + SERVICE_UNAVAILABLE_OVERLOADED, + SERVICE_UNAVAILABLE_CLOSED + }; + + + typedef TpString TpTelephoneNumber; + + + struct TpPerson { + TpPersonName PersonName; + TpPostalAddress PostalAddress; + TpTelephoneNumber TelephoneNumber; + TpEmail Email; + TpHomePage HomePage; + TpPersonProperties PersonProperties; + }; + + + typedef TpPerson TpBillingContact; + + + typedef TpPerson TpServiceRequestor; + + + struct TpServiceContractDescription { + TpServiceRequestor ServiceRequestor; + TpBillingContact BillingContact; + TpServiceStartDate ServiceStartDate; + TpServiceEndDate ServiceEndDate; + TpServiceTypeName ServiceTypeName; + TpServiceID ServiceID; + TpServiceSubscriptionProperties ServiceSubscriptionProperties; + TpBoolean InUse; + }; + + + union TpLoadStatisticEntityID switch(TpLoadStatisticEntityType) { + case P_LOAD_STATISTICS_FW_TYPE: TpFwID FrameworkID; + case P_LOAD_STATISTICS_SVC_TYPE: TpServiceID ServiceID; + case P_LOAD_STATISTICS_APP_TYPE: TpClientAppID ClientAppID; + }; + + + enum TpLoadStatisticError { + + P_LOAD_INFO_ERROR_UNDEFINED, + P_LOAD_INFO_UNAVAILABLE + }; + + typedef sequence TpLoadStatisticErrorList; + + + union TpLoadStatisticInfo switch(TpLoadStatisticInfoType) { + case P_LOAD_STATISTICS_VALID: TpLoadStatisticData LoadStatisticData; + case P_LOAD_STATISTICS_INVALID: TpLoadStatisticError LoadStatisticError; + }; + + + struct TpLoadStatistic { + TpLoadStatisticEntityID LoadStatisticEntityID; + TpDateAndTime TimeStamp; + TpLoadStatisticInfo LoadStatisticInfo; + }; + + + typedef sequence TpLoadStatisticList; + + + exception P_INVALID_SERVICE_ID { + TpString ExtraInformation; + }; + + + exception P_SERVICE_ACCESS_DENIED { + TpString ExtraInformation; + }; + + + exception P_ACCESS_DENIED { + TpString ExtraInformation; + }; + + + exception P_SERVICE_NOT_ENABLED { + TpString ExtraInformation; + }; + + + exception P_INVALID_ENCRYPTION_CAPABILITY { + TpString ExtraInformation; + }; + + + exception P_NO_ACCEPTABLE_ENCRYPTION_CAPABILITY { + TpString ExtraInformation; + }; + + + exception P_INVALID_AGREEMENT_TEXT { + TpString ExtraInformation; + }; + + + exception P_INVALID_SERVICE_TOKEN { + TpString ExtraInformation; + }; + + + exception P_INVALID_SIGNATURE { + TpString ExtraInformation; + }; + + + exception P_INVALID_SIGNING_ALGORITHM { + TpString ExtraInformation; + }; + + + exception P_INVALID_DOMAIN_ID { + TpString ExtraInformation; + }; + + + exception P_INVALID_PROPERTY { + TpString ExtraInformation; + }; + + + struct TpServiceContract { + TpServiceContractID ServiceContractID; + TpServiceContractDescription ServiceContractDescription; + }; + + + struct TpServiceProfile { + TpServiceProfileID ServiceProfileID; + TpServiceProfileDescription ServiceProfileDescription; + }; + + + exception P_INVALID_ACCESS_TYPE { + TpString ExtraInformation; + }; + + + exception P_ILLEGAL_SERVICE_TYPE { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_SERVICE_TYPE { + TpString ExtraInformation; + }; + + + exception P_MISSING_MANDATORY_PROPERTY { + TpString ExtraInformation; + }; + + + exception P_DUPLICATE_PROPERTY_NAME { + TpString ExtraInformation; + }; + + + exception P_PROPERTY_TYPE_MISMATCH { + TpString ExtraInformation; + }; + + + exception P_INVALID_SERVICE_TYPE { + TpString ExtraInformation; + }; + + + exception P_INVALID_CLIENT_APP_ID { + TpString ExtraInformation; + }; + + + exception P_INVALID_AUTH_TYPE { + TpString ExtraInformation; + }; + + + exception P_INVALID_SAG_ID { + TpString ExtraInformation; + }; + + + exception P_INVALID_SERVICE_PROFILE_ID { + TpString ExtraInformation; + }; + + + exception P_INVALID_SERVICE_CONTRACT_ID { + TpString ExtraInformation; + }; + + + exception P_INVALID_ACTIVITY_TEST_ID { + TpString ExtraInformation; + }; + + + exception P_INVALID_ENT_OP_ID { + TpString ExtraInformation; + }; + + + exception P_ILLEGAL_SERVICE_ID { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_SERVICE_ID { + TpString ExtraInformation; + }; + + + typedef sequence TpInterfaceNameList; + + + enum TpSubjectType { + + P_SUBJECT_UNDEFINED, + P_SUBJECT_CLIENT_APP, + P_SUBJECT_FW + }; + + + enum TpFaultStatisticsError { + + P_FAULT_INFO_ERROR_UNDEFINED, + P_FAULT_INFO_UNAVAILABLE + }; + + + typedef TpString TpServiceInstanceID; + + + union TpDomainID switch(TpDomainIDType) { + case P_FW: TpFwID FwID; + case P_CLIENT_APPLICATION: TpClientAppID ClientAppID; + case P_ENT_OP: TpEntOpID EntOpID; + case P_SERVICE_INSTANCE: TpServiceInstanceID ServiceID; + case P_SERVICE_SUPPLIER: TpServiceSupplierID ServiceSupplierID; + }; + + + struct TpAuthDomain { + TpDomainID DomainID; + IpInterface AuthInterface; + }; + + + typedef sequence TpServiceContractIDList; + + + exception P_SERVICE_TYPE_UNAVAILABLE { + TpString ExtraInformation; + }; + + + struct TpSagProfilePair { + TpSagID Sag; + TpServiceProfileID ServiceProfile; + }; + + + struct TpAddSagMembersConflict { + TpClientAppID ClientApplication; + TpSagProfilePair ConflictGeneratingSagProfilePair; + TpSagProfilePair AlreadyAssignedSagProfilePair; + TpServiceID Service; + }; + + + typedef sequence TpAddSagMembersConflictList; + + + struct TpAssignSagToServiceProfileConflict { + TpClientAppID ClientApplication; + TpSagProfilePair AlreadyAssignedSagProfilePair; + TpServiceID Service; + }; + + + typedef sequence TpAssignSagToServiceProfileConflictList; + + + exception P_INVALID_ADDITION_TO_SAG { + TpString ExtraInformation; + }; + + + exception P_INVALID_SAG_TO_SERVICE_PROFILE_ASSIGNMENT { + TpString ExtraInformation; + }; + + + typedef TpString TpAuthMechanism; + + + typedef TpString TpAuthMechanismList; + + + typedef TpString TpSigningAlgorithmCapabilityList; + + + exception P_NO_ACCEPTABLE_AUTHENTICATION_MECHANISM { + TpString ExtraInformation; + }; + + + exception P_NO_ACCEPTABLE_SIGNING_ALGORITHM { + TpString ExtraInformation; + }; + + + enum TpSvcAvailStatusReason { + + SVC_UNAVAILABLE_UNDEFINED, + SVC_UNAVAILABLE_LOCAL_FAILURE, + SVC_UNAVAILABLE_GATEWAY_FAILURE, + SVC_UNAVAILABLE_OVERLOADED, + SVC_UNAVAILABLE_CLOSED, + SVC_UNAVAILABLE_NO_RESPONSE, + SVC_UNAVAILABLE_SW_UPGRADE, + SVC_AVAILABLE + }; + + + enum TpAppAvailStatusReason { + + APP_UNAVAILABLE_UNDEFINED, + APP_UNAVAILABLE_LOCAL_FAILURE, + APP_UNAVAILABLE_REMOTE_FAILURE, + APP_UNAVAILABLE_OVERLOADED, + APP_UNAVAILABLE_CLOSED, + APP_UNAVAILABLE_NO_RESPONSE, + APP_UNAVAILABLE_SW_UPGRADE, + APP_AVAILABLE + }; + + + typedef TpInt32 TpLoadTestID; + + + typedef sequence TpFaultStatsErrorList; + + + typedef TpInt32 TpFaultReqID; + + + struct TpServiceTypePropertyValue { + TpServicePropertyName ServicePropertyName; + TpServiceTypePropertyMode ServiceTypePropertyMode; + TpServicePropertyTypeName ServicePropertyTypeName; + TpServicePropertyValueList ServicePropertyValueList; + }; + + + typedef sequence TpServiceTypePropertyValueList; + + + enum TpMigrationAdditionalInfoType { + + P_MIGRATION_INFO_UNDEFINED + }; + + + union TpMigrationAdditionalInfo switch(TpMigrationAdditionalInfoType) { + default: short Dummy; + }; + + + typedef sequence TpMigrationAdditionalInfoSet; + + + struct TpFwMigrationServiceAvailableInfo { + TpServiceTypeName ServiceType; + TpServiceID ServiceID; + TpServiceID CompatibleServiceID; + TpBoolean BackwardCompatibilityLevel; + TpBoolean MigrationRequired; + TpBoolean DataMigrated; + TpDateAndTime MigrationDataAndTime; + TpMigrationAdditionalInfoSet MigrationAdditionalInfo; + }; + + + enum TpFwAvailStatusReason { + + FRAMEWORK_UNAVAILABLE_UNDEFINED, + FRAMEWORK_UNAVAILABLE_LOCAL_FAILURE, + FRAMEWORK_UNAVAILABLE_REMOTE_FAILURE, + FRAMEWORK_UNAVAILABLE_OVERLOADED, + FRAMEWORK_UNAVAILABLE_CLOSED, + FRAMEWORK_UNAVAILABLE_PROTOCOL_FAILURE, + FRAMEWORK_UNAVAILABLE_SW_UPGRADE, + FRAMEWORK_AVAILABLE + }; + + + struct TpFwAgreementInfo { + TpClientAppID ClientApplicationID; + TpServiceID ServiceID; + TpServiceContractID ServiceContractID; + TpServiceProfileID ServiceProfileID; + }; + + + union TpFwEventInfo switch(TpFwEventName) { + case P_EVENT_FW_NAME_UNDEFINED: TpString EventNameUndefined; + case P_EVENT_FW_SERVICE_AVAILABLE: TpServiceIDList ServiceIDList; + case P_EVENT_FW_SERVICE_UNAVAILABLE: TpServiceIDList UnavailableServiceIDList; + case P_EVENT_FW_MIGRATION_SERVICE_AVAILABLE: TpFwMigrationServiceAvailableInfo MigrationServiceAvailable; + case P_EVENT_FW_APP_SESSION_CREATED: TpClientAppID AppSessionCreated; + case P_EVENT_FW_APP_SESSION_TERMINATED: TpClientAppID AppSessionTerminated; + case P_EVENT_FW_APP_AGREEMENT_SIGNED: TpFwAgreementInfo AppAgreementSigned; + case P_EVENT_FW_APP_AGREEMENT_ENDED: TpFwAgreementInfo AppAgreementEnded; + }; + + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/fw_if.idl b/idl/parlay/fw_if.idl new file mode 100644 index 0000000000..7c07f43002 --- /dev/null +++ b/idl/parlay/fw_if.idl @@ -0,0 +1,1361 @@ +//Source file: fw_if_access.idl +//Date: 13 October 2004 +//Framework Access Interfaces for ES 203 915-03 V1.1.1, DES/TISPAN-01005-03-OSA, Parlay 5.0 + +#ifndef __FW_IF_ACCESS_DEFINED +#define __FW_IF_ACCESS_DEFINED + + +#include "osa.idl" +#include "fw_data.idl" + +module org { + + module csapi { + + module fw { + + module fw_access { + + + module trust_and_security { + + + interface IpInitial : IpInterface { + TpAuthDomain initiateAuthentication ( + in TpAuthDomain clientDomain, + in TpAuthType authType + ) + raises (TpCommonExceptions,P_INVALID_DOMAIN_ID,P_INVALID_INTERFACE_TYPE,P_INVALID_AUTH_TYPE); + + TpAuthDomain initiateAuthenticationWithVersion ( + in TpAuthDomain clientDomain, + in TpAuthType authType, + in TpVersion frameworkVersion + ) + raises (TpCommonExceptions,P_INVALID_DOMAIN_ID,P_INVALID_INTERFACE_TYPE,P_INVALID_AUTH_TYPE,P_INVALID_VERSION); + + }; + + + interface IpAuthentication : IpInterface { + IpInterface requestAccess ( + in TpAccessType accessType, + in IpInterface clientAccessInterface + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_ACCESS_TYPE,P_INVALID_INTERFACE_TYPE); + + }; + + + interface IpClientAccess : IpInterface { + void terminateAccess ( + in TpString terminationText, + in TpSigningAlgorithm signingAlgorithm, + in TpOctetSet digitalSignature + ) + raises (TpCommonExceptions,P_INVALID_SIGNING_ALGORITHM,P_INVALID_SIGNATURE); + + }; + + + interface IpAccess : IpInterface { + IpInterface obtainInterface ( + in TpInterfaceName interfaceName + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_INTERFACE_NAME); + + IpInterface obtainInterfaceWithCallback ( + in TpInterfaceName interfaceName, + in IpInterface clientInterface + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_INTERFACE_NAME,P_INVALID_INTERFACE_TYPE); + + void endAccess ( + in TpEndAccessProperties endAccessProperties + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_PROPERTY); + + TpInterfaceNameList listInterfaces () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + void releaseInterface ( + in TpInterfaceName interfaceName + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_INTERFACE_NAME); + + TpSigningAlgorithm selectSigningAlgorithm ( + in TpSigningAlgorithmCapabilityList signingAlgorithmCaps + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_NO_ACCEPTABLE_SIGNING_ALGORITHM); + + void terminateAccess ( + in TpString terminationText, + in TpOctetSet digitalSignature + ) + raises (TpCommonExceptions,P_INVALID_SIGNATURE); + + void relinquishInterface ( + in TpInterfaceName interfaceName, + in TpString terminationText, + in TpOctetSet digitalSignature + ) + raises (TpCommonExceptions,P_INVALID_SIGNATURE,P_INVALID_INTERFACE_NAME); + + }; + + + interface IpClientAPILevelAuthentication : IpInterface { + TpOctetSet authenticate ( + in TpOctetSet challenge + ); + + void abortAuthentication (); + + void authenticationSucceeded (); + + TpOctetSet challenge ( + in TpOctetSet challenge + ); + + }; + + + interface IpAPILevelAuthentication : IpAuthentication { + TpEncryptionCapability selectEncryptionMethod ( + in TpEncryptionCapabilityList encryptionCaps + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_NO_ACCEPTABLE_ENCRYPTION_CAPABILITY); + + TpOctetSet authenticate ( + in TpOctetSet challenge + ) + raises (TpCommonExceptions,P_ACCESS_DENIED); + + void abortAuthentication () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + void authenticationSucceeded () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + TpAuthMechanism selectAuthenticationMechanism ( + in TpAuthMechanismList authMechanismList + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_NO_ACCEPTABLE_AUTHENTICATION_MECHANISM); + + TpOctetSet challenge ( + in TpOctetSet challenge + ) + raises (TpCommonExceptions,P_ACCESS_DENIED); + + }; + + }; + + }; + + + }; + + }; + +}; +module org { + + module csapi { + + module fw { + + module fw_application { + + module notification { + + + interface IpAppEventNotification : IpInterface { + void reportNotification ( + in TpFwEventInfo eventInfo, + in TpAssignmentID assignmentID + ); + + void notificationTerminated (); + + }; + + + interface IpEventNotification : IpInterface { + TpAssignmentID createNotification ( + in TpFwEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CRITERIA,P_INVALID_EVENT_TYPE); + + void destroyNotification ( + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_ASSIGNMENT_ID); + + }; + + }; + + module integrity { + interface IpAppHeartBeatMgmt ; + interface IpHeartBeat ; + interface IpAppHeartBeat ; + + + + interface IpAppFaultManager : IpInterface { + void activityTestRes ( + in TpActivityTestID activityTestID, + in TpActivityTestRes activityTestResult + ); + + void appActivityTestReq ( + in TpActivityTestID activityTestID + ); + + void fwFaultReportInd ( + in TpInterfaceFault fault + ); + + void fwFaultRecoveryInd ( + in TpInterfaceFault fault + ); + + void svcUnavailableInd ( + in TpServiceID serviceID, + in TpSvcUnavailReason reason + ); + + void genFaultStatsRecordRes ( + in TpFaultStatsRecord faultStatistics, + in TpServiceIDList serviceIDs + ); + + void fwUnavailableInd ( + in TpFwUnavailReason reason + ); + + void activityTestErr ( + in TpActivityTestID activityTestID + ); + + void genFaultStatsRecordErr ( + in TpFaultStatisticsError faultStatisticsError, + in TpServiceIDList serviceIDs + ); + + void appUnavailableInd ( + in TpServiceID serviceID + ); + + void genFaultStatsRecordReq ( + in TpTimeInterval timePeriod + ); + + void svcAvailStatusInd ( + in TpServiceID serviceID, + in TpSvcAvailStatusReason reason + ); + + void generateFaultStatisticsRecordRes ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatsRecord faultStatistics, + in TpServiceIDList serviceIDs + ); + + void generateFaultStatisticsRecordErr ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatsErrorList faultStatistics, + in TpServiceIDList serviceIDs + ); + + void generateFaultStatisticsRecordReq ( + in TpFaultReqID faultStatsReqID, + in TpTimeInterval timePeriod + ); + + void fwAvailStatusInd ( + in TpFwAvailStatusReason reason + ); + + }; + + + interface IpAppLoadManager : IpInterface { + void queryAppLoadReq ( + in TpTimeInterval timeInterval + ); + + void queryLoadRes ( + in TpLoadStatisticList loadStatistics + ); + + void queryLoadErr ( + in TpLoadStatisticError loadStatisticsError + ); + + void loadLevelNotification ( + in TpLoadStatisticList loadStatistics + ); + + void resumeNotification (); + + void suspendNotification (); + + void createLoadLevelNotification (); + + void destroyLoadLevelNotification (); + + void queryAppLoadStatsReq ( + in TpLoadTestID loadStatsReqID, + in TpTimeInterval timeInterval + ); + + void queryLoadStatsRes ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticList loadStatistics + ); + + void queryLoadStatsErr ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticError loadStatisticsError + ); + + }; + + + interface IpLoadManager : IpInterface { + void reportLoad ( + in TpLoadLevel loadLevel + ) + raises (TpCommonExceptions); + + void queryLoadReq ( + in TpServiceIDList serviceIDs, + in TpTimeInterval timeInterval + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_SERVICE_NOT_ENABLED,P_UNAUTHORISED_PARAMETER_VALUE); + + void queryAppLoadRes ( + in TpLoadStatisticList loadStatistics + ) + raises (TpCommonExceptions); + + void queryAppLoadErr ( + in TpLoadStatisticError loadStatisticsError + ) + raises (TpCommonExceptions); + + void createLoadLevelNotification ( + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_UNAUTHORISED_PARAMETER_VALUE); + + void destroyLoadLevelNotification ( + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_UNAUTHORISED_PARAMETER_VALUE); + + void resumeNotification ( + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_SERVICE_NOT_ENABLED,P_UNAUTHORISED_PARAMETER_VALUE); + + void suspendNotification ( + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_SERVICE_NOT_ENABLED,P_UNAUTHORISED_PARAMETER_VALUE); + + void queryLoadStatsReq ( + in TpLoadTestID loadStatsReqID, + in TpServiceIDList serviceIDs, + in TpTimeInterval timeInterval + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_SERVICE_NOT_ENABLED,P_UNAUTHORISED_PARAMETER_VALUE); + + void queryAppLoadStatsRes ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticList loadStatistics + ) + raises (TpCommonExceptions); + + void queryAppLoadStatsErr ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticError loadStatisticsError + ) + raises (TpCommonExceptions); + + }; + + + interface IpAppOAM : IpInterface { + TpDateAndTime systemDateTimeQuery ( + in TpDateAndTime systemDateAndTime + ); + + }; + + + interface IpOAM : IpInterface { + TpDateAndTime systemDateTimeQuery ( + in TpDateAndTime clientDateAndTime + ) + raises (TpCommonExceptions,P_INVALID_TIME_AND_DATE_FORMAT); + + }; + + + interface IpFaultManager : IpInterface { + void activityTestReq ( + in TpActivityTestID activityTestID, + in TpServiceID svcID + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_UNAUTHORISED_PARAMETER_VALUE); + + void appActivityTestRes ( + in TpActivityTestID activityTestID, + in TpActivityTestRes activityTestResult + ) + raises (TpCommonExceptions,P_INVALID_ACTIVITY_TEST_ID); + + void svcUnavailableInd ( + in TpServiceID serviceID + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_UNAUTHORISED_PARAMETER_VALUE); + + void genFaultStatsRecordReq ( + in TpTimeInterval timePeriod, + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_UNAUTHORISED_PARAMETER_VALUE); + + void appActivityTestErr ( + in TpActivityTestID activityTestID + ) + raises (TpCommonExceptions,P_INVALID_ACTIVITY_TEST_ID); + + void appUnavailableInd ( + in TpServiceID serviceID + ) + raises (TpCommonExceptions); + + void genFaultStatsRecordRes ( + in TpFaultStatsRecord faultStatistics + ) + raises (TpCommonExceptions); + + void genFaultStatsRecordErr ( + in TpFaultStatisticsError faultStatisticsError + ) + raises (TpCommonExceptions); + + void appAvailStatusInd ( + in TpAppAvailStatusReason reason + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordReq ( + in TpFaultReqID faultStatsReqID, + in TpTimeInterval timePeriod, + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_UNAUTHORISED_PARAMETER_VALUE); + + void generateFaultStatisticsRecordRes ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatsRecord faultStatistics + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordErr ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatisticsError faultStatisticsError + ) + raises (TpCommonExceptions); + + }; + + + interface IpHeartBeatMgmt : IpInterface { + + void enableHeartBeat ( + in TpInt32 interval, + in IpAppHeartBeat appInterface + ) + raises (TpCommonExceptions); + + void disableHeartBeat () + raises (TpCommonExceptions); + + void changeInterval ( + in TpInt32 interval + ) + raises (TpCommonExceptions); + + }; + + + interface IpAppHeartBeat : IpInterface { + + void pulse (); + + }; + + + interface IpHeartBeat : IpInterface { + + void pulse () + raises (TpCommonExceptions); + + }; + + + interface IpAppHeartBeatMgmt : IpInterface { + + void enableAppHeartBeat ( + in TpInt32 interval, + in IpHeartBeat fwInterface + ); + + void disableAppHeartBeat (); + + void changeInterval ( + in TpInt32 interval + ); + + }; + + }; + + + module discovery { + + + interface IpServiceDiscovery : IpInterface { + TpServiceTypeNameList listServiceTypes () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + TpServiceTypeDescription describeServiceType ( + in TpServiceTypeName name + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_ILLEGAL_SERVICE_TYPE,P_UNKNOWN_SERVICE_TYPE); + + TpServiceList discoverService ( + in TpServiceTypeName serviceTypeName, + in TpServicePropertyList desiredPropertyList, + in TpInt32 max + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_ILLEGAL_SERVICE_TYPE,P_UNKNOWN_SERVICE_TYPE,P_INVALID_PROPERTY); + + TpServiceList listSubscribedServices () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + }; + + }; + + module service_agreement { + + + interface IpAppServiceAgreementManagement : IpInterface { + TpOctetSet signServiceAgreement ( + in TpServiceToken serviceToken, + in TpString agreementText, + in TpSigningAlgorithm signingAlgorithm + ) + raises (TpCommonExceptions,P_INVALID_AGREEMENT_TEXT,P_INVALID_SERVICE_TOKEN,P_INVALID_SIGNING_ALGORITHM); + + void terminateServiceAgreement ( + in TpServiceToken serviceToken, + in TpString terminationText, + in TpOctetSet digitalSignature + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_TOKEN,P_INVALID_SIGNATURE); + + }; + + + interface IpServiceAgreementManagement : IpInterface { + TpSignatureAndServiceMgr signServiceAgreement ( + in TpServiceToken serviceToken, + in TpString agreementText, + in TpSigningAlgorithm signingAlgorithm + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_AGREEMENT_TEXT,P_INVALID_SERVICE_TOKEN,P_INVALID_SIGNING_ALGORITHM,P_SERVICE_ACCESS_DENIED); + + void terminateServiceAgreement ( + in TpServiceToken serviceToken, + in TpString terminationText, + in TpOctetSet digitalSignature + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_TOKEN,P_INVALID_SIGNATURE); + + TpServiceToken selectService ( + in TpServiceID serviceID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_ID,P_SERVICE_ACCESS_DENIED); + + void initiateSignServiceAgreement ( + in TpServiceToken serviceToken + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_TOKEN,P_SERVICE_ACCESS_DENIED); + + }; + + }; + + }; + + }; + + }; + +}; + +module org { + + module csapi { + + module fw { + + module fw_enterprise_operator { + + + module service_subscription { + + + interface IpServiceProfileManagement : IpInterface { + TpServiceProfileID createServiceProfile ( + in TpServiceProfileDescription serviceProfileDescription + ) + raises (TpCommonExceptions,P_ACCESS_DENIED); + + void modifyServiceProfile ( + in TpServiceProfile serviceProfile + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_PROFILE_ID); + + void deleteServiceProfile ( + in TpServiceProfileID serviceProfileID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_PROFILE_ID); + + void assign ( + in TpSagID sagID, + in TpServiceProfileID serviceProfileID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SAG_ID,P_INVALID_SERVICE_PROFILE_ID,P_INVALID_SAG_TO_SERVICE_PROFILE_ASSIGNMENT); + + void deassign ( + in TpSagID sagID, + in TpServiceProfileID serviceProfileID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SAG_ID,P_INVALID_SERVICE_PROFILE_ID); + + TpAssignSagToServiceProfileConflictList requestConflictInfo () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + }; + + + interface IpServiceProfileInfoQuery : IpInterface { + TpServiceProfileIDList listServiceProfiles () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + TpServiceProfileDescription describeServiceProfile ( + in TpServiceProfileID serviceProfileID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_PROFILE_ID); + + TpSagIDList listAssignedMembers ( + in TpServiceProfileID serviceProfileID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_PROFILE_ID); + + }; + + + interface IpServiceContractManagement : IpInterface { + TpServiceContractID createServiceContract ( + in TpServiceContractDescription serviceContractDescription + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_ID); + + void modifyServiceContract ( + in TpServiceContract serviceContract + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_ID,P_INVALID_SERVICE_CONTRACT_ID); + + void deleteServiceContract ( + in TpServiceContractID serviceContractID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_CONTRACT_ID); + + }; + + + interface IpServiceContractInfoQuery : IpInterface { + TpServiceContractDescription describeServiceContract ( + in TpServiceContractID serviceContractID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_CONTRACT_ID); + + TpServiceContractIDList listServiceContracts () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + TpServiceProfileIDList listServiceProfiles ( + in TpServiceContractID serviceContractID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_CONTRACT_ID); + + }; + + + interface IpEntOpAccountManagement : IpInterface { + void modifyEntOpAccount ( + in TpEntOpProperties enterpriseOperatorProperties + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_PROPERTY); + + void deleteEntOpAccount () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + }; + + + interface IpEntOpAccountInfoQuery : IpInterface { + TpEntOp describeEntOpAccount () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + }; + + + interface IpClientAppManagement : IpInterface { + void createClientApp ( + in TpClientAppDescription clientAppDescription + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID); + + void modifyClientApp ( + in TpClientAppDescription clientAppDescription + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID); + + void deleteClientApp ( + in TpClientAppID clientAppID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID); + + void createSAG ( + in TpSag sag, + in TpClientAppIDList clientAppIDs + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID,P_INVALID_SAG_ID); + + void modifySAG ( + in TpSag sag + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SAG_ID); + + void deleteSAG ( + in TpSagID sagID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SAG_ID); + + void addSAGMembers ( + in TpSagID sagID, + in TpClientAppIDList clientAppIDs + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID,P_INVALID_SAG_ID,P_INVALID_ADDITION_TO_SAG); + + void removeSAGMembers ( + in TpSagID sagID, + in TpClientAppIDList clientAppIDList + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID,P_INVALID_SAG_ID); + + TpAddSagMembersConflictList requestConflictInfo () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + }; + + + interface IpClientAppInfoQuery : IpInterface { + TpClientAppDescription describeClientApp ( + in TpClientAppID clientAppID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID); + + TpClientAppIDList listClientApps () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + TpSagDescription describeSAG ( + in TpSagID sagID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SAG_ID); + + TpSagIDList listSAGs () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + TpClientAppIDList listSAGMembers ( + in TpSagID sagID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SAG_ID); + + TpSagIDList listClientAppMembership ( + in TpClientAppID clientAppID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID); + + }; + + }; + + module notification { + + + interface IpClientEventNotification : IpInterface { + void reportNotification ( + in TpFwEventInfo eventInfo, + in TpAssignmentID assignmentID + ); + + void notificationTerminated (); + + }; + + + interface IpEventNotification : IpInterface { + TpAssignmentID createNotification ( + in TpFwEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CRITERIA,P_INVALID_EVENT_TYPE); + + void destroyNotification ( + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_ASSIGNMENT_ID); + + }; + + }; + + }; + + + }; + + }; + +}; + + +module org { + + module csapi { + + module fw { + + module fw_service { + + module discovery { + + + interface IpFwServiceDiscovery : IpInterface { + TpServiceTypeNameList listServiceTypes () + raises (TpCommonExceptions); + + TpServiceTypeDescription describeServiceType ( + in TpServiceTypeName name + ) + raises (TpCommonExceptions,P_ILLEGAL_SERVICE_TYPE,P_UNKNOWN_SERVICE_TYPE); + + TpServiceList discoverService ( + in TpServiceTypeName serviceTypeName, + in TpServicePropertyList desiredPropertyList, + in TpInt32 max + ) + raises (TpCommonExceptions,P_ILLEGAL_SERVICE_TYPE,P_UNKNOWN_SERVICE_TYPE,P_INVALID_PROPERTY); + + TpServiceList listRegisteredServices () + raises (TpCommonExceptions); + + }; + + }; + + module service_lifecycle { + + + interface IpServiceInstanceLifecycleManager : IpInterface { + IpService createServiceManager ( + in TpClientAppID application, + in TpServicePropertyList serviceProperties, + in TpServiceInstanceID serviceInstanceID + ) + raises (TpCommonExceptions,P_INVALID_PROPERTY); + + void destroyServiceManager ( + in TpServiceInstanceID serviceInstance + ) + raises (TpCommonExceptions); + + }; + + }; + + module service_registration { + + + interface IpFwServiceRegistration : IpInterface { + TpServiceID registerService ( + in TpServiceTypeName serviceTypeName, + in TpServicePropertyList servicePropertyList + ) + raises (TpCommonExceptions,P_PROPERTY_TYPE_MISMATCH,P_DUPLICATE_PROPERTY_NAME,P_ILLEGAL_SERVICE_TYPE,P_UNKNOWN_SERVICE_TYPE,P_MISSING_MANDATORY_PROPERTY,P_SERVICE_TYPE_UNAVAILABLE); + + void announceServiceAvailability ( + in TpServiceID serviceID, + in service_lifecycle::IpServiceInstanceLifecycleManager serviceInstanceLifecycleManagerRef + ) + raises (TpCommonExceptions,P_ILLEGAL_SERVICE_ID,P_UNKNOWN_SERVICE_ID,P_INVALID_INTERFACE_TYPE); + + void unregisterService ( + in TpServiceID serviceID + ) + raises (TpCommonExceptions,P_ILLEGAL_SERVICE_ID,P_UNKNOWN_SERVICE_ID); + + TpServiceDescription describeService ( + in TpServiceID serviceID + ) + raises (TpCommonExceptions,P_ILLEGAL_SERVICE_ID,P_UNKNOWN_SERVICE_ID); + + void unannounceService ( + in TpServiceID serviceID + ) + raises (TpCommonExceptions,P_ILLEGAL_SERVICE_ID,P_UNKNOWN_SERVICE_ID); + + TpServiceID registerServiceSubType ( + in TpServiceTypeName serviceTypeName, + in TpServicePropertyList servicePropertyList, + in TpServiceTypePropertyValueList extendedServicePropertyList + ) + raises (TpCommonExceptions,P_PROPERTY_TYPE_MISMATCH,P_DUPLICATE_PROPERTY_NAME,P_ILLEGAL_SERVICE_TYPE,P_UNKNOWN_SERVICE_TYPE,P_MISSING_MANDATORY_PROPERTY,P_SERVICE_TYPE_UNAVAILABLE); + + }; + + }; + + module integrity { + interface IpSvcHeartBeatMgmt ; + interface IpFwHeartBeat ; + interface IpSvcHeartBeat ; + + + + interface IpSvcLoadManager : IpInterface { + void querySvcLoadReq ( + in TpTimeInterval timeInterval + ) + raises (TpCommonExceptions); + + void queryLoadRes ( + in TpLoadStatisticList loadStatistics + ) + raises (TpCommonExceptions); + + void queryLoadErr ( + in TpLoadStatisticError loadStatisticsError + ) + raises (TpCommonExceptions); + + void loadLevelNotification ( + in TpLoadStatisticList loadStatistics + ) + raises (TpCommonExceptions); + + void suspendNotification () + raises (TpCommonExceptions); + + void resumeNotification () + raises (TpCommonExceptions); + + void createLoadLevelNotification () + raises (TpCommonExceptions); + + void destroyLoadLevelNotification () + raises (TpCommonExceptions); + + void querySvcLoadStatsReq ( + in TpLoadTestID loadStatsReqID, + in TpTimeInterval timeInterval + ) + raises (TpCommonExceptions); + + void queryLoadStatsRes ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticList loadStatistics + ) + raises (TpCommonExceptions); + + void queryLoadStatsErr ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticError loadStatisticsError + ) + raises (TpCommonExceptions); + + }; + + + interface IpFwLoadManager : IpInterface { + void reportLoad ( + in TpLoadLevel loadLevel + ) + raises (TpCommonExceptions); + + void queryLoadReq ( + in TpSubjectType querySubject, + in TpTimeInterval timeInterval + ) + raises (TpCommonExceptions); + + void querySvcLoadRes ( + in TpLoadStatisticList loadStatistics + ) + raises (TpCommonExceptions); + + void querySvcLoadErr ( + in TpLoadStatisticError loadStatisticError + ) + raises (TpCommonExceptions); + + void createLoadLevelNotification ( + in TpSubjectType notificationSubject + ) + raises (TpCommonExceptions); + + void destroyLoadLevelNotification ( + in TpSubjectType notificationSubject + ) + raises (TpCommonExceptions); + + void suspendNotification ( + in TpSubjectType notificationSubject + ) + raises (TpCommonExceptions); + + void resumeNotification ( + in TpSubjectType notificationSubject + ) + raises (TpCommonExceptions); + + void queryLoadStatsReq ( + in TpLoadTestID loadStatsReqID, + in TpSubjectType querySubject, + in TpTimeInterval timeInterval + ) + raises (TpCommonExceptions); + + void querySvcLoadStatsRes ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticList loadStatistics + ) + raises (TpCommonExceptions); + + void querySvcLoadStatsErr ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticError loadStatisticError + ) + raises (TpCommonExceptions); + + }; + + + interface IpSvcFaultManager : IpInterface { + void activityTestRes ( + in TpActivityTestID activityTestID, + in TpActivityTestRes activityTestResult + ) + raises (TpCommonExceptions,P_INVALID_ACTIVITY_TEST_ID); + + void svcActivityTestReq ( + in TpActivityTestID activityTestID + ) + raises (TpCommonExceptions); + + void fwFaultReportInd ( + in TpInterfaceFault fault + ) + raises (TpCommonExceptions); + + void fwFaultRecoveryInd ( + in TpInterfaceFault fault + ) + raises (TpCommonExceptions); + + void fwUnavailableInd ( + in TpFwUnavailReason reason + ) + raises (TpCommonExceptions); + + void svcUnavailableInd () + raises (TpCommonExceptions); + + void appUnavailableInd () + raises (TpCommonExceptions); + + void genFaultStatsRecordRes ( + in TpFaultStatsRecord faultStatistics, + in TpSubjectType recordSubject + ) + raises (TpCommonExceptions); + + void activityTestErr ( + in TpActivityTestID activityTestID + ) + raises (TpCommonExceptions,P_INVALID_ACTIVITY_TEST_ID); + + void genFaultStatsRecordErr ( + in TpFaultStatisticsError faultStatisticsError, + in TpSubjectType recordSubject + ) + raises (TpCommonExceptions); + + void genFaultStatsRecordReq ( + in TpTimeInterval timePeriod, + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_UNAUTHORISED_PARAMETER_VALUE); + + void generateFaultStatsRecordReq ( + in TpTimeInterval timePeriod + ) + raises (TpCommonExceptions); + + void appAvailStatusInd ( + in TpAppAvailStatusReason reason + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordRes ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatsRecord faultStatistics, + in TpSubjectType recordSubject + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordErr ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatisticsError faultStatisticsError, + in TpSubjectType recordSubject + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordReq ( + in TpFaultReqID faultStatsReqID, + in TpTimeInterval timePeriod + ) + raises (TpCommonExceptions); + + void fwAvailStatusInd ( + in TpFwAvailStatusReason reason + ); + + }; + + + interface IpFwFaultManager : IpInterface { + void activityTestReq ( + in TpActivityTestID activityTestID, + in TpSubjectType testSubject + ) + raises (TpCommonExceptions); + + void svcActivityTestRes ( + in TpActivityTestID activityTestID, + in TpActivityTestRes activityTestResult + ) + raises (TpCommonExceptions,P_INVALID_ACTIVITY_TEST_ID); + + void appUnavailableInd () + raises (TpCommonExceptions); + + void genFaultStatsRecordReq ( + in TpTimeInterval timePeriod, + in TpSubjectType recordSubject + ) + raises (TpCommonExceptions); + + void svcUnavailableInd ( + in TpSvcUnavailReason reason + ) + raises (TpCommonExceptions); + + void svcActivityTestErr ( + in TpActivityTestID activityTestID + ) + raises (TpCommonExceptions,P_INVALID_ACTIVITY_TEST_ID); + + void genFaultStatsRecordRes ( + in TpFaultStatsRecord faultStatistics, + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions); + + void genFaultStatsRecordErr ( + in TpFaultStatisticsError faultStatisticsError, + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions); + + void generateFaultStatsRecordRes ( + in TpFaultStatsRecord faultStatistics + ) + raises (TpCommonExceptions); + + void generateFaultStatsRecordErr ( + in TpFaultStatisticsError faultStatisticsError + ) + raises (TpCommonExceptions); + + void svcAvailStatusInd ( + in TpSvcAvailStatusReason reason + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordReq ( + in TpFaultReqID faultStatsReqID, + in TpTimeInterval timePeriod, + in TpSubjectType recordSubject + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordRes ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatsRecord faultStatistics + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordErr ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatisticsError faultStatisticsError + ) + raises (TpCommonExceptions); + + }; + + + interface IpSvcOAM : IpInterface { + TpDateAndTime systemDateTimeQuery ( + in TpDateAndTime systemDateAndTime + ) + raises (TpCommonExceptions,P_INVALID_TIME_AND_DATE_FORMAT); + + }; + + + interface IpFwOAM : IpInterface { + TpDateAndTime systemDateTimeQuery ( + in TpDateAndTime clientDateAndTime + ) + raises (TpCommonExceptions,P_INVALID_TIME_AND_DATE_FORMAT); + + }; + + + interface IpFwHeartBeatMgmt : IpInterface { + + void enableHeartBeat ( + in TpInt32 interval, + in IpSvcHeartBeat svcInterface + ) + raises (TpCommonExceptions,P_INVALID_INTERFACE_TYPE); + + void disableHeartBeat () + raises (TpCommonExceptions); + + void changeInterval ( + in TpInt32 interval + ) + raises (TpCommonExceptions); + + }; + + + interface IpSvcHeartBeat : IpInterface { + + void pulse () + raises (TpCommonExceptions); + + }; + + + interface IpFwHeartBeat : IpInterface { + + void pulse () + raises (TpCommonExceptions); + + }; + + + interface IpSvcHeartBeatMgmt : IpInterface { + + void enableSvcHeartBeat ( + in TpInt32 interval, + in IpFwHeartBeat fwInterface + ) + raises (TpCommonExceptions,P_INVALID_INTERFACE_TYPE); + + void disableSvcHeartBeat () + raises (TpCommonExceptions); + + void changeInterval ( + in TpInt32 interval + ) + raises (TpCommonExceptions); + + }; + + }; + + module notification { + + + interface IpFwEventNotification : IpInterface { + TpAssignmentID createNotification ( + in TpFwEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_INVALID_EVENT_TYPE,P_INVALID_CRITERIA); + + void destroyNotification ( + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + }; + + + interface IpSvcEventNotification : IpInterface { + void reportNotification ( + in TpFwEventInfo eventInfo, + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + void notificationTerminated () + raises (TpCommonExceptions); + + }; + + }; + + }; + + + }; + + }; + +}; +#endif diff --git a/idl/parlay/fw_if_access.idl b/idl/parlay/fw_if_access.idl new file mode 100644 index 0000000000..b50ea0647c --- /dev/null +++ b/idl/parlay/fw_if_access.idl @@ -0,0 +1,164 @@ +//Source file: fw_if_access.idl +//Date: 13 October 2004 +//Framework Access Interfaces for ES 203 915-03 V1.1.1, DES/TISPAN-01005-03-OSA, Parlay 5.0 + +#ifndef __FW_IF_ACCESS_DEFINED +#define __FW_IF_ACCESS_DEFINED + + +#include "osa.idl" +#include "fw_data.idl" + +module org { + + module csapi { + + module fw { + + module fw_access { + + + module trust_and_security { + + + interface IpInitial : IpInterface { + TpAuthDomain initiateAuthentication ( + in TpAuthDomain clientDomain, + in TpAuthType authType + ) + raises (TpCommonExceptions,P_INVALID_DOMAIN_ID,P_INVALID_INTERFACE_TYPE,P_INVALID_AUTH_TYPE); + + TpAuthDomain initiateAuthenticationWithVersion ( + in TpAuthDomain clientDomain, + in TpAuthType authType, + in TpVersion frameworkVersion + ) + raises (TpCommonExceptions,P_INVALID_DOMAIN_ID,P_INVALID_INTERFACE_TYPE,P_INVALID_AUTH_TYPE,P_INVALID_VERSION); + + }; + + + interface IpAuthentication : IpInterface { + IpInterface requestAccess ( + in TpAccessType accessType, + in IpInterface clientAccessInterface + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_ACCESS_TYPE,P_INVALID_INTERFACE_TYPE); + + }; + + + interface IpClientAccess : IpInterface { + void terminateAccess ( + in TpString terminationText, + in TpSigningAlgorithm signingAlgorithm, + in TpOctetSet digitalSignature + ) + raises (TpCommonExceptions,P_INVALID_SIGNING_ALGORITHM,P_INVALID_SIGNATURE); + + }; + + + interface IpAccess : IpInterface { + IpInterface obtainInterface ( + in TpInterfaceName interfaceName + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_INTERFACE_NAME); + + IpInterface obtainInterfaceWithCallback ( + in TpInterfaceName interfaceName, + in IpInterface clientInterface + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_INTERFACE_NAME,P_INVALID_INTERFACE_TYPE); + + void endAccess ( + in TpEndAccessProperties endAccessProperties + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_PROPERTY); + + TpInterfaceNameList listInterfaces () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + void releaseInterface ( + in TpInterfaceName interfaceName + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_INTERFACE_NAME); + + TpSigningAlgorithm selectSigningAlgorithm ( + in TpSigningAlgorithmCapabilityList signingAlgorithmCaps + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_NO_ACCEPTABLE_SIGNING_ALGORITHM); + + void terminateAccess ( + in TpString terminationText, + in TpOctetSet digitalSignature + ) + raises (TpCommonExceptions,P_INVALID_SIGNATURE); + + void relinquishInterface ( + in TpInterfaceName interfaceName, + in TpString terminationText, + in TpOctetSet digitalSignature + ) + raises (TpCommonExceptions,P_INVALID_SIGNATURE,P_INVALID_INTERFACE_NAME); + + }; + + + interface IpClientAPILevelAuthentication : IpInterface { + TpOctetSet authenticate ( + in TpOctetSet challenge + ); + + void abortAuthentication (); + + void authenticationSucceeded (); + + TpOctetSet challenge ( + in TpOctetSet challenge + ); + + }; + + + interface IpAPILevelAuthentication : IpAuthentication { + TpEncryptionCapability selectEncryptionMethod ( + in TpEncryptionCapabilityList encryptionCaps + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_NO_ACCEPTABLE_ENCRYPTION_CAPABILITY); + + TpOctetSet authenticate ( + in TpOctetSet challenge + ) + raises (TpCommonExceptions,P_ACCESS_DENIED); + + void abortAuthentication () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + void authenticationSucceeded () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + TpAuthMechanism selectAuthenticationMechanism ( + in TpAuthMechanismList authMechanismList + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_NO_ACCEPTABLE_AUTHENTICATION_MECHANISM); + + TpOctetSet challenge ( + in TpOctetSet challenge + ) + raises (TpCommonExceptions,P_ACCESS_DENIED); + + }; + + }; + + }; + + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/fw_if_app.idl b/idl/parlay/fw_if_app.idl new file mode 100644 index 0000000000..ba671e0319 --- /dev/null +++ b/idl/parlay/fw_if_app.idl @@ -0,0 +1,465 @@ +//Source file: fw_if_app.idl +//Date: 13 October 2004 +//Framework to Application Interfaces for ES 203 915-03 V1.1.1, DES/TISPAN-01005-03-OSA, Parlay 5.0 + +#ifndef __FW_IF_APP_DEFINED +#define __FW_IF_APP_DEFINED + + +#include "osa.idl" +#include "fw_data.idl" + +module org { + + module csapi { + + module fw { + + module fw_application { + + module notification { + + + interface IpAppEventNotification : IpInterface { + void reportNotification ( + in TpFwEventInfo eventInfo, + in TpAssignmentID assignmentID + ); + + void notificationTerminated (); + + }; + + + interface IpEventNotification : IpInterface { + TpAssignmentID createNotification ( + in TpFwEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CRITERIA,P_INVALID_EVENT_TYPE); + + void destroyNotification ( + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_ASSIGNMENT_ID); + + }; + + }; + + module integrity { + interface IpAppHeartBeatMgmt ; + interface IpHeartBeat ; + interface IpAppHeartBeat ; + + + + interface IpAppFaultManager : IpInterface { + void activityTestRes ( + in TpActivityTestID activityTestID, + in TpActivityTestRes activityTestResult + ); + + void appActivityTestReq ( + in TpActivityTestID activityTestID + ); + + void fwFaultReportInd ( + in TpInterfaceFault fault + ); + + void fwFaultRecoveryInd ( + in TpInterfaceFault fault + ); + + void svcUnavailableInd ( + in TpServiceID serviceID, + in TpSvcUnavailReason reason + ); + + void genFaultStatsRecordRes ( + in TpFaultStatsRecord faultStatistics, + in TpServiceIDList serviceIDs + ); + + void fwUnavailableInd ( + in TpFwUnavailReason reason + ); + + void activityTestErr ( + in TpActivityTestID activityTestID + ); + + void genFaultStatsRecordErr ( + in TpFaultStatisticsError faultStatisticsError, + in TpServiceIDList serviceIDs + ); + + void appUnavailableInd ( + in TpServiceID serviceID + ); + + void genFaultStatsRecordReq ( + in TpTimeInterval timePeriod + ); + + void svcAvailStatusInd ( + in TpServiceID serviceID, + in TpSvcAvailStatusReason reason + ); + + void generateFaultStatisticsRecordRes ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatsRecord faultStatistics, + in TpServiceIDList serviceIDs + ); + + void generateFaultStatisticsRecordErr ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatsErrorList faultStatistics, + in TpServiceIDList serviceIDs + ); + + void generateFaultStatisticsRecordReq ( + in TpFaultReqID faultStatsReqID, + in TpTimeInterval timePeriod + ); + + void fwAvailStatusInd ( + in TpFwAvailStatusReason reason + ); + + }; + + + interface IpAppLoadManager : IpInterface { + void queryAppLoadReq ( + in TpTimeInterval timeInterval + ); + + void queryLoadRes ( + in TpLoadStatisticList loadStatistics + ); + + void queryLoadErr ( + in TpLoadStatisticError loadStatisticsError + ); + + void loadLevelNotification ( + in TpLoadStatisticList loadStatistics + ); + + void resumeNotification (); + + void suspendNotification (); + + void createLoadLevelNotification (); + + void destroyLoadLevelNotification (); + + void queryAppLoadStatsReq ( + in TpLoadTestID loadStatsReqID, + in TpTimeInterval timeInterval + ); + + void queryLoadStatsRes ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticList loadStatistics + ); + + void queryLoadStatsErr ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticError loadStatisticsError + ); + + }; + + + interface IpLoadManager : IpInterface { + void reportLoad ( + in TpLoadLevel loadLevel + ) + raises (TpCommonExceptions); + + void queryLoadReq ( + in TpServiceIDList serviceIDs, + in TpTimeInterval timeInterval + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_SERVICE_NOT_ENABLED,P_UNAUTHORISED_PARAMETER_VALUE); + + void queryAppLoadRes ( + in TpLoadStatisticList loadStatistics + ) + raises (TpCommonExceptions); + + void queryAppLoadErr ( + in TpLoadStatisticError loadStatisticsError + ) + raises (TpCommonExceptions); + + void createLoadLevelNotification ( + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_UNAUTHORISED_PARAMETER_VALUE); + + void destroyLoadLevelNotification ( + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_UNAUTHORISED_PARAMETER_VALUE); + + void resumeNotification ( + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_SERVICE_NOT_ENABLED,P_UNAUTHORISED_PARAMETER_VALUE); + + void suspendNotification ( + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_SERVICE_NOT_ENABLED,P_UNAUTHORISED_PARAMETER_VALUE); + + void queryLoadStatsReq ( + in TpLoadTestID loadStatsReqID, + in TpServiceIDList serviceIDs, + in TpTimeInterval timeInterval + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_SERVICE_NOT_ENABLED,P_UNAUTHORISED_PARAMETER_VALUE); + + void queryAppLoadStatsRes ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticList loadStatistics + ) + raises (TpCommonExceptions); + + void queryAppLoadStatsErr ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticError loadStatisticsError + ) + raises (TpCommonExceptions); + + }; + + + interface IpAppOAM : IpInterface { + TpDateAndTime systemDateTimeQuery ( + in TpDateAndTime systemDateAndTime + ); + + }; + + + interface IpOAM : IpInterface { + TpDateAndTime systemDateTimeQuery ( + in TpDateAndTime clientDateAndTime + ) + raises (TpCommonExceptions,P_INVALID_TIME_AND_DATE_FORMAT); + + }; + + + interface IpFaultManager : IpInterface { + void activityTestReq ( + in TpActivityTestID activityTestID, + in TpServiceID svcID + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_UNAUTHORISED_PARAMETER_VALUE); + + void appActivityTestRes ( + in TpActivityTestID activityTestID, + in TpActivityTestRes activityTestResult + ) + raises (TpCommonExceptions,P_INVALID_ACTIVITY_TEST_ID); + + void svcUnavailableInd ( + in TpServiceID serviceID + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_UNAUTHORISED_PARAMETER_VALUE); + + void genFaultStatsRecordReq ( + in TpTimeInterval timePeriod, + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_UNAUTHORISED_PARAMETER_VALUE); + + void appActivityTestErr ( + in TpActivityTestID activityTestID + ) + raises (TpCommonExceptions,P_INVALID_ACTIVITY_TEST_ID); + + void appUnavailableInd ( + in TpServiceID serviceID + ) + raises (TpCommonExceptions); + + void genFaultStatsRecordRes ( + in TpFaultStatsRecord faultStatistics + ) + raises (TpCommonExceptions); + + void genFaultStatsRecordErr ( + in TpFaultStatisticsError faultStatisticsError + ) + raises (TpCommonExceptions); + + void appAvailStatusInd ( + in TpAppAvailStatusReason reason + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordReq ( + in TpFaultReqID faultStatsReqID, + in TpTimeInterval timePeriod, + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_UNAUTHORISED_PARAMETER_VALUE); + + void generateFaultStatisticsRecordRes ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatsRecord faultStatistics + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordErr ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatisticsError faultStatisticsError + ) + raises (TpCommonExceptions); + + }; + + + interface IpHeartBeatMgmt : IpInterface { + + void enableHeartBeat ( + in TpInt32 interval, + in IpAppHeartBeat appInterface + ) + raises (TpCommonExceptions); + + void disableHeartBeat () + raises (TpCommonExceptions); + + void changeInterval ( + in TpInt32 interval + ) + raises (TpCommonExceptions); + + }; + + + interface IpAppHeartBeat : IpInterface { + + void pulse (); + + }; + + + interface IpHeartBeat : IpInterface { + + void pulse () + raises (TpCommonExceptions); + + }; + + + interface IpAppHeartBeatMgmt : IpInterface { + + void enableAppHeartBeat ( + in TpInt32 interval, + in IpHeartBeat fwInterface + ); + + void disableAppHeartBeat (); + + void changeInterval ( + in TpInt32 interval + ); + + }; + + }; + + + module discovery { + + + interface IpServiceDiscovery : IpInterface { + TpServiceTypeNameList listServiceTypes () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + TpServiceTypeDescription describeServiceType ( + in TpServiceTypeName name + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_ILLEGAL_SERVICE_TYPE,P_UNKNOWN_SERVICE_TYPE); + + TpServiceList discoverService ( + in TpServiceTypeName serviceTypeName, + in TpServicePropertyList desiredPropertyList, + in TpInt32 max + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_ILLEGAL_SERVICE_TYPE,P_UNKNOWN_SERVICE_TYPE,P_INVALID_PROPERTY); + + TpServiceList listSubscribedServices () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + }; + + }; + + module service_agreement { + + + interface IpAppServiceAgreementManagement : IpInterface { + TpOctetSet signServiceAgreement ( + in TpServiceToken serviceToken, + in TpString agreementText, + in TpSigningAlgorithm signingAlgorithm + ) + raises (TpCommonExceptions,P_INVALID_AGREEMENT_TEXT,P_INVALID_SERVICE_TOKEN,P_INVALID_SIGNING_ALGORITHM); + + void terminateServiceAgreement ( + in TpServiceToken serviceToken, + in TpString terminationText, + in TpOctetSet digitalSignature + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_TOKEN,P_INVALID_SIGNATURE); + + }; + + + interface IpServiceAgreementManagement : IpInterface { + TpSignatureAndServiceMgr signServiceAgreement ( + in TpServiceToken serviceToken, + in TpString agreementText, + in TpSigningAlgorithm signingAlgorithm + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_AGREEMENT_TEXT,P_INVALID_SERVICE_TOKEN,P_INVALID_SIGNING_ALGORITHM,P_SERVICE_ACCESS_DENIED); + + void terminateServiceAgreement ( + in TpServiceToken serviceToken, + in TpString terminationText, + in TpOctetSet digitalSignature + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_TOKEN,P_INVALID_SIGNATURE); + + TpServiceToken selectService ( + in TpServiceID serviceID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_ID,P_SERVICE_ACCESS_DENIED); + + void initiateSignServiceAgreement ( + in TpServiceToken serviceToken + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_TOKEN,P_SERVICE_ACCESS_DENIED); + + }; + + }; + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/fw_if_entop.idl b/idl/parlay/fw_if_entop.idl new file mode 100644 index 0000000000..4c6ae83c57 --- /dev/null +++ b/idl/parlay/fw_if_entop.idl @@ -0,0 +1,248 @@ +//Source file: fw_if_entop.idl +//Date: 13 October 2004 +//Framework to Enterprise Operator Interfaces for ES 203 915-03 V1.1.1, DES/TISPAN-01005-03-OSA, Parlay 5.0 + +#ifndef __FW_IF_ENTOP_DEFINED +#define __FW_IF_ENTOP_DEFINED + +#include "osa.idl" +#include "fw_data.idl" + +module org { + + module csapi { + + module fw { + + module fw_enterprise_operator { + + + module service_subscription { + + + interface IpServiceProfileManagement : IpInterface { + TpServiceProfileID createServiceProfile ( + in TpServiceProfileDescription serviceProfileDescription + ) + raises (TpCommonExceptions,P_ACCESS_DENIED); + + void modifyServiceProfile ( + in TpServiceProfile serviceProfile + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_PROFILE_ID); + + void deleteServiceProfile ( + in TpServiceProfileID serviceProfileID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_PROFILE_ID); + + void assign ( + in TpSagID sagID, + in TpServiceProfileID serviceProfileID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SAG_ID,P_INVALID_SERVICE_PROFILE_ID,P_INVALID_SAG_TO_SERVICE_PROFILE_ASSIGNMENT); + + void deassign ( + in TpSagID sagID, + in TpServiceProfileID serviceProfileID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SAG_ID,P_INVALID_SERVICE_PROFILE_ID); + + TpAssignSagToServiceProfileConflictList requestConflictInfo () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + }; + + + interface IpServiceProfileInfoQuery : IpInterface { + TpServiceProfileIDList listServiceProfiles () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + TpServiceProfileDescription describeServiceProfile ( + in TpServiceProfileID serviceProfileID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_PROFILE_ID); + + TpSagIDList listAssignedMembers ( + in TpServiceProfileID serviceProfileID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_PROFILE_ID); + + }; + + + interface IpServiceContractManagement : IpInterface { + TpServiceContractID createServiceContract ( + in TpServiceContractDescription serviceContractDescription + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_ID); + + void modifyServiceContract ( + in TpServiceContract serviceContract + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_ID,P_INVALID_SERVICE_CONTRACT_ID); + + void deleteServiceContract ( + in TpServiceContractID serviceContractID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_CONTRACT_ID); + + }; + + + interface IpServiceContractInfoQuery : IpInterface { + TpServiceContractDescription describeServiceContract ( + in TpServiceContractID serviceContractID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_CONTRACT_ID); + + TpServiceContractIDList listServiceContracts () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + TpServiceProfileIDList listServiceProfiles ( + in TpServiceContractID serviceContractID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SERVICE_CONTRACT_ID); + + }; + + + interface IpEntOpAccountManagement : IpInterface { + void modifyEntOpAccount ( + in TpEntOpProperties enterpriseOperatorProperties + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_PROPERTY); + + void deleteEntOpAccount () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + }; + + + interface IpEntOpAccountInfoQuery : IpInterface { + TpEntOp describeEntOpAccount () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + }; + + + interface IpClientAppManagement : IpInterface { + void createClientApp ( + in TpClientAppDescription clientAppDescription + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID); + + void modifyClientApp ( + in TpClientAppDescription clientAppDescription + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID); + + void deleteClientApp ( + in TpClientAppID clientAppID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID); + + void createSAG ( + in TpSag sag, + in TpClientAppIDList clientAppIDs + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID,P_INVALID_SAG_ID); + + void modifySAG ( + in TpSag sag + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SAG_ID); + + void deleteSAG ( + in TpSagID sagID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SAG_ID); + + void addSAGMembers ( + in TpSagID sagID, + in TpClientAppIDList clientAppIDs + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID,P_INVALID_SAG_ID,P_INVALID_ADDITION_TO_SAG); + + void removeSAGMembers ( + in TpSagID sagID, + in TpClientAppIDList clientAppIDList + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID,P_INVALID_SAG_ID); + + TpAddSagMembersConflictList requestConflictInfo () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + }; + + + interface IpClientAppInfoQuery : IpInterface { + TpClientAppDescription describeClientApp ( + in TpClientAppID clientAppID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID); + + TpClientAppIDList listClientApps () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + TpSagDescription describeSAG ( + in TpSagID sagID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SAG_ID); + + TpSagIDList listSAGs () + raises (TpCommonExceptions,P_ACCESS_DENIED); + + TpClientAppIDList listSAGMembers ( + in TpSagID sagID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_SAG_ID); + + TpSagIDList listClientAppMembership ( + in TpClientAppID clientAppID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CLIENT_APP_ID); + + }; + + }; + + module notification { + + + interface IpClientEventNotification : IpInterface { + void reportNotification ( + in TpFwEventInfo eventInfo, + in TpAssignmentID assignmentID + ); + + void notificationTerminated (); + + }; + + + interface IpEventNotification : IpInterface { + TpAssignmentID createNotification ( + in TpFwEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_CRITERIA,P_INVALID_EVENT_TYPE); + + void destroyNotification ( + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_ACCESS_DENIED,P_INVALID_ASSIGNMENT_ID); + + }; + + }; + + }; + + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/fw_if_service.idl b/idl/parlay/fw_if_service.idl new file mode 100644 index 0000000000..dcb9c26f32 --- /dev/null +++ b/idl/parlay/fw_if_service.idl @@ -0,0 +1,519 @@ +//Source file: fw_if_service.idl +//Date: 13 October 2004 +//Framework to Service Interfaces for ES 203 915-03 V1.1.1, DES/TISPAN-01005-03-OSA, Parlay 5.0 + +#ifndef __FW_IF_SERVICE_DEFINED +#define __FW_IF_SERVICE_DEFINED + +#include "osa.idl" +#include "fw_data.idl" + +module org { + + module csapi { + + module fw { + + module fw_service { + + module discovery { + + + interface IpFwServiceDiscovery : IpInterface { + TpServiceTypeNameList listServiceTypes () + raises (TpCommonExceptions); + + TpServiceTypeDescription describeServiceType ( + in TpServiceTypeName name + ) + raises (TpCommonExceptions,P_ILLEGAL_SERVICE_TYPE,P_UNKNOWN_SERVICE_TYPE); + + TpServiceList discoverService ( + in TpServiceTypeName serviceTypeName, + in TpServicePropertyList desiredPropertyList, + in TpInt32 max + ) + raises (TpCommonExceptions,P_ILLEGAL_SERVICE_TYPE,P_UNKNOWN_SERVICE_TYPE,P_INVALID_PROPERTY); + + TpServiceList listRegisteredServices () + raises (TpCommonExceptions); + + }; + + }; + + module service_lifecycle { + + + interface IpServiceInstanceLifecycleManager : IpInterface { + IpService createServiceManager ( + in TpClientAppID application, + in TpServicePropertyList serviceProperties, + in TpServiceInstanceID serviceInstanceID + ) + raises (TpCommonExceptions,P_INVALID_PROPERTY); + + void destroyServiceManager ( + in TpServiceInstanceID serviceInstance + ) + raises (TpCommonExceptions); + + }; + + }; + + module service_registration { + + + interface IpFwServiceRegistration : IpInterface { + TpServiceID registerService ( + in TpServiceTypeName serviceTypeName, + in TpServicePropertyList servicePropertyList + ) + raises (TpCommonExceptions,P_PROPERTY_TYPE_MISMATCH,P_DUPLICATE_PROPERTY_NAME,P_ILLEGAL_SERVICE_TYPE,P_UNKNOWN_SERVICE_TYPE,P_MISSING_MANDATORY_PROPERTY,P_SERVICE_TYPE_UNAVAILABLE); + + void announceServiceAvailability ( + in TpServiceID serviceID, + in service_lifecycle::IpServiceInstanceLifecycleManager serviceInstanceLifecycleManagerRef + ) + raises (TpCommonExceptions,P_ILLEGAL_SERVICE_ID,P_UNKNOWN_SERVICE_ID,P_INVALID_INTERFACE_TYPE); + + void unregisterService ( + in TpServiceID serviceID + ) + raises (TpCommonExceptions,P_ILLEGAL_SERVICE_ID,P_UNKNOWN_SERVICE_ID); + + TpServiceDescription describeService ( + in TpServiceID serviceID + ) + raises (TpCommonExceptions,P_ILLEGAL_SERVICE_ID,P_UNKNOWN_SERVICE_ID); + + void unannounceService ( + in TpServiceID serviceID + ) + raises (TpCommonExceptions,P_ILLEGAL_SERVICE_ID,P_UNKNOWN_SERVICE_ID); + + TpServiceID registerServiceSubType ( + in TpServiceTypeName serviceTypeName, + in TpServicePropertyList servicePropertyList, + in TpServiceTypePropertyValueList extendedServicePropertyList + ) + raises (TpCommonExceptions,P_PROPERTY_TYPE_MISMATCH,P_DUPLICATE_PROPERTY_NAME,P_ILLEGAL_SERVICE_TYPE,P_UNKNOWN_SERVICE_TYPE,P_MISSING_MANDATORY_PROPERTY,P_SERVICE_TYPE_UNAVAILABLE); + + }; + + }; + + module integrity { + interface IpSvcHeartBeatMgmt ; + interface IpFwHeartBeat ; + interface IpSvcHeartBeat ; + + + + interface IpSvcLoadManager : IpInterface { + void querySvcLoadReq ( + in TpTimeInterval timeInterval + ) + raises (TpCommonExceptions); + + void queryLoadRes ( + in TpLoadStatisticList loadStatistics + ) + raises (TpCommonExceptions); + + void queryLoadErr ( + in TpLoadStatisticError loadStatisticsError + ) + raises (TpCommonExceptions); + + void loadLevelNotification ( + in TpLoadStatisticList loadStatistics + ) + raises (TpCommonExceptions); + + void suspendNotification () + raises (TpCommonExceptions); + + void resumeNotification () + raises (TpCommonExceptions); + + void createLoadLevelNotification () + raises (TpCommonExceptions); + + void destroyLoadLevelNotification () + raises (TpCommonExceptions); + + void querySvcLoadStatsReq ( + in TpLoadTestID loadStatsReqID, + in TpTimeInterval timeInterval + ) + raises (TpCommonExceptions); + + void queryLoadStatsRes ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticList loadStatistics + ) + raises (TpCommonExceptions); + + void queryLoadStatsErr ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticError loadStatisticsError + ) + raises (TpCommonExceptions); + + }; + + + interface IpFwLoadManager : IpInterface { + void reportLoad ( + in TpLoadLevel loadLevel + ) + raises (TpCommonExceptions); + + void queryLoadReq ( + in TpSubjectType querySubject, + in TpTimeInterval timeInterval + ) + raises (TpCommonExceptions); + + void querySvcLoadRes ( + in TpLoadStatisticList loadStatistics + ) + raises (TpCommonExceptions); + + void querySvcLoadErr ( + in TpLoadStatisticError loadStatisticError + ) + raises (TpCommonExceptions); + + void createLoadLevelNotification ( + in TpSubjectType notificationSubject + ) + raises (TpCommonExceptions); + + void destroyLoadLevelNotification ( + in TpSubjectType notificationSubject + ) + raises (TpCommonExceptions); + + void suspendNotification ( + in TpSubjectType notificationSubject + ) + raises (TpCommonExceptions); + + void resumeNotification ( + in TpSubjectType notificationSubject + ) + raises (TpCommonExceptions); + + void queryLoadStatsReq ( + in TpLoadTestID loadStatsReqID, + in TpSubjectType querySubject, + in TpTimeInterval timeInterval + ) + raises (TpCommonExceptions); + + void querySvcLoadStatsRes ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticList loadStatistics + ) + raises (TpCommonExceptions); + + void querySvcLoadStatsErr ( + in TpLoadTestID loadStatsReqID, + in TpLoadStatisticError loadStatisticError + ) + raises (TpCommonExceptions); + + }; + + + interface IpSvcFaultManager : IpInterface { + void activityTestRes ( + in TpActivityTestID activityTestID, + in TpActivityTestRes activityTestResult + ) + raises (TpCommonExceptions,P_INVALID_ACTIVITY_TEST_ID); + + void svcActivityTestReq ( + in TpActivityTestID activityTestID + ) + raises (TpCommonExceptions); + + void fwFaultReportInd ( + in TpInterfaceFault fault + ) + raises (TpCommonExceptions); + + void fwFaultRecoveryInd ( + in TpInterfaceFault fault + ) + raises (TpCommonExceptions); + + void fwUnavailableInd ( + in TpFwUnavailReason reason + ) + raises (TpCommonExceptions); + + void svcUnavailableInd () + raises (TpCommonExceptions); + + void appUnavailableInd () + raises (TpCommonExceptions); + + void genFaultStatsRecordRes ( + in TpFaultStatsRecord faultStatistics, + in TpSubjectType recordSubject + ) + raises (TpCommonExceptions); + + void activityTestErr ( + in TpActivityTestID activityTestID + ) + raises (TpCommonExceptions,P_INVALID_ACTIVITY_TEST_ID); + + void genFaultStatsRecordErr ( + in TpFaultStatisticsError faultStatisticsError, + in TpSubjectType recordSubject + ) + raises (TpCommonExceptions); + + void genFaultStatsRecordReq ( + in TpTimeInterval timePeriod, + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions,P_INVALID_SERVICE_ID,P_UNAUTHORISED_PARAMETER_VALUE); + + void generateFaultStatsRecordReq ( + in TpTimeInterval timePeriod + ) + raises (TpCommonExceptions); + + void appAvailStatusInd ( + in TpAppAvailStatusReason reason + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordRes ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatsRecord faultStatistics, + in TpSubjectType recordSubject + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordErr ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatisticsError faultStatisticsError, + in TpSubjectType recordSubject + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordReq ( + in TpFaultReqID faultStatsReqID, + in TpTimeInterval timePeriod + ) + raises (TpCommonExceptions); + + void fwAvailStatusInd ( + in TpFwAvailStatusReason reason + ); + + }; + + + interface IpFwFaultManager : IpInterface { + void activityTestReq ( + in TpActivityTestID activityTestID, + in TpSubjectType testSubject + ) + raises (TpCommonExceptions); + + void svcActivityTestRes ( + in TpActivityTestID activityTestID, + in TpActivityTestRes activityTestResult + ) + raises (TpCommonExceptions,P_INVALID_ACTIVITY_TEST_ID); + + void appUnavailableInd () + raises (TpCommonExceptions); + + void genFaultStatsRecordReq ( + in TpTimeInterval timePeriod, + in TpSubjectType recordSubject + ) + raises (TpCommonExceptions); + + void svcUnavailableInd ( + in TpSvcUnavailReason reason + ) + raises (TpCommonExceptions); + + void svcActivityTestErr ( + in TpActivityTestID activityTestID + ) + raises (TpCommonExceptions,P_INVALID_ACTIVITY_TEST_ID); + + void genFaultStatsRecordRes ( + in TpFaultStatsRecord faultStatistics, + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions); + + void genFaultStatsRecordErr ( + in TpFaultStatisticsError faultStatisticsError, + in TpServiceIDList serviceIDs + ) + raises (TpCommonExceptions); + + void generateFaultStatsRecordRes ( + in TpFaultStatsRecord faultStatistics + ) + raises (TpCommonExceptions); + + void generateFaultStatsRecordErr ( + in TpFaultStatisticsError faultStatisticsError + ) + raises (TpCommonExceptions); + + void svcAvailStatusInd ( + in TpSvcAvailStatusReason reason + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordReq ( + in TpFaultReqID faultStatsReqID, + in TpTimeInterval timePeriod, + in TpSubjectType recordSubject + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordRes ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatsRecord faultStatistics + ) + raises (TpCommonExceptions); + + void generateFaultStatisticsRecordErr ( + in TpFaultReqID faultStatsReqID, + in TpFaultStatisticsError faultStatisticsError + ) + raises (TpCommonExceptions); + + }; + + + interface IpSvcOAM : IpInterface { + TpDateAndTime systemDateTimeQuery ( + in TpDateAndTime systemDateAndTime + ) + raises (TpCommonExceptions,P_INVALID_TIME_AND_DATE_FORMAT); + + }; + + + interface IpFwOAM : IpInterface { + TpDateAndTime systemDateTimeQuery ( + in TpDateAndTime clientDateAndTime + ) + raises (TpCommonExceptions,P_INVALID_TIME_AND_DATE_FORMAT); + + }; + + + interface IpFwHeartBeatMgmt : IpInterface { + + void enableHeartBeat ( + in TpInt32 interval, + in IpSvcHeartBeat svcInterface + ) + raises (TpCommonExceptions,P_INVALID_INTERFACE_TYPE); + + void disableHeartBeat () + raises (TpCommonExceptions); + + void changeInterval ( + in TpInt32 interval + ) + raises (TpCommonExceptions); + + }; + + + interface IpSvcHeartBeat : IpInterface { + + void pulse () + raises (TpCommonExceptions); + + }; + + + interface IpFwHeartBeat : IpInterface { + + void pulse () + raises (TpCommonExceptions); + + }; + + + interface IpSvcHeartBeatMgmt : IpInterface { + + void enableSvcHeartBeat ( + in TpInt32 interval, + in IpFwHeartBeat fwInterface + ) + raises (TpCommonExceptions,P_INVALID_INTERFACE_TYPE); + + void disableSvcHeartBeat () + raises (TpCommonExceptions); + + void changeInterval ( + in TpInt32 interval + ) + raises (TpCommonExceptions); + + }; + + }; + + module notification { + + + interface IpFwEventNotification : IpInterface { + TpAssignmentID createNotification ( + in TpFwEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_INVALID_EVENT_TYPE,P_INVALID_CRITERIA); + + void destroyNotification ( + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + }; + + + interface IpSvcEventNotification : IpInterface { + void reportNotification ( + in TpFwEventInfo eventInfo, + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + void notificationTerminated () + raises (TpCommonExceptions); + + }; + + }; + + }; + + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/gcc_data.idl b/idl/parlay/gcc_data.idl new file mode 100644 index 0000000000..18f1d965fc --- /dev/null +++ b/idl/parlay/gcc_data.idl @@ -0,0 +1,207 @@ +//Source file: gcc_data.idl +//Date: 6 October 2004 +//Generic Call Control Data Types for ES 203 915-4-2 V1.1.1, DES/TISPAN-01005-04-2-OSA, Parlay 5.0 + +#ifndef __GCC_DATA_DEFINED +#define __GCC_DATA_DEFINED + + +#include "common_cc_data.idl" +#include "osa.idl" + +module org { + + module csapi { + + module cc { + + module gccs { + + const TpInt32 P_EVENT_NAME_UNDEFINED = 0; + + const TpInt32 P_EVENT_GCCS_OFFHOOK_EVENT = 1; + + const TpInt32 P_EVENT_GCCS_ADDRESS_COLLECTED_EVENT = 2; + + const TpInt32 P_EVENT_GCCS_ADDRESS_ANALYSED_EVENT = 4; + + const TpInt32 P_EVENT_GCCS_CALLED_PARTY_BUSY = 8; + + const TpInt32 P_EVENT_GCCS_CALLED_PARTY_UNREACHABLE = 16; + + const TpInt32 P_EVENT_GCCS_NO_ANSWER_FROM_CALLED_PARTY = 32; + + const TpInt32 P_EVENT_GCCS_ROUTE_SELECT_FAILURE = 64; + + const TpInt32 P_EVENT_GCCS_ANSWER_FROM_CALL_PARTY = 128; + + + typedef TpInt32 TpCallEventName; + + + enum TpCallNotificationType { + + P_ORIGINATING, + P_TERMINATING + }; + + + struct TpCallEventCriteria { + TpAddressRange DestinationAddress; + TpAddressRange OriginatingAddress; + TpCallEventName CallEventName; + TpCallNotificationType CallNotificationType; + TpCallMonitorMode MonitorMode; + }; + + + struct TpCallEventCriteriaResult { + TpCallEventCriteria CallEventCriteria; + TpInt32 AssignmentID; + }; + + + typedef sequence TpCallEventCriteriaResultSet; + + + enum TpCallAppInfoType { + + P_CALL_APP_UNDEFINED, + P_CALL_APP_ALERTING_MECHANISM, + P_CALL_APP_NETWORK_ACCESS_TYPE, + P_CALL_APP_TELE_SERVICE, + P_CALL_APP_BEARER_SERVICE, + P_CALL_APP_PARTY_CATEGORY, + P_CALL_APP_PRESENTATION_ADDRESS, + P_CALL_APP_GENERIC_INFO, + P_CALL_APP_ADDITIONAL_ADDRESS + }; + + + union TpCallAppInfo switch(TpCallAppInfoType) { + case P_CALL_APP_ALERTING_MECHANISM: TpCallAlertingMechanism CallAppAlertingMechanism; + case P_CALL_APP_NETWORK_ACCESS_TYPE: TpCallNetworkAccessType CallAppNetworkAccessType; + case P_CALL_APP_TELE_SERVICE: TpCallTeleService CallAppTeleService; + case P_CALL_APP_BEARER_SERVICE: TpCallBearerService CallAppBearerService; + case P_CALL_APP_PARTY_CATEGORY: TpCallPartyCategory CallAppPartyCategory; + case P_CALL_APP_PRESENTATION_ADDRESS: TpAddress CallAppPresentationAddress; + case P_CALL_APP_GENERIC_INFO: TpString CallAppGenericInfo; + case P_CALL_APP_ADDITIONAL_ADDRESS: TpAddress CallAppAdditionalAddress; + default: short Dummy; + }; + + + typedef sequence TpCallAppInfoSet; + + + struct TpCallReleaseCause { + TpInt32 Value; + TpInt32 Location; + }; + + + enum TpCallReportType { + + P_CALL_REPORT_UNDEFINED, + P_CALL_REPORT_PROGRESS, + P_CALL_REPORT_ALERTING, + P_CALL_REPORT_ANSWER, + P_CALL_REPORT_BUSY, + P_CALL_REPORT_NO_ANSWER, + P_CALL_REPORT_DISCONNECT, + P_CALL_REPORT_REDIRECTED, + P_CALL_REPORT_SERVICE_CODE, + P_CALL_REPORT_ROUTING_FAILURE, + P_CALL_REPORT_QUEUED, + P_CALL_REPORT_NOT_REACHABLE + }; + + + union TpCallAdditionalReportInfo switch(TpCallReportType) { + case P_CALL_REPORT_BUSY: TpCallReleaseCause Busy; + case P_CALL_REPORT_DISCONNECT: TpCallReleaseCause CallDisconnect; + case P_CALL_REPORT_REDIRECTED: TpAddress ForwardAddress; + case P_CALL_REPORT_SERVICE_CODE: TpCallServiceCode ServiceCode; + case P_CALL_REPORT_ROUTING_FAILURE: TpCallReleaseCause RoutingFailure; + case P_CALL_REPORT_QUEUED: TpString QueueStatus; + case P_CALL_REPORT_NOT_REACHABLE: TpCallReleaseCause NotReachable; + default: short Dummy; + }; + + + struct TpCallReport { + TpCallMonitorMode MonitorMode; + TpDateAndTime CallEventTime; + TpCallReportType CallReportType; + TpCallAdditionalReportInfo AdditionalReportInfo; + }; + + + union TpCallAdditionalReportCriteria switch(TpCallReportType) { + case P_CALL_REPORT_NO_ANSWER: TpDuration NoAnswerDuration; + case P_CALL_REPORT_SERVICE_CODE: TpCallServiceCode ServiceCode; + default: short Dummy; + }; + + + struct TpCallReportRequest { + TpCallMonitorMode MonitorMode; + TpCallReportType CallReportType; + TpCallAdditionalReportCriteria AdditionalReportCriteria; + }; + + + typedef sequence TpCallReportRequestSet; + + + struct TpCallEventInfo { + TpAddress DestinationAddress; + TpAddress OriginatingAddress; + TpAddress OriginalDestinationAddress; + TpAddress RedirectingAddress; + TpCallAppInfoSet CallAppInfo; + TpCallEventName CallEventName; + TpCallNotificationType CallNotificationType; + TpCallMonitorMode MonitorMode; + }; + + + struct TpCallEndedReport { + TpSessionID CallLegSessionID; + TpCallReleaseCause Cause; + }; + + + struct TpCallInfoReport { + TpCallInfoType CallInfoType; + TpDateAndTime CallInitiationStartTime; + TpDateAndTime CallConnectedToResourceTime; + TpDateAndTime CallConnectedToDestinationTime; + TpDateAndTime CallEndTime; + TpCallReleaseCause Cause; + }; + + + struct TpCallTreatment { + TpCallTreatmentType CallTreatmentType; + TpCallReleaseCause ReleaseCause; + TpCallAdditionalTreatmentInfo AdditionalTreatmentInfo; + }; + + + enum TpCallFault { + + P_CALL_FAULT_UNDEFINED, + P_CALL_TIMEOUT_ON_RELEASE, + P_CALL_TIMEOUT_ON_INTERRUPT + }; + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/gcc_interfaces.idl b/idl/parlay/gcc_interfaces.idl new file mode 100644 index 0000000000..726307bd13 --- /dev/null +++ b/idl/parlay/gcc_interfaces.idl @@ -0,0 +1,225 @@ +//Source file: gcc_interfaces.idl +//Date: 7 October 2004 +//Generic Call Control Interfaces for ES 203 915-4-2 V1.1.1, DES/TISPAN-01005-04-2-OSA, Parlay 5.0 + + +#ifndef __GCC_INTERFACES_DEFINED +#define __GCC_INTERFACES_DEFINED + + +#include "osa.idl" +#include "common_cc_data.idl" +#include "gcc_data.idl" + +module org { + + module csapi { + + module cc { + + module gccs { + + interface IpCall; + + struct TpCallIdentifier { + IpCall CallReference; + TpSessionID CallSessionID; + }; + + + + interface IpAppCall : IpInterface { + void routeRes ( + in TpSessionID callSessionID, + in TpCallReport eventReport, + in TpSessionID callLegSessionID + ); + + void routeErr ( + in TpSessionID callSessionID, + in TpCallError errorIndication, + in TpSessionID callLegSessionID + ); + + void getCallInfoRes ( + in TpSessionID callSessionID, + in TpCallInfoReport callInfoReport + ); + + void getCallInfoErr ( + in TpSessionID callSessionID, + in TpCallError errorIndication + ); + + void superviseCallRes ( + in TpSessionID callSessionID, + in TpCallSuperviseReport report, + in TpDuration usedTime + ); + + void superviseCallErr ( + in TpSessionID callSessionID, + in TpCallError errorIndication + ); + + void callFaultDetected ( + in TpSessionID callSessionID, + in TpCallFault fault + ); + + void getMoreDialledDigitsRes ( + in TpSessionID callSessionID, + in TpString digits + ); + + void getMoreDialledDigitsErr ( + in TpSessionID callSessionID, + in TpCallError errorIndication + ); + + void callEnded ( + in TpSessionID callSessionID, + in TpCallEndedReport report + ); + + }; + + + interface IpCall : IpService { + TpSessionID routeReq ( + in TpSessionID callSessionID, + in TpCallReportRequestSet responseRequested, + in TpAddress targetAddress, + in TpAddress originatingAddress, + in TpAddress originalDestinationAddress, + in TpAddress redirectingAddress, + in TpCallAppInfoSet appInfo + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_ADDRESS,P_UNSUPPORTED_ADDRESS_PLAN,P_INVALID_NETWORK_STATE,P_INVALID_CRITERIA,P_INVALID_EVENT_TYPE); + + void release ( + in TpSessionID callSessionID, + in TpCallReleaseCause cause + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE); + + void deassignCall ( + in TpSessionID callSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void getCallInfoReq ( + in TpSessionID callSessionID, + in TpCallInfoType callInfoRequested + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void setCallChargePlan ( + in TpSessionID callSessionID, + in TpCallChargePlan callChargePlan + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void setAdviceOfCharge ( + in TpSessionID callSessionID, + in TpAoCInfo aOCInfo, + in TpDuration tariffSwitch + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void getMoreDialledDigitsReq ( + in TpSessionID callSessionID, + in TpInt32 length + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void superviseCallReq ( + in TpSessionID callSessionID, + in TpDuration time, + in TpCallSuperviseTreatment treatment + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void continueProcessing ( + in TpSessionID callSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE); + + }; + + + interface IpAppCallControlManager : IpInterface { + void callAborted ( + in TpSessionID callReference + ); + + IpAppCall callEventNotify ( + in TpCallIdentifier callReference, + in TpCallEventInfo eventInfo, + in TpAssignmentID assignmentID + ); + + void callNotificationInterrupted (); + + void callNotificationContinued (); + + void callOverloadEncountered ( + in TpAssignmentID assignmentID + ); + + void callOverloadCeased ( + in TpAssignmentID assignmentID + ); + + void abortMultipleCalls ( + in TpSessionIDSet callReferenceSet + ); + + }; + + + interface IpCallControlManager : IpService { + TpCallIdentifier createCall ( + in IpAppCall appCall + ) + raises (TpCommonExceptions,P_INVALID_INTERFACE_TYPE); + + TpAssignmentID enableCallNotification ( + in IpAppCallControlManager appCallControlManager, + in TpCallEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_INVALID_CRITERIA,P_INVALID_INTERFACE_TYPE,P_INVALID_EVENT_TYPE); + + void disableCallNotification ( + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + TpAssignmentID setCallLoadControl ( + in TpDuration duration, + in TpCallLoadControlMechanism mechanism, + in TpCallTreatment treatment, + in TpAddressRange addressRange + ) + raises (TpCommonExceptions,P_INVALID_ADDRESS,P_UNSUPPORTED_ADDRESS_PLAN); + + void changeCallNotification ( + in TpAssignmentID assignmentID, + in TpCallEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID,P_INVALID_CRITERIA,P_INVALID_EVENT_TYPE); + + TpCallEventCriteriaResultSet getCriteria () + raises (TpCommonExceptions); + + }; + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/gms.idl b/idl/parlay/gms.idl new file mode 100644 index 0000000000..a12f6085c8 --- /dev/null +++ b/idl/parlay/gms.idl @@ -0,0 +1,464 @@ +//Source file: gms.idl +//Date: 11 October 2004 +//Generic Messaging Interfaces and Data Types for ETSI ES 203 915-09 V1.1.1, DES/TISPAN-01005-09-OSA, Parlay 5.0 + +#ifndef __GMS_DEFINED +#define __GMS_DEFINED + + +#include "osa.idl" + +module org { + + module csapi { + + + module gms { + interface IpAppMessagingManager ; + interface IpMailbox ; + interface IpMailboxFolder ; + + + + enum TpMessagingFault { + + P_MESSAGING_FAULT_UNDEFINED + }; + + + enum TpMessagingEventName { + + P_EVENT_GMS_NAME_UNDEFINED, + P_EVENT_GMS_NEW_MESSAGE_ARRIVED + }; + + + enum TpMessageStatus { + + P_MESSAGING_MESSAGE_STATUS_READ_MESSAGE, + P_MESSAGING_MESSAGE_STATUS_UNREAD_MESSAGE, + P_MESSAGING_MESSAGE_STATUS_FORWARDED_MESSAGE, + P_MESSAGING_MESSAGE_STATUS_REPLIED_TO_MESSAGE, + P_MESSAGING_MESSAGE_STATUS_SAVED_OR_UNSENT_MESSAGE, + P_MESSAGING_MESSAGE_STATUS_NOTIFICATION_THAT_A_MESSAGE_WAS_DELIVERED, + P_MESSAGING_MESSAGE_STATUS_NOTIFICATION_THAT_A_MESSAGE_WAS_READ, + P_MESSAGING_MESSAGE_STATUS_NOTIFICATION_THAT_A_MESSAGE_WAS_NOT_DELIVERED, + P_MESSAGING_MESSAGE_STATUS_NOTIFICATION_THAT_A_MESSAGE_WAS_NOT_READ + }; + + + enum TpMessagePriority { + + P_MESSAGING_MESSAGE_PRIORITY_UNDEFINED, + P_MESSAGING_MESSAGE_PRIORITY_HIGH, + P_MESSAGING_MESSAGE_PRIORITY_LOW + }; + + + enum TpMessageInfoPropertyName { + + P_MESSAGING_MESSAGE_UNDEFINED, + P_MESSAGING_MESSAGE_ID, + P_MESSAGING_MESSAGE_SUBJECT, + P_MESSAGING_MESSAGE_DATE_SENT, + P_MESSAGING_MESSAGE_DATE_RECEIVED, + P_MESSAGING_MESSAGE_DATE_CHANGED, + P_MESSAGING_MESSAGE_SENT_FROM, + P_MESSAGING_MESSAGE_SENT_TO, + P_MESSAGING_MESSAGE_CC_TO, + P_MESSAGING_MESSAGE_BCC_TO, + P_MESSAGING_MESSAGE_SIZE, + P_MESSAGING_MESSAGE_PRIORITY, + P_MESSAGING_MESSAGE_FORMAT, + P_MESSAGING_MESSAGE_FOLDER, + P_MESSAGING_MESSAGE_STATUS + }; + + + enum TpMessageFormat { + + P_MESSAGING_MESSAGE_FORMAT_UNDEFINED, + P_MESSAGING_MESSAGE_FORMAT_TEXT, + P_MESSAGING_MESSAGE_FORMAT_BINARY, + P_MESSAGING_MESSAGE_FORMAT_UUENCODED, + P_MESSAGING_MESSAGE_FORMAT_MIME, + P_MESSAGING_MESSAGE_FORMAT_WAVE, + P_MESSAGING_MESSAGE_FORMAT_AU + }; + + + union TpMessageInfoProperty switch(TpMessageInfoPropertyName) { + case P_MESSAGING_MESSAGE_ID: TpString MessagingMessageID; + case P_MESSAGING_MESSAGE_SUBJECT: TpString MessagingMessageSubject; + case P_MESSAGING_MESSAGE_DATE_SENT: TpDateAndTime MessagingMessageDateSent; + case P_MESSAGING_MESSAGE_DATE_RECEIVED: TpDateAndTime MessagingMessageDateReceived; + case P_MESSAGING_MESSAGE_DATE_CHANGED: TpDateAndTime MessagingMessageDateChanged; + case P_MESSAGING_MESSAGE_SENT_FROM: TpAddress MessagingMessageSentFrom; + case P_MESSAGING_MESSAGE_SENT_TO: TpAddress MessagingMessageSentTo; + case P_MESSAGING_MESSAGE_CC_TO: TpAddress MessagingMessageCCTo; + case P_MESSAGING_MESSAGE_BCC_TO: TpAddress MessagingMessageBCCTo; + case P_MESSAGING_MESSAGE_SIZE: TpInt32 MessagingMessageSize; + case P_MESSAGING_MESSAGE_PRIORITY: TpMessagePriority MessagingMessagePriority; + case P_MESSAGING_MESSAGE_FORMAT: TpMessageFormat MessagingMessageFormat; + case P_MESSAGING_MESSAGE_FOLDER: TpString MessagingMessageFolder; + case P_MESSAGING_MESSAGE_STATUS: TpMessageStatus MessagingMessageStatus; + default: short Dummy; + }; + + + typedef sequence TpMessageInfoPropertySet; + + + enum TpMailboxInfoPropertyName { + + P_MESSAGING_MAILBOX_UNDEFINED, + P_MESSAGING_MAILBOX_ID, + P_MESSAGING_MAILBOX_OWNER, + P_MESSAGING_MAILBOX_FOLDER, + P_MESSAGING_MAILBOX_DATE_CREATED, + P_MESSAGING_MAILBOX_DATE_CHANGED + }; + + + union TpMailboxInfoProperty switch(TpMailboxInfoPropertyName) { + case P_MESSAGING_MAILBOX_ID: TpAddress MessagingMailboxID; + case P_MESSAGING_MAILBOX_OWNER: TpString MessagingMailboxOwner; + case P_MESSAGING_MAILBOX_FOLDER: TpString MessagingMailboxFolder; + case P_MESSAGING_MAILBOX_DATE_CREATED: TpDateAndTime MessagingMailboxDateCreated; + case P_MESSAGING_MAILBOX_DATE_CHANGED: TpDateAndTime MessagingMailboxDateChanged; + default: short Dummy; + }; + + + typedef sequence TpMailboxInfoPropertySet; + + + struct TpGMSNewMessageArrivedInfo { + TpAddress MailboxID; + TpString FolderID; + TpString MessageID; + TpInt32 NumberOfProperties; + }; + + + union TpMessagingEventInfo switch(TpMessagingEventName) { + case P_EVENT_GMS_NAME_UNDEFINED: TpString EventNameUndefined; + case P_EVENT_GMS_NEW_MESSAGE_ARRIVED: TpGMSNewMessageArrivedInfo EventGMSNewMessageArrived; + }; + + + struct TpGMSNewMessageArrivedCriteria { + TpAddress MailboxID; + TpString AuthenticationInfo; + }; + + + union TpMessagingEventCriteria switch(TpMessagingEventName) { + case P_EVENT_GMS_NEW_MESSAGE_ARRIVED: TpGMSNewMessageArrivedCriteria EventGMSNewMessageArrived; + default: short Dummy; + }; + + + enum TpFolderInfoPropertyName { + + P_MESSAGING_FOLDER_UNDEFINED, + P_MESSAGING_FOLDER_ID, + P_MESSAGING_FOLDER_MESSAGE, + P_MESSAGING_FOLDER_SUBFOLDER, + P_MESSAGING_FOLDER_DATE_CREATED, + P_MESSAGING_FOLDER_DATE_CHANGED + }; + + + union TpFolderInfoProperty switch(TpFolderInfoPropertyName) { + case P_MESSAGING_FOLDER_ID: TpString MessagingFolderID; + case P_MESSAGING_FOLDER_MESSAGE: TpString MessagingFolderMessage; + case P_MESSAGING_FOLDER_SUBFOLDER: TpString MessagingFolderSubfolder; + case P_MESSAGING_FOLDER_DATE_CREATED: TpDateAndTime MessagingFolderDateCreated; + case P_MESSAGING_FOLDER_DATE_CHANGED: TpDateAndTime MessagingFolderDateChanged; + default: short Dummy; + }; + + + typedef sequence TpFolderInfoPropertySet; + + + exception P_GMS_INVALID_FOLDER_ID { + TpString ExtraInformation; + }; + + + exception P_GMS_INSUFFICIENT_PRIVILEGE { + TpString ExtraInformation; + }; + + + exception P_GMS_INVALID_AUTHENTICATION_INFORMATION { + TpString ExtraInformation; + }; + + + exception P_GMS_INVALID_MAILBOX { + TpString ExtraInformation; + }; + + + exception P_GMS_INVALID_MESSAGE_ID { + TpString ExtraInformation; + }; + + + exception P_GMS_LOCKING_LOCKED_MAILBOX { + TpString ExtraInformation; + }; + + + exception P_GMS_MESSAGE_NOT_REMOVED { + TpString ExtraInformation; + }; + + + exception P_GMS_NUMBER_NOT_POSITIVE { + TpString ExtraInformation; + }; + + + exception P_GMS_UNLOCKING_UNLOCKED_MAILBOX { + TpString ExtraInformation; + }; + + + exception P_GMS_MAILBOX_LOCKED { + TpString ExtraInformation; + }; + + + exception P_GMS_CANNOT_UNLOCK_MAILBOX { + TpString ExtraInformation; + }; + + + exception P_GMS_PROPERTY_NOT_SET { + TpString ExtraInformation; + }; + + + exception P_GMS_FOLDER_IS_OPEN { + TpString ExtraInformation; + }; + + + exception P_GMS_MAILBOX_OPEN { + TpString ExtraInformation; + }; + + + typedef TpLongString TpMessage; + + + struct TpMailboxIdentifier { + IpMailbox Mailbox; + TpSessionID SessionID; + }; + + + struct TpMailboxFolderIdentifier { + IpMailboxFolder MailboxFolder; + TpSessionID SessionID; + }; + + + interface IpMessagingManager : IpService { + + TpMailboxIdentifier openMailbox ( + in TpAddress mailboxID, + in TpString authenticationInfo + ) + raises (TpCommonExceptions,P_GMS_INVALID_MAILBOX,P_GMS_INVALID_AUTHENTICATION_INFORMATION); + + TpAssignmentID enableMessagingNotification ( + in IpAppMessagingManager appInterface, + in TpMessagingEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_INVALID_CRITERIA); + + void disableMessagingNotification ( + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + }; + + + interface IpAppMessagingManager : IpInterface { + void mailboxTerminated ( + in IpMailbox mailbox, + in TpSessionID mailboxSessionID + ); + + void mailboxFaultDetected ( + in IpMailbox mailbox, + in TpSessionID mailboxSessionID, + in TpMessagingFault fault + ); + + void messagingEventNotify ( + in IpMessagingManager messagingManager, + in TpMessagingEventInfo eventInfo, + in TpAssignmentID assignmentID + ); + + void messagingNotificationTerminated (); + + }; + + + interface IpMailbox : IpService { + + void close ( + in TpSessionID mailboxSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void lock ( + in TpSessionID mailboxSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_LOCKING_LOCKED_MAILBOX); + + void unlock ( + in TpSessionID mailboxSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_UNLOCKING_UNLOCKED_MAILBOX,P_GMS_CANNOT_UNLOCK_MAILBOX); + + TpInt32 getInfoAmount ( + in TpSessionID mailboxSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + TpMailboxInfoPropertySet getInfoProperties ( + in TpSessionID mailboxSessionID, + in TpInt32 firstProperty, + in TpInt32 numberOfProperties + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_NUMBER_NOT_POSITIVE); + + void setInfoProperties ( + in TpSessionID mailboxSessionID, + in TpInt32 firstProperty, + in TpMailboxInfoPropertySet mailboxInfoProperties + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_PROPERTY_NOT_SET,P_GMS_MAILBOX_LOCKED); + + TpMailboxFolderIdentifier openFolder ( + in TpSessionID mailboxSessionID, + in TpString folderID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_FOLDER_IS_OPEN,P_GMS_INVALID_FOLDER_ID,P_GMS_MAILBOX_LOCKED); + + void createFolder ( + in TpSessionID mailboxSessionID, + in TpString folderID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_INVALID_FOLDER_ID,P_GMS_MAILBOX_LOCKED); + + void remove ( + in TpAddress mailboxID, + in TpString authenticationInfo + ) + raises (TpCommonExceptions,P_GMS_INSUFFICIENT_PRIVILEGE,P_GMS_INVALID_MAILBOX,P_GMS_MAILBOX_LOCKED,P_GMS_MAILBOX_OPEN,P_GMS_INVALID_AUTHENTICATION_INFORMATION); + + }; + + interface IpMessage : IpService { + + TpInt32 getInfoAmount ( + in TpSessionID folderSessionID, + in TpString messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_INVALID_MESSAGE_ID); + + TpMessageInfoPropertySet getInfoProperties ( + in TpSessionID folderSessionID, + in TpString messageID, + in TpInt32 firstProperty, + in TpInt32 numberOfProperties + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_NUMBER_NOT_POSITIVE,P_GMS_INVALID_MESSAGE_ID); + + void setInfoProperties ( + in TpSessionID folderSessionID, + in TpString messageID, + in TpInt32 firstProperty, + in TpMessageInfoPropertySet messageInfoProperties + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_INVALID_MESSAGE_ID,P_GMS_PROPERTY_NOT_SET); + + void remove ( + in TpSessionID folderSessionID, + in TpString messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_INSUFFICIENT_PRIVILEGE,P_GMS_MESSAGE_NOT_REMOVED,P_GMS_INVALID_MESSAGE_ID); + + TpMessage getContent ( + in TpSessionID folderSessionID, + in TpString messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_INVALID_MESSAGE_ID); + + }; + + interface IpMailboxFolder : IpService { + + TpInt32 getInfoAmount ( + in TpSessionID folderSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + TpFolderInfoPropertySet getInfoProperties ( + in TpSessionID folderSessionID, + in TpInt32 firstProperty, + in TpInt32 numberOfProperties + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_NUMBER_NOT_POSITIVE); + + void setInfoProperties ( + in TpSessionID folderSessionID, + in TpInt32 firstProperty, + in TpFolderInfoPropertySet folderInfoProperties + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_PROPERTY_NOT_SET); + + void putMessage ( + in TpSessionID folderSessionID, + in TpMessage message, + in TpMessageInfoPropertySet messageInfoProperties + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + IpMessage getMessage ( + in TpSessionID folderSessionID, + in TpString messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_INVALID_MESSAGE_ID); + + void close ( + in TpSessionID mailboxSessionID, + in TpSessionID folderSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void remove ( + in TpSessionID mailboxSessionID, + in TpString folderID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_GMS_INSUFFICIENT_PRIVILEGE,P_GMS_INVALID_FOLDER_ID,P_GMS_FOLDER_IS_OPEN); + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/mm.idl b/idl/parlay/mm.idl new file mode 100644 index 0000000000..cefb8c40b9 --- /dev/null +++ b/idl/parlay/mm.idl @@ -0,0 +1,842 @@ +//Source file: mm.idl +//Date: 8 October 2004 +//Mobility Interfaces and Data Types for ETSI ES 203 915-06 V1.1.1, DES/TISPAN-01005-06-OSA, Parlay 5.0 + +#ifndef __MM_DEFINED +#define __MM_DEFINED + + +#include "osa.idl" + +module org { + + module csapi { + + module mm { + + + enum TpLocationPriority { + + P_M_NORMAL, + P_M_HIGH + }; + + + enum TpLocationResponseIndicator { + + P_M_NO_DELAY, + P_M_LOW_DELAY, + P_M_DELAY_TOLERANT, + P_M_USE_TIMER_VALUE + }; + + + struct TpLocationResponseTime { + TpLocationResponseIndicator ResponseTime; + TpInt32 TimerValue; + }; + + + enum TpLocationTriggerCriteria { + + P_UL_ENTERING_AREA, + P_UL_LEAVING_AREA + }; + + + struct TpLocationTrigger { + TpFloat Longitude; + TpFloat Latitude; + TpFloat AreaSemiMajor; + TpFloat AreaSemiMinor; + TpInt32 AngleOfSemiMajor; + TpLocationTriggerCriteria Criterion; + TpDuration ReportingInterval; + }; + + + typedef sequence TpLocationTriggerSet; + + + enum TpLocationType { + + P_M_CURRENT, + P_M_CURRENT_OR_LAST_KNOWN, + P_M_INITIAL + }; + + + struct TpLocationRequest { + TpFloat RequestedAccuracy; + TpLocationResponseTime RequestedResponseTime; + TpBoolean AltitudeRequested; + TpLocationType Type; + TpLocationPriority Priority; + TpString RequestedLocationMethod; + }; + + + enum TpLocationUncertaintyShape { + + P_M_SHAPE_NONE, + P_M_SHAPE_CIRCLE, + P_M_SHAPE_CIRCLE_SECTOR, + P_M_SHAPE_CIRCLE_ARC_STRIPE, + P_M_SHAPE_ELLIPSE, + P_M_SHAPE_ELLIPSE_SECTOR, + P_M_SHAPE_ELLIPSE_ARC_STRIPE + }; + + + struct TpGeographicalPosition { + TpFloat Longitude; + TpFloat Latitude; + TpLocationUncertaintyShape TypeOfUncertaintyShape; + TpFloat UncertaintyInnerSemiMajor; + TpFloat UncertaintyOuterSemiMajor; + TpFloat UncertaintyInnerSemiMinor; + TpFloat UncertaintyOuterSemiMinor; + TpInt32 AngleOfSemiMajor; + TpInt32 SegmentStartAngle; + TpInt32 SegmentEndAngle; + }; + + + enum TpMobilityDiagnostic { + + P_M_NO_INFORMATION, + P_M_APPL_NOT_IN_PRIV_EXCEPT_LST, + P_M_CALL_TO_USER_NOT_SETUP, + P_M_PRIVACY_OVERRIDE_NOT_APPLIC, + P_M_DISALL_BY_LOCAL_REGULAT_REQ, + P_M_CONGESTION, + P_M_INSUFFICIENT_RESOURCES, + P_M_INSUFFICIENT_MEAS_DATA, + P_M_INCONSISTENT_MEAS_DATA, + P_M_LOC_PROC_NOT_COMPLETED, + P_M_LOC_PROC_NOT_SUPP_BY_USER, + P_M_QOS_NOT_ATTAINABLE + }; + + + enum TpMobilityError { + + P_M_OK, + P_M_SYSTEM_FAILURE, + P_M_UNAUTHORIZED_NETWORK, + P_M_UNAUTHORIZED_APPLICATION, + P_M_UNKNOWN_SUBSCRIBER, + P_M_ABSENT_SUBSCRIBER, + P_M_POSITION_METHOD_FAILURE + }; + + + enum TpMobilityStopScope { + + P_M_ALL_IN_ASSIGNMENT, + P_M_SPECIFIED_USERS + }; + + + struct TpMobilityStopAssignmentData { + TpAssignmentID AssignmentId; + TpMobilityStopScope StopScope; + TpAddressSet Users; + }; + + + enum TpTerminalType { + + P_M_FIXED, + P_M_MOBILE, + P_M_IP + }; + + + struct TpUlExtendedData { + TpGeographicalPosition GeographicalPosition; + TpTerminalType TerminalType; + TpBoolean AltitudePresent; + TpFloat Altitude; + TpFloat UncertaintyAltitude; + TpBoolean TimestampPresent; + TpDateAndTime Timestamp; + TpString UsedLocationMethod; + }; + + + typedef sequence TpUlExtendedDataSet; + + + struct TpUserLocation { + TpAddress UserID; + TpMobilityError StatusCode; + TpGeographicalPosition GeographicalPosition; + }; + + + struct TpUserLocationExtended { + TpAddress UserID; + TpMobilityError StatusCode; + TpUlExtendedDataSet Locations; + }; + + + typedef sequence TpUserLocationExtendedSet; + + + typedef sequence TpUserLocationSet; + + + typedef TpString TpLocationCellIDOrLAI; + + + struct TpLocationTriggerCamel { + TpBoolean UpdateInsideVlr; + TpBoolean UpdateOutsideVlr; + }; + + + struct TpUserLocationCamel { + TpAddress UserID; + TpMobilityError StatusCode; + TpBoolean GeographicalPositionPresent; + TpGeographicalPosition GeographicalPosition; + TpBoolean TimestampPresent; + TpDateAndTime Timestamp; + TpBoolean VlrNumberPresent; + TpAddress VlrNumber; + TpBoolean LocationNumberPresent; + TpAddress LocationNumber; + TpBoolean CellIdOrLaiPresent; + TpLocationCellIDOrLAI CellIdOrLai; + }; + + + typedef sequence TpUserLocationCamelSet; + + + typedef TpString TpIMEI; + + + typedef TpString TpNaESRD; + + + typedef TpString TpNaESRK; + + + struct TpUserLocationEmergencyRequest { + TpBoolean UserAddressPresent; + TpAddress UserAddress; + TpBoolean NaEsrdPresent; + TpNaESRD NaEsrd; + TpBoolean NaEsrkPresent; + TpNaESRK NaEsrk; + TpBoolean ImeiPresent; + TpIMEI Imei; + TpLocationRequest LocationReq; + }; + + + enum TpUserLocationEmergencyTrigger { + + P_ULE_CALL_ORIGINATION, + P_ULE_CALL_RELEASE, + P_ULE_LOCATION_REQUEST + }; + + + struct TpUserLocationEmergency { + TpMobilityError StatusCode; + TpBoolean UserIdPresent; + TpAddress UserId; + TpBoolean NaEsrdPresent; + TpNaESRD NaEsrd; + TpBoolean NaEsrkPresent; + TpNaESRK NaEsrk; + TpBoolean ImeiPresent; + TpIMEI Imei; + TpUserLocationEmergencyTrigger TriggeringEvent; + TpBoolean GeographicalPositionPresent; + TpGeographicalPosition GeographicalPosition; + TpBoolean AltitudePresent; + TpFloat Altitude; + TpFloat UncertaintyAltitude; + TpBoolean TimestampPresent; + TpDateAndTime Timestamp; + TpString UsedLocationMethod; + }; + + + enum TpUserStatusIndicator { + + P_US_REACHABLE, + P_US_NOT_REACHABLE, + P_US_BUSY + }; + + + struct TpUserStatus { + TpAddress UserID; + TpMobilityError StatusCode; + TpUserStatusIndicator Status; + TpTerminalType TerminalType; + }; + + + typedef sequence TpUserStatusSet; + + + exception P_REQUESTED_ACCURACY_CANNOT_BE_DELIVERED { + TpString ExtraInformation; + }; + + + exception P_REQUESTED_RESPONSE_TIME_CANNOT_BE_DELIVERED { + TpString ExtraInformation; + }; + + + exception P_INVALID_REPORTING_INTERVAL { + TpString ExtraInformation; + }; + + + exception P_TRIGGER_CONDITIONS_NOT_SUBSCRIBED { + TpString ExtraInformation; + }; + + + struct TpTriggeredStatusRequest { + TpAddressSet Users; + TpAssignmentID AssignmentID; + }; + + + typedef sequence TpTriggeredStatusRequestSet; + + + struct TpTriggeredStatusRequestSetEntry { + TpTriggeredStatusRequestSet Requests; + TpBoolean Final; + }; + + + struct TpPeriodicLocationRequest { + TpAddressSet Users; + TpLocationRequest Request; + TpDuration ReportingInterval; + TpAssignmentID AssignmentID; + }; + + + typedef sequence TpPeriodicLocationRequestSet; + + + struct TpPeriodicLocationRequestSetEntry { + TpPeriodicLocationRequestSet Requests; + TpBoolean Final; + }; + + + struct TpTriggeredLocationRequest { + TpAddressSet Users; + TpLocationRequest Request; + TpAssignmentID AssignmentID; + }; + + + typedef sequence TpTriggeredLocationRequestSet; + + + struct TpTriggeredLocationRequestSetEntry { + TpTriggeredLocationRequestSet Requests; + TpBoolean Final; + }; + + + struct TpUserStatusIndicatorExtended { + TpUserStatusIndicator UserStatusIndicator; + TpBoolean PDPContextActive; + }; + + + enum TpAuthStatusIndicator { + + P_AUTHENTICATED_FOR_NETWORK_ONLY, + P_AUTHENTICATED_FOR_NETWORK_AND_IP_SERVICES, + P_NOT_AUTHENTICATED + }; + + + struct TpUserInfo { + TpString UserName; + TpString Password; + }; + + + enum TpAccessTechnology { + + P_MOBILE_ACCESS_PS, + P_MOBILE_ACCESS_CS, + P_FIXED_ACCESS + }; + + + enum TpRoamingStatus { + + P_UNKNOWN_ROAMING_STATUS, + P_HOME_USER, + P_NATIONAL_ROAMING, + P_INTERNATIONAL_ROAMING, + P_OPERATOR_ROAMING + }; + + + struct TpNetworkStatusIndicator { + TpString CountryCode; + TpString MobileNetworkCode; + TpAccessTechnology AccessTechnology; + TpRoamingStatus RoamingStatus; + }; + + + struct TpUserStatusExtended { + TpString UserID; + TpMobilityError StatusCode; + TpUserStatusIndicatorExtended Status; + TpTerminalType TerminalType; + TpAuthStatusIndicator AuthenticationStatus; + TpNetworkStatusIndicator NetworkStatus; + TpString UserIPAddress; + TpString UserMSISDN; + TpUserInfo UserInfo; + TpString UserConnectionID; + TpString AccessPointName; + }; + + + typedef sequence TpUserStatusExtendedSet; + + + typedef TpInt32 TpBindingNotificationCriteriaType; + + + const TpInt32 P_UB_NEW = 1; + + const TpInt32 P_UB_REMOVE = 2; + + const TpInt32 P_UB_UPDATE = 4; + + struct TpBindingNotificationCriteria { + TpBindingNotificationCriteriaType NotificationCriteriaType; + TpAddressSet ContactAddressSet; + }; + + + typedef sequence TpBindingNotificationCriteriaSet; + + + enum TpBindingEntryType { + + P_UB_UNDEFINED, + P_UB_EXPIRES, + P_UB_CONTACT_ADDRESS, + P_UB_PREFERENCE + }; + + + union TpBindingEntry switch(TpBindingEntryType) { + case P_UB_EXPIRES: TpInt32 UBExpires; + case P_UB_CONTACT_ADDRESS: TpAddress UBContactAddress; + case P_UB_PREFERENCE: TpFloat UBPreference; + default: short Dummy; + }; + + + typedef sequence TpBindingEntrySet; + + + typedef sequence TpBindingSet; + + + module ul { + + interface IpAppUserLocation : IpInterface { + void locationReportRes ( + in TpAssignmentID assignmentId, + in TpUserLocationSet locations + ); + + void locationReportErr ( + in TpAssignmentID assignmentId, + in TpMobilityError cause, + in TpMobilityDiagnostic diagnostic + ); + + void extendedLocationReportRes ( + in TpAssignmentID assignmentId, + in TpUserLocationExtendedSet locations + ); + + void extendedLocationReportErr ( + in TpAssignmentID assignmentId, + in TpMobilityError cause, + in TpMobilityDiagnostic diagnostic + ); + + void periodicLocationReport ( + in TpAssignmentID assignmentId, + in TpUserLocationExtendedSet locations + ); + + void periodicLocationReportErr ( + in TpAssignmentID assignmentId, + in TpMobilityError cause, + in TpMobilityDiagnostic diagnostic + ); + + }; + + + interface IpUserLocation : IpService { + TpAssignmentID locationReportReq ( + in IpAppUserLocation appLocation, + in TpAddressSet users + ) + raises (TpCommonExceptions,P_APPLICATION_NOT_ACTIVATED,P_INFORMATION_NOT_AVAILABLE,P_INVALID_INTERFACE_TYPE); + + TpAssignmentID extendedLocationReportReq ( + in IpAppUserLocation appLocation, + in TpAddressSet users, + in TpLocationRequest request + ) + raises (TpCommonExceptions,P_APPLICATION_NOT_ACTIVATED,P_REQUESTED_ACCURACY_CANNOT_BE_DELIVERED,P_REQUESTED_RESPONSE_TIME_CANNOT_BE_DELIVERED,P_INFORMATION_NOT_AVAILABLE,P_INVALID_INTERFACE_TYPE); + + TpAssignmentID periodicLocationReportingStartReq ( + in IpAppUserLocation appLocation, + in TpAddressSet users, + in TpLocationRequest request, + in TpDuration reportingInterval + ) + raises (TpCommonExceptions,P_INVALID_REPORTING_INTERVAL,P_REQUESTED_ACCURACY_CANNOT_BE_DELIVERED,P_REQUESTED_RESPONSE_TIME_CANNOT_BE_DELIVERED,P_APPLICATION_NOT_ACTIVATED,P_INFORMATION_NOT_AVAILABLE,P_INVALID_INTERFACE_TYPE); + + void periodicLocationReportingStop ( + in TpMobilityStopAssignmentData stopRequest + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + TpPeriodicLocationRequestSetEntry getNextPeriodicLocationRequest ( + in TpBoolean reset + ) + raises (TpCommonExceptions); + + }; + + + interface IpAppTriggeredUserLocation : IpAppUserLocation { + void triggeredLocationReport ( + in TpAssignmentID assignmentId, + in TpUserLocationExtended location, + in TpLocationTriggerCriteria criterion + ); + + void triggeredLocationReportErr ( + in TpAssignmentID assignmentId, + in TpMobilityError cause, + in TpMobilityDiagnostic diagnostic + ); + + }; + + + interface IpTriggeredUserLocation : IpUserLocation { + TpAssignmentID triggeredLocationReportingStartReq ( + in IpAppTriggeredUserLocation appLocation, + in TpAddressSet users, + in TpLocationRequest request, + in TpLocationTriggerSet triggers + ) + raises (TpCommonExceptions,P_REQUESTED_ACCURACY_CANNOT_BE_DELIVERED,P_REQUESTED_RESPONSE_TIME_CANNOT_BE_DELIVERED,P_TRIGGER_CONDITIONS_NOT_SUBSCRIBED,P_UNKNOWN_SUBSCRIBER,P_APPLICATION_NOT_ACTIVATED,P_INFORMATION_NOT_AVAILABLE,P_INVALID_INTERFACE_TYPE); + + void triggeredLocationReportingStop ( + in TpMobilityStopAssignmentData stopRequest + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + TpTriggeredLocationRequestSetEntry getNextTriggeredLocationRequest ( + in TpBoolean reset + ) + raises (TpCommonExceptions); + + }; + + }; + + + module ulc { + + + interface IpAppUserLocationCamel : IpInterface { + void locationReportRes ( + in TpAssignmentID assignmentId, + in TpUserLocationCamelSet locations + ); + + void locationReportErr ( + in TpAssignmentID assignmentId, + in TpMobilityError cause, + in TpMobilityDiagnostic diagnostic + ); + + void periodicLocationReport ( + in TpAssignmentID assignmentId, + in TpUserLocationCamelSet locations + ); + + void periodicLocationReportErr ( + in TpAssignmentID assignmentId, + in TpMobilityError cause, + in TpMobilityDiagnostic diagnostic + ); + + void triggeredLocationReport ( + in TpAssignmentID assignmentId, + in TpUserLocationCamel location, + in TpLocationTriggerCamel criterion + ); + + void triggeredLocationReportErr ( + in TpAssignmentID assignmentId, + in TpMobilityError cause, + in TpMobilityDiagnostic diagnostic + ); + + }; + + + interface IpUserLocationCamel : IpService { + TpAssignmentID locationReportReq ( + in IpAppUserLocationCamel appLocationCamel, + in TpAddressSet users + ) + raises (TpCommonExceptions,P_UNKNOWN_SUBSCRIBER,P_APPLICATION_NOT_ACTIVATED,P_INFORMATION_NOT_AVAILABLE,P_INVALID_INTERFACE_TYPE); + + TpAssignmentID periodicLocationReportingStartReq ( + in IpAppUserLocationCamel appLocationCamel, + in TpAddressSet users, + in TpDuration reportingInterval + ) + raises (TpCommonExceptions,P_INVALID_REPORTING_INTERVAL,P_UNKNOWN_SUBSCRIBER,P_APPLICATION_NOT_ACTIVATED,P_INFORMATION_NOT_AVAILABLE,P_INVALID_INTERFACE_TYPE); + + void periodicLocationReportingStop ( + in TpMobilityStopAssignmentData stopRequest + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + TpAssignmentID triggeredLocationReportingStartReq ( + in IpAppUserLocationCamel appLocationCamel, + in TpAddressSet users, + in TpLocationTriggerCamel trigger + ) + raises (TpCommonExceptions,P_UNKNOWN_SUBSCRIBER,P_APPLICATION_NOT_ACTIVATED,P_INFORMATION_NOT_AVAILABLE,P_INVALID_INTERFACE_TYPE); + + void triggeredLocationReportingStop ( + in TpMobilityStopAssignmentData stopRequest + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + TpPeriodicLocationRequestSetEntry getNextPeriodicLocationRequest ( + in TpBoolean reset + ) + raises (TpCommonExceptions); + + TpTriggeredLocationRequestSetEntry getNextTriggeredLocationRequest ( + in TpBoolean reset + ) + raises (TpCommonExceptions); + + }; + + }; + + + module ule { + + + interface IpAppUserLocationEmergency : IpInterface { + void emergencyLocationReport ( + in TpAssignmentID assignmentId, + in TpUserLocationEmergency location + ); + + void emergencyLocationReportErr ( + in TpAssignmentID assignmentId, + in TpMobilityError cause, + in TpMobilityDiagnostic diagnostic + ); + + }; + + + interface IpUserLocationEmergency : IpService { + TpAssignmentID emergencyLocationReportReq ( + in IpAppUserLocationEmergency appEmergencyLocation, + in TpUserLocationEmergencyRequest request + ) + raises (TpCommonExceptions,P_UNKNOWN_SUBSCRIBER,P_INFORMATION_NOT_AVAILABLE,P_APPLICATION_NOT_ACTIVATED,P_INVALID_INTERFACE_TYPE); + + TpAssignmentID subscribeEmergencyLocationReports ( + in IpAppUserLocationEmergency appEmergencyLocation + ) + raises (TpCommonExceptions,P_INVALID_INTERFACE_TYPE); + + void unSubscribeEmergencyLocationReports ( + in TpAssignmentID assignmentId + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + }; + + }; + + + module us { + + + interface IpAppUserStatus : IpInterface { + void statusReportRes ( + in TpAssignmentID assignmentId, + in TpUserStatusSet status + ); + + void statusReportErr ( + in TpAssignmentID assignmentId, + in TpMobilityError cause, + in TpMobilityDiagnostic diagnostic + ); + + void triggeredStatusReport ( + in TpAssignmentID assignmentId, + in TpUserStatus status + ); + + void triggeredStatusReportErr ( + in TpAssignmentID assignmentId, + in TpMobilityError cause, + in TpMobilityDiagnostic diagnostic + ); + + void extendedStatusReportRes ( + in TpAssignmentID assignmentId, + in TpUserStatusExtendedSet status + ); + + void extendedStatusReportErr ( + in TpAssignmentID assignmentId, + in TpMobilityError cause, + in TpMobilityDiagnostic diagnostic + ); + + void extTriggeredStatusReport ( + in TpAssignmentID assignmentId, + in TpUserStatusExtended status + ); + + void extTriggeredStatusReportErr ( + in TpAssignmentID assignmentId, + in TpMobilityError cause, + in TpMobilityDiagnostic diagnostic + ); + + }; + + + interface IpUserStatus : IpService { + TpAssignmentID statusReportReq ( + in IpAppUserStatus appStatus, + in TpAddressSet users + ) + raises (TpCommonExceptions,P_UNKNOWN_SUBSCRIBER,P_INFORMATION_NOT_AVAILABLE,P_APPLICATION_NOT_ACTIVATED,P_INVALID_INTERFACE_TYPE); + + TpAssignmentID triggeredStatusReportingStartReq ( + in IpAppUserStatus appStatus, + in TpAddressSet users + ) + raises (TpCommonExceptions,P_UNKNOWN_SUBSCRIBER,P_INFORMATION_NOT_AVAILABLE,P_APPLICATION_NOT_ACTIVATED,P_INVALID_INTERFACE_TYPE); + + void triggeredStatusReportingStop ( + in TpMobilityStopAssignmentData stopRequest + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + TpTriggeredStatusRequestSetEntry getNextTriggeredStatusRequest ( + in TpBoolean reset + ) + raises (TpCommonExceptions); + + TpAssignmentID extendedStatusReportReq ( + in IpAppUserStatus appStatus, + in TpAddressSet users + ) + raises (TpCommonExceptions,P_UNKNOWN_SUBSCRIBER,P_INFORMATION_NOT_AVAILABLE,P_APPLICATION_NOT_ACTIVATED,P_INVALID_INTERFACE_TYPE); + + TpAssignmentID extTriggeredStatusReportingStartReq ( + in IpAppUserStatus appStatus, + in TpAddressSet users + ) + raises (TpCommonExceptions,P_UNKNOWN_SUBSCRIBER,P_INFORMATION_NOT_AVAILABLE,P_APPLICATION_NOT_ACTIVATED,P_INVALID_INTERFACE_TYPE); + + void extTriggeredStatusReportingStop ( + in TpMobilityStopAssignmentData stopRequest + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + }; + + }; + + + module ub { + + + interface IpAppUserBinding : IpInterface { + TpBindingSet triggeredBindingRequestNotification ( + in TpAssignmentID assignmentId, + in TpAddress address, + in TpBindingSet contactInformation + ); + + void triggeredBindingRequestNotificationStartErr ( + in TpAssignmentID assignmentId, + in TpMobilityError cause, + in TpMobilityDiagnostic diagnostic + ); + + }; + + + interface IpUserBinding : IpService { + TpAssignmentID triggeredBindingRequestNotificationStartReq ( + in IpAppUserBinding appStatus, + in TpAddressSet users, + in TpBindingNotificationCriteriaSet criteria + ) + raises (TpCommonExceptions,P_UNKNOWN_SUBSCRIBER,P_INFORMATION_NOT_AVAILABLE,P_APPLICATION_NOT_ACTIVATED,P_INVALID_INTERFACE_TYPE); + + void triggeredBindingRequestNotificationStop ( + in TpAssignmentID assignmentId + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + }; + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/mmccs.idl b/idl/parlay/mmccs.idl new file mode 100644 index 0000000000..f120f01983 --- /dev/null +++ b/idl/parlay/mmccs.idl @@ -0,0 +1,320 @@ +//Source file: mmccs.idl +//Date: 7 October 2004 +//Multi Media Call Control for ETSI ES 203 915-04-4 V1.1.1, DES/TISPAN-01005-04-4-OSA, Parlay 5.0 + +#ifndef __MMCCS_DEFINED +#define __MMCCS_DEFINED + + +#include "osa.idl" +#include "mpcc_interfaces.idl" +#include "common_cc_data.idl" +#include "mpcc_data.idl" + +module org { + + module csapi { + + module cc { + + module mmccs { + + interface IpMultiMediaCall; + interface IpAppMultiMediaCall; + interface IpMultiMediaCallLeg; + interface IpAppMultiMediaCallLeg; + interface IpMultiMediaStream; + + enum TpMediaStreamDirection { + + P_SEND_ONLY, + P_RECEIVE_ONLY, + P_SEND_RECEIVE + }; + + + typedef TpInt32 TpAudioCapabilitiesType; + + + const TpInt32 P_G711_64K = 1; + + const TpInt32 P_G711_56K = 2; + + const TpInt32 P_G722_64K = 4; + + const TpInt32 P_G722_56K = 8; + + const TpInt32 P_G722_48K = 16; + + const TpInt32 P_G7231 = 32; + + const TpInt32 P_G728 = 64; + + const TpInt32 P_G729 = 128; + + const TpInt32 P_G729_ANNEX_A = 256; + + const TpInt32 P_IS11172_3 = 512; + + const TpInt32 P_IS13818_3 = 1024; + + const TpInt32 P_G729_ANNEXB = 2048; + + const TpInt32 P_G729_ANNEX_A_AND_B = 4096; + + const TpInt32 P_G7231_ANNEX_C = 8192; + + const TpInt32 P_GSM_FULLRATE = 16384; + + const TpInt32 P_GSM_HALFRATE = 32768; + + const TpInt32 P_GSM_ENHANCED = 65536; + + typedef TpInt32 TpVideoCapabilitiesType; + + + const TpInt32 P_H261 = 1; + + const TpInt32 P_H262 = 2; + + const TpInt32 P_H263 = 4; + + const TpInt32 P_IS11172_2 = 8; + + typedef TpInt32 TpDataCapabilities; + + + enum TpMediaStreamEventType { + + P_MEDIA_STREAM_ADDED, + P_MEDIA_STREAM_SUBTRACTED, + P_MEDIA_STREAM_QOS_CLASS_CHANGED + }; + + + struct TpCallSuperviseVolume { + TpInt32 VolumeQuantity; + TpInt32 VolumeUnit; + }; + + + enum TpMediaStreamDataTypeRequestType { + + P_AUDIO_CAPABILITIES, + P_VIDEO_CAPABILITIES, + P_DATA_CAPABILITIES + }; + + + union TpMediaStreamDataTypeRequest switch(TpMediaStreamDataTypeRequestType) { + case P_AUDIO_CAPABILITIES: TpAudioCapabilitiesType Audio; + case P_VIDEO_CAPABILITIES: TpVideoCapabilitiesType Video; + case P_DATA_CAPABILITIES: TpDataCapabilities Data; + }; + + + struct TpMediaStreamRequest { + TpMediaStreamDirection Direction; + TpMediaStreamDataTypeRequest DataTypeRequest; + TpCallMonitorMode MediaMonitorMode; + TpMediaStreamEventType EventType; + }; + + + typedef sequence TpMediaStreamRequestSet; + + + typedef TpMediaStreamDataTypeRequest TpMediaStreamDataType; + + + struct TpMediaStream { + TpMediaStreamDirection Direction; + TpMediaStreamDataType DataType; + TpSessionID ChannelSessionID; + IpMultiMediaStream MediaStream; + }; + + + typedef sequence TpMediaStreamSet; + + + struct TpNotificationMediaRequest { + TpCallNotificationScope MediaNotificationScope; + TpMediaStreamRequestSet MediaStreamsRequested; + }; + + + struct TpMediaNotificationRequested { + TpNotificationMediaRequest AppNotificationMediaRequest; + TpInt32 AssignmentID; + }; + + + typedef sequence TpMediaNotificationRequestedSet; + + + const TpInt32 P_UMTS_AMR_NB = 131072; + + const TpInt32 P_UMTS_AMR_WB = 262144; + + const TpInt32 P_IS14496_2 = 16; + + + struct TpMultiMediaCallIdentifier { + IpMultiMediaCall MMCallReference; + TpSessionID MMCallSessionID; + }; + + + struct TpMultiMediaCallLegIdentifier { + IpMultiMediaCallLeg MMCallLegReference; + TpSessionID MMCallLegSessionID; + }; + + + typedef sequence TpMultiMediaCallIdentifierSet; + + + enum TpAppMultiMediaCallBackRefType { + + P_APP_CALLBACK_UNDEFINED, + P_APP_MULTIMEDIA_CALL_CALLBACK, + P_APP_CALL_LEG_CALLBACK, + P_APP_CALL_AND_CALL_LEG_CALLBACK + }; + + + typedef sequence TpAppMultiMediaCallLegRefSet; + + + struct TpAppMultiMediaCallLegCallBack { + IpAppMultiMediaCall AppMultiMediaCall; + TpAppMultiMediaCallLegRefSet AppCallLegSet; + }; + + + union TpAppMultiMediaCallBack switch(TpAppMultiMediaCallBackRefType) { + case P_APP_MULTIMEDIA_CALL_CALLBACK: IpAppMultiMediaCall AppMultiMediaCall; + case P_APP_CALL_LEG_CALLBACK: IpAppMultiMediaCallLeg AppMultiMediaCallLeg; + case P_APP_CALL_AND_CALL_LEG_CALLBACK: TpAppMultiMediaCallLegCallBack AppMultiMediaCallAndCallLeg; + default: short Dummy; + }; + + + typedef sequence TpMultiMediaCallLegIdentifierSet; + + + + + interface IpAppMultiMediaCall : mpccs::IpAppMultiPartyCall { + void superviseVolumeRes ( + in TpSessionID callSessionID, + in TpCallSuperviseReport report, + in TpCallSuperviseVolume usedVolume, + in TpDataSessionQosClass qualityOfService + ); + + void superviseVolumeErr ( + in TpSessionID callSessionID, + in TpCallError errorIndication + ); + + }; + + + interface IpAppMultiMediaCallLeg : mpccs::IpAppCallLeg { + void mediaStreamMonitorRes ( + in TpSessionID callLegSessionID, + in TpMediaStreamSet streams, + in TpMediaStreamEventType type + ); + + }; + + + interface IpMultiMediaStream : IpService { + void subtract ( + in TpSessionID mediaStreamSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + }; + + + interface IpMultiMediaCallLeg : mpccs::IpCallLeg { + void mediaStreamAllow ( + in TpSessionID callLegSessionID, + in TpSessionIDSet mediaStreamList + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void mediaStreamMonitorReq ( + in TpSessionID callLegSessionID, + in TpMediaStreamRequestSet mediaStreamEventCriteria + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_CRITERIA,P_INVALID_EVENT_TYPE); + + TpMediaStreamSet getMediaStreams ( + in TpSessionID callLegSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + }; + + + interface IpMultiMediaCall : mpccs::IpMultiPartyCall { + void superviseVolumeReq ( + in TpSessionID callSessionID, + in TpCallSuperviseVolume volume, + in TpCallSuperviseTreatment treatment + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + }; + + + interface IpAppMultiMediaCallControlManager : mpccs::IpAppMultiPartyCallControlManager { + TpAppMultiMediaCallBack reportMediaNotification ( + in TpMultiMediaCallIdentifier callReference, + in TpMultiMediaCallLegIdentifierSet callLegReferenceSet, + in TpMediaStreamSet mediaStreams, + in TpMediaStreamEventType type, + in TpDataSessionQosClass qualityOfService, + in TpAssignmentID assignmentID + ); + + }; + + + interface IpMultiMediaCallControlManager : mpccs::IpMultiPartyCallControlManager { + TpAssignmentID createMediaNotification ( + in IpAppMultiMediaCallControlManager appInterface, + in TpNotificationMediaRequest notificationMediaRequest + ) + raises (TpCommonExceptions,P_INVALID_CRITERIA,P_INVALID_INTERFACE_TYPE,P_INVALID_EVENT_TYPE); + + void destroyMediaNotification ( + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions); + + void changeMediaNotification ( + in TpAssignmentID assignmentID, + in TpNotificationMediaRequest notificationMediaRequest + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID,P_INVALID_CRITERIA,P_INVALID_EVENT_TYPE); + + TpMediaNotificationRequestedSet getMediaNotification () + raises (TpCommonExceptions); + + }; + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/mmm.idl b/idl/parlay/mmm.idl new file mode 100644 index 0000000000..78ed554474 --- /dev/null +++ b/idl/parlay/mmm.idl @@ -0,0 +1,1085 @@ +//Source file: mmm.idl +//Date: 1 September 2004 +//Multi Media Messaging for draft ETSI ES 203 915-15 v.0.0.2, DES/TISPAN-01005-15-OSA, Parlay 5.0 + + +#ifndef __MMM_DEFINED +#define __MMM_DEFINED + + +#include "osa.idl" + +module org { + + module csapi { + + + module mmm { + + interface IpMailbox; + interface IpMultiMediaMessaging; + interface IpAppMailbox; + interface IpAppMultiMediaMessaging; + + struct TpMailboxIdentifier { + IpMailbox Mailbox; + TpSessionID SessionID; + }; + + + exception P_MMM_INVALID_AUTHENTICATION_INFORMATION { + TpString ExtraInformation; + }; + + + exception P_MMM_INVALID_MAILBOX { + TpString ExtraInformation; + }; + + + struct TpMultiMediaMessagingIdentifier { + IpMultiMediaMessaging MultiMediaMessaging; + TpSessionID SessionID; + }; + + + exception P_MMM_INVALID_DELIVERY_TYPE { + TpString ExtraInformation; + }; + + + enum TpFolderInfoPropertyName { + + P_MMM_FOLDER_UNDEFINED, + P_MMM_FOLDER_DATE_CREATED, + P_MMM_FOLDER_DATE_CHANGED, + P_MMM_FOLDER_SIZE, + P_MMM_FOLDER_NUMBER_OF_MESSAGES + }; + + + union TpFolderInfoProperty switch(TpFolderInfoPropertyName) { + case P_MMM_FOLDER_DATE_CREATED: TpDateAndTime FolderDateCreated; + case P_MMM_FOLDER_DATE_CHANGED: TpDateAndTime FolderDateChanged; + case P_MMM_FOLDER_SIZE: TpInt32 FolderSize; + case P_MMM_FOLDER_NUMBER_OF_MESSAGES: TpInt32 FolderNumberOfMessages; + default: short Dummy; + }; + + + typedef sequence TpFolderInfoPropertySet; + + + enum TpMailboxInfoPropertyName { + + P_MMM_MAILBOX_UNDEFINED, + P_MMM_MAILBOX_OWNER, + P_MMM_MAILBOX_DATE_CREATED, + P_MMM_MAILBOX_DATE_CHANGED, + P_MMM_MAILBOX_SIZE + }; + + + union TpMailboxInfoProperty switch(TpMailboxInfoPropertyName) { + case P_MMM_MAILBOX_OWNER: TpString MailboxOwner; + case P_MMM_MAILBOX_DATE_CREATED: TpDateAndTime MailboxDateCreated; + case P_MMM_MAILBOX_DATE_CHANGED: TpDateAndTime MailboxDateChanged; + case P_MMM_MAILBOX_SIZE: TpInt32 MailboxSize; + default: short Dummy; + }; + + + enum TpMessageInfoPropertyName { + + P_MMM_MESSAGE_UNDEFINED, + P_MMM_MESSAGE_DATE_CREATED, + P_MMM_MESSAGE_DATE_RECEIVED, + P_MMM_MESSAGE_DATE_CHANGED, + P_MMM_MESSAGE_SIZE, + P_MMM_MESSAGE_STATUS + }; + + + enum TpMessagePriority { + + P_MMM_MESSAGE_PRIORITY_UNDEFINED, + P_MMM_MESSAGE_PRIORITY_HIGH, + P_MMM_MESSAGE_PRIORITY_LOW + }; + + + typedef sequence TpMailboxInfoPropertySet; + + + struct TpListMessagesCriteria { + TpBoolean OnlyUnreadMessages; + }; + + + struct TpMailboxFolderStatusInformation { + TpInt32 TotalMessageCount; + }; + + + struct TpMessageDescription { + TpString MessageID; + TpAddress From; + TpAddressSet To; + TpString Subject; + TpDateAndTime ReceivedDate; + TpInt32 Size; + }; + + + typedef sequence TpMessageDescriptionList; + + + struct TpBodyPartDescription { + TpString ContentDescription; + TpInt32 ContentSize; + TpString ContentType; + TpString ContentTransferEncoding; + TpString ContentID; + TpString ContentDisposition; + TpString PartID; + TpInt32 NestingLevel; + }; + + + typedef sequence TpBodyPartDescriptionList; + + + struct TpBodyPart { + TpBodyPartDescription BodyPartHeader; + TpOctetSet BodyPartContent; + }; + + + typedef sequence TpBodyPartList; + + + enum TpMessageHeaderFieldType { + + P_MESSAGE_DATE_SENT, + P_MESSAGE_SENT_FROM, + P_MESSAGE_SENDER, + P_MESSAGE_REPLY_TO, + P_MESSAGE_SENT_TO, + P_MESSAGE_CC_TO, + P_MESSAGE_BCC_TO, + P_MESSAGE_RFC822_MESSAGE_ID, + P_MESSAGE_IN_REPLY_TO, + P_MESSAGE_REFERENCES, + P_MESSAGE_SUBJECT, + P_MESSAGE_COMMENTS, + P_MESSAGE_KEYWORDS, + P_MESSAGE_TRACE_FIELD, + P_MESSAGE_RESENT_FIELD, + P_MESSAGE_MIME_VERSION, + P_MESSAGE_MIME_CONTENT, + P_MESSAGE_MIME_ENCODING, + P_MESSAGE_MIME_ID, + P_MESSAGE_MIME_DESCRIPTION, + P_MESSAGE_MIME_DISPOSITION, + P_MESSAGE_MIME_EXTENSION_FIELD, + P_MESSAGE_EXTENSION_FIELD, + P_MESSAGE_PRIORITY + }; + + + enum TpMailboxMessageStatus { + + P_MMM_RECEIVED_MSG_STATUS_READ, + P_MMM_RECEIVED_MSG_STATUS_UNREAD, + P_MMM_RECEIVED_MSG_STATUS_FORWARDED, + P_MMM_RECEIVED_MSG_STATUS_REPLIED_TO, + P_MMM_DRAFT_MSG_STATUS_SAVED_OR_UNSENT, + P_MMM_SENT_MSG_STATUS_SENT, + P_MMM_SENT_MSG_STATUS_DELIVERED, + P_MMM_SENT_MSG_STATUS_READ, + P_MMM_SENT_MSG_STATUS_DELETED_UNREAD, + P_MMM_SENT_MSG_STATUS_NOT_DELIVERABLE, + P_MMM_SENT_MSG_STATUS_EXPIRED + }; + + + union TpMessageInfoProperty switch(TpMessageInfoPropertyName) { + case P_MMM_MESSAGE_DATE_CREATED: TpDateAndTime MessageDateCreated; + case P_MMM_MESSAGE_DATE_RECEIVED: TpDateAndTime MessageDateReceived; + case P_MMM_MESSAGE_DATE_CHANGED: TpDateAndTime MessageDateChanged; + case P_MMM_MESSAGE_SIZE: TpInt32 MessageSize; + case P_MMM_MESSAGE_STATUS: TpMailboxMessageStatus MessageStatus; + default: short Dummy; + }; + + + typedef sequence TpMessageInfoPropertySet; + + + struct TpGenericHeaderField { + TpString FieldName; + TpString FieldValue; + }; + + + union TpMessageHeaderField switch(TpMessageHeaderFieldType) { + case P_MESSAGE_DATE_SENT: TpDateAndTime DateSent; + case P_MESSAGE_SENT_FROM: TpAddressSet From; + case P_MESSAGE_SENDER: TpAddress Sender; + case P_MESSAGE_REPLY_TO: TpAddressSet ReplyTo; + case P_MESSAGE_SENT_TO: TpAddressSet To; + case P_MESSAGE_CC_TO: TpAddressSet Cc; + case P_MESSAGE_BCC_TO: TpAddressSet Bcc; + case P_MESSAGE_RFC822_MESSAGE_ID: TpString RFC822MessageID; + case P_MESSAGE_IN_REPLY_TO: TpStringSet InReplyTo; + case P_MESSAGE_REFERENCES: TpStringSet References; + case P_MESSAGE_SUBJECT: TpString Subject; + case P_MESSAGE_COMMENTS: TpString Comments; + case P_MESSAGE_KEYWORDS: TpStringSet Keywords; + case P_MESSAGE_TRACE_FIELD: TpGenericHeaderField TraceField; + case P_MESSAGE_RESENT_FIELD: TpGenericHeaderField ResentField; + case P_MESSAGE_MIME_VERSION: TpString MimeVersion; + case P_MESSAGE_MIME_CONTENT: TpString MimeContent; + case P_MESSAGE_MIME_ENCODING: TpString MimeEncoding; + case P_MESSAGE_MIME_ID: TpString MimeID; + case P_MESSAGE_MIME_DESCRIPTION: TpString MimeDescription; + case P_MESSAGE_MIME_DISPOSITION: TpString MimeDisposition; + case P_MESSAGE_MIME_EXTENSION_FIELD: TpGenericHeaderField MimeExtensionField; + case P_MESSAGE_EXTENSION_FIELD: TpGenericHeaderField ExtensionField; + case P_MESSAGE_PRIORITY: TpMessagePriority Priority; + }; + + + typedef sequence TpMessageHeaderFieldSet; + + + enum TpSetPropertyError { + + P_MMM_PROPERTY_NOT_SET, + P_MMM_PROPERTY_READONLY, + P_MMM_PROPERTY_INSUFFICIENT_PRIVILEGE, + P_MMM_PROPERTY_NAME_UNKNOWN + }; + + + struct TpMessageInfoPropertyError { + TpMessageInfoPropertyName MessagePropertyName; + TpSetPropertyError Error; + }; + + + typedef sequence TpMessageInfoPropertyErrorSet; + + + enum TpMessagingEventName { + + P_EVENT_MSG_NAME_UNDEFINED, + P_EVENT_MSG_NEW_MAILBOX_MESSAGE_ARRIVED, + P_EVENT_MSG_NEW_MESSAGE_ARRIVED + }; + + + struct TpNewMailboxMessageArrivedCriteria { + TpString MailboxID; + TpString AuthenticationInfo; + }; + + + struct TpNewMailboxMessageArrivedInfo { + TpString MailboxID; + TpString FolderID; + TpMessageDescriptionList MessageDescription; + TpMessageHeaderFieldSet ExtendedHeaderInformation; + }; + + + typedef TpInt32 TpMessageDeliveryReportType; + + + const TpMessageDeliveryReportType P_MESSAGE_REPORT_DELIVERY_UNDEFINED = 0; + + const TpMessageDeliveryReportType P_MESSAGE_REPORT_DELIVERED = 1; + + const TpMessageDeliveryReportType P_MESSAGE_REPORT_READ = 2; + + const TpMessageDeliveryReportType P_MESSAGE_REPORT_DELETED_UNREAD = 4; + + const TpMessageDeliveryReportType P_MESSAGE_REPORT_NOT_DELIVERABLE = 8; + + const TpMessageDeliveryReportType P_MESSAGE_REPORT_EXPIRED = 16; + + struct TpQueryStatusReport { + TpAddress DestinationAddress; + TpMessageDeliveryReportType ReportedStatus; + }; + + + typedef sequence TpQueryStatusReportSet; + + + enum TpDeliveryTimeType { + + P_MMM_SEND_IMMEDIATE, + P_MMM_DELIVERY_TIME + }; + + + union TpDeliveryTime switch(TpDeliveryTimeType) { + case P_MMM_DELIVERY_TIME: TpDateAndTime DeliveryTime; + default: short Dummy; + }; + + + typedef TpString TpMessageDeliveryType; + + + const TpMessageDeliveryType P_MMM_SMS = "P_MMM_SMS"; + + const TpMessageDeliveryType P_MMM_SMS_BINARY = "P_MMM_SMS_BINARY"; + + const TpMessageDeliveryType P_MMM_MMS = "P_MMM_MMS"; + + const TpMessageDeliveryType P_MMM_WAP_PUSH = "P_MMM_WAP_PUSH"; + + const TpMessageDeliveryType P_MMM_EMAIL = "P_MMM_EMAIL"; + + enum TpMessageTreatmentType { + + P_MMM_TREATMENT_UNDEFINED, + P_MMM_TREATMENT_REPORT_REQUESTED, + P_MMM_TREATMENT_BILLING_ID, + P_MMM_TREATMENT_DELIVERY_TIME, + P_MMM_TREATMENT_VALIDITY_TIME + }; + + + union TpMessageTreatment switch(TpMessageTreatmentType) { + case P_MMM_TREATMENT_REPORT_REQUESTED: TpMessageDeliveryReportType DeliveryReport; + case P_MMM_TREATMENT_BILLING_ID: TpString BillingID; + case P_MMM_TREATMENT_DELIVERY_TIME: TpDeliveryTime DeliveryTime; + case P_MMM_TREATMENT_VALIDITY_TIME: TpDateAndTime ValidityTime; + }; + + + typedef sequence TpMessageTreatmentSet; + + + struct TpTerminatingAddressList { + TpAddressSet ToAddressList; + TpAddressSet CcAddressList; + TpAddressSet BccAddressList; + }; + + + exception P_MMM_MAX_MESSAGE_SIZE_EXCEEDED { + TpString ExtraInformation; + }; + + + exception P_MMM_INVALID_FOLDER_ID { + TpString ExtraInformation; + }; + + + exception P_MMM_INVALID_MESSAGE_ID { + TpString ExtraInformation; + }; + + + exception P_MMM_INVALID_PART_ID { + TpString ExtraInformation; + }; + + + exception P_MMM_DELIVERY_TYPE_ADDRESS_TYPE_MISMATCH { + TpString ExtraInformation; + }; + + + exception P_MMM_DELIVERY_TYPE_MESSAGE_TYPE_MISMATCH { + TpString ExtraInformation; + }; + + + exception P_MMM_INVALID_PROPERTY { + TpString ExtraInformation; + }; + + + enum TpMessagingError { + + P_MMM_ERROR_UNDEFINED, + P_MMM_ERROR_INVALID_AUTHENTICATION_INFORMATION, + P_MMM_ERROR_INVALID_MAILBOX, + P_MMM_ERROR_INVALID_DELIVERY_TYPE, + P_MMM_ERROR_MAX_MESSAGE_SIZE_EXCEEDED, + P_MMM_ERROR_INVALID_FOLDER_ID, + P_MMM_ERROR_INVALID_MESSAGE_ID, + P_MMM_ERROR_INVALID_PART_ID, + P_MMM_ERROR_DELIVERY_TYPE_ADDRESS_TYPE_MISMATCH, + P_MMM_ERROR_DELIVERY_TYPE_MESSAGE_TYPE_MISMATCH, + P_MMM_ERROR_INVALID_DELIVERY_TIME, + P_MMM_ERROR_INVALID_VALIDITY_TIME, + P_MMM_ERROR_MAX_SUBJECT_SIZE_EXCEEDED, + P_MMM_ERROR_INVALID_ID, + P_MMM_ERROR_INVALID_NESTING_LEVEL, + P_MMM_ERROR_INVALID_CRITERIA, + P_MMM_ERROR_INFORMATION_NOT_AVAILABLE, + P_MMM_ERROR_CANNOT_CANCEL, + P_MMM_ERROR_INVALID_HEADER, + P_MMM_INVALID_NETWORK_STATE, + P_MMM_ERROR_RESOURCE_UNAVAILABLE, + P_MMM_ERROR_RESOURCE_TIMEOUT + }; + + + exception P_MMM_INVALID_DELIVERY_TIME { + TpString ExtraInformation; + }; + + + exception P_MMM_INVALID_VALIDITY_TIME { + TpString ExtraInformation; + }; + + + exception P_MMM_MAX_SUBJECT_SIZE_EXCEEDED { + TpString ExtraInformation; + }; + + + exception P_MMM_INFORMATION_NOT_AVAILABLE { + TpString ExtraInformation; + }; + + + exception P_MMM_CANNOT_CANCEL { + TpString ExtraInformation; + }; + + + exception P_MMM_INVALID_HEADER { + TpString ExtraInformation; + }; + + + struct TpNewMessageArrivedCriteria { + TpAddressRange SourceAddress; + TpAddressRange DestinationAddress; + TpBoolean CreateMultiMediaMessagingSession; + }; + + + union TpMessagingEventCriteria switch(TpMessagingEventName) { + case P_EVENT_MSG_NEW_MAILBOX_MESSAGE_ARRIVED: TpNewMailboxMessageArrivedCriteria EventNewMailboxMessageArrived; + case P_EVENT_MSG_NEW_MESSAGE_ARRIVED: TpNewMessageArrivedCriteria EventNewMessageArrived; + default: short Dummy; + }; + + + typedef sequence TpMessagingEventCriteriaSet; + + + struct TpMessagingNotificationRequested { + TpMessagingEventCriteriaSet EventCriteria; + TpInt32 AssignmentID; + }; + + + typedef sequence TpMessagingNotificationRequestedSet; + + + struct TpMessagingNotificationRequestedSetEntry { + TpMessagingNotificationRequestedSet MessagingNotificationRequestedSet; + TpBoolean Final; + }; + + + struct TpNewMessageArrivedInfo { + TpAddress SourceAddress; + TpAddressSet DestinationAddressSet; + TpOctetSet Message; + TpMessageHeaderFieldSet Headers; + TpMultiMediaMessagingIdentifier MultiMediaMessagingIdentifier; + }; + + + union TpMessagingEventInfo switch(TpMessagingEventName) { + case P_EVENT_MSG_NAME_UNDEFINED: TpString EventNameUndefined; + case P_EVENT_MSG_NEW_MAILBOX_MESSAGE_ARRIVED: TpNewMailboxMessageArrivedInfo EventNewMailboxMessageArrived; + case P_EVENT_MSG_NEW_MESSAGE_ARRIVED: TpNewMessageArrivedInfo EventNewMessageArrived; + }; + + + typedef sequence TpMessagingEventInfoSet; + + + typedef sequence TpMailboxIdentifierSet; + + + typedef sequence TpMultiMediaMessagingIdentifierSet; + + + interface IpAppMultiMediaMessagingManager : IpInterface { + void mailboxTerminated ( + in TpMailboxIdentifier mailboxIdentifier + ); + + IpAppMultiMediaMessaging reportNotification ( + in TpAssignmentID assignmentID, + in TpMessagingEventInfoSet eventInfo + ); + + void notificationsInterrupted (); + + void notificationsResumed (); + + void multiMediaMessagingTerminated ( + in TpMultiMediaMessagingIdentifier multimediaMessagingIdentifier + ); + + void terminateMultipleMailboxes ( + in TpMailboxIdentifierSet mailboxSet + ); + + void terminateMultipleMultiMediaMessagingSessions ( + in TpMultiMediaMessagingIdentifierSet multiMediaMessagingSet + ); + + }; + + + interface IpMultiMediaMessagingManager : IpService { + TpMailboxIdentifier openMailbox ( + in TpString mailboxID, + in TpString authenticationInfo, + in IpAppMailbox appMailbox + ) + raises (TpCommonExceptions,P_MMM_INVALID_MAILBOX,P_MMM_INVALID_AUTHENTICATION_INFORMATION,P_INVALID_INTERFACE_TYPE); + + TpMultiMediaMessagingIdentifier openMultiMediaMessaging ( + in TpTerminatingAddressList defaultDestinationAddressList, + in TpAddress defaultSourceAddress, + in IpAppMultiMediaMessaging appMultiMediaMessaging + ) + raises (TpCommonExceptions,P_INVALID_INTERFACE_TYPE,P_INVALID_ADDRESS); + + TpAssignmentID createNotification ( + in IpAppMultiMediaMessagingManager appMultiMediaMessagingManager, + in TpMessagingEventCriteriaSet eventCriteria + ) + raises (TpCommonExceptions,P_INVALID_CRITERIA,P_INVALID_INTERFACE_TYPE); + + void destroyNotification ( + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + void changeNotification ( + in TpAssignmentID assignmentID, + in TpMessagingEventCriteriaSet eventCriteria + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID,P_INVALID_CRITERIA); + + TpMessagingNotificationRequestedSetEntry getNextNotification ( + in TpBoolean reset + ) + raises (TpCommonExceptions); + + TpAssignmentID enableNotifications ( + in IpAppMultiMediaMessagingManager appMultiMediaMessagingManager + ) + raises (TpCommonExceptions,P_INVALID_INTERFACE_TYPE); + + void disableNotifications () + raises (TpCommonExceptions); + + }; + + interface IpAppMailbox : IpInterface { + void createFolderRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpString folderID + ); + + void createFolderErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void getFoldersRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpString folderID, + in TpStringList folderNames + ); + + void getFoldersErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpString folderID, + in TpMessagingError error, + in TpString errorDetails + ); + + void deleteFolderRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID + ); + + void deleteFolderErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void copyFolderRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID + ); + + void copyFolderErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void moveFolderRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID + ); + + void moveFolderErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void putMessageRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpString messageID + ); + + void putMessageErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void copyMessageRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID + ); + + void copyMessageErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void moveMessageRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID + ); + + void moveMessageErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void deleteMessageRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID + ); + + void deleteMessageErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void listMessagesRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessageDescriptionList messageList, + in TpMailboxFolderStatusInformation mailboxStatusInfo, + in TpBoolean final + ); + + void listMessagesErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void listMessageBodyPartsRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpBodyPartDescriptionList partsList + ); + + void listMessageBodyPartsErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void getMessageBodyPartsRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpBodyPartList bodyParts + ); + + void getMessageBodyPartsErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void getMessageHeadersRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessageHeaderFieldSet headers + ); + + void getMessageHeadersErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void getMessageContentRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpString contentType, + in TpString contentTransferEncoding, + in TpOctetSet content + ); + + void getMessageContentErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void getFullMessageRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpOctetSet message + ); + + void getFullMessageErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void getMailboxInfoPropertiesRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMailboxInfoPropertySet returnedProperties + ); + + void getFolderInfoPropertiesRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpString folderID, + in TpFolderInfoPropertySet returnedProperties + ); + + void getMessageInfoPropertiesRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpString messageID, + in TpMessageInfoPropertySet returnedProperties + ); + + void setMessageInfoPropertiesRes ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpString messageID, + in TpMessageInfoPropertySet propertiesUpdated + ); + + void setMessageInfoPropertiesErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpString messageID, + in TpMessageInfoPropertyErrorSet propertiesNotUpdated + ); + + void getMailboxInfoPropertiesErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void getFolderInfoPropertiesErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + void getMessageInfoPropertiesErr ( + in TpSessionID mailboxSessionID, + in TpAssignmentID requestID, + in TpMessagingError error, + in TpString errorDetails + ); + + }; + + + interface IpMailbox : IpService { + void close ( + in TpSessionID mailboxSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + TpAssignmentID createFolderReq ( + in TpSessionID mailboxSessionID, + in TpString folderID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID); + + TpAssignmentID getFoldersReq ( + in TpSessionID mailboxSessionID, + in TpString folderID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID); + + TpAssignmentID deleteFolderReq ( + in TpSessionID mailboxSessionID, + in TpString folderID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID); + + TpAssignmentID copyFolderReq ( + in TpSessionID mailboxSessionID, + in TpString sourceFolderID, + in TpString destinationFolderID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID); + + TpAssignmentID moveFolderReq ( + in TpSessionID mailboxSessionID, + in TpString sourceFolderID, + in TpString destinationFolderID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID); + + TpAssignmentID putMessageReq ( + in TpSessionID mailboxSessionID, + in TpString folderID, + in TpOctetSet message + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID,P_MMM_MAX_MESSAGE_SIZE_EXCEEDED); + + TpAssignmentID copyMessageReq ( + in TpSessionID mailboxSessionID, + in TpString fromFolderID, + in TpString toFolderID, + in TpString messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID,P_MMM_INVALID_MESSAGE_ID); + + TpAssignmentID moveMessageReq ( + in TpSessionID mailboxSessionID, + in TpString fromFolderID, + in TpString toFolderID, + in TpString messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID,P_MMM_INVALID_MESSAGE_ID); + + TpAssignmentID deleteMessageReq ( + in TpSessionID mailboxSessionID, + in TpString fromFolderID, + in TpString messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID,P_MMM_INVALID_MESSAGE_ID); + + TpAssignmentID listMessagesReq ( + in TpSessionID mailboxSessionID, + in TpString folderID, + in TpListMessagesCriteria criteria, + in TpBoolean reset + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID,P_INVALID_CRITERIA); + + TpAssignmentID listMessageBodyPartsReq ( + in TpSessionID mailboxSessionID, + in TpString folderID, + in TpString messageID, + in TpInt32 maxNestingLevel + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID,P_MMM_INVALID_MESSAGE_ID); + + TpAssignmentID getMessageBodyPartsReq ( + in TpSessionID mailboxSessionID, + in TpString folderID, + in TpString messageID, + in TpStringList partIDs + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID,P_MMM_INVALID_MESSAGE_ID,P_MMM_INVALID_PART_ID); + + TpAssignmentID getMessageHeadersReq ( + in TpSessionID mailboxSessionID, + in TpString folderID, + in TpString messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID,P_MMM_INVALID_MESSAGE_ID); + + TpAssignmentID getMessageContentReq ( + in TpSessionID mailboxSessionID, + in TpString folderID, + in TpString messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID,P_MMM_INVALID_MESSAGE_ID); + + TpAssignmentID getFullMessageReq ( + in TpSessionID mailboxSessionID, + in TpString folderID, + in TpString messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID,P_MMM_INVALID_MESSAGE_ID); + + TpAssignmentID getMailboxInfoPropertiesReq ( + in TpSessionID mailboxSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + TpAssignmentID getFolderInfoPropertiesReq ( + in TpSessionID mailboxSessionID, + in TpString folderID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_FOLDER_ID); + + TpAssignmentID getMessageInfoPropertiesReq ( + in TpSessionID mailboxSessionID, + in TpString messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_MESSAGE_ID); + + TpAssignmentID setMessageInfoPropertiesReq ( + in TpSessionID mailboxSessionID, + in TpString messageID, + in TpMessageInfoPropertySet properties + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_MMM_INVALID_MESSAGE_ID,P_MMM_INVALID_PROPERTY); + + }; + + + interface IpAppMultiMediaMessaging : IpInterface { + void sendMessageRes ( + in TpSessionID sessionID, + in TpAssignmentID assignmentID + ); + + void sendMessageErr ( + in TpSessionID sessionID, + in TpAssignmentID assignmentID, + in TpMessagingError error, + in TpString errorDetails + ); + + void cancelMessageRes ( + in TpSessionID sessionID, + in TpAssignmentID assignmentID + ); + + void cancelMessageErr ( + in TpSessionID sessionID, + in TpAssignmentID assignmentID, + in TpMessagingError error, + in TpString errorDetails + ); + + void queryStatusRes ( + in TpSessionID sessionID, + in TpAssignmentID assignmentID, + in TpQueryStatusReportSet result + ); + + void queryStatusErr ( + in TpSessionID sessionID, + in TpAssignmentID assignmentID, + in TpMessagingError error, + in TpString errorDetails + ); + + void messageStatusReport ( + in TpSessionID sessionID, + in TpAssignmentID assignmentID, + in TpAddress destinationAddress, + in TpMessageDeliveryReportType deliveryReportType, + in TpString deliveryReportInfo + ); + + void messageReceived ( + in TpSessionID sessionID, + in TpOctetSet message, + in TpMessageHeaderFieldSet headers + ); + + }; + + + interface IpMultiMediaMessaging : IpService { + TpAssignmentID sendMessageReq ( + in TpSessionID sessionID, + in TpAddress sourceAddress, + in TpTerminatingAddressList destinationAddressList, + in TpMessageDeliveryType deliveryType, + in TpMessageTreatmentSet messageTreatment, + in TpOctetSet message, + in TpMessageHeaderFieldSet additionalHeaders + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_ADDRESS,P_MMM_INVALID_DELIVERY_TYPE,P_MMM_MAX_MESSAGE_SIZE_EXCEEDED,P_MMM_DELIVERY_TYPE_ADDRESS_TYPE_MISMATCH,P_MMM_DELIVERY_TYPE_MESSAGE_TYPE_MISMATCH,P_MMM_INVALID_DELIVERY_TIME,P_MMM_INVALID_VALIDITY_TIME,P_MMM_MAX_SUBJECT_SIZE_EXCEEDED,P_MMM_INVALID_HEADER); + + void cancelMessageReq ( + in TpSessionID sessionID, + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions, P_INVALID_SESSION_ID, P_INVALID_ASSIGNMENT_ID,P_INVALID_NETWORK_STATE,P_MMM_CANNOT_CANCEL); + + void queryStatusReq ( + in TpSessionID sessionID, + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions, P_INVALID_SESSION_ID, P_INVALID_ASSIGNMENT_ID,P_MMM_INFORMATION_NOT_AVAILABLE); + + void close ( + in TpSessionID sessionID + ) + raises (TpCommonExceptions, P_INVALID_SESSION_ID); + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/mpcc_data.idl b/idl/parlay/mpcc_data.idl new file mode 100644 index 0000000000..f6547811a4 --- /dev/null +++ b/idl/parlay/mpcc_data.idl @@ -0,0 +1,259 @@ +//Source file: mpcc_data.idl +//Date: 7 October 2004 +//Multi Party Call Control Data Types for ETSI ES 203 915-04-3 V1.1.1, DES/TISPAN-01005-04-3-OSA, Parlay 5.0 + +#ifndef __MPCC_DATA_DEFINED +#define __MPCC_DATA_DEFINED + + +#include "osa.idl" +#include "common_cc_data.idl" + +module org { + + module csapi { + + module cc { + + enum TpCallAppInfoType { + + P_CALL_APP_UNDEFINED, + P_CALL_APP_ALERTING_MECHANISM, + P_CALL_APP_NETWORK_ACCESS_TYPE, + P_CALL_APP_TELE_SERVICE, + P_CALL_APP_BEARER_SERVICE, + P_CALL_APP_PARTY_CATEGORY, + P_CALL_APP_PRESENTATION_ADDRESS, + P_CALL_APP_GENERIC_INFO, + P_CALL_APP_ADDITIONAL_ADDRESS, + P_CALL_APP_ORIGINAL_DESTINATION_ADDRESS, + P_CALL_APP_REDIRECTING_ADDRESS, + P_CALL_APP_HIGH_PROBABILITY_COMPLETION, + P_CALL_APP_CARRIER + }; + + + enum TpCallEventType { + + P_CALL_EVENT_UNDEFINED, + P_CALL_EVENT_ORIGINATING_CALL_ATTEMPT, + P_CALL_EVENT_ORIGINATING_CALL_ATTEMPT_AUTHORISED, + P_CALL_EVENT_ADDRESS_COLLECTED, + P_CALL_EVENT_ADDRESS_ANALYSED, + P_CALL_EVENT_ORIGINATING_SERVICE_CODE, + P_CALL_EVENT_ORIGINATING_RELEASE, + P_CALL_EVENT_TERMINATING_CALL_ATTEMPT, + P_CALL_EVENT_TERMINATING_CALL_ATTEMPT_AUTHORISED, + P_CALL_EVENT_ALERTING, + P_CALL_EVENT_ANSWER, + P_CALL_EVENT_TERMINATING_RELEASE, + P_CALL_EVENT_REDIRECTED, + P_CALL_EVENT_TERMINATING_SERVICE_CODE, + P_CALL_EVENT_QUEUED + }; + + + union TpCallAdditionalEventInfo switch(TpCallEventType) { + case P_CALL_EVENT_ADDRESS_COLLECTED: TpAddress CollectedAddress; + case P_CALL_EVENT_ADDRESS_ANALYSED: TpAddress CalledAddress; + case P_CALL_EVENT_ORIGINATING_SERVICE_CODE: TpCallServiceCode OriginatingServiceCode; + case P_CALL_EVENT_ORIGINATING_RELEASE: TpReleaseCause OriginatingReleaseCause; + case P_CALL_EVENT_TERMINATING_RELEASE: TpReleaseCause TerminatingReleaseCause; + case P_CALL_EVENT_REDIRECTED: TpAddress ForwardAddress; + case P_CALL_EVENT_TERMINATING_SERVICE_CODE: TpCallServiceCode TerminatingServiceCode; + default: short Dummy; + }; + + + struct TpCallNotificationScope { + TpAddressRange DestinationAddress; + TpAddressRange OriginatingAddress; + }; + + + struct TpCallNotificationReportScope { + TpAddress DestinationAddress; + TpAddress OriginatingAddress; + }; + + + typedef sequence TpReleaseCauseSet; + + + union TpAdditionalCallEventCriteria switch(TpCallEventType) { + case P_CALL_EVENT_ADDRESS_COLLECTED: TpInt32 MinAddressLength; + case P_CALL_EVENT_ORIGINATING_SERVICE_CODE: TpCallServiceCodeSet OriginatingServiceCode; + case P_CALL_EVENT_ORIGINATING_RELEASE: TpReleaseCauseSet OriginatingReleaseCauseSet; + case P_CALL_EVENT_TERMINATING_RELEASE: TpReleaseCauseSet TerminatingReleaseCauseSet; + case P_CALL_EVENT_TERMINATING_SERVICE_CODE: TpCallServiceCodeSet TerminatingServiceCode; + default: short Dummy; + }; + + + struct TpCallEventRequest { + TpCallEventType CallEventType; + TpAdditionalCallEventCriteria AdditionalCallEventCriteria; + TpCallMonitorMode CallMonitorMode; + }; + + + typedef sequence TpCallEventRequestSet; + + + struct TpCallNotificationRequest { + TpCallNotificationScope CallNotificationScope; + TpCallEventRequestSet CallEventsRequested; + }; + + + struct TpNotificationRequested { + TpCallNotificationRequest AppCallNotificationRequest; + TpInt32 AssignmentID; + }; + + + typedef sequence TpNotificationRequestedSet; + + + enum TpCallLegAttachMechanism { + + P_CALLLEG_ATTACH_IMPLICITLY, + P_CALLLEG_ATTACH_EXPLICITLY + }; + + + struct TpCallLegConnectionProperties { + TpCallLegAttachMechanism AttachMechanism; + }; + + + const TpInt32 P_CALL_LEG_INFO_UNDEFINED = 0; + + const TpInt32 P_CALL_LEG_INFO_TIMES = 1; + + const TpInt32 P_CALL_LEG_INFO_RELEASE_CAUSE = 2; + + const TpInt32 P_CALL_LEG_INFO_ADDRESS = 4; + + const TpInt32 P_CALL_LEG_INFO_APPINFO = 8; + + typedef TpInt32 TpCallLegInfoType; + + + struct TpCallEventInfo { + TpCallEventType CallEventType; + TpCallAdditionalEventInfo AdditionalCallEventInfo; + TpCallMonitorMode CallMonitorMode; + TpDateAndTime CallEventTime; + }; + + + typedef TpInt32 TpCallLegSuperviseTreatment; + + + const TpInt32 P_CALL_LEG_SUPERVISE_RELEASE = 1; + + const TpInt32 P_CALL_LEG_SUPERVISE_RESPOND = 2; + + const TpInt32 P_CALL_LEG_SUPERVISE_APPLY_TONE = 4; + + typedef TpInt32 TpCallHighProbabilityCompletion; + + + struct TpNotificationRequestedSetEntry { + TpNotificationRequestedSet NotificationRequestSet; + TpBoolean Final; + }; + + + typedef TpOctetSet TpCarrierID; + + + enum TpCarrierSelectionField { + + P_CIC_UNDEFINED, + P_CIC_NO_INPUT, + P_CIC_INPUT, + P_CIC_UNDETERMINED, + P_CIC_NOT_PRESCRIBED + }; + + + struct TpCarrier { + TpCarrierID CarrierID; + TpCarrierSelectionField CarrierSelectionField; + }; + + + typedef sequence TpCarrierSet; + + + union TpCallAppInfo switch(TpCallAppInfoType) { + case P_CALL_APP_ALERTING_MECHANISM: TpCallAlertingMechanism CallAppAlertingMechanism; + case P_CALL_APP_NETWORK_ACCESS_TYPE: TpCallNetworkAccessType CallAppNetworkAccessType; + case P_CALL_APP_TELE_SERVICE: TpCallTeleService CallAppTeleService; + case P_CALL_APP_BEARER_SERVICE: TpCallBearerService CallAppBearerService; + case P_CALL_APP_PARTY_CATEGORY: TpCallPartyCategory CallAppPartyCategory; + case P_CALL_APP_PRESENTATION_ADDRESS: TpAddress CallAppPresentationAddress; + case P_CALL_APP_GENERIC_INFO: TpString CallAppGenericInfo; + case P_CALL_APP_ADDITIONAL_ADDRESS: TpAddress CallAppAdditionalAddress; + case P_CALL_APP_ORIGINAL_DESTINATION_ADDRESS: TpAddress CallAppOriginalDestinationAddress; + case P_CALL_APP_REDIRECTING_ADDRESS: TpAddress CallAppRedirectingAddress; + case P_CALL_APP_HIGH_PROBABILITY_COMPLETION: TpCallHighProbabilityCompletion CallHighProbabilityCompletion; + case P_CALL_APP_CARRIER: TpCarrierSet CallAppCarrier; + default: short Dummy; + }; + + + typedef sequence TpCallAppInfoSet; + + + struct TpCallNotificationInfo { + TpCallNotificationReportScope CallNotificationReportScope; + TpCallAppInfoSet CallAppInfo; + TpCallEventInfo CallEventInfo; + }; + + + struct TpCallLegInfoReport { + TpCallLegInfoType CallLegInfoType; + TpDateAndTime CallLegStartTime; + TpDateAndTime CallLegConnectedToResourceTime; + TpDateAndTime CallLegConnectedToAddressTime; + TpDateAndTime CallLegEndTime; + TpAddress ConnectedAddress; + TpReleaseCause CallLegReleaseCause; + TpCallAppInfoSet CallAppInfo; + }; + + + typedef TpString TpCallLegPropertyName; + + + const TpCallLegPropertyName P_CALL_LEG_PROPERTY_INFO = "P_CALL_LEG_PROPERTY_INFO"; + + const TpCallLegPropertyName P_CALL_LEG_PROPERTY_ICON = "P_CALL_LEG_PROPERTY_ICON"; + + const TpCallLegPropertyName P_CALL_LEG_PROPERTY_CARD = "P_CALL_LEG_PROPERTY_CARD"; + + typedef sequence TpCallLegPropertyNameList; + + + typedef TpString TpCallLegPropertyValue; + + + struct TpCallLegProperty { + TpCallLegPropertyName CallLegPropertyName; + TpCallLegPropertyValue CallLegPropertyValue; + }; + + + typedef sequence TpCallLegPropertyList; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/mpcc_interfaces.idl b/idl/parlay/mpcc_interfaces.idl new file mode 100644 index 0000000000..8bda97be45 --- /dev/null +++ b/idl/parlay/mpcc_interfaces.idl @@ -0,0 +1,414 @@ +//Source file: mpcc_interfaces.idl +//Date: 7 October 2004 +//Multi Party Call Control Interfaces for ETSI ES 203 915-04-3 V1.1.1, DES/TISPAN-01005-04-3-OSA, Parlay 5.0 + +#ifndef __MPCC_INTERFACES_DEFINED +#define __MPCC_INTERFACES_DEFINED + + +#include "osa.idl" +#include "common_cc_data.idl" +#include "mpcc_data.idl" + +module org { + + module csapi { + + module cc { + + module mpccs { + interface IpAppMultiPartyCallControlManager ; + interface IpMultiPartyCall ; + interface IpAppMultiPartyCall ; + interface IpCallLeg; + interface IpAppCallLeg; + + + enum TpAppMultiPartyCallBackRefType { + P_APP_CALLBACK_UNDEFINED, + P_APP_MULTIPARTY_CALL_CALLBACK, + P_APP_CALL_LEG_CALLBACK, + P_APP_CALL_AND_CALL_LEG_CALLBACK + }; + + + typedef sequence TpAppCallLegRefSet; + + + struct TpMultiPartyCallIdentifier { + IpMultiPartyCall CallReference; + TpSessionID CallSessionID; + }; + + + struct TpCallLegIdentifier { + IpCallLeg CallLegReference; + TpSessionID CallLegSessionID; + }; + + + + typedef sequence TpCallLegIdentifierSet; + + + typedef sequence TpMultiPartyCallIdentifierSet; + + + struct TpAppCallLegCallBack { + IpAppMultiPartyCall AppMultiPartyCall; + TpAppCallLegRefSet AppCallLegSet; + }; + + + union TpAppMultiPartyCallBack switch(TpAppMultiPartyCallBackRefType) { + case P_APP_MULTIPARTY_CALL_CALLBACK: IpAppMultiPartyCall AppMultiPartyCall; + case P_APP_CALL_LEG_CALLBACK: IpAppCallLeg AppCallLeg; + case P_APP_CALL_AND_CALL_LEG_CALLBACK: TpAppCallLegCallBack AppMultiPartyCallAndCallLeg; + default: short Dummy; + }; + + + + interface IpAppCallLeg : IpInterface { + void eventReportRes ( + in TpSessionID callLegSessionID, + in TpCallEventInfo eventInfo + ); + + void eventReportErr ( + in TpSessionID callLegSessionID, + in TpCallError errorIndication + ); + + void attachMediaRes ( + in TpSessionID callLegSessionID + ); + + void attachMediaErr ( + in TpSessionID callLegSessionID, + in TpCallError errorIndication + ); + + void detachMediaRes ( + in TpSessionID callLegSessionID + ); + + void detachMediaErr ( + in TpSessionID callLegSessionID, + in TpCallError errorIndication + ); + + void getInfoRes ( + in TpSessionID callLegSessionID, + in TpCallLegInfoReport callLegInfoReport + ); + + void getInfoErr ( + in TpSessionID callLegSessionID, + in TpCallError errorIndication + ); + + void routeErr ( + in TpSessionID callLegSessionID, + in TpCallError errorIndication + ); + + void superviseRes ( + in TpSessionID callLegSessionID, + in TpCallSuperviseReport report, + in TpDuration usedTime + ); + + void superviseErr ( + in TpSessionID callLegSessionID, + in TpCallError errorIndication + ); + + void callLegEnded ( + in TpSessionID callLegSessionID, + in TpReleaseCause cause + ); + + }; + + + interface IpMultiPartyCallControlManager : IpService { + TpMultiPartyCallIdentifier createCall ( + in IpAppMultiPartyCall appCall + ) + raises (TpCommonExceptions,P_INVALID_INTERFACE_TYPE); + + TpAssignmentID createNotification ( + in IpAppMultiPartyCallControlManager appCallControlManager, + in TpCallNotificationRequest notificationRequest + ) + raises (TpCommonExceptions,P_INVALID_CRITERIA,P_INVALID_INTERFACE_TYPE,P_INVALID_EVENT_TYPE); + + void destroyNotification ( + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + void changeNotification ( + in TpAssignmentID assignmentID, + in TpCallNotificationRequest notificationRequest + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID,P_INVALID_CRITERIA,P_INVALID_EVENT_TYPE); + + TpNotificationRequestedSet getNotification () + raises (TpCommonExceptions); + + TpAssignmentID setCallLoadControl ( + in TpDuration duration, + in TpCallLoadControlMechanism mechanism, + in TpCallTreatment treatment, + in TpAddressRange addressRange + ) + raises (TpCommonExceptions,P_INVALID_ADDRESS,P_UNSUPPORTED_ADDRESS_PLAN); + + TpAssignmentID enableNotifications ( + in IpAppMultiPartyCallControlManager appCallControlManager + ) + raises (TpCommonExceptions); + + void disableNotifications () + raises (TpCommonExceptions); + + TpNotificationRequestedSetEntry getNextNotification ( + in TpBoolean reset + ) + raises (TpCommonExceptions); + + }; + + + interface IpCallLeg : IpService { + void routeReq ( + in TpSessionID callLegSessionID, + in TpAddress targetAddress, + in TpAddress originatingAddress, + in TpCallAppInfoSet appInfo, + in TpCallLegConnectionProperties connectionProperties + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE,P_INVALID_ADDRESS,P_UNSUPPORTED_ADDRESS_PLAN); + + void eventReportReq ( + in TpSessionID callLegSessionID, + in TpCallEventRequestSet eventsRequested + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_EVENT_TYPE,P_INVALID_CRITERIA); + + void release ( + in TpSessionID callLegSessionID, + in TpReleaseCause cause + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE); + + void getInfoReq ( + in TpSessionID callLegSessionID, + in TpCallLegInfoType callLegInfoRequested + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + TpMultiPartyCallIdentifier getCall ( + in TpSessionID callLegSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void attachMediaReq ( + in TpSessionID callLegSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE); + + void detachMediaReq ( + in TpSessionID callLegSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE); + + TpAddress getCurrentDestinationAddress ( + in TpSessionID callLegSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void continueProcessing ( + in TpSessionID callLegSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE); + + void setChargePlan ( + in TpSessionID callLegSessionID, + in TpCallChargePlan callChargePlan + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void setAdviceOfCharge ( + in TpSessionID callLegSessionID, + in TpAoCInfo aOCInfo, + in TpDuration tariffSwitch + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_CURRENCY,P_INVALID_AMOUNT); + + void superviseReq ( + in TpSessionID callLegSessionID, + in TpDuration time, + in TpCallLegSuperviseTreatment treatment + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void deassign ( + in TpSessionID callLegSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + TpCallLegPropertyList getProperties ( + in TpSessionID callLegSessionID, + in TpCallLegPropertyNameList propertyNames + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE,P_INFORMATION_NOT_AVAILABLE,P_UNAUTHORISED_PARAMETER_VALUE); + + void setProperties ( + in TpSessionID callLegSessionID, + in TpCallLegPropertyList properties + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE,P_INFORMATION_NOT_AVAILABLE,P_UNAUTHORISED_PARAMETER_VALUE); + + }; + + + interface IpAppMultiPartyCall : IpInterface { + void getInfoRes ( + in TpSessionID callSessionID, + in TpCallInfoReport callInfoReport + ); + + void getInfoErr ( + in TpSessionID callSessionID, + in TpCallError errorIndication + ); + + void superviseRes ( + in TpSessionID callSessionID, + in TpCallSuperviseReport report, + in TpDuration usedTime + ); + + void superviseErr ( + in TpSessionID callSessionID, + in TpCallError errorIndication + ); + + void callEnded ( + in TpSessionID callSessionID, + in TpCallEndedReport report + ); + + void createAndRouteCallLegErr ( + in TpSessionID callSessionID, + in TpCallLegIdentifier callLegReference, + in TpCallError errorIndication + ); + + }; + + + interface IpMultiPartyCall : IpService { + TpCallLegIdentifierSet getCallLegs ( + in TpSessionID callSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + TpCallLegIdentifier createCallLeg ( + in TpSessionID callSessionID, + in IpAppCallLeg appCallLeg + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_INTERFACE_TYPE); + + TpCallLegIdentifier createAndRouteCallLegReq ( + in TpSessionID callSessionID, + in TpCallEventRequestSet eventsRequested, + in TpAddress targetAddress, + in TpAddress originatingAddress, + in TpCallAppInfoSet appInfo, + in IpAppCallLeg appLegInterface + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_INTERFACE_TYPE,P_INVALID_ADDRESS,P_UNSUPPORTED_ADDRESS_PLAN,P_INVALID_NETWORK_STATE,P_INVALID_EVENT_TYPE,P_INVALID_CRITERIA); + + void release ( + in TpSessionID callSessionID, + in TpReleaseCause cause + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE); + + void deassignCall ( + in TpSessionID callSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void getInfoReq ( + in TpSessionID callSessionID, + in TpCallInfoType callInfoRequested + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void setChargePlan ( + in TpSessionID callSessionID, + in TpCallChargePlan callChargePlan + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void setAdviceOfCharge ( + in TpSessionID callSessionID, + in TpAoCInfo aOCInfo, + in TpDuration tariffSwitch + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_CURRENCY,P_INVALID_AMOUNT); + + void superviseReq ( + in TpSessionID callSessionID, + in TpDuration time, + in TpCallSuperviseTreatment treatment + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + }; + + + interface IpAppMultiPartyCallControlManager : IpInterface { + TpAppMultiPartyCallBack reportNotification ( + in TpMultiPartyCallIdentifier callReference, + in TpCallLegIdentifierSet callLegReferenceSet, + in TpCallNotificationInfo notificationInfo, + in TpAssignmentID assignmentID + ); + + void callAborted ( + in TpSessionID callReference + ); + + void managerInterrupted (); + + void managerResumed (); + + void callOverloadEncountered ( + in TpAssignmentID assignmentID + ); + + void callOverloadCeased ( + in TpAssignmentID assignmentID + ); + + void abortMultipleCalls ( + in TpSessionIDSet callReferenceSet + ); + + }; + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/osa.idl b/idl/parlay/osa.idl new file mode 100644 index 0000000000..5a9634373d --- /dev/null +++ b/idl/parlay/osa.idl @@ -0,0 +1,441 @@ +//Source file: osa.idl +//Date: 7 October 2004 +//Common Data Types for ES 203 915-2 V1.1.1, DES/TISPAN-01005-02, Parlay 5.0 + +#ifndef __OSA_DEFINED +#define __OSA_DEFINED + +module org { + + module csapi { + + + enum TpAddressError { + + P_ADDRESS_INVALID_UNDEFINED, + P_ADDRESS_INVALID_MISSING, + P_ADDRESS_INVALID_MISSING_ELEMENT, + P_ADDRESS_INVALID_OUT_OF_RANGE, + P_ADDRESS_INVALID_INCOMPLETE, + P_ADDRESS_INVALID_CANNOT_DECODE + }; + + + enum TpAddressPlan { + + P_ADDRESS_PLAN_NOT_PRESENT, + P_ADDRESS_PLAN_UNDEFINED, + P_ADDRESS_PLAN_IP, + P_ADDRESS_PLAN_MULTICAST, + P_ADDRESS_PLAN_UNICAST, + P_ADDRESS_PLAN_E164, + P_ADDRESS_PLAN_AESA, + P_ADDRESS_PLAN_URL, + P_ADDRESS_PLAN_NSAP, + P_ADDRESS_PLAN_SMTP, + P_ADDRESS_PLAN_MSMAIL, + P_ADDRESS_PLAN_X400, + P_ADDRESS_PLAN_SIP, + P_ADDRESS_PLAN_ANY, + P_ADDRESS_PLAN_NATIONAL + }; + + + enum TpAddressPresentation { + + P_ADDRESS_PRESENTATION_UNDEFINED, + P_ADDRESS_PRESENTATION_ALLOWED, + P_ADDRESS_PRESENTATION_RESTRICTED, + P_ADDRESS_PRESENTATION_ADDRESS_NOT_AVAILABLE + }; + + + enum TpAddressScreening { + + P_ADDRESS_SCREENING_UNDEFINED, + P_ADDRESS_SCREENING_USER_VERIFIED_PASSED, + P_ADDRESS_SCREENING_USER_NOT_VERIFIED, + P_ADDRESS_SCREENING_USER_VERIFIED_FAILED, + P_ADDRESS_SCREENING_NETWORK + }; + + + typedef boolean TpBoolean; + + + typedef float TpFloat; + + + typedef long TpInt32; + + + const TpInt32 P_METHOD_NOT_SUPPORTED = 22; + + const TpInt32 P_NO_CALLBACK_ADDRESS_SET = 17; + + const TpInt32 P_RESOURCES_UNAVAILABLE = 13; + + const TpInt32 P_TASK_CANCELLED = 15; + + const TpInt32 P_TASK_REFUSED = 14; + + typedef TpInt32 TpAssignmentID; + + + typedef TpInt32 TpDuration; + + + typedef TpInt32 TpSessionID; + + + typedef sequence TpSessionIDSet; + + + typedef string TpString; + + + exception P_INVALID_ASSIGNMENT_ID { + TpString ExtraInformation; + }; + + + exception P_INVALID_TIME_AND_DATE_FORMAT { + TpString ExtraInformation; + }; + + + exception P_INVALID_EVENT_TYPE { + TpString ExtraInformation; + }; + + + exception P_INVALID_INTERFACE_NAME { + TpString ExtraInformation; + }; + + + exception P_INVALID_INTERFACE_TYPE { + TpString ExtraInformation; + }; + + + exception P_UNKNOWN_SUBSCRIBER { + TpString ExtraInformation; + }; + + + exception P_INFORMATION_NOT_AVAILABLE { + TpString ExtraInformation; + }; + + + struct TpAddress { + TpAddressPlan Plan; + TpString AddrString; + TpString Name; + TpAddressPresentation Presentation; + TpAddressScreening Screening; + TpString SubAddressString; + }; + + + struct TpAddressRange { + TpAddressPlan Plan; + TpString AddrString; + TpString Name; + TpString SubAddressString; + }; + + + typedef sequence TpAddressSet; + + + typedef TpString TpPrice; + + + typedef TpString TpDate; + + + typedef TpString TpDateAndTime; + + + typedef TpString TpTime; + + + typedef TpString TpURL; + + + typedef TpString TpLanguage; + + enum TpCallAoCOrderCategory { + + P_CHARGE_ADVICE_INFO, + P_CHARGE_PER_TIME, + P_CHARGE_NETWORK + }; + + + struct TpCAIElements { + TpInt32 UnitsPerInterval; + TpInt32 SecondsPerTimeInterval; + TpInt32 ScalingFactor; + TpInt32 UnitIncrement; + TpInt32 UnitsPerDataInterval; + TpInt32 SegmentsPerDataInterval; + TpInt32 InitialSecsPerTimeInterval; + }; + + + struct TpChargeAdviceInfo { + TpCAIElements CurrentCAI; + TpCAIElements NextCAI; + }; + + + struct TpChargePerTime { + TpInt32 InitialCharge; + TpInt32 CurrentChargePerMinute; + TpInt32 NextChargePerMinute; + }; + + + union TpAoCOrder switch(TpCallAoCOrderCategory) { + case P_CHARGE_ADVICE_INFO: TpChargeAdviceInfo ChargeAdviceInfo; + case P_CHARGE_PER_TIME: TpChargePerTime ChargePerTime; + case P_CHARGE_NETWORK: TpString NetworkCharge; + }; + + + struct TpAoCInfo { + TpAoCOrder ChargeOrder; + TpString Currency; + }; + + + exception P_INVALID_CRITERIA { + TpString ExtraInformation; + }; + + + const TpInt32 P_INVALID_STATE = 744; + + exception P_INVALID_SESSION_ID { + TpString ExtraInformation; + }; + + + exception TpCommonExceptions { + TpInt32 ExceptionType; + TpString ExtraInformation; + }; + + + exception P_INVALID_CURRENCY { + TpString ExtraInformation; + }; + + + exception P_INVALID_AMOUNT { + TpString ExtraInformation; + }; + + + struct TpTimeInterval { + TpDateAndTime StartTime; + TpDateAndTime StopTime; + }; + + + exception P_APPLICATION_NOT_ACTIVATED { + TpString ExtraInformation; + }; + + + exception P_INVALID_ADDRESS { + TpString ExtraInformation; + }; + + + typedef octet TpOctet; + + + typedef sequence TpOctetSet; + + + exception P_UNSUPPORTED_ADDRESS_PLAN { + TpString ExtraInformation; + }; + + + exception P_UNAUTHORISED_PARAMETER_VALUE { + TpString ExtraInformation; + }; + + + typedef string TpLongString; + + + typedef any TpAny; + + + typedef long long TpInt64; + + + typedef TpString TpVersion; + + + exception P_INVALID_VERSION { + TpString ExtraInformation; + }; + + + typedef sequence TpStringList; + + + typedef sequence TpStringSet; + + + enum TpDataSessionQosClass { + + P_DATA_SESSION_QOS_CLASS_CONVERSATIONAL, + P_DATA_SESSION_QOS_CLASS_STREAMING, + P_DATA_SESSION_QOS_CLASS_INTERACTIVE, + P_DATA_SESSION_QOS_CLASS_BACKGROUND + }; + + + typedef TpString TpURN; + + + exception P_INVALID_NETWORK_STATE { + TpString ExtraInformation; + }; + + + typedef sequence TpUnorderedOctetSet; + + + typedef char TpChar; + + + typedef wchar TpWChar; + + + typedef wstring TpWString; + + + typedef short TpInt16; + + + typedef unsigned short TpUnsignedInt16; + + + typedef unsigned long TpUnsignedInt32; + + + typedef unsigned long long TpUnsignedInt64; + + + typedef double TpDouble; + + + typedef TpString TpXMLString; + + + typedef TpString TpStructuredAttributeType; + + + struct TpStructuredAttributeValue { + TpStructuredAttributeType Type; + TpAny Value; + }; + + + enum TpSimpleAttributeTypeInfo { + + P_BOOLEAN, + P_OCTET, + P_CHAR, + P_WCHAR, + P_STRING, + P_WSTRING, + P_INT16, + P_UNSIGNED_INT16, + P_INT32, + P_UNSIGNED_INT32, + P_INT64, + P_UNSIGNED_INT64, + P_FLOAT, + P_DOUBLE + }; + + + union TpSimpleAttributeValue switch(TpSimpleAttributeTypeInfo) { + case P_BOOLEAN: TpBoolean BooleanValue; + case P_OCTET: TpOctet OctetValue; + case P_CHAR: TpChar CharValue; + case P_WCHAR: TpWChar WCharValue; + case P_STRING: TpString StringValue; + case P_WSTRING: TpWString WStringValue; + case P_INT16: TpInt16 Int16Value; + case P_UNSIGNED_INT16: TpUnsignedInt16 UnsignedInt16Value; + case P_INT32: TpInt32 Int32Value; + case P_UNSIGNED_INT32: TpUnsignedInt32 UnsignedInt32Value; + case P_INT64: TpInt64 Int64Value; + case P_UNSIGNED_INT64: TpUnsignedInt64 UnsignedInt64Value; + case P_FLOAT: TpFloat FloatValue; + case P_DOUBLE: TpDouble DoubleValue; + }; + + + enum TpAttributeTagInfo { + + P_SIMPLE_TYPE, + P_STRUCTURED_TYPE, + P_XML_TYPE + }; + + + union TpAttributeValue switch(TpAttributeTagInfo) { + case P_SIMPLE_TYPE: TpSimpleAttributeValue SimpleValue; + case P_STRUCTURED_TYPE: TpStructuredAttributeValue StructuredValue; + case P_XML_TYPE: TpXMLString XMLValue; + }; + + + struct TpAttribute { + TpString AttributeName; + TpAttributeValue AttributeValue; + }; + + + typedef sequence TpAttributeList; + + + typedef sequence TpAttributeSet; + + + + interface IpInterface { + }; + + + interface IpService : IpInterface { + void setCallback ( + in IpInterface appInterface + ) + raises (TpCommonExceptions,P_INVALID_INTERFACE_TYPE); + + void setCallbackWithSessionID ( + in IpInterface appInterface, + in TpSessionID sessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_INTERFACE_TYPE); + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/pam_data.idl b/idl/parlay/pam_data.idl new file mode 100644 index 0000000000..7b862faf6f --- /dev/null +++ b/idl/parlay/pam_data.idl @@ -0,0 +1,550 @@ +//Source file: pam_data.idl +//Date: 13 October 2004 +//Presence and Availability Management Data Types for ES 203 915-14 V1.1.1, DES/TISPAN-01005-14-OSA, Parlay 5.0 + +#ifndef __PAM_DATA_DEFINED +#define __PAM_DATA_DEFINED + + +#include "osa.idl" + +module org { + + module csapi { + + module pam { + + + typedef TpInt64 TpPAMTimeInterval; + + + typedef TpURN TpPAMFQName; + + + typedef sequence TpPAMFQNameList; + + + typedef TpOctetSet TpPAMCredential; + + + typedef TpString TpPAMCapability; + + + typedef sequence TpPAMCapabilityList; + + + struct TpPAMAttributeDef { + TpString Name; + TpString Type; + TpBoolean IsStatic; + TpBoolean IsRevertOnExpiration; + TpAny DefaultValues; + }; + + + typedef sequence TpPAMAttributeDefList; + + + struct TpPAMAttribute { + TpString AttributeName; + TpAttributeValue AttributeValue; + TpPAMTimeInterval ExpiresIn; + }; + + + typedef sequence TpPAMAttributeList; + + const TpInt64 PAM_MAX_LONGINT = 0x7fffffff; + + exception P_PAM_UNKNOWN_TYPE { + TpString ExtraInformation; + }; + + + exception P_PAM_UNKNOWN_MEMBER { + TpString ExtraInformation; + }; + + + exception P_PAM_UNKNOWN_IDENTITY { + TpString ExtraInformation; + }; + + + exception P_PAM_UNKNOWN_GROUP { + TpString ExtraInformation; + }; + + + exception P_PAM_UNKNOWN_CAPABILITY { + TpString ExtraInformation; + }; + + + exception P_PAM_UNKNOWN_ATTRIBUTES { + TpString ExtraInformation; + }; + + + exception P_PAM_UNKNOWN_ATTRIBUTE { + TpString ExtraInformation; + }; + + + exception P_PAM_UNKNOWN_ASSIGNMENT { + TpString ExtraInformation; + }; + + + exception P_PAM_UNKNOWN_ALIAS { + TpString ExtraInformation; + }; + + + exception P_PAM_UNKNOWN_AGENT { + TpString ExtraInformation; + }; + + + exception P_PAM_UNASSIGNED_ALIAS { + TpString ExtraInformation; + }; + + + exception P_PAM_TYPE_EXISTS { + TpString ExtraInformation; + }; + + + exception P_PAM_TYPE_ASSOCIATED { + TpString ExtraInformation; + }; + + + exception P_PAM_NOT_REGISTERED { + TpString ExtraInformation; + }; + + + exception P_PAM_NOT_MEMBER { + TpString ExtraInformation; + }; + + + exception P_PAM_NO_CAPABILITY { + TpString ExtraInformation; + }; + + + exception P_PAM_MEMBER_EXISTS { + TpString ExtraInformation; + }; + + + exception P_PAM_IS_CYCLIC { + TpString ExtraInformation; + }; + + + exception P_PAM_IDENTITY_EXISTS { + TpString ExtraInformation; + }; + + + exception P_PAM_DISASSOCIATED_TYPE { + TpString ExtraInformation; + }; + + + exception P_PAM_ATTRIBUTE_EXISTS { + TpString ExtraInformation; + }; + + + exception P_PAM_ALIAS_NOT_UNIQUE { + TpString ExtraInformation; + }; + + + exception P_PAM_ALIAS_EXISTS { + TpString ExtraInformation; + }; + + + exception P_PAM_AGENT_EXISTS { + TpString ExtraInformation; + }; + + + struct TpPAMPresenceData { + TpString Name; + TpString subscriberStatus; + TpString networkStatus; + TpPAMCapability communicationMeans; + TpAddress contactAddress; + TpString subscriberProvidedLocation; + TpString networkProvidedLocation; + TpInt32 Priority; + TpString otherInfo; + }; + + + typedef sequence TpPAMPresenceDataList; + + + typedef TpString TpPAMPrivacyCode; + + + struct TpPAMAvailabilityProfile { + TpPAMPrivacyCode PrivacyCode; + TpPAMPresenceData AvailabilityData; + }; + + + typedef sequence TpPAMAvailabilityProfileList; + + + enum TpPAMContextName { + + PAM_CONTEXT_ANY, + PAM_CONTEXT_COMMUNICATION + }; + + + struct TpPAMCommunicationContext { + TpPAMCapability CommunicationCapability; + }; + + + union TpPAMContextData switch(TpPAMContextName) { + case PAM_CONTEXT_COMMUNICATION: TpPAMCommunicationContext CommunicationContext; + default: short Dummy; + }; + + + struct TpPAMContext { + TpPAMContextData ContextData; + TpAttributeList AskerData; + }; + + + typedef sequence TpPAMContextList; + + + enum TpPAMACLDefault { + + PAM_ACCESS_ALLOW, + PAM_ACCESS_DENY + }; + + + struct TpPAMAccessControlData { + TpPAMACLDefault DefaultPolicy; + TpPAMFQNameList AllowList; + TpPAMFQNameList DenyList; + }; + + + typedef TpString TpPAMPreferenceOp; + + + enum TpPAMPreferenceType { + + PAM_ACCESS_LIST, + PAM_EXTERNAL_CONTROL + }; + + + enum TpPAMEventName { + + PAM_CE_IDENTITY_PRESENCE_SET, + PAM_CE_AVAILABILITY_CHANGED, + PAM_CE_WATCHERS_CHANGED, + PAM_CE_IDENTITY_CREATED, + PAM_CE_IDENTITY_DELETED, + PAM_CE_GROUP_MEMBERSHIP_CHANGED, + PAM_CE_AGENT_CREATED, + PAM_CE_AGENT_DELETED, + PAM_CE_AGENT_ASSIGNED, + PAM_CE_AGENT_UNASSIGNED, + PAM_CE_CAPABILITY_CHANGED, + PAM_CE_AGENT_CAPABILITY_PRESENCE_SET, + PAM_CE_AGENT_PRESENCE_SET + }; + + + typedef sequence TpPAMEventNameList; + + + struct TpPAMICEventData { + TpStringList IdentityType; + }; + + + struct TpPAMICNotificationData { + TpPAMFQNameList Identities; + }; + + + struct TpPAMIDEventData { + TpPAMFQNameList IdentityName; + TpStringList IdentityType; + }; + + + struct TpPAMIDNotificationData { + TpPAMFQNameList Identities; + }; + + + struct TpPAMGMCEventData { + TpPAMFQNameList GroupName; + TpStringList GroupType; + }; + + + struct TpPAMGMCNotificationData { + TpPAMFQNameList Groups; + }; + + + struct TpPAMACEventData { + TpStringList AgentType; + }; + + + struct TpPAMACNotificationData { + TpPAMFQNameList Agents; + }; + + + struct TpPAMADEventData { + TpPAMFQNameList AgentName; + TpStringList AgentType; + }; + + + struct TpPAMADNotificationData { + TpPAMFQNameList Agents; + }; + + + struct TpPAMAAEventData { + TpPAMFQNameList IdentityName; + TpStringList IdentityType; + TpPAMFQNameList AgentName; + TpStringList AgentType; + }; + + + struct TpPAMAANotificationData { + TpPAMFQName Identity; + TpPAMFQName Agent; + }; + + + struct TpPAMAUEventData { + TpPAMFQNameList IdentityName; + TpStringList IdentityType; + TpPAMFQNameList AgentName; + TpStringList AgentType; + }; + + + struct TpPAMAUNotificationData { + TpPAMFQName Identity; + TpPAMFQName Agent; + }; + + + struct TpPAMCCEventData { + TpPAMFQNameList IdentityName; + TpStringList IdentityType; + TpPAMCapabilityList Capabilities; + }; + + + struct TpPAMCCNotificationData { + TpPAMFQName Identity; + TpPAMCapabilityList Capabilities; + }; + + + struct TpPAMACPSEventData { + TpPAMFQNameList AgentName; + TpStringList AgentType; + TpPAMCapabilityList Capabilities; + TpStringList AttributeNames; + TpPAMTimeInterval ReportingPeriod; + }; + + + struct TpPAMACPSNotificationData { + TpPAMFQName Agent; + TpPAMCapability Capability; + TpStringList AttributeNames; + }; + + + struct TpPAMAPSEventData { + TpPAMFQNameList AgentName; + TpStringList AgentType; + TpStringList AttributeNames; + TpPAMTimeInterval ReportingPeriod; + }; + + + struct TpPAMAPSNotificationData { + TpPAMFQName Agent; + TpStringList AttributeNames; + }; + + + struct TpPAMIPSEventData { + TpPAMFQNameList IdentityName; + TpStringList IdentityType; + TpStringList AttributeNames; + TpPAMTimeInterval ReportingPeriod; + }; + + + struct TpPAMIPSNotificationData { + TpPAMFQName Identity; + TpPAMPresenceDataList Attributes; + }; + + + struct TpPAMAVCEventData { + TpPAMFQNameList IdentityName; + TpStringList IdentityType; + TpPAMContextList PAMContext; + TpStringList AttributeNames; + TpPAMTimeInterval ReportingPeriod; + }; + + + struct TpPAMAVCNotificationData { + TpPAMFQName Identity; + TpPAMAvailabilityProfileList Availability; + }; + + + struct TpPAMWCEventData { + TpPAMEventNameList Events; + TpPAMFQNameList IdentityName; + TpStringList IdentityType; + TpPAMTimeInterval ReportingPeriod; + }; + + + union TpPAMEventInfo switch(TpPAMEventName) { + case PAM_CE_IDENTITY_PRESENCE_SET: TpPAMIPSEventData IdentityPresenceSet; + case PAM_CE_AVAILABILITY_CHANGED: TpPAMAVCEventData AvailabilityChanged; + case PAM_CE_WATCHERS_CHANGED: TpPAMWCEventData WatchersChanged; + case PAM_CE_IDENTITY_CREATED: TpPAMICEventData IdentityCreated; + case PAM_CE_IDENTITY_DELETED: TpPAMIDEventData IdentityDeleted; + case PAM_CE_GROUP_MEMBERSHIP_CHANGED: TpPAMGMCEventData GroupMembershipChanged; + case PAM_CE_AGENT_CREATED: TpPAMACEventData AgentCreated; + case PAM_CE_AGENT_DELETED: TpPAMADEventData AgentDeleted; + case PAM_CE_AGENT_ASSIGNED: TpPAMAAEventData AgentAssigned; + case PAM_CE_AGENT_UNASSIGNED: TpPAMAUEventData AgentUnassigned; + case PAM_CE_CAPABILITY_CHANGED: TpPAMCCEventData CapabilityChanged; + case PAM_CE_AGENT_CAPABILITY_PRESENCE_SET: TpPAMACPSEventData AgentCapabilityPresenceSet; + case PAM_CE_AGENT_PRESENCE_SET: TpPAMAPSEventData AgentPresenceSet; + }; + + + enum TpPAMwatcherChangeType { + + PAM_WATCHERS_PERIODIC, + PAM_WATCHERS_ADDED, + PAM_WATCHERS_DELETED + }; + + + struct TpPAMWCNotificationData { + TpPAMEventName Event; + TpPAMwatcherChangeType ChangeType; + TpPAMFQName Identity; + TpPAMFQNameList Watchers; + }; + + + union TpPAMNotificationInfo switch(TpPAMEventName) { + case PAM_CE_IDENTITY_PRESENCE_SET: TpPAMIPSNotificationData IdentityPresenceSetNotify; + case PAM_CE_AVAILABILITY_CHANGED: TpPAMAVCNotificationData AvailabilityChangedNotify; + case PAM_CE_WATCHERS_CHANGED: TpPAMWCNotificationData WatchersChangedNotify; + case PAM_CE_IDENTITY_CREATED: TpPAMICNotificationData IdentityCreatedNotify; + case PAM_CE_IDENTITY_DELETED: TpPAMIDNotificationData IdentityDeletedNotify; + case PAM_CE_GROUP_MEMBERSHIP_CHANGED: TpPAMGMCNotificationData GroupMembershipChangedNotify; + case PAM_CE_AGENT_CREATED: TpPAMACNotificationData AgentCreatedNotify; + case PAM_CE_AGENT_DELETED: TpPAMADNotificationData AgentDeletedNotify; + case PAM_CE_AGENT_ASSIGNED: TpPAMAANotificationData AgentAssignedNotify; + case PAM_CE_AGENT_UNASSIGNED: TpPAMAUNotificationData AgentUnassignedNotify; + case PAM_CE_CAPABILITY_CHANGED: TpPAMCCNotificationData CapabilityChangedNotify; + case PAM_CE_AGENT_CAPABILITY_PRESENCE_SET: TpPAMACPSNotificationData AgentCapabilityPresenceSetNotify; + case PAM_CE_AGENT_PRESENCE_SET: TpPAMAPSNotificationData AgentPresenceSetNotify; + }; + + + typedef TpString TpPAMProvisioningInterfaceName; + + + typedef TpString TpPAMPresenceAvailabilityInterfaceName; + + + typedef TpString TpPAMEventInterfaceName; + + + typedef sequence TpPAMEventInfoList; + + + typedef sequence TpPAMNotificationInfoList; + + + enum TpPAMErrorCause { + + P_PAM_CAUSE_UNDEFINED, + P_PAM_CAUSE_INVALID_ADDRESS, + P_PAM_CAUSE_SYSTEM_FAILURE, + P_PAM_CAUSE_INFO_UNAVAILABLE, + P_PAM_CAUSE_EVENT_REGISTRATION_CANCELLED + }; + + + struct TpPAMErrorInfo { + TpPAMErrorCause Cause; + TpPAMNotificationInfo ErrorData; + }; + + + exception P_PAM_UNAVAILABLE_INTERFACE { + TpString ExtraInformation; + }; + + + typedef TpInt32 TpPAMClientID; + + + typedef TpAssignmentID TpPAMEventID; + + + exception P_PAM_INVALID_CREDENTIAL { + TpString ExtraInformation; + }; + + + const TpPAMCapability P_PAM_VOICE = "P_PAM_VOICE"; + + const TpPAMCapability P_PAM_SMS = "P_PAM_SMS"; + + const TpPAMCapability P_PAM_IM = "P_PAM_IM"; + + const TpPAMCapability P_PAM_MMS = "P_PAM_MMS"; + }; + + }; + +}; + +#endif diff --git a/idl/parlay/pam_interfaces.idl b/idl/parlay/pam_interfaces.idl new file mode 100644 index 0000000000..bed8b5f9df --- /dev/null +++ b/idl/parlay/pam_interfaces.idl @@ -0,0 +1,842 @@ +//Source file: pam_interfaces.idl +//Date: 13 October 2004 +//Presence and Availability Management Interfaces for ES 203 915-14 V1.1.1, DES/TISPAN-01005-14-OSA, Parlay 5.0 + +#ifndef __PAM_INTERFACES_DEFINED +#define __PAM_INTERFACES_DEFINED + + +#include "osa.idl" +#include "pam_data.idl" + +module org { + + module csapi { + + module pam { + + module access { + interface IpAppPAMPreferenceCheck ; + }; + + + union TpPAMPreferenceData switch(TpPAMPreferenceType) { + case PAM_EXTERNAL_CONTROL: access::IpAppPAMPreferenceCheck ExternalControlInterface; + default: short Dummy; + }; + + + module provisioning { + + + interface IpPAMIdentityManagement : IpInterface { + void createIdentity ( + in TpPAMFQName identity, + in TpStringList identityTypes, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_IDENTITY_EXISTS,P_PAM_UNKNOWN_TYPE,P_PAM_INVALID_CREDENTIAL); + + void deleteIdentity ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + TpBoolean isIdentity ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_INVALID_CREDENTIAL); + + void createGroupIdentity ( + in TpPAMFQName identity, + in TpStringList identityTypes, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_IDENTITY_EXISTS,P_PAM_UNKNOWN_TYPE,P_PAM_INVALID_CREDENTIAL); + + void deleteGroupIdentity ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + void addToGroup ( + in TpPAMFQName group, + in TpPAMFQName member, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_MEMBER_EXISTS,P_PAM_UNKNOWN_GROUP,P_PAM_UNKNOWN_MEMBER,P_PAM_IS_CYCLIC,P_PAM_INVALID_CREDENTIAL); + + void removeFromGroup ( + in TpPAMFQName group, + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_NOT_MEMBER,P_PAM_UNKNOWN_GROUP,P_PAM_UNKNOWN_MEMBER,P_PAM_INVALID_CREDENTIAL); + + TpPAMFQNameList listMembers ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_GROUP,P_PAM_INVALID_CREDENTIAL); + + TpBoolean isGroupIdentity ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_INVALID_CREDENTIAL); + + TpPAMFQNameList listGroupMembership ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + void addAlias ( + in TpPAMFQName identity, + in TpPAMFQName alias, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_ALIAS_EXISTS,P_PAM_ALIAS_NOT_UNIQUE,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + void removeAliases ( + in TpPAMFQName identity, + in TpPAMFQName alias, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_UNASSIGNED_ALIAS,P_PAM_INVALID_CREDENTIAL); + + TpPAMFQNameList listAliases ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + TpPAMFQName lookupByAlias ( + in TpPAMFQName alias, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_ALIAS,P_PAM_INVALID_CREDENTIAL); + + void associateTypes ( + in TpPAMFQName identity, + in TpStringList identityTypes, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_UNKNOWN_TYPE,P_PAM_TYPE_ASSOCIATED,P_PAM_INVALID_CREDENTIAL); + + void disassociateTypes ( + in TpPAMFQName identity, + in TpStringList identityTypes, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_DISASSOCIATED_TYPE,P_PAM_INVALID_CREDENTIAL); + + TpPAMFQNameList listTypesOfIdentity ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + TpBoolean hasType ( + in TpPAMFQName identity, + in TpString typeName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + TpPAMAttributeList getIdentityAttributes ( + in TpPAMFQName identity, + in TpString identityType, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + void setIdentityAttributes ( + in TpPAMFQName identity, + in TpString identityType, + in TpPAMAttributeList attributes, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_ATTRIBUTES,P_PAM_INVALID_CREDENTIAL); + + }; + + + interface IpPAMAgentManagement : IpInterface { + void createAgent ( + in TpPAMFQName agentName, + in TpStringList agentTypes, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_AGENT_EXISTS,P_PAM_UNKNOWN_TYPE,P_PAM_INVALID_CREDENTIAL); + + void deleteAgent ( + in TpPAMFQName agentName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_INVALID_CREDENTIAL); + + TpBoolean isAgent ( + in TpPAMFQName agentName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_INVALID_CREDENTIAL); + + void enableCapabilities ( + in TpPAMFQName agentName, + in TpPAMCapabilityList capabilities, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_INVALID_CREDENTIAL); + + void disableCapabilities ( + in TpPAMFQName agentName, + in TpPAMCapabilityList capabilities, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_NO_CAPABILITY,P_PAM_INVALID_CREDENTIAL); + + TpPAMCapabilityList listEnabledCapabilities ( + in TpPAMFQName agentName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_INVALID_CREDENTIAL); + + TpPAMCapabilityList listAllCapabilities ( + in TpPAMFQName agentName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_INVALID_CREDENTIAL); + + TpBoolean isCapableOf ( + in TpPAMFQName agentName, + in TpPAMCapability capability, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_INVALID_CREDENTIAL); + + void associateTypes ( + in TpPAMFQName agentName, + in TpStringList agentTypes, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_UNKNOWN_TYPE,P_PAM_TYPE_ASSOCIATED,P_PAM_INVALID_CREDENTIAL); + + void disassociateTypes ( + in TpPAMFQName agentName, + in TpStringList agentTypes, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_DISASSOCIATED_TYPE,P_PAM_INVALID_CREDENTIAL); + + TpStringList listTypesOfAgent ( + in TpPAMFQName agentName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_INVALID_CREDENTIAL); + + TpBoolean hasType ( + in TpPAMFQName agentName, + in TpString typeName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_INVALID_CREDENTIAL); + + TpPAMAttributeList getAgentAttributes ( + in TpPAMFQName agentName, + in TpString agentType, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + void setAgentAttributes ( + in TpPAMFQName agentName, + in TpString agentType, + in TpPAMAttributeList attributes, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_ATTRIBUTES,P_PAM_INVALID_CREDENTIAL); + + }; + + + interface IpPAMAgentAssignment : IpInterface { + void assignAgent ( + in TpPAMFQName identity, + in TpPAMFQName agentName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_UNKNOWN_AGENT,P_PAM_INVALID_CREDENTIAL); + + void unassignAgent ( + in TpPAMFQName identity, + in TpPAMFQName agentName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_UNKNOWN_AGENT,P_PAM_UNKNOWN_ASSIGNMENT,P_PAM_INVALID_CREDENTIAL); + + TpPAMFQNameList listAssignedAgents ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + TpPAMFQNameList listAssociatedIdentitiesOfAgent ( + in TpPAMFQName agentName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_INVALID_CREDENTIAL); + + TpPAMFQNameList listAssignedAgentsByCapability ( + in TpPAMFQName identity, + in TpPAMCapability capability, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + TpPAMCapabilityList listCapabilitiesOfIdentity ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + TpBoolean isIdentityCapableOf ( + in TpPAMFQName identity, + in TpPAMCapability capability, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + }; + + + interface IpPAMIdentityTypeManagement : IpInterface { + void createIdentityAttribute ( + in TpPAMAttributeDef pAttribute, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_ATTRIBUTE_EXISTS,P_PAM_INVALID_CREDENTIAL); + + void deleteIdentityAttribute ( + in TpString attributeName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + TpPAMAttributeDef getIdentityAttributeDefinition ( + in TpString attributeName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + TpStringList listAllIdentityAttributes ( + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_INVALID_CREDENTIAL); + + void createIdentityType ( + in TpString typeName, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_TYPE_EXISTS,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + void deleteIdentityType ( + in TpString typeName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_INVALID_CREDENTIAL); + + TpStringList listIdentityTypes ( + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_INVALID_CREDENTIAL); + + void addIdentityTypeAttributes ( + in TpString typeName, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_ATTRIBUTE_EXISTS,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + void removeIdentityTypeAttributes ( + in TpString typeName, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + TpStringList listIdentityTypeAttributes ( + in TpString typeName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_INVALID_CREDENTIAL); + + }; + + + interface IpPAMAgentTypeManagement : IpInterface { + void createAgentAttribute ( + in TpPAMAttributeDef pAttribute, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_ATTRIBUTE_EXISTS,P_PAM_INVALID_CREDENTIAL); + + void deleteAgentAttribute ( + in TpString attributeName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + TpPAMAttributeDef getAgentAttributeDefinition ( + in TpString attributeName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + TpStringList listAllAgentAttributes ( + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_INVALID_CREDENTIAL); + + void createAgentType ( + in TpString typeName, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_TYPE_EXISTS,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + void deleteAgentType ( + in TpString typeName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_INVALID_CREDENTIAL); + + TpStringList listAgentTypes ( + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_INVALID_CREDENTIAL); + + void addAgentTypeAttributes ( + in TpString typeName, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_ATTRIBUTE_EXISTS,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + void removeAgentTypeAttributes ( + in TpString typeName, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + TpStringList listAgentTypeAttributes ( + in TpString typeName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_INVALID_CREDENTIAL); + + }; + + + interface IpPAMCapabilityManagement : IpInterface { + void createCapabilityAttribute ( + in TpPAMAttributeDef pAttribute, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_ATTRIBUTE_EXISTS,P_PAM_INVALID_CREDENTIAL); + + void deleteCapabilityAttribute ( + in TpString attributeName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + TpPAMAttributeDef getCapabilityAttributeDefinition ( + in TpString attributeName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + TpStringList listAllCapabilityAttributes ( + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_INVALID_CREDENTIAL); + + void createCapability ( + in TpPAMCapability capabilityName, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_TYPE_EXISTS,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + void deleteCapability ( + in TpPAMCapability capabilityName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_INVALID_CREDENTIAL); + + TpPAMCapabilityList listCapabilities ( + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_INVALID_CREDENTIAL); + + void addCapabilityAttributes ( + in TpPAMCapability capabilityName, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_ATTRIBUTE_EXISTS,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + void removeCapabilityAttributes ( + in TpPAMCapability capabilityName, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + TpStringList listCapabilityAttributes ( + in TpPAMCapability capabilityName, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_INVALID_CREDENTIAL); + + void assignCapabilitiesToType ( + in TpString agentType, + in TpPAMCapabilityList capabilities, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_CAPABILITY,P_PAM_INVALID_CREDENTIAL); + + void unassignCapabilitiesFromType ( + in TpString agentType, + in TpPAMCapabilityList capabilities, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_CAPABILITY,P_PAM_INVALID_CREDENTIAL); + + TpPAMCapabilityList listCapabilitiesOfType ( + in TpString agentType, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_TYPE,P_PAM_INVALID_CREDENTIAL); + + }; + + + interface IpPAMProvisioningManager : IpService { + TpPAMCredential getAuthToken ( + in TpAttributeList askerData + ) + raises (TpCommonExceptions,P_PAM_INVALID_CREDENTIAL); + + IpInterface obtainInterface ( + in TpPAMProvisioningInterfaceName interfaceName + ) + raises (TpCommonExceptions,P_PAM_UNAVAILABLE_INTERFACE); + + TpPAMAccessControlData getAccessControl ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + void setAccessControl ( + in TpPAMFQName identity, + in TpPAMPreferenceOp operation, + in TpPAMAccessControlData newAccessControl, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + }; + + }; + + + module access { + + + interface IpPAMIdentityPresence : IpInterface { + void setIdentityPresence ( + in TpPAMFQName identity, + in TpString identityType, + in TpPAMAttributeList attributes, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + void setIdentityPresenceExpiration ( + in TpPAMFQName identity, + in TpString identityType, + in TpStringList attributeNames, + in TpPAMTimeInterval expiresIn, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + TpPAMAttributeList getIdentityPresence ( + in TpPAMFQName identity, + in TpString identityType, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + }; + + + interface IpPAMAgentPresence : IpInterface { + void setAgentPresence ( + in TpPAMFQName agent, + in TpString agentType, + in TpPAMAttributeList attributes, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + void setCapabilityPresence ( + in TpPAMFQName agent, + in TpPAMCapability capability, + in TpPAMAttributeList attributes, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_UNKNOWN_CAPABILITY,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + void setAgentPresenceExpiration ( + in TpPAMFQName agent, + in TpString agentType, + in TpStringList attributeNames, + in TpPAMTimeInterval expiresIn, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + void setCapabilityPresenceExpiration ( + in TpPAMFQName agent, + in TpPAMCapability capability, + in TpStringList attributeNames, + in TpPAMTimeInterval expiresIn, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_NO_CAPABILITY,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + TpPAMAttributeList getAgentPresence ( + in TpPAMFQName agent, + in TpString agentType, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_UNKNOWN_TYPE,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + TpPAMAttributeList getCapabilityPresence ( + in TpPAMFQName agent, + in TpPAMCapability capability, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_AGENT,P_PAM_UNKNOWN_CAPABILITY,P_PAM_UNKNOWN_ATTRIBUTE,P_PAM_INVALID_CREDENTIAL); + + }; + + + interface IpAppPAMPreferenceCheck : IpInterface { + TpPAMAvailabilityProfileList computeAvailability ( + in TpPAMFQName identity, + in TpPAMContext pamContext, + in TpStringList attributeNames, + in TpPAMCredential authToken + ); + + }; + + + interface IpPAMAvailability : IpInterface { + TpPAMAvailabilityProfileList getAvailability ( + in TpPAMFQName identity, + in TpPAMContext pamContext, + in TpStringList attributeNames, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + TpPAMPreferenceData getPreference ( + in TpPAMFQName identity, + in TpPAMContext pamContext, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + void setPreference ( + in TpPAMFQName identity, + in TpPAMContext pamContext, + in TpPAMPreferenceOp operation, + in TpPAMPreferenceData newPreference, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + }; + + + interface IpPAMPresenceAvailabilityManager : IpService { + TpPAMCredential getAuthToken ( + in TpAttributeList askerData + ) + raises (TpCommonExceptions,P_PAM_INVALID_CREDENTIAL); + + IpInterface obtainInterface ( + in TpPAMPresenceAvailabilityInterfaceName interfaceName + ) + raises (TpCommonExceptions,P_PAM_UNAVAILABLE_INTERFACE); + + TpPAMAccessControlData getAccessControl ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + void setAccessControl ( + in TpPAMFQName identity, + in TpPAMPreferenceOp operation, + in TpPAMAccessControlData newAccessControl, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + void activateService ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + void deactivateService ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + TpBoolean isActiveIdentity ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + }; + + }; + + + module event { + + + interface IpAppPAMEventHandler : IpInterface { + void eventNotify ( + in TpPAMEventID eventID, + in TpPAMNotificationInfoList eventInfo + ); + + void eventNotifyErr ( + in TpPAMEventID eventID, + in TpPAMErrorInfo errorInfo + ); + + }; + + + interface IpPAMEventHandler : IpInterface { + TpBoolean isRegistered ( + in TpPAMClientID clientID, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_INVALID_CREDENTIAL); + + TpPAMClientID registerAppInterface ( + in IpAppPAMEventHandler appInterface, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_INVALID_CREDENTIAL); + + TpPAMEventID registerForEvent ( + in TpPAMClientID clientID, + in TpPAMEventInfoList eventList, + in TpDuration validFor, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_NOT_REGISTERED,P_PAM_INVALID_CREDENTIAL); + + void deregisterAppInterface ( + in TpPAMClientID clientID, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_NOT_REGISTERED,P_PAM_INVALID_CREDENTIAL); + + void deregisterFromEvent ( + in TpPAMEventID eventID, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_NOT_REGISTERED,P_PAM_INVALID_CREDENTIAL); + + }; + + + interface IpPAMEventManager : IpService { + TpPAMCredential getAuthToken ( + in TpAttributeList askerData + ) + raises (TpCommonExceptions,P_PAM_INVALID_CREDENTIAL); + + IpInterface obtainInterface ( + in TpPAMEventInterfaceName interfaceName + ) + raises (TpCommonExceptions,P_PAM_UNAVAILABLE_INTERFACE); + + TpPAMAccessControlData getAccessControl ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + void setAccessControl ( + in TpPAMFQName identity, + in TpPAMPreferenceOp operation, + in TpPAMAccessControlData newAccessControl, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + void activateService ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + void deactivateService ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + TpBoolean isActiveIdentity ( + in TpPAMFQName identity, + in TpPAMCredential authToken + ) + raises (TpCommonExceptions,P_PAM_UNKNOWN_IDENTITY,P_PAM_INVALID_CREDENTIAL); + + }; + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/policy_data.idl b/idl/parlay/policy_data.idl new file mode 100644 index 0000000000..b1e5056ea0 --- /dev/null +++ b/idl/parlay/policy_data.idl @@ -0,0 +1,146 @@ +//Source file: policy_data.idl +//Date: 13 October 2004 +//Policy Management Data Types for ES 203 915-13 V1.1.1, DES/TISPAN-01005-13-OSA, Parlay 5.0 + +#ifndef __POLICY_DATA_DEFINED +#define __POLICY_DATA_DEFINED + + +#include "osa.idl" + +module org { + + module csapi { + + module policy { + + + enum TpPolicyConditionListType { + + P_PM_DNF, + P_PM_CNF + }; + + + enum TpPolicyConditionType { + + P_PM_TIME_PERIOD_CONDITION, + P_PM_EVENT_CONDITION, + P_PM_EXPRESSION_CONDITION + }; + + + enum TpPolicyActionType { + + P_PM_EVENT_ACTION, + P_PM_EXPRESSION_ACTION + }; + + + struct TpPolicyEvent { + TpInt32 EventID; + TpDateAndTime TimeGenerated; + TpAttributeSet Attributes; + TpString EventDefinitionName; + TpString EventDomainName; + }; + + + typedef TpString TpPolicyKeyword; + + + typedef sequence TpPolicyKeywordSet; + + + exception P_ACCESS_VIOLATION { + TpString ExtraInformation; + }; + + + exception P_SYNTAX_ERROR { + TpString ExtraInformation; + }; + + + exception P_NAME_SPACE_ERROR { + TpString ExtraInformation; + }; + + + exception P_NO_TRANSACTION_IN_PROCESS { + TpString ExtraInformation; + }; + + + exception P_TRANSACTION_IN_PROCESS { + TpString ExtraInformation; + }; + + + typedef TpInt32 TpPolicyError; + + + const TpPolicyError P_PM_ERROR_UNDEFINED = 0; + + const TpPolicyError P_PM_ERROR_INSUFFICIENT_INPUTS = 1; + + const TpPolicyError P_PM_ERROR_INVALID_INPUT_NAME = 2; + + const TpPolicyError P_PM_ERROR_INVALID_INPUT_VALUE = 3; + + const TpPolicyError P_PM_ERROR_EVALUATION_ERROR = 5; + + const TpPolicyError P_PM_ERROR_DB_ERROR = 4; + + enum TpPolicyTypeInfo { + + P_PM_SIMPLE_TYPE, + P_PM_TYPE_RECORD, + P_PM_TYPE_LIST, + P_PM_STRUCTURED_TYPE, + P_PM_XML_TYPE + }; + + + struct TpPolicyNameValue { + TpString Name; + TpAny Value; + }; + + + typedef sequence TpPolicyNameValueList; + + + union TpPolicyType switch(TpPolicyTypeInfo) { + case P_PM_SIMPLE_TYPE: TpSimpleAttributeTypeInfo SimpleType; + case P_PM_TYPE_RECORD: + struct TpPolicyRecordType { + sequence Names; + sequence Types; + } RecordType; + case P_PM_TYPE_LIST: + struct TpPolicyListType { + sequence ElementType; + } ListType; + case P_PM_STRUCTURED_TYPE: TpStructuredAttributeType StructuredType; + case P_PM_XML_TYPE: TpXMLString XMLString; + }; + + + struct TpPolicyVar { + TpString VarName; + TpPolicyType VarType; + TpAny VarValue; + }; + + + typedef sequence TpPolicyVarSet; + + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/policy_interfaces.idl b/idl/parlay/policy_interfaces.idl new file mode 100644 index 0000000000..71a1662dfc --- /dev/null +++ b/idl/parlay/policy_interfaces.idl @@ -0,0 +1,725 @@ +//Source file: policy_interfaces.idl +//Date: 13 October 2004 +//Policy Management Interfaces for ES 203 915-13 V1.1.1, DES/TISPAN-01005-13-OSA, Parlay 5.0 + +#ifndef __POLICY_INTERFACES_DEFINED +#define __POLICY_INTERFACES_DEFINED + + +#include "osa.idl" +#include "policy_data.idl" + +module org { + + module csapi { + + module policy { + + module provisioning { + + interface IpPolicyCondition ; + interface IpPolicyAction ; + + }; + + + struct TpPolicyConditionListElement { + provisioning::IpPolicyCondition Condition; + TpInt32 GroupNumber; + TpBoolean Negated; + }; + + + typedef sequence TpPolicyConditionList; + + + struct TpPolicyActionListElement { + provisioning::IpPolicyAction Action; + TpInt32 SequenceNumber; + }; + + + typedef sequence TpPolicyActionList; + + module evaluation { + + + interface IpAppPolicyDomain : IpInterface { + void reportNotification ( + in TpAssignmentID assignmentID , + in TpPolicyEvent event + ); + + void evalPolicyRes ( + in TpAssignmentID assignmentID, + in TpPolicyNameValueList outputVariables + ); + + void evalPolicyErr ( + in TpAssignmentID assignmentID, + in TpPolicyError error + ); + + }; + + + interface IpPolicyEvalManager : IpService { + TpPolicyNameValueList evalPolicy ( + in TpString domainName, + in TpString signatureName, + in TpPolicyNameValueList inputVariables + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + TpAssignmentID evalPolicyReq ( + in TpString domainName, + in TpString signatureName, + in TpPolicyNameValueList inputVariables, + in IpAppPolicyDomain appPolicyDomain + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void abortEvalPolicyReq ( + in TpString domainName, + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + void generateEvent ( + in TpString domainName, + in TpString eventDefinitionName, + in TpAttributeSet attributes + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + TpAssignmentID createNotification ( + in TpString domainName, + in IpAppPolicyDomain appPolicyDomain, + in TpStringSet events + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void destroyNotification ( + in TpAssignmentID assignmentID, + in TpStringSet events + ) + raises (TpCommonExceptions,P_SYNTAX_ERROR); + + }; + + }; + + module provisioning { + interface IpPolicyRepository ; + interface IpPolicyManager ; + interface IpPolicyEventDefinition ; + interface IpPolicyCondition ; + interface IpPolicyAction ; + interface IpPolicyTimePeriodCondition ; + interface IpPolicyGroup ; + interface IpPolicyDomain ; + interface IpPolicyEventAction ; + + + + interface IpPolicy : IpInterface { + + TpAttribute getAttribute ( + in TpString attributeName + ) + raises (TpCommonExceptions,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void setAttribute ( + in TpAttribute targetAttribute + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_NO_TRANSACTION_IN_PROCESS); + + TpAttributeSet getAttributes ( + in TpStringList attributeNames + ) + raises (TpCommonExceptions); + + void setAttributes ( + in TpAttributeSet targetAttributes + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_NO_TRANSACTION_IN_PROCESS); + + }; + + + interface IpPolicyIterator : IpPolicy { + TpStringSet getList ( + in TpInt32 startIndex, + in TpInt32 numberRequested + ) + raises (TpCommonExceptions); + + }; + + + interface IpPolicyRepository : IpPolicy { + + IpPolicyRepository getParentRepository () + raises (TpCommonExceptions); + + IpPolicyRepository createRepository ( + in TpString repositoryName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicyRepository getRepository ( + in TpString repositoryName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeRepository ( + in TpString repositoryName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getRepositoryCount () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyIterator getRepositoryIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyCondition createCondition ( + in TpString conditionName, + in TpPolicyConditionType conditionType, + in TpAttributeSet conditionAttributes + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicyCondition getCondition ( + in TpString conditionName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeCondition ( + in TpString conditionName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getConditionCount () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyIterator getConditionIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyAction createAction ( + in TpString actionName, + in TpPolicyActionType actionType, + in TpAttributeSet actionAttributes + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicyAction getAction ( + in TpString actionName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeAction ( + in TpString actionName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getActionCount () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyIterator getActionIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + }; + + + interface IpPolicyRule : IpPolicy { + + IpPolicyGroup getParentGroup () + raises (TpCommonExceptions); + + IpPolicyDomain getParentDomain () + raises (TpCommonExceptions); + + IpPolicyCondition createCondition ( + in TpString conditionName, + in TpPolicyConditionType conditionType, + in TpAttributeSet conditionAttributes + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicyCondition getCondition ( + in TpString conditionName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeCondition ( + in TpString conditionName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getConditionCount () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyIterator getConditionIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyAction createAction ( + in TpString actionName, + in TpPolicyActionType actionType, + in TpAttributeSet actionAttributes + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicyAction getAction ( + in TpString actionName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeAction ( + in TpString actionName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getActionCount () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyIterator getActionIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + void setValidityPeriodConditionByName ( + in TpString conditionName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + void setValidityPeriodCondition ( + in IpPolicyTimePeriodCondition conditionReference + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicyTimePeriodCondition getValidityPeriodCondition () + raises (TpCommonExceptions); + + void unsetValidityPeriodCondition () + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_NO_TRANSACTION_IN_PROCESS); + + void setConditionList ( + in TpPolicyConditionList conditionList + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpPolicyConditionList getConditionList () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + void setActionList ( + in TpPolicyActionList actionList + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpPolicyActionList getActionList () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + }; + + + interface IpPolicyManager : IpService { + + IpPolicyDomain createDomain ( + in TpString domainName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicyDomain getDomain ( + in TpString domainName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeDomain ( + in TpString domainName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getDomainCount () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyIterator getDomainIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + TpStringSet findMatchingDomains ( + in TpAttributeSet matchingAttributes + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyRepository createRepository ( + in TpString repositoryName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicyRepository getRepository ( + in TpString repositoryName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeRepository ( + in TpString repositoryName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getRepositoryCount () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyIterator getRepositoryIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + void startTransaction () + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_TRANSACTION_IN_PROCESS); + + TpBoolean commitTransaction () + raises (TpCommonExceptions,P_NO_TRANSACTION_IN_PROCESS); + + void abortTransaction () + raises (TpCommonExceptions,P_NO_TRANSACTION_IN_PROCESS); + + }; + + + interface IpPolicyGroup : IpPolicy { + + IpPolicyDomain getParentDomain () + raises (TpCommonExceptions); + + IpPolicyGroup getParentGroup () + raises (TpCommonExceptions); + + IpPolicyGroup createGroup ( + in TpString groupName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicyGroup getGroup ( + in TpString groupName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeGroup ( + in TpString groupName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getGroupCount () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyIterator getGroupIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyRule createRule ( + in TpString ruleName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicyRule getRule ( + in TpString ruleName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeRule ( + in TpString ruleName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getRuleCount () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyIterator getRuleIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + }; + + + interface IpPolicyEventDefinition : IpPolicy { + + void setRequiredAttributes ( + in TpAttributeSet requiredAttributes + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_NO_TRANSACTION_IN_PROCESS); + + void setOptionalAttributes ( + in TpAttributeSet optionalAttributes + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_NO_TRANSACTION_IN_PROCESS); + + TpAttributeSet getRequiredAttributes () + raises (TpCommonExceptions); + + TpAttributeSet getOptionalAttributes () + raises (TpCommonExceptions); + + IpPolicyDomain getParentDomain () + raises (TpCommonExceptions); + + }; + + + interface IpPolicyCondition : IpPolicy { + + IpPolicyRepository getParentRepository () + raises (TpCommonExceptions); + + IpPolicyRule getParentRule () + raises (TpCommonExceptions); + + }; + + + interface IpPolicyTimePeriodCondition : IpPolicyCondition { + }; + + + interface IpPolicyExpressionCondition : IpPolicyCondition { + }; + + + interface IpPolicyEventCondition : IpPolicyCondition { + }; + + + interface IpPolicyAction : IpPolicy { + + IpPolicyRepository getParentRepository () + raises (TpCommonExceptions); + + IpPolicyRule getParentRule () + raises (TpCommonExceptions); + + }; + + + interface IpPolicyExpressionAction : IpPolicyAction { + }; + + + interface IpPolicyEventAction : IpPolicyAction { + }; + + + interface IpPolicySignature : IpPolicy { + + void setInputVariables ( + in TpStringSet inputVariables + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + void setOutputVariables ( + in TpStringSet outputVariables + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpStringSet getInputVariables () + raises (TpCommonExceptions); + + TpStringSet getOutputVariables () + raises (TpCommonExceptions); + + void setGroupNames ( + in TpStringSet groupNames + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + void setPolicyRoles ( + in TpStringSet roleNames + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpStringSet getGroupNames () + raises (TpCommonExceptions); + + TpStringSet getPolicyRoles () + raises (TpCommonExceptions); + + IpPolicyDomain getParentDomain () + raises (TpCommonExceptions); + + }; + + + interface IpPolicyDomain : IpPolicy { + + IpPolicyDomain getParentDomain () + raises (TpCommonExceptions); + + IpPolicyDomain createDomain ( + in TpString domainName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicyDomain getDomain ( + in TpString domainName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeDomain ( + in TpString domainName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getDomainCount () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyIterator getDomainIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyGroup createGroup ( + in TpString groupName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicyGroup getGroup ( + in TpString groupName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeGroup ( + in TpString groupName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getGroupCount () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyIterator getGroupIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyRule createRule ( + in TpString ruleName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicyRule getRule ( + in TpString ruleName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeRule ( + in TpString ruleName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getRuleCount () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyIterator getRuleIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyEventDefinition createEventDefinition ( + in TpString eventDefinitionName, + in TpStringSet requiredAttributes, + in TpStringSet optionalAttributes + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicyEventDefinition getEventDefinition ( + in TpString eventDefinitionName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeEventDefinition ( + in TpString eventDefinitionName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getEventDefinitionCount () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyIterator getEventDefinitionIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + void createVariableSet ( + in TpString variableSetName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpPolicyVarSet getVariableSet ( + in TpString variableSetName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeVariableSet ( + in TpString variableSetName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getVariableSetCount () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + IpPolicyIterator getVariableSetIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + void createVariable ( + in TpString variableSetName, + in TpString variableName, + in TpPolicyType variableType + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + void setVariableValue ( + in TpString variableSetName, + in TpString variableName, + in TpAny variableValue + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpPolicyType getVariableType ( + in TpString variableSetName, + in TpString variableName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + TpAny getVariableValue ( + in TpString variableSetName, + in TpString variableName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + TpPolicyVar getVariable ( + in TpString variableSetName, + in TpString variableName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeVariable ( + in TpString variablSetName, + in TpString variableName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicySignature createSignature ( + in TpString signatureName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + IpPolicySignature getSignature ( + in TpString signatureName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR); + + void removeSignature ( + in TpString signatureName + ) + raises (TpCommonExceptions,P_ACCESS_VIOLATION,P_SYNTAX_ERROR,P_NAME_SPACE_ERROR,P_NO_TRANSACTION_IN_PROCESS); + + TpInt32 getSignatureCount () + raises (TpCommonExceptions); + + IpPolicyIterator getSignatureIterator () + raises (TpCommonExceptions,P_ACCESS_VIOLATION); + + }; + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/termcap.idl b/idl/parlay/termcap.idl new file mode 100644 index 0000000000..c8c8395c7c --- /dev/null +++ b/idl/parlay/termcap.idl @@ -0,0 +1,113 @@ +//Source file: termcap.idl +//Date: 11 October 2004 +//Terminal Capability Interfaces and Data Types for ETSI ES 203 915-07 V1.1.1, DES/TISPAN-01005-07-OSA, Parlay 5.0 + +#ifndef __TERMCAP_DEFINED +#define __TERMCAP_DEFINED + + +#include "osa.idl" + +module org { + + module csapi { + + + module termcap { + + + struct TpTerminalCapabilities { + TpString TerminalCapabilities; + TpBoolean StatusCode; + }; + + + enum TpTerminalCapabilitiesError { + + P_TERMCAP_ERROR_UNDEFINED, + P_TERMCAP_INVALID_TERMINALID, + P_TERMCAP_SYSTEM_FAILURE, + P_TERMCAP_INFO_UNAVAILABLE + }; + + + exception P_INVALID_TERMINAL_ID { + TpString ExtraInformation; + }; + + + typedef TpInt32 TpTerminalCapabilityChangeCriteria; + + + const TpTerminalCapabilityChangeCriteria P_TERMINAL_CAPABILITY_CHANGE_CRITERIA_UNDEFINED = 0; + + const TpTerminalCapabilityChangeCriteria P_TERMINAL_CAPABILITY_CHANGE_CRITERIA_GENERAL = 1; + + const TpTerminalCapabilityChangeCriteria P_TERMINAL_CAPABILITY_CHANGE_CRITERIA_HW_UPDATE = 2; + + const TpTerminalCapabilityChangeCriteria P_TERMINAL_CAPABILITY_CHANGE_CRITERIA_SW_UPDATE = 4; + + const TpTerminalCapabilityChangeCriteria P_TERMINAL_CAPABILITY_CHANGE_CRITERIA_INITIAL = 8; + + enum TpTerminalCapabilityScopeType { + + P_TERMINAL_CAPABILITY_SCOPE_TYPE_UNDEFINED, + P_TERMINAL_CAPABILITY_SCOPE_TYPE_CCPP + }; + + + struct TpTerminalCapabilityScope { + TpTerminalCapabilityScopeType ScopeType; + TpString Scope; + }; + + + interface IpTerminalCapabilities : IpService { + TpTerminalCapabilities getTerminalCapabilities ( + in TpString terminalIdentity + ) + raises (TpCommonExceptions,P_INVALID_TERMINAL_ID); + + }; + + + interface IpAppExtendedTerminalCapabilities : IpInterface { + void triggeredTerminalCapabilityReport ( + in TpAssignmentID assignmentID, + in TpAddressSet terminals, + in TpTerminalCapabilityChangeCriteria criteria, + in TpTerminalCapabilities capabilities + ); + + void triggeredTerminalCapabilityReportErr ( + in TpAssignmentID assignmentId, + in TpAddressSet terminals, + in TpTerminalCapabilitiesError cause + ); + + }; + + + interface IpExtendedTerminalCapabilities : IpTerminalCapabilities { + TpAssignmentID triggeredTerminalCapabilityStartReq ( + in IpAppExtendedTerminalCapabilities appTerminalCapabilities, + in TpAddressSet terminals, + in TpTerminalCapabilityScope capabilityScope, + in TpTerminalCapabilityChangeCriteria criteria + ) + raises (TpCommonExceptions,P_INFORMATION_NOT_AVAILABLE,P_INVALID_INTERFACE_TYPE,P_INVALID_CRITERIA,P_INVALID_TERMINAL_ID); + + void triggeredTerminalCapabilityStop ( + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + }; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/ui_data.idl b/idl/parlay/ui_data.idl new file mode 100644 index 0000000000..60f461b10a --- /dev/null +++ b/idl/parlay/ui_data.idl @@ -0,0 +1,295 @@ +//Source file: ui_data.idl +//Date: 8 October 2004 +//User Interaction Data Types for ETSI ES 203 915-05 V1.1.1, DES/TISPAN-01005-05-OSA, Parlay 5.0 + +#ifndef __UI_DATA_DEFINED +#define __UI_DATA_DEFINED + + +#include "osa.idl" + +module org { + + module csapi { + + + module ui { + + + enum TpUIVariablePartType { + + P_UI_VARIABLE_PART_INT, + P_UI_VARIABLE_PART_ADDRESS, + P_UI_VARIABLE_PART_TIME, + P_UI_VARIABLE_PART_DATE, + P_UI_VARIABLE_PART_PRICE + }; + + + union TpUIVariableInfo switch(TpUIVariablePartType) { + case P_UI_VARIABLE_PART_INT: TpInt32 VariablePartInteger; + case P_UI_VARIABLE_PART_ADDRESS: TpString VariablePartAddress; + case P_UI_VARIABLE_PART_TIME: TpTime VariablePartTime; + case P_UI_VARIABLE_PART_DATE: TpDate VariablePartDate; + case P_UI_VARIABLE_PART_PRICE: TpPrice VariablePartPrice; + }; + + + typedef sequence TpUIVariableInfoSet; + + + typedef TpInt32 TpUIResponseRequest; + + + enum TpUIReport { + + P_UI_REPORT_UNDEFINED, + P_UI_REPORT_INFO_SENT, + P_UI_REPORT_INFO_COLLECTED, + P_UI_REPORT_NO_INPUT, + P_UI_REPORT_TIMEOUT, + P_UI_REPORT_MESSAGE_STORED, + P_UI_REPORT_MESSAGE_NOT_STORED, + P_UI_REPORT_MESSAGE_DELETED, + P_UI_REPORT_MESSAGE_NOT_DELETED + }; + + + struct TpUIMessageCriteria { + TpString EndSequence; + TpDuration MaxMessageTime; + TpInt32 MaxMessageSize; + }; + + + enum TpUIInfoType { + + P_UI_INFO_ID, + P_UI_INFO_DATA, + P_UI_INFO_ADDRESS, + P_UI_INFO_BIN_DATA, + P_UI_INFO_UUENCODED, + P_UI_INFO_MIME, + P_UI_INFO_WAVE, + P_UI_INFO_AU, + P_UI_INFO_VXML, + P_UI_INFO_SYNTHESIS + }; + + + enum TpUIFault { + + P_UI_FAULT_UNDEFINED, + P_UI_CALL_ENDED + }; + + + enum TpUIEventInfoDataType { + + P_UI_EVENT_DATA_TYPE_UNDEFINED, + P_UI_EVENT_DATA_TYPE_UNSPECIFIED, + P_UI_EVENT_DATA_TYPE_TEXT, + P_UI_EVENT_DATA_TYPE_USSD_DATA + }; + + + struct TpUIEventInfo { + TpAddress OriginatingAddress; + TpAddress DestinationAddress; + TpString ServiceCode; + TpUIEventInfoDataType DataTypeIndication; + TpString DataString; + }; + + + struct TpUIEventCriteria { + TpAddressRange OriginatingAddress; + TpAddressRange DestinationAddress; + TpString ServiceCode; + }; + + + enum TpUIError { + + P_UI_ERROR_UNDEFINED, + P_UI_ERROR_ILLEGAL_INFO, + P_UI_ERROR_ID_NOT_FOUND, + P_UI_ERROR_RESOURCE_UNAVAILABLE, + P_UI_ERROR_ILLEGAL_RANGE, + P_UI_ERROR_IMPROPER_USER_RESPONSE, + P_UI_ERROR_ABANDON, + P_UI_ERROR_NO_OPERATION_ACTIVE, + P_UI_ERROR_NO_SPACE_AVAILABLE, + P_UI_ERROR_RESOURCE_TIMEOUT + }; + + + const TpInt32 P_UI_RESPONSE_REQUIRED = 1; + + const TpInt32 P_UI_LAST_ANNOUNCEMENT_IN_A_ROW = 2; + + const TpInt32 P_UI_FINAL_REQUEST = 4; + + struct TpUIEventCriteriaResult { + TpUIEventCriteria EventCriteria; + TpInt32 AssignmentID; + }; + + + typedef sequence TpUIEventCriteriaResultSet; + + + exception P_ID_NOT_FOUND { + TpString ExtraInformation; + }; + + + exception P_ILLEGAL_ID { + TpString ExtraInformation; + }; + + + exception P_ILLEGAL_RANGE { + TpString ExtraInformation; + }; + + + exception P_INVALID_COLLECTION_CRITERIA { + TpString ExtraInformation; + }; + + + struct TpUIEventNotificationInfo { + TpAddress OriginatingAddress; + TpAddress DestinationAddress; + TpString ServiceCode; + TpUIEventInfoDataType DataTypeIndication; + TpOctetSet UIEventData; + }; + + + typedef TpString TpUIRecognitionGrammar; + + + struct TpUIRecognitionProperty { + TpString PropertyName; + TpString PropertyValue; + }; + + + typedef sequence TpUIRecognitionPropertySet; + + + typedef TpString TpUIRecognitionSpeakerID; + + + struct TpUIRecognitionCriteria { + TpUIRecognitionSpeakerID SpeakerID; + TpUIRecognitionPropertySet Properties; + TpUIRecognitionGrammar Grammar; + }; + + + enum TpUICollectMode { + + P_UI_COLLECT_MODE_DTMF, + P_UI_COLLECT_MODE_VOICE, + P_UI_COLLECT_MODE_DTMFANDVOICE + }; + + + struct TpUICollectCriteria { + TpInt32 MinLength; + TpInt32 MaxLength; + TpString EndSequence; + TpDuration StartTimeout; + TpDuration InterCharTimeout; + TpUICollectMode CollectMode; + TpUIRecognitionCriteria RecognitionCriteria; + }; + + + enum TpUIPronounceType { + + P_UI_PRONOUNCE_IPA, + P_UI_PRONOUNCE_SOUNDSLIKE + }; + + + struct TpUIWordOverride { + TpString Spelling; + TpUIPronounceType PronounceType; + TpString PronounceAs; + }; + + + typedef sequence TpUIWordOverrideSet; + + + enum TpUISynthesisRange { + + P_UI_RANGE_CALMER, + P_UI_RANGE_CALM, + P_UI_RANGE_AVERAGE, + P_UI_RANGE_EXCITED, + P_UI_RANGE_MORE_EXCITED + }; + + + enum TpUISynthesisRate { + + P_UI_RATE_SLOW, + P_UI_RATE_AVERAGE, + P_UI_RATE_FAST + }; + + + enum TpUISynthesisAge { + + P_UI_AGE_CHILD, + P_UI_AGE_YOUNG_ADULT, + P_UI_AGE_ADULT, + P_UI_AGE_OLDER_ADULT + }; + + + enum TpUISynthesisGender { + + P_UI_GENDER_MALE, + P_UI_GENDER_FEMALE + }; + + + struct TpUISynthesisInfoData { + TpUISynthesisGender SpeakerGender; + TpUISynthesisAge SpeakerAge; + TpUISynthesisRate SpeakerRate; + TpUISynthesisRange SpeakerRange; + TpString TextData; + TpUIWordOverrideSet WordOverrideSet; + }; + + + union TpUIInfo switch(TpUIInfoType) { + case P_UI_INFO_ID: TpInt32 InfoID; + case P_UI_INFO_DATA: TpString InfoData; + case P_UI_INFO_ADDRESS: TpURL InfoAddress; + case P_UI_INFO_BIN_DATA: TpOctetSet InfoBinData; + case P_UI_INFO_UUENCODED: TpString InfoUUEncData; + case P_UI_INFO_MIME: TpOctetSet InfoMimeData; + case P_UI_INFO_WAVE: TpOctetSet InfoWaveData; + case P_UI_INFO_AU: TpOctetSet InfoAuData; + case P_UI_INFO_VXML: TpString InfoVXMLData; + case P_UI_INFO_SYNTHESIS: TpUISynthesisInfoData InfoSynthData; + }; + + + typedef sequence TpMessageIDList; + + }; + + }; + +}; + +#endif diff --git a/idl/parlay/ui_interfaces.idl b/idl/parlay/ui_interfaces.idl new file mode 100644 index 0000000000..21386e9240 --- /dev/null +++ b/idl/parlay/ui_interfaces.idl @@ -0,0 +1,361 @@ +//Source file: ui_interfaces.idl +//Date: 8 October 2004 +//User Interaction Interfaces for ETSI ES 203 915-05 V1.1.1, DES/TISPAN-01005-05-OSA, Parlay 5.0 + + +#ifndef __UI_INTERFACES_DEFINED +#define __UI_INTERFACES_DEFINED + + +#include "osa.idl" +#include "ui_data.idl" +#include "gcc_interfaces.idl" +#include "mpcc_interfaces.idl" + +module org { + + module csapi { + + + module ui { + interface IpUI; + interface IpUICall; + + enum TpUITargetObjectType { + + P_UI_TARGET_OBJECT_CALL, + P_UI_TARGET_OBJECT_MULTI_PARTY_CALL, + P_UI_TARGET_OBJECT_CALL_LEG + }; + + + union TpUITargetObject switch(TpUITargetObjectType) { + case P_UI_TARGET_OBJECT_CALL: cc::gccs::TpCallIdentifier Call; + case P_UI_TARGET_OBJECT_MULTI_PARTY_CALL: cc::mpccs::TpMultiPartyCallIdentifier MultiPartyCall; + case P_UI_TARGET_OBJECT_CALL_LEG: cc::mpccs::TpCallLegIdentifier CallLeg; + }; + + + struct TpUIIdentifier { + IpUI UIRef; + TpSessionID UserInteractionSessionID; + }; + + + typedef sequence TpUIIdentifierSet; + + struct TpUICallIdentifier { + IpUICall UICallRef; + TpSessionID UserInteractionSessionID; + }; + + + + interface IpAppUI : IpInterface { + void sendInfoRes ( + in TpSessionID userInteractionSessionID, + in TpAssignmentID assignmentID, + in TpUIReport response + ); + + void sendInfoErr ( + in TpSessionID userInteractionSessionID, + in TpAssignmentID assignmentID, + in TpUIError error + ); + + void sendInfoAndCollectRes ( + in TpSessionID userInteractionSessionID, + in TpAssignmentID assignmentID, + in TpUIReport response, + in TpString collectedInfo + ); + + void sendInfoAndCollectErr ( + in TpSessionID userInteractionSessionID, + in TpAssignmentID assignmentID, + in TpUIError error + ); + + void userInteractionFaultDetected ( + in TpSessionID userInteractionSessionID, + in TpUIFault fault + ); + + }; + + + interface IpAppUICall : IpAppUI { + void recordMessageRes ( + in TpSessionID userInteractionSessionID, + in TpAssignmentID assignmentID, + in TpUIReport response, + in TpInt32 messageID + ); + + void recordMessageErr ( + in TpSessionID userInteractionSessionID, + in TpAssignmentID assignmentID, + in TpUIError error + ); + + void deleteMessageRes ( + in TpSessionID usrInteractionSessionID, + in TpUIReport response, + in TpAssignmentID assignmentID + ); + + void deleteMessageErr ( + in TpSessionID usrInteractionSessionID, + in TpUIError error, + in TpAssignmentID assignmentID + ); + + void abortActionRes ( + in TpSessionID userInteractionSessionID, + in TpAssignmentID assignmentID + ); + + void abortActionErr ( + in TpSessionID userInteractionSessionID, + in TpAssignmentID assignmentID, + in TpUIError error + ); + + void getMessageRes ( + in TpSessionID userInteractionSessionID, + in TpAssignmentID assignmentID, + in TpUIInfo message + ); + + void getMessageErr ( + in TpSessionID userInteractionSessionID, + in TpAssignmentID assignmentID, + in TpUIError error + ); + + }; + + + interface IpAppUIManager : IpInterface { + void userInteractionAborted ( + in TpUIIdentifier userInteraction + ); + + void userInteractionNotificationInterrupted (); + + void userInteractionNotificationContinued (); + + IpAppUI reportEventNotification ( + in TpUIIdentifier userInteraction, + in TpUIEventNotificationInfo eventNotificationInfo, + in TpAssignmentID assignmentID + ); + + void abortMultipleUserInteractions ( + in TpUIIdentifierSet userInteractionSet + ); + + }; + + + interface IpUI : IpService { + TpAssignmentID sendInfoReq ( + in TpSessionID userInteractionSessionID, + in TpUIInfo info, + in TpLanguage language, + in TpUIVariableInfoSet variableInfo, + in TpInt32 repeatIndicator, + in TpUIResponseRequest responseRequested + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE,P_ILLEGAL_ID,P_ID_NOT_FOUND); + + TpAssignmentID sendInfoAndCollectReq ( + in TpSessionID userInteractionSessionID, + in TpUIInfo info, + in TpLanguage language, + in TpUIVariableInfoSet variableInfo, + in TpUICollectCriteria criteria, + in TpUIResponseRequest responseRequested + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE,P_ILLEGAL_ID,P_ID_NOT_FOUND,P_ILLEGAL_RANGE,P_INVALID_COLLECTION_CRITERIA); + + void release ( + in TpSessionID userInteractionSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID); + + void setOriginatingAddress ( + in TpSessionID userInteractionSessionID, + in TpString origin + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE,P_INVALID_ADDRESS); + + TpString getOriginatingAddress ( + in TpSessionID userInteractionSessionID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE); + + }; + + + interface IpUICall : IpUI { + TpAssignmentID recordMessageReq ( + in TpSessionID userInteractionSessionID, + in TpUIInfo info, + in TpUIMessageCriteria criteria + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE,P_ILLEGAL_ID,P_ID_NOT_FOUND,P_INVALID_CRITERIA); + + TpAssignmentID deleteMessageReq ( + in TpSessionID usrInteractionSessionID, + in TpInt32 messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_ILLEGAL_ID,P_ID_NOT_FOUND); + + void abortActionReq ( + in TpSessionID userInteractionSessionID, + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_ASSIGNMENT_ID); + + TpAssignmentID getMessageReq ( + in TpSessionID userInteractionSessionID, + in TpInt32 messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE,P_ILLEGAL_ID,P_ID_NOT_FOUND); + + }; + + + interface IpUIManager : IpService { + TpUIIdentifier createUI ( + in IpAppUI appUI, + in TpAddress userAddress + ) + raises (TpCommonExceptions,P_INVALID_NETWORK_STATE,P_INVALID_INTERFACE_TYPE); + + TpUICallIdentifier createUICall ( + in IpAppUICall appUI, + in TpUITargetObject uiTargetObject + ) + raises (TpCommonExceptions,P_INVALID_NETWORK_STATE,P_INVALID_INTERFACE_TYPE); + + TpAssignmentID createNotification ( + in IpAppUIManager appUIManager, + in TpUIEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_INVALID_CRITERIA,P_INVALID_INTERFACE_TYPE); + + void destroyNotification ( + in TpAssignmentID assignmentID + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID); + + void changeNotification ( + in TpAssignmentID assignmentID, + in TpUIEventCriteria eventCriteria + ) + raises (TpCommonExceptions,P_INVALID_ASSIGNMENT_ID,P_INVALID_CRITERIA); + + TpUIEventCriteriaResultSet getNotification () + raises (TpCommonExceptions); + + TpAssignmentID enableNotifications ( + in IpAppUIManager appUIManager + ) + raises (TpCommonExceptions); + + void disableNotifications () + raises (TpCommonExceptions); + + }; + + + interface IpAppUIAdminManager : IpInterface { + void getMessageRes ( + in TpSessionID usrInteractionSessionID, + in TpAssignmentID assignmentID, + in TpUIInfo message + ); + + void getMessageErr ( + in TpSessionID usrInteractionSessionID, + in TpAssignmentID assignmentID, + in TpUIError error + ); + + void deleteMessageRes ( + in TpSessionID usrInteractionSessionID, + in TpUIReport response, + in TpAssignmentID assignmentID + ); + + void deleteMessageErr ( + in TpSessionID usrInteractionSessionID, + in TpUIError error, + in TpAssignmentID assignmentID + ); + + void putMessageRes ( + in TpSessionID usrInteractionSessionID, + in TpAssignmentID assignmentID, + in TpInt32 messageID + ); + + void putMessageErr ( + in TpSessionID usrInteractionSessionID, + in TpAssignmentID assignmentID, + in TpUIError error + ); + + void getMessageListRes ( + in TpSessionID usrInteractionSessionID, + in TpAssignmentID assignmentID, + in TpMessageIDList messageIDList, + in TpBoolean final + ); + + void getMessageListErr ( + in TpSessionID usrInteractionSessionID, + in TpAssignmentID assignmentID, + in TpUIError error + ); + + }; + + + interface IpUIAdminManager : IpService { + TpAssignmentID getMessageReq ( + in TpSessionID usrInteractionSessionID, + in TpInt32 messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE,P_ILLEGAL_ID,P_ID_NOT_FOUND); + + TpAssignmentID putMessageReq ( + in TpSessionID usrInteractionSessionID, + in TpUIInfo info + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_ILLEGAL_ID,P_ID_NOT_FOUND); + + TpAssignmentID deleteMessageReq ( + in TpSessionID usrInteractionSessionID, + in TpInt32 messageID + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_ILLEGAL_ID,P_ID_NOT_FOUND); + + TpAssignmentID getMessageListReq ( + in TpSessionID usrInteractionSessionID, + in TpBoolean reset + ) + raises (TpCommonExceptions,P_INVALID_SESSION_ID,P_INVALID_NETWORK_STATE); + + }; + + }; + + }; + +}; + +#endif -- cgit v1.2.1