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

// File SPFEESubCommonTypes.idl
	// Contents:
	// This file include common definitions required by the subscription
	// magement component and its clients.
	// @see SPFEECommonTypes
	// @see SPFEEAccessCommonTypes
	//

	#ifndef SPFEESUBCOMMONTYPES_IDL
	#define SPFEESUBCOMMONTYPES_IDL

	// This file provides definitions that are common to the service architecture.
	#include "SPFEEAccessCommonTypes.idl" 

	// Module with common types definitions for subscription management.
	module SPFEESubCommonTypes {

	// List of Service Identifiers.
	typedef sequence<SPFEEAccessCommonTypes::t_ServiceId> t_ServiceIdList;

	// Service Types
	typedef string t_ServiceType;

	// Terminal Type: Just an example.
	enum t_TermType {UndefinedTermType,PersonalComputer, WorkStation, TVset, Videotelephone, Cellularphone, PBX, VideoServer, VideoBridge, Telephone, G4Fax};

	// NAP type: used to determine the instantation of available QoS.
	enum t_NapType {UndefinedNapType,NapTypeFixed, NapTypeWireless};

	// List of NAPs
	typedef sequence<SPFEEAccessCommonTypes::t_NAPId> t_NAPIdList;


	// Terminal presentation technology. This is just an example
	enum t_PresentationSupport { UndefinedPresSupp,X11R6, WINDOWS95, MGEG };

	// The Account Number represents the Subscriber identifier.
	typedef string t_AccountNumber;
	typedef sequence<t_AccountNumber> t_SubscriberIdList;
						
	// Types required for SAG management

	// Users, terminals and NAPs are considered (subscription) entities
	enum t_entityType {user, terminal, nap};

	// Entity Id allows to identity uniquely an entity inside the retailer domain.
	union t_entityId switch (t_entityType) {
	        case user:     SPFEECommonTypes::t_UserId            userId;
	        case terminal: SPFEEAccessCommonTypes::t_TerminalId  terminalId;
	        case nap:      SPFEEAccessCommonTypes::t_NAPId       napId;
	};
	typedef sequence<t_entityId> t_entityIdList;

	// An entity is characterized by its identifier and name and a set of properties.
	struct t_Entity {
	        t_entityId                        entityId;
	        string                            entityName;
	        SPFEECommonTypes::t_PropertyList   properties;
	};
	typedef sequence<t_Entity> t_EntityList;

	// The SAE is characterized by an identifier, a name and a set of properties
	struct t_Sae {
	        t_entityId       entityId;
	        string           entityName; 
	        SPFEECommonTypes::t_PropertyList   properties; // like password
	};

	// The SAG identifier identifies a SAG uniquely inside the retailer domain.
	typedef short    t_SagId;
	typedef sequence<t_SagId> t_SagIdList;

	// A SAG is characterized by its identifier, a textual description of the
	// group and the list of entities composing it. 
	// The identifier is the same as the one for SAG Service profile corresponding to that SAG.
	struct t_Sag {
	        t_SagId          sagId;
	        string           sagDescription;
	        t_entityIdList   entityList;
	};
	typedef sequence<t_Sag>   t_SagList;

	// Subscriber Information:

	// Time and Date.
	struct t_DateTime {
	        string           date;
	        string           time;
	};

	// Textual identification of a person. For example, name, address and position.
	typedef string       t_Person;


	// Indicates the date and time an authorization expires on and the person who granted it. 
	struct t_AuthLimit {
	        t_DateTime       limitDate;
	        string           authority;
	}; // note: Shouldn't this be per service contract?

	// A subscriber is identified by its account number and characterized by
	// name, address, monthly charge, payment record, credit information,
	// date which its subscription expires on, the list of subscribed services
	// and the list of defined SAGs.
	struct t_Subscriber {
	        t_AccountNumber           accountNumber;
	        SPFEECommonTypes::t_UserId subscriberName;
	        t_Person                  identificationInfo;
	        t_Person                  billingContactPoint;
	        string                    RatePlan;
	        any                       paymentRecord;
	        any                       credit;
	};
	typedef sequence<t_Subscriber> t_SubscriberList;

	// This structure contains information about the minimal required configuration
	// of a service. This is used to specify a configuration for a particular service session
	struct t_RequiredConfiguration {
		t_TermType termType;
		t_NapType nap_type;
		t_PresentationSupport presentation_support;
		SPFEECommonTypes::t_PropertyList others; // to be determined. 
	};

	// Service access rights.
	enum t_AccessRight {create,join,be_invited};  

	// List of possible service access rights.
	typedef sequence<t_AccessRight> t_AccessRightList;  

	// Service Parameter name.
	typedef string  t_ParameterName;

	// Service Parameter configurability.
	enum t_ParameterConfigurability {
	    FIXED_BY_PROVIDER, CONFIGURABLE_BY_SUBSCRIBER, CUSTOMIZABLE_BY_USER
	};

	// Service Parameter value.
	typedef any     t_ParameterValue;

	// Service Parameters definition:
	struct t_Parameter {
	    t_ParameterName             name; 
	    t_ParameterConfigurability  configurability;
	    t_ParameterValue            value;
	};
	typedef sequence<t_Parameter> t_ParameterList;

	struct t_ServiceDescription {
	        SPFEEAccessCommonTypes::t_ServiceId               serviceId;
	        SPFEEAccessCommonTypes::t_UserServiceName         serviceName;
	        t_ParameterList                              serviceCommonParams;
	        t_ParameterList                             serviceSpecificParams;
	};


	// t_serviceTemplate: It describes a service instance.
	struct t_ServiceTemplate {
	        SPFEEAccessCommonTypes::t_ServiceId         serviceInstanceId;
	        SPFEEAccessCommonTypes::t_UserServiceName   serviceInstanceName;
	        t_ServiceIdList	                           requiredServices;
	        t_ServiceDescription                       serviceDescription;
	};
	typedef sequence<t_ServiceTemplate> t_ServiceTemplateList;

	// t_ServiceProfile: It describes a service customization.
	typedef string t_ServiceProfileId;
	typedef sequence<t_ServiceProfileId> t_ServiceProfileIdList;
	struct t_ServiceProfile {
	        t_ServiceProfileId                         spId;
	        t_ServiceDescription                       serviceDescription;
	};
	typedef sequence<t_ServiceProfile> t_ServiceProfileList;

	// Service Profile for a SAG.
	typedef t_ServiceProfile t_SagServiceProfile;

	// Service Profile by default in a Service Contract.
	typedef t_ServiceProfile t_SubscriptionProfile;

	// List of SAG Service Profiles
	typedef sequence<t_SagServiceProfile> t_SagServiceProfileList;

	// Service Contract: Describes the relationship of a subscriber with the
	// provider for the provision of a service.
	struct t_ServiceContract {
	        SPFEEAccessCommonTypes::t_ServiceId  serviceId;
	        t_AccountNumber                     accountNumber;
	        short                               maxNumOfServiceProfiles;
	        t_DateTime                          actualStart;
	        t_DateTime                          requestedStart;
	        t_Person                            requester;
	        t_Person                            technicalContactPoint;
	        t_AuthLimit                         authorityLimit;
	        t_SubscriptionProfile               subscriptionProfile;
	        t_SagServiceProfileList             sagServiceProfileList;
	};

	// Notification Type, used in "i_SubscriptionNotify::notify"
	enum t_subNotificationType {NEW_SERVICES,PROFILE_MODIFIED,SERVICES_WITHDRAWN};
	// Notification Type, used in "i_ServiceNotify::notify"
	enum t_slcmNotificationType {NEW_SERVICE,TEMPLATE_MODIFIED,SERVICE_WITHDRAWN};
	};
	#endif // File SPFEESubCommonTypes.idl