-- IDL module extracted from ITU-T Q Suppl. 28 (12/1999)

	// File SPFEECommonTypes.idl
	#ifndef spfeecommontypes_idl
	#define spfeecommontypes_idl

	module SPFEECommonTypes {

	// ElementIds (mainly used in usage part)


	// Element types
	enum t_ElTypes { 
		SpfeeParty, 	// see also t_PartyId
		SpfeeResource, SpfeeMember, 
		SpfeeGroup, SpfeeMemberGroup, SpfeePartyGroup, SpfeeResourceGroup,
		SpfeeRelation, SpfeeRelationGroup, SpfeeControlRelation, 
		SpfeeStreamBinding, SpfeeStreamFlow, SpfeeStreamInterface, SpfeeSFEP 
	};

	// Element Identifier (elements in a service session)
	typedef unsigned long t_ElId;

	// Element Type Identifiers
	typedef t_ElTypes t_ElTypeId;

	// Overall element Identifier
	struct t_ElementId
	{
		t_ElId id;
		t_ElTypeId elType;
	};

	typedef sequence <t_ElementId> t_ElementIdList;

	// t_PropertyList
	// list of properties, (name value pairs).
	// Used in many operations to allow a list of as yet undefined 
	// properties, and values, to be sent.
	//

	typedef string t_PropertyName;
	typedef sequence<t_PropertyName> t_PropertyNameList;
	typedef any t_PropertyValue;

	struct t_Property {
		t_PropertyName name;
		t_PropertyValue value;
	};

	typedef sequence<t_Property> t_PropertyList;

	enum t_HowManyProps {none, some, all};
	union t_SpecifiedProps switch (t_HowManyProps) {
		case some: t_PropertyNameList prop_names;
		case none: octet dummy1;
		case all: octet dummy2;
	};

	typedef string Istring;

	// enum t_ReferenceSort { 
	// ObjectRef, 
	// StringifiedReference 
	// };

	// union t_Reference switch(t_ReferenceSort) {
	// 	case ObjectRef: Object IRef;
	// 	case StringifiedReference: SPFEECommonTypes::Istring IORef;
	// };

	enum t_WhichProperties {
		NoProperties,	// don't can ignore all the properties
		SomeProperties,	// match at least one property (name & value)
		SomePropertiesNamesOnly, // check name only (ignore value)

		AllProperties,	// match all properties (name & value)
		AllPropertiesNamesOnly	// check name only (ignore value)
	};

	struct t_MatchProperties {
		t_WhichProperties whichProperties;
		t_PropertyList properties;
	};

	typedef /*CORBA::*/Object t_Interface;

	typedef string t_InterfaceTypeName;
	typedef sequence<t_InterfaceTypeName> t_InterfaceTypeList;
	typedef t_PropertyList t_InterfaceProperties;

	struct t_InterfaceStruct {
	        t_InterfaceTypeName itfType;
	        Object ref;                        
				// if NULL: use getInterface(type)
				// to get the reference
	        t_InterfaceProperties properties;
				// interface type specific properties
				// interpreted by the session.
	};

	typedef sequence<t_InterfaceStruct> t_InterfaceList;

	typedef unsigned long t_InterfaceIndex;
	typedef sequence<t_InterfaceIndex> t_InterfaceIndexList; 

	// when registering multiple interfaces need to match index vs itfType & props:
	struct t_RegisterInterfaceStruct {
	      t_InterfaceTypeName itfType;	// set before call to registerInterfaces
	      Object ref;
	t_InterfaceProperties properties;	// as above
	t_InterfaceIndex index;	// set on return 
	};

	typedef sequence<t_RegisterInterfaceStruct> t_RegisterInterfaceList;

	// Session Models
	// t_SessionModelName name: 
	// defined names
	//    "SPFEEServiceSessionModel"	SPFEE Service Session Model
	//    "SPFEECommSessionModel"	SPFEE Communication Session Model
	// No other names defined at present
	//
	// (previous versions of Ret-RP used "SPFEESessionModel" and "SPFEE //    Session Model" for the SPFEE Service Session Model (previously named //    SPFEE Session Model)

	typedef string t_SessionModelName;

	typedef sequence<t_SessionModelName> t_SessionModelNameList;

	// t_SessionModelProperties properties: 
	//
	// t_SessionModelName name: "SPFEEServiceSessionModel"
	// defined Property names:
	// name: 	"FEATURE SETS"
	// value:	t_FeatureSetList
	// No other names defined at present


	// t_SessionModelName name: "SPFEECommSessionModel"
	// defined Property names:
	// name: 	"FEATURE SETS"
	// value:	t_FeatureSetList
	//
	// No feature sets are defined for the TIACommSessionModel at present.
	//
	// No other names defined at present

	typedef t_PropertyList t_SessionModelProperties;

	struct t_SessionModel {
		t_SessionModelName name;	// reserved names defined below
		t_SessionModelProperties properties;	// properties defined above
	};

	typedef sequence<t_SessionModel> t_SessionModelList;

	enum t_WhichSessionModels {
		NoSessionModels,	// can ignore all the SessionModels
		SomeSessionModels,	// match at least one SessionModel (name & value)
		SomeSessionModelsNamesOnly,	// check name only (ignore value)
		AllSessionModels,	// match all SessionModels (name & value)
		AllSessionModelsNamesOnly	// check name only (ignore value)
	};

	struct t_SessionModelReq {
		t_WhichSessionModels which;
		t_SessionModelList sessionModels;
	};

	typedef string t_FeatureSetName;

	struct t_FeatureSet {
		t_FeatureSetName name;
		t_InterfaceList itfs;
						// can return ref or NULL
	};

	typedef sequence<t_FeatureSet> t_FeatureSetList;

	// User Info
	typedef Istring t_UserId;
	typedef Istring t_UserName;
	typedef t_Property t_UserProperty;
	typedef t_PropertyList t_UserProperties;
	// Property Names defined for t_UserProperties:
	// name:	"PASSWORD"
	// value:	string
	// use:	user password, as a string.

	// name:	"SecurityContext"
	// value:	opaque
	// use: 	to carry a retailer specific security context
	//			e.g. could be used for an encoded user password.

	struct t_UserDetails {
		t_UserId id;
		t_UserProperties properties;
	};

	typedef Istring t_UserCtxtName;
	typedef sequence<t_UserCtxtName> t_UserCtxtNameList;	


	typedef sequence<octet, 16> t_ParticipantSecretId;
	typedef t_ElId t_PartyId;	// corresponds to SpfeeParty enum t_ElTypes
	typedef sequence<t_PartyId> t_PartyIdList;

	// SessionId
	// A SessionId is generated by a UA when a new session is started.
	// This Id is unique within a UA, and can be used to identify a 
	// session to the UA. 
	// User's joining a session will have a different SessionId generated
	// by their UA for the session.

	typedef unsigned long t_SessionId;
	typedef sequence<t_SessionId> t_SessionIdList;
	typedef t_PropertyList t_SessionProperties;

	// Invitation and Announcements
	//
	enum t_InvitationReplyCodes { // Based on MMUSIC replys
		SUCCESS,			// user agrees to participate
		UNSUCCESSFUL,			// couldn't contact user
		DECLINE,			// user declines
		UNKNOWN,			// user is unknown
		ERROR,				// for some unknown reason
		FORBIDDEN,			// authorisation failure
		RINGING,			// user is being contacted
		TRYING,				// some further action is being taken
		STORED,				// invitation is stored
		REDIRECT,		// try this different address	
		NEGOTIATE,			// alternatives described in properties
			// Not MMUSIC replys, can be treated as UNSUCCESSFUL
		BUSY, 				// couldn't contact because busy
		TIMEOUT				// timed out while trying to contact
	};

	typedef t_PropertyList t_InvitationReplyProperties;

	struct t_InvitationReply {
		t_InvitationReplyCodes reply;
		t_InvitationReplyProperties properties;
	};

	typedef t_PropertyList t_AnnouncementProperties;
	struct t_SessionAnnouncement {
		t_AnnouncementProperties properties;
	};

	typedef sequence<t_SessionAnnouncement> t_AnnouncementList;

	// Exceptions

	enum t_PropertyErrorCode {
		UnknownPropertyError,
		InvalidProperty,
		// UnknownPropertyName: If the server receives a property name 
		// it doesnot know, it can raise an exception, using this code. 
		// However, servers may decide to ignore a property with an 
		// unknown property name, and not raise an exception.
		UnknownPropertyName,
		InvalidPropertyName,
		InvalidPropertyValue,
		NoPropertyError		// the Property is not in error
	};


	// defined so it can be used in other exceptions
	struct t_PropertyErrorStruct {
		t_PropertyErrorCode errorCode;
		t_PropertyName name;
		t_PropertyValue value;
	};

	exception e_PropertyError {
		t_PropertyErrorCode errorCode;
		t_PropertyName name;
		t_PropertyValue value;
	};

	enum t_InterfacesErrorCode {
		UnknownInterfacesError,
		InvalidInterfaceTypeName, // Thats not a valid i/f type name
		InvalidInterfaceRef,
		InvalidInterfaceProperty,
		InvalidInterfaceIndex
	};

	// must remain consistent with e_InterfacesError
	struct t_InterfacesErrorStruct {
		t_InterfacesErrorCode errorCode;
		t_InterfaceTypeName itfType;
		t_PropertyErrorStruct propertyError; 
			//PropertyError, if errorCode= InvalidInterfaceProperty
	};

	exception e_InterfacesError {
		t_InterfacesErrorCode errorCode;
		t_InterfaceTypeName itfType;
		t_PropertyErrorStruct propertyError;
			//PropertyError, if errorCode= InvalidInterfaceProperty
	};

	enum t_RegisterErrorCode {
		UnableToRegisterInterfaceType
	};

	exception e_RegisterError {
		t_RegisterErrorCode errorCode;
		t_InterfaceTypeName itfType;
		t_InterfaceProperties properties;
	};

	enum t_UnregisterErrorCode {
		UnableToUnregisterInterface
	};

	exception e_UnregisterError {
		t_UnregisterErrorCode errorCode;
		t_InterfaceIndexList indexes; 	// can unregister multiple itfs
	};

	enum t_SessionModelErrorCode {
		UnknownSessionModelError,
		InvalidSessionModelName,	// Thats not a valid i/f type name
		SessionModelNotSupported,
		InvalidFeatureSetName,
		FeatureSetNotSupported,
		InvalidFeatureSetInterfaceType
	};


	exception e_SessionModelError {
		t_SessionModelErrorCode errorCode;
		t_SessionModelName sessionModelName;
		t_FeatureSetName featureSetName;// Only for FeatureSet errs
		t_InterfaceTypeName itfType;	// Only for FeatureSet errs
	};

	enum t_UserDetailsErrorCode {
		InvalidUserName,
		InvalidUserProperty
	};

	exception e_UserDetailsError {
		t_UserDetailsErrorCode errorCode;
		t_UserName name;
		t_PropertyErrorStruct propertyError;
					// Return the properties in error
	};

	enum t_ListErrorCode {
		ListUnavailable
	};

	exception e_ListError {
		t_ListErrorCode errorCode;
	};

	enum t_InvitationReplyErrorCode {
		InvalidInvitationReplyCode,
		InvitationReplyPropertyError
	};

	exception e_InvitationReplyError {
		t_InvitationReplyErrorCode errorCode;
		t_PropertyErrorStruct propertyError;
	};

	};	// end module SPFEECommonTypes

	#endif