/**
 *	@author   STF 346, STF366, STF368, STF369
 *  @version  $Id$
 *	@desc     This module defines message, header, structured and simple SIP 
 *            types as well constants used by LipSip constructs. <br>
 *            Note that any changes made to the definitions in this module
 *            may be overwritten by future releases of this library
 *            End users are encouraged to contact the distributers of this  
 *            module regarding their modifications or additions
 *  @remark   Adding of new message and header types is ok;
 *            Adding of new optional header fields in @see MessageHeader type 
 *            is ok but should be done at same time as dummy template updates;
 *            Existing message or header types shall not be changed or removed -
 *            change requests shall be made to http://t-ort.etsi.org
 */

module LibSip_SIPTypesAndValues language "TTCN-3:2005"//MRO
{
	//	SipAts
	import from LibSip_SDPTypes all;
	import from LibSip_XMLTypes all;

group Constants 
{	
group SimpleConstants
    {
      // SIP name protocol plus version
      const charstring c_sipNameVersion := "SIP/2.0";
      
      // SIP name protocol
      const charstring c_sipName := "SIP";
      
      // SIP version
      const charstring c_sipVersion := "2.0";
      
      // SIP scheme
      const charstring c_sipScheme := "sip";
      
	  // TEL scheme
	  const charstring c_telScheme := "tel";
      
      // TAG_ID
      const charstring c_tagId := "tag";
      
      // BRANCH_ID
      const charstring c_branchId := "branch";
      
      // BRANCH_COOKIE
      const charstring c_branchCookie := "z9hG4bK";
      
      // EXPIRES_ID
      const charstring c_expiresId := "expires";
      
      // MADDR_ID
      const charstring c_maddrId := "maddr";
      
      // METHOD_ID
      const charstring c_methodId := "method";
      
      // RECEIVED_ID
      const charstring c_receivedId := "received";
      
      // TTL_ID
      const charstring c_ttlId := "ttl";
      
      // USER_ID
      const charstring c_userId := "user";
      
      // SDP name application
      const charstring c_sdpAplication := "application/sdp";
      
	  // XML name application
	  const charstring c_xmlAplication := "application/xml";
      
	  // MIME name application
	  const charstring c_mimeMultipart := "multipart/mixed";
	  
	  // IMS 3GPP name application
	  const charstring c_ims3gppAplication := "application/3gpp-ims+xml";
	  
	  // IMS 3GPP name CW application
	  const charstring c_ims3gppCwApplication := "application/vnd.3gpp.cw+xml";
      
	  // OCTET-STREAM name application
	  const charstring c_octetAplication := "application/octet-stream";
	  
      // PLAIN-TEXT name application
	  const charstring c_plainText := "text/plain";
	  
	  //text content of 1300 bytes for messages with message body
	  const charstring c_longMessageContent_1300Bytes :=
	  "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"&
	  "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"&
	  "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"&
	  "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"&
	  "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"&
	  "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"&
	  "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"&
	  "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"&
	  "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"&
	  "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"&
	  "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"&
	  "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"&
	  "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789";
	  
 
      // Default SIP port number : 5060
      const integer c_defaultSipPort := 5060;
      
      // Default SIP protocol : UDP
      const charstring c_defaultSipProt := "UDP";
      
      // Fixed IP multicast address
      const charstring c_mcastSipIpaddr := "224.0.1.75";
      
      // Short delta-second used in expires parameter to acknowledge a registration
      const charstring c_shortRegistration := "3600";

	  // ([RFC3891]Sec 6.1)
	  const charstring c_earlyFlag := "early-only";

	  // option tag replaces ([RFC3261])
	  const charstring c_replaces := "replaces";
      
	  // option tag 100rel (reliable provisional response [RFC3262])
	  const charstring c_tag100rel := "100rel";
      
	  // option tag from-change ([RFC4916])
	  const charstring c_tagFromChange := "from-change";
      
	  // option tag precondition (ch.11 [RFC3312])
	  const charstring c_tagPrecond := "precondition";

	  // due to problem with TAU compiler because hardcoded return statement constant is created
	  const HostPort c_hostport_dummy := {host:="", portField:=c_defaultSipPort};

	  // CLIP/CLIR information
	  const PrivacyValue c_privacy_none := "none";		
	  const PrivacyValue c_privacy_id := "id";
	  const PrivacyValue c_privacy_header := "header";
	  const PrivacyValue c_privacy_user := "user";
	  const PrivacyValue c_privacy_critical := "critical";
	  
	  // @ (at) sign
	  const charstring c_AT := "@";
	  //MRO
		const charstring c_SP := oct2char('20'O);
		const charstring c_SLASH := oct2char('2F'O);
		const charstring c_LT := oct2char('3C'O);
		const charstring c_GT := oct2char('3E'O);
	  
	  // * (wildchard) sign
	  const charstring c_WILDCARD := "*";
	  
	  const integer c_CRlen := 2; // length of new line (0d0a)

	  const GenericParam c_Integrity_protected_yes := {"Integrity protected","yes"}
	  const GenericParam c_Integrity_protected_no := {"Integrity protected","no"}

} //end group SimpleConstants

group AuthorizationConstants {
	
	const charstring c_ik := "";
	const charstring c_ck := "";
	const charstring c_algorithm := "MD5";
	const charstring c_nonce := ""

} //end group AuthorizationConstants

group HeaderFieldConstants {

	const CallId	c_empty_CallId :=
	{
	  fieldName := CALL_ID_E,
	  callid := ""
	};

	const ContentType	c_empty_ContentType :=
	{
	  fieldName := CONTENT_TYPE_E,
	  mediaType := ""
	};
		  
	const CSeq	c_empty_cSeq := {
		fieldName := CSEQ_E, 
		seqNumber:=0, 
		method:="" };
	
	const From	c_empty_From := { 
	  fieldName := FROM_E,
	  addressField := {nameAddr := 
		{displayName := omit,
		  addrSpec := {
			scheme  := c_sipScheme,
			userInfo := omit ,
			hostPort := {host:="", portField:=c_defaultSipPort},
			urlParameters := omit,
			headers := omit
		  }
		}
	  },
	  fromParams := omit
	};
	
	const MaxForwards c_maxForwards70 := {fieldName:=MAX_FORWARDS_E, forwards:=70}
	
	const SipUrl c_empty_RequestUri :=
	{
	  scheme  := c_sipScheme,
	  userInfo := omit ,
	  hostPort := {host:="", portField:=c_defaultSipPort},
	  urlParameters := omit,
	  headers := omit
	};

	const SipUrl c_unavailableUri :=
	{
			scheme  := c_sipScheme,
			userInfo := {userOrTelephoneSubscriber:="unavailable", password:=omit},
			hostPort := {host:="anonymous.invalid", portField:=c_defaultSipPort},
			urlParameters := omit,
			headers := omit
	};

	const To	c_empty_To := 
	{ // value of To header
	  fieldName := TO_E,
	  addressField := 
	  {
		nameAddr := 
		{
		  displayName := omit,
		  addrSpec := 
		  {
			scheme  := c_sipScheme,
			userInfo := omit ,
			hostPort := {host:="", portField:=c_defaultSipPort},
			urlParameters := omit,
			headers := omit
		  }
		}
	  },
	  toParams := omit
	};
	
	const Via c_empty_Via := {
	  fieldName := VIA_E,
	  viaBody :={
		{sentProtocol := {
			protocolName := c_sipName,
			protocolVersion := c_sipVersion,
			transport := c_defaultSipProt
		  },
		  sentBy := {host:="", portField:=c_defaultSipPort},
		  viaParams:= omit
		}
	  }};
		

}


group UserProfileConstants
{
	  // number of user profile from 1-10 for SIP profile
	  const integer c_userProfile_SIP1_home := 1;
	  const integer c_userProfile_SIP2_home := 2;

} //end group UserProfileConstants

group StatusLines
	{
		const StatusLine c_statusLine100	:=	{c_sipNameVersion, 100, "Trying"};
		const StatusLine c_statusLine180	:=	{c_sipNameVersion, 180, "Ringing"};
		const StatusLine c_statusLine181	:=	{c_sipNameVersion, 181, "Call is Being Forwarded"};
		const StatusLine c_statusLine182	:=	{c_sipNameVersion, 182, "Queued"};
		const StatusLine c_statusLine183	:=	{c_sipNameVersion, 183, "Session Progress"};

		const StatusLine c_statusLine200	:=	{c_sipNameVersion, 200, "OK"};
		const StatusLine c_statusLine202	:=	{c_sipNameVersion, 202, "Accepted"};

		const StatusLine c_statusLine300	:=	{c_sipNameVersion, 300, "Multiple Choices"};
		const StatusLine c_statusLine301	:=	{c_sipNameVersion, 301, "Moved Permanently"};
		const StatusLine c_statusLine302	:=	{c_sipNameVersion, 302, "Moved Temporarily"};
		const StatusLine c_statusLine305	:=	{c_sipNameVersion, 305, "Use Proxy"};
		const StatusLine c_statusLine380	:=	{c_sipNameVersion, 380, "Alternative Service"};

		const StatusLine c_statusLine400	:=	{c_sipNameVersion, 400, "Bad Request"};
		const StatusLine c_statusLine401	:=	{c_sipNameVersion, 401, "Unauthorised"};
		const StatusLine c_statusLine402	:=	{c_sipNameVersion, 402, "Payment Required"};
		const StatusLine c_statusLine403	:=	{c_sipNameVersion, 403, "Forbidden"};
		const StatusLine c_statusLine404	:=	{c_sipNameVersion, 404, "Not Found"};
		const StatusLine c_statusLine405	:=	{c_sipNameVersion, 405, "Method Not Allowed"};
		const StatusLine c_statusLine406	:=	{c_sipNameVersion, 406, "Not Acceptable"};
		const StatusLine c_statusLine407	:=	{c_sipNameVersion, 407, "Proxy authentication required"};
		const StatusLine c_statusLine408	:=	{c_sipNameVersion, 408, "Request Timeout"};
		const StatusLine c_statusLine410	:=	{c_sipNameVersion, 410, "Gone"};
		const StatusLine c_statusLine413	:=	{c_sipNameVersion, 413, "Request Entity too long"};
		const StatusLine c_statusLine414	:=	{c_sipNameVersion, 414, "Request-uri too long"};
		const StatusLine c_statusLine415	:=	{c_sipNameVersion, 415, "Unsupported Media type"};
		const StatusLine c_statusLine416	:=	{c_sipNameVersion, 416, "Unsupported URI scheme"};
		const StatusLine c_statusLine420	:=	{c_sipNameVersion, 420, "Bad Extension"};
		const StatusLine c_statusLine421	:=	{c_sipNameVersion, 421, "Extension required"};
		const StatusLine c_statusLine422	:=	{c_sipNameVersion, 422, "Session Interval Too Small"};
		const StatusLine c_statusLine423	:=	{c_sipNameVersion, 423, "Interval Too Brief"};
  		const StatusLine c_statusLine433	:=	{c_sipNameVersion, 433, "Anonymity Disallowed"};
		const StatusLine c_statusLine480	:=	{c_sipNameVersion, 480, "Temporarily Unavailable"};
		const StatusLine c_statusLine481	:=	{c_sipNameVersion, 481, "Call/Transaction doesnot exist"};
		const StatusLine c_statusLine482	:=	{c_sipNameVersion, 482, "Loop Detected"};
		const StatusLine c_statusLine483	:=	{c_sipNameVersion, 483, "Too many hops"};
		const StatusLine c_statusLine484	:=	{c_sipNameVersion, 484, "Address Incomplete"};
		const StatusLine c_statusLine485	:=	{c_sipNameVersion, 485, "Ambiguous"};
		const StatusLine c_statusLine486	:=	{c_sipNameVersion, 486, "Busy Here"};
		const StatusLine c_statusLine487	:=	{c_sipNameVersion, 487, "Request Terminated"};
		const StatusLine c_statusLine488	:=	{c_sipNameVersion, 488, "Not acceptable here"};
		const StatusLine c_statusLine493	:=	{c_sipNameVersion, 493, "Undecipherable"};
		const StatusLine c_statusLine500	:=	{c_sipNameVersion, 500, "Server Internal error"};
		const StatusLine c_statusLine501	:=	{c_sipNameVersion, 501, "Not implemented"};
		const StatusLine c_statusLine502	:=	{c_sipNameVersion, 502, "Bad Gateway"};
		const StatusLine c_statusLine503	:=	{c_sipNameVersion, 503, "Service Unavailable"};
		const StatusLine c_statusLine504	:=	{c_sipNameVersion, 504, "Server timeout"};
		const StatusLine c_statusLine505	:=	{c_sipNameVersion, 505, "Version not supported"};
		const StatusLine c_statusLine513	:=	{c_sipNameVersion, 513, "Message too long"};
		const StatusLine c_statusLine580	:=	{c_sipNameVersion, 580, "Precondition failure"};
		const StatusLine c_statusLine600	:=	{c_sipNameVersion, 600, "Busy Everywhere"};
		const StatusLine c_statusLine603	:=	{c_sipNameVersion, 603, "Decline"};
		const StatusLine c_statusLine604	:=	{c_sipNameVersion, 604, "Does not exist anywhere"};
		const StatusLine c_statusLine606	:=	{c_sipNameVersion, 606, "Not acceptable"};
		
} //end StatusLines

group SIPSyncPointNames {
		const charstring c_Ringing := "Ringing";
		const charstring c_uPlane := "uPlane";
		const charstring c_sync1 := "sync1";
		const charstring c_sync2 := "sync2";
		const charstring c_sync3 := "sync3";
 		const charstring c_uPlaneStop := "uPlaneStop";
		const charstring c_annoucA := "announcementA";
		const charstring c_annoucB := "announcementB";
		const charstring c_annouc := "announcement";
		const charstring c_voicem := "voiceMessage";
 }

} //end group Constants

group Types {
group SubTypes{// Subtypes
    
    group TokenTypes // TokensTypes
    {
      // [20]
      type enumerated FieldName
      {
        ACCEPT_E,
        ACCEPT_ENCODING_E,
        ACCEPT_LANGUAGE_E,
        ALERT_INFO_E,
        ALLOW_E,
        AUTHENTICATION_INFO_E,
        AUTHORIZATION_E,
        CALL_ID_E,
        CALL_INFO_E,
        CONTACT_E,
        CONTENT_DISPOSITION_E,
        CONTENT_ENCODING_E,
        CONTENT_LANGUAGE_E,
        CONTENT_LENGTH_E,
        CONTENT_TYPE_E,
        CSEQ_E,
        DATE_E,
        ERROR_INFO_E,
        EXPIRES_E,
        FROM_E,
        IN_REPLY_TO_E,
        MAX_FORWARDS_E,
        MIME_VERSION_E,
        MIN_EXPIRES_E,
        ORGANIZATION_E,
        PRIORITY_E,
        PROXY_AUTHENTICATE_E,
        PROXY_AUTHORIZATION_E,
        PROXY_REQUIRE_E,
        RECORD_ROUTE_E,
        REPLY_TO_E,
        REQUIRE_E,
        RETRY_AFTER_E,
        ROUTE_E,
        SERVER_E,
        SUBJECT_E,
        SUPPORTED_E,
        TIMESTAMP_E,
        TO_E,
        UNSUPPORTED_E,
        USER_AGENT_E,
        VIA_E,
        WARNING_E,
        WWW_AUTHENTICATE_E,
        
		// [3262/7.1]
		RACK_E,
		RSEQ_E,
		
		// [3265/7.2]
		ALLOW_EVENTS_E,
		EVENT_E,
		SUBSCRIPTION_STATE_E,
		
		// [3313]
		P_MEDIA_AUTHORIZATION_E,
		
		// [3323]
		PRIVACY_E,
		
		// [3325]
		P_ASSERTED_ID_E,
		P_PREFERRED_ID_E, 
		       
		// [3326]
		REASON_E,

		// [3515] - REFER method
		REFER_TO_E,
		
		// [3891] 
		REPLACES_E,

		// [3892] - REFER method
		REFERRED_BY_E,
		
		// [4244]
		HISTORY_INFO_E,
		
		// [3313]
		P_MEDIA_AUTH_E,
		
		// [3327]
		PATH_E,	
		
		// [3329]
		SECURITY_CLIENT_E,	
		SECURITY_SERVER_E,
		SECURITY_VERIFY_E,  
		 
		// [3455]
		P_ACCESS_NETWORK_INFO_E,
		P_ASSOCIATED_URI_E,
		P_CALLED_PARTY_E,
		P_CHARGING_FUNCTION_ADDRESSES_E,
		P_CHARGING_VECTOR_E,
		P_VISITED_NETWORK_E,
		
		// [3608]
		SERVICE_ROUTE_E,
		
		// [3841]
		ACCEPT_CONTACT_E,
		
		// [4028]
		MIN_SE_E,
		SESSION_EXPIRES_E,
	
		P_ASSERTED_SERVICE_E,
		
		//[5009]
		P_EARLY_MEDIA_E,
		
		//http://tools.ietf.org/html/draft-johnston-sipping-cc-uui-07
		//Transporting User to User Call Control Information in SIP for ISDN Interworking
		USER_TO_USER_E
		
      }
      
	  // [7.1]
	  type enumerated Method {
		  ACK_E,
		  BYE_E,
		  CANCEL_E,
		  INVITE_E,
		  OPTIONS_E,
		  REGISTER_E,
		  PRACK_E, // Note: this element is not defined in [5]
		  SUBSCRIBE_E, NOTIFY_E, // [3265]
		  PUBLISH_E, // [3903/12]
		  REFER_E, // [3515]
		  UPDATE_E, // [3311]
		  MESSAGE_E, // [3428]
		  INFO_E	// [2976]
		  }
	        
      // [20.1, 20.3, 20.4, 20.7, 20.9, 20.10, 20.11, 20.18, 20.20, 20.27, 20.28, 20.30, 20.31,
      // 20.33, 20.34, 20.39, 20.42, 20.44]
      type record GenericParam
      {
        charstring                 id,
        charstring                paramValue optional
      }
      
      // [?]
      type set of GenericParam SemicolonParam_List;
      
      // [?]
      type set of GenericParam AmpersandParam_List;
      
      // [?]
      type set of GenericParam CommaParam_List;
      
      // [20.10, 20.20, 20.30, 20.31, 20.34, 20.39, 20.42, 20.43]
      type record HostPort
      {
        charstring             host optional,                // hostname, IPv4 or IPv6
        integer                portField optional        // represented as an integer
      }
      
      // [20.10, 20.20, 20.30, 20.31, 20.34, 20.39]
/**
 * 
 * @desc identifier for user or telephone subscriber
 * @member userOrTelephoneSubscriber provides the username or a phone name identifying the subscriber
 * @member password related password information
 * 
 */
     type record UserInfo
      {
        charstring	       userOrTelephoneSubscriber,
        charstring	       password optional
      }
      
      // [19.1.1 ;used in: 20.10, 20.20, 20.30, 20.31, 20.34, 20.39]


/**
 * 
 * @desc Uniform Resource Identifier (URI)
 * @member scheme distinguishes call types, e.g. voice, fax etc. or related address scheme, e.g. tel, sip
 * @member userInfo Contains user information (also in non-SIP URLs) with optional parameter as passwords
 * @member hostPort Hostname or IP address information and port identifier of the target
 * @member urlParameters Contains either SIP or TEL URL parameters, separated by semicolons, e.g. transport=tcp or user=phone
 * @member headers Additional information added after the parameters, e.g. priority=urgent
 */
      type record SipUrl
      {
        charstring		scheme,  // e.g "sip" or "tel"
        UserInfo		userInfo optional,
        HostPort		hostPort optional,
        SemicolonParam_List	urlParameters optional,
        AmpersandParam_List	headers optional
      }
      
      // [20.1, RFC2616 14.1]
      type record AcceptBody
      {
        charstring 		mediaRange,
        SemicolonParam_List	acceptParam optional
      }
      
      // [20.1, RFC2616 14.1]
      type set of AcceptBody AcceptBody_List;
      
      // [20.4]
      type record AlertInfoBody
      {
        charstring			url,	// any URI
        SemicolonParam_List	genericParams optional
      }
      
      // [20.4]
      type set of AlertInfoBody AlertInfoBody_List;
      
      // [20.8]
      type charstring CallidString;    // token ["@" token]
      
      // [20.8]
      type set of CallidString CallidString_List;
      
      // [20.9]
      type record CallInfoBody
      {
        charstring	 		url,	// any URI
        SemicolonParam_List		infoParams optional
      }
      
      // [20.9]
      type set of CallInfoBody CallInfoBody_List;
      
      // [20.27, 20.44, .......10.32, 10.48; RFC2616 14.33, 14.47; RFC2617 1.2]
      type union Challenge
      {
        CommaParam_List digestCln,
        OtherAuth	otherChallenge
      }
      
      // [20.10, 20.20, 20.30, 20.31, 20.34, 20.39]
      type record NameAddr
      {
        charstring	displayName optional,
        SipUrl		addrSpec
      }
      
      // [20.10, 20.20, 20.31, 20.39]
      type union Addr_Union
      {
        NameAddr	nameAddr,
        SipUrl		addrSpecUnion // STS: "Union" added to filed name to avoid dangerous name equivalence with 2nd NameAddr field
      }
      
      // [20.10]
      type record ContactAddress
      {
        Addr_Union 		addressField,
        SemicolonParam_List	contactParams optional
      }
      
      // [20.10]
      type set of ContactAddress ContactAddress_List; // 1 or more elements
      
      // [20.10]
      type union ContactBody
      {
        charstring		wildcard,
        ContactAddress_List	contactAddresses
      }
      
      // [20.2, 20.12; RFC2616 14.3, 14.11]
      type charstring ContentCoding;
      
      // [20.2, 20.12; RFC2616 14.3, 14.11]
      type set of ContentCoding ContentCoding_List;
      
      // [20.7, 20.28; RFC2616 14.35 RFC2617 1.2]
      type union Credentials
      {
        CommaParam_List	digestResponse,
        OtherAuth  	    otherResponse
      }
      
      // allow multiple Authorization headers due to RFC3261 ch. 20.7 and 20.28
	  type record of Credentials CredentialsList;
      
      // [20.19, 20.23, 20.33]
      type charstring	DeltaSec;	// an external operation can handle this field
      
      // [20.18]
      type record ErrorInfoBody
      {
        charstring			uri,		// any URI
        SemicolonParam_List		genericParams optional
      }
      
      // [20.18]
      type set of ErrorInfoBody ErrorInfoBody_List;
      
      // [20.3 RFC2616 14.4]
      type record LanguageBody
      {
        charstring 		languageRange,
        SemicolonParam_List	acceptParam optional
      }
      
      // [20.3 RFC2616 14.4]
      type set of LanguageBody LanguageBody_List;
      
      // [20.13; RFC2616 14.12]
      type charstring LanguageTag;
      
      // [20.13; RFC2616 14.12]
      type set of LanguageTag LanguageTag_List;
      
      // [20.5]
      type set of charstring Method_List;
      
      
      // [20.29, 20.32, 20.37, 20.40]
      type charstring OptionTag;
      
      // [20.29, 20.32, 20.37, 20.40]
      type set of OptionTag OptionTag_List;
      
      
      // [20.7, 20.27, 20.28, 20.44  ; RFC2616 14.33, 14.47; RFC2617 1.2]
      type record OtherAuth
      {
        charstring		authScheme,
        CommaParam_List	authParams
      }
      
      type record Payload
      {
        integer		payloadlength,
        charstring 		payloadvalue
      }
      
      // [20.30,20.34]
      type record RouteBody
      {
        NameAddr			nameAddr,
        SemicolonParam_List	rrParam optional
      }
      
      // [20.30,20.34]
      type record of RouteBody RouteBody_List;
      
      // [20.42]
      type record SentProtocol
      {
        charstring		protocolName,
        charstring		protocolVersion,
        charstring		transport
      }
      
      // [20.35, 20.41; RFC2616 14.43]
      type charstring ServerVal;
      
      // [20.35, 20.41; RFC2616 14.43]
      type set of ServerVal ServerVal_List;
      
      // [20.38]
      type record TimeValue
      {
        integer			majorDigit,		// represented as an integer
        integer			minorDigit optional	// represented as an integer
      }
      
      // [20.42]
      type record ViaBody
      {
        SentProtocol	sentProtocol,
        HostPort		sentBy,
        SemicolonParam_List	viaParams optional
      }
      
      // [20.42]
      type record of ViaBody ViaBody_List;
      
      // [20.43]
      type union WarnAgent
      {
        HostPort		hostPort,
        charstring		pseudonym
      }
      
      // [20.43]
      type record WarningValue
      {
        integer		warnCode,	// represented as an integer
        WarnAgent		warnAgent,
        charstring		WarnText
      }
      
      // [20.43]
      type set of WarningValue WarningValue_List;

	  type Addr_Union PAssertedIDValue;
      
	  type record of PAssertedIDValue PAssertedIDValue_List;

	  type charstring PAssertedServiceValue;

	  type Addr_Union PPreferredIDValue;
      
	  type record of PPreferredIDValue PPreferredIDValue_List;

	  type charstring PrivacyValue;
      
	  type record of PrivacyValue PrivacyValue_List;

      
    } // end group TokensType
    
    
    group HeaderFieldTypes  // Header Fields
    {
	group CommonHeaderFieldTypes
    {
      // [20.1, RFC2616 14.1]
      type record Accept
      {
        FieldName		fieldName (ACCEPT_E),
        AcceptBody_List	        acceptArgs optional
      }
      
      // [20.2, RFC2616 14.3]
      type record AcceptEncoding
      {
        FieldName		fieldName (ACCEPT_ENCODING_E),
        ContentCoding_List	contentCoding optional
      }
      
      // [20.3, RFC2616 14.4]
      type record AcceptLanguage
      {
        FieldName		fieldName (ACCEPT_LANGUAGE_E),
        LanguageBody_List	languageBody optional
      }
      
      // [20.4]
      type record AlertInfo
      {
        FieldName		fieldName (ALERT_INFO_E),
        AlertInfoBody_List	alertInfoBody optional
      }
      
      // [20.5]
      type record Allow
      {
        FieldName		fieldName (ALLOW_E),
        Method_List		methods optional
      }
      
      // [20.6]
      type record AuthenticationInfo
      {
        FieldName		fieldName (AUTHENTICATION_INFO_E),
        CommaParam_List	ainfo
      }
      
      // [20.7 RFC2617 3.2.2]
      type record Authorization
      {
        FieldName		fieldName (AUTHORIZATION_E),
		CredentialsList	body // changed from Credentials to allow multiple Authorization headers
      }
      
      // [20.8]
      type record CallId
      {
        FieldName		fieldName (CALL_ID_E),
        CallidString       	callid
      }
      
      // [20.9]
      type record CallInfo
      {
        FieldName		fieldName (CALL_INFO_E),
        CallInfoBody_List	callInfoBody optional
      }
      
      // [20.10]
      type record Contact
      {
        FieldName		fieldName (CONTACT_E),
        ContactBody		contactBody
      }
      
      // [20.11]
      type record ContentDisposition
      {
        FieldName		fieldName (CONTENT_DISPOSITION_E),
        charstring		dispositionType,
        SemicolonParam_List	dispositionParams optional
      }
      
      // [20.12 RFC2616 14.11]
      type record ContentEncoding
      {
        FieldName		fieldName (CONTENT_ENCODING_E),
        ContentCoding_List	contentCoding
      }
      
      // [20.13 RFC2616 14.12]
      type record ContentLanguage
      {
        FieldName		fieldName (CONTENT_LANGUAGE_E),
        LanguageTag_List	languageTag
      }
      
      // [20.14]
      type record ContentLength
      {
        FieldName		fieldName (CONTENT_LENGTH_E),
        integer		len	// this field is represented as an integer
      }
      
      // [20.15]
      type record ContentType
      {
        FieldName		fieldName (CONTENT_TYPE_E),
        charstring		mediaType
      }
      
      // [20.16]
      type record CSeq
      {
        FieldName		fieldName (CSEQ_E),
        integer		seqNumber,	// this field is represented as an integer
        charstring   	method
      }
      
      // [20.17]
      type record Date
      {
        FieldName		fieldName (DATE_E),
        charstring		sipDate
      }
      
      // [20.18]
      type record ErrorInfo
      {
        FieldName		fieldName (ERROR_INFO_E),
        ErrorInfoBody_List	errorInfo optional
      }
      
      // [20.19]
      type record Expires
      {
        FieldName		fieldName (EXPIRES_E),
        DeltaSec		deltaSec
      }
      
      // [20.20]
      type record From
      {
        FieldName		fieldName (FROM_E),
        Addr_Union    	addressField,
        SemicolonParam_List	fromParams optional
      }
      
      // [20.21]
      type record InReplyTo
      {
        FieldName		fieldName (IN_REPLY_TO_E),
        CallidString_List	callids
      }
      
      // [20.22]
      type record MaxForwards
      {
        FieldName		fieldName (MAX_FORWARDS_E),
        integer		forwards	// this field is represented as an integer
      }
      
      // [20.23]
      type record MinExpires
      {
        FieldName		fieldName (MIN_EXPIRES_E),
        DeltaSec		deltaSec
      }
      
      // [20.24 RFC2616 19.4.1]
      type record MimeVersion
      {
        FieldName		fieldName (MIME_VERSION_E),
        integer		majorNumber,	// this field is represented as an integer
        integer		minorNumber	// this field is represented as an integer
      }
      
      // [20.25]
      type record Organization
      {
        FieldName		fieldName (ORGANIZATION_E),
        charstring		organization
      }
      
      // [20.26]
      type record Priority
      {
        FieldName		fieldName (PRIORITY_E),
        charstring		priorityValue
      }
      
      // [20.27 RFC2616 14.33 RFC2617 1.2]
      type record ProxyAuthenticate
      {
        FieldName		fieldName (PROXY_AUTHENTICATE_E),
        Challenge		challenge
      }
      
      // [20.28 RFC2616 14.35 RFC2617 1.2]
      type record ProxyAuthorization
      {
        FieldName		fieldName (PROXY_AUTHORIZATION_E),
        CredentialsList		credentials // changed from Credentials to allow multiple Authorization headers
      }
      
      // [20.29]
      type record ProxyRequire
      {
        FieldName		fieldName (PROXY_REQUIRE_E),
        OptionTag_List	optionsTags
      }
      
      // [20.30]
      type record RecordRoute
      {
        FieldName		fieldName (RECORD_ROUTE_E),
        RouteBody_List	routeBody
      }
      
      // [20.31]
      type record ReplyTo
      {
        FieldName		fieldName (REPLY_TO_E),
        Addr_Union    	addressField,
        SemicolonParam_List	replyToParams optional
      }
      
      // [20.32]
      type record Require
      {
        FieldName		fieldName (REQUIRE_E),
        OptionTag_List	optionsTags
      }
      
      // [20.33]
      type record RetryAfter
      {
        FieldName		fieldName (RETRY_AFTER_E),
        DeltaSec    	deltaSec,
        charstring		comment optional,
        SemicolonParam_List	retryParams optional
      }
      
      // [20.34]
      type record Route
      {
        FieldName		fieldName (ROUTE_E),
        RouteBody_List	routeBody
      }
      
      // [20.35 RFC2616 14.38]
      type record Server
      {
        FieldName		fieldName (SERVER_E),
        ServerVal_List	serverBody
      }
      
      // [20.36]
      type record Subject
      {
        FieldName		fieldName (SUBJECT_E),
        charstring		summary
      }
      
      // [20.37]
      type record Supported
      {
        FieldName		fieldName (SUPPORTED_E),
        OptionTag_List	optionsTags optional
      }
      
      // [20.38]
      type record Timestamp
      {
        FieldName		fieldName (TIMESTAMP_E),
        TimeValue		timeValue optional,
        TimeValue		delay optional
      }
      
      // [20.39]
      type record To
      {
        FieldName		fieldName (TO_E),
        Addr_Union      	addressField,
        SemicolonParam_List	toParams optional
      }
      
      // [20.40]
      type record Unsupported
      {
        FieldName		fieldName (UNSUPPORTED_E),
        OptionTag_List		optionsTags
      }
      
      // Undefined header field
      type record UndefinedHeader
      {
        charstring		headerName,
        charstring		headerValue
      }
      
      type set of UndefinedHeader UndefinedHeader_List;
      
      // [20.41 RFC2616 14.43]
      type record UserAgent
      {
        FieldName		fieldName (USER_AGENT_E),
        ServerVal_List 	userAgentBody
      }
      
      // [20.42]
      type record Via
      {
        FieldName		fieldName (VIA_E),
        ViaBody_List		viaBody
      }
      
      // [20.43]
      type record Warning
      {
        FieldName		fieldName (WARNING_E),
        WarningValue_List	warningValue
      }
      
      // [20.44 RFC2616 14.47 RFC2617 1.2]
      type record WwwAuthenticate
      {
        FieldName		fieldName (WWW_AUTHENTICATE_E),
        Challenge		challenge
      }
      }//end group CommonHeaderFieldTypes
	  group RFC3262HeaderFieldTypes
	  {
	  // [3262/7.1]
	  type record RSeq {
		  FieldName fieldName(RSEQ_E),
		  integer responseNum
	  }

	  // [3262/7.2]
	  type record RAck {
		  FieldName fieldName(RACK_E),
		  integer responseNum,
		  integer seqNumber,
		  charstring method
	  }
	  }//end group RFC3262HeaderFieldTypes

	  group RFC3265HeaderFieldTypes
	  {
	  // [3265/7.2]
	  type record AllowEvents {
		  FieldName fieldName(ALLOW_EVENTS_E),
		  EventType_List eventTypes
	  }
	  
	  type set of EventType EventType_List;
	  type charstring EventType;
	  
	  // [3265/7.2]
	  type record Event {
		  FieldName fieldName(EVENT_E),
		  EventType eventType,
		  SemicolonParam_List eventParams optional
	  }
	  
	  // [3265/7.2]
	  type record SubscriptionState {
		  FieldName fieldName(SUBSCRIPTION_STATE_E),
		  SubState subState,
		  SemicolonParam_List substateParams optional
	  }
	  
	  type charstring SubState;
	  }//end group RFC3265HeaderFieldTypes	

	  group RFC3313HeaderFieldTypes
	  {
	  // [3313/5]
	  type record PMediaAuthorization {
		  FieldName fieldName(P_MEDIA_AUTHORIZATION_E),
		  PMediaAuthorization_List pMediaAuthorizations
	  }
			
	  type charstring PMediaAuthValue; //HEXDIG "0"-"9", "A"-"F"
	  
	  type record of PMediaAuthValue PMediaAuthorization_List;
	  
	  }//end group RFC3265HeaderFieldTypes

	  group RFC3323HeaderFieldTypes
	  {
	  // [3323]
	  type record Privacy {
		  FieldName fieldName(PRIVACY_E),
		  PrivacyValue_List privValueList
	  }   
	  }//end group RFC3323HeaderFieldTypes     

	  group RFC3325HeaderFieldTypes
	  {
	  // [3325]
	  type record PAssertedID {
		  FieldName fieldName(P_ASSERTED_ID_E),
		  PAssertedIDValue_List pAssertedIDValueList
	  }

	  // [3325]
	  type record PPreferredID {
		  FieldName fieldName(P_PREFERRED_ID_E),
		  PPreferredIDValue_List pPreferredIDValueList
	  }
      }//end group RFC3325HeaderFieldTypes
	  
	  group RFC3326HeaderFieldTypes
	  {
	  //[3326]
	  type record of ReasonValue ReasonValues;
	  
	  type record ReasonValue {
	  charstring token,
	  SemicolonParam_List reasonParams optional
  	  } 	  
	  
	  type record Reason {
	  FieldName fieldName(REASON_E),
	  ReasonValues reasonValues
	  }
	  }//end group RFC3326HeaderFieldTypes
	  
	  group RFC3327HeaderFieldTypes
	  {	  
	  // [3327]
	  type record Path {
		  FieldName fieldName(PATH_E),
		  PathValues pathValues
	  }
	  
	  type record of PathValue PathValues;

	  type record PathValue {
		  NameAddr nameAddr,
		  SemicolonParam_List rrParam optional
	  }
	  }//end group RFC3515HeaderFieldTypes
	  
	  group RFC3329HeaderFieldTypes
	  {			
	  // [RFC3329/2.2]
	  type record SecurityMechanism {
		charstring mechName,
		SemicolonParam_List mechParams optional
	  }

	  type set of SecurityMechanism SecurityMechanism_List;
			
	  type record SecurityClient {
		FieldName fieldName(SECURITY_CLIENT_E),
		SecurityMechanism_List securityMech
	  }

	  type record SecurityServer {
		FieldName fieldName(SECURITY_SERVER_E),
		SecurityMechanism_List securityMech
	  }

	  type record SecurityVerify {
		FieldName fieldName(SECURITY_VERIFY_E),
		SecurityMechanism_List securityMech
	  }
	  }//end group RFC3329HeaderFieldTypes
	  
	  group RFC3455HeaderFieldTypes
	  {	  
	  type record of NameAddrParam NameAddrParam_List;

	  type record NameAddrParam {
		  NameAddr nameAddr,
		  SemicolonParam_List genericParams optional
	  }
	  //[3455/5.1]
	  type record PAssociatedURI {
		FieldName fieldName(P_ASSOCIATED_URI_E),
		NameAddrParam_List nameAddrList
	  }	  
	  //[3455/5.2]
	  type record PCalledPartyID {
		  FieldName fieldName(P_CALLED_PARTY_E),
		  NameAddrParam nameAddParams
	  }

	  type record of VnetworkSpec VnetworkSpec_List;

	  type record VnetworkSpec {
		charstring vNetworkSpecToken,
		SemicolonParam_List genericParams optional
	  }
	  
	  //[3455/5.3]
	  type record PVisitedNetworkID {
		FieldName fieldName(P_VISITED_NETWORK_E),
		VnetworkSpec_List vNetWorkSpec
	  }
	  
	  //[3455/5.4]
	  type record PAccessNetworkInfo {
		FieldName fieldName(P_ACCESS_NETWORK_INFO_E),
		charstring accessType,
		SemicolonParam_List genericParams optional
	  }
	  
	  //[3455/5.5]			
	  type record PChargingFunctionAddresses {
		FieldName fieldName(P_CHARGING_FUNCTION_ADDRESSES_E),
		SemicolonParam_List chargeAddrParams optional
	  }
				
	  //[3455/5.6] 
	  type record PChargingVector {
		FieldName fieldName(P_CHARGING_VECTOR_E),
		SemicolonParam_List chargeParams optional
	  }
	  }//end group RFC33455HeaderFieldTypes
	  
	  group RFC3515HeaderFieldTypes
	  {
	  // [3515]
	  type record ReferTo {
		  FieldName fieldName(REFER_TO_E),
		  NameAddr nameAddr,
		  SemicolonParam_List referToParams optional
	  }
	  }//end group RFC3515HeaderFieldTypes

	  group RFC3608HeaderFieldTypes
	  {
	  // [3608]
	  type record ServiceRoute {
		FieldName fieldName(SERVICE_ROUTE_E),
		RouteBody_List	routeBody
	  }
	  }//end group RFC33608HeaderFieldTypes
	  

	  group RFC3841HeaderFieldTypes
	  {
	  // [3841]
	  type record AcceptContact {
		  FieldName fieldName(ACCEPT_CONTACT_E),
		  AcRcValue_List acValues
	  }

	  type set of AcRcValue AcRcValue_List;

	  type record AcRcValue {
		  charstring wildcard(c_WILDCARD),
		  SemicolonParam_List acRcParams optional
	  }	  	  
	  }// end group RFC3841HeaderFieldTypes

	  group RFC3891HeaderFieldTypes
	  {
	  // [3891]
      type record Replaces
      {
        FieldName			fieldName (REPLACES_E),
		SemicolonParam_List replacesParams
      }
      }// end group RFC3891HeaderFieldTypes
      
	  group RFC3892HeaderFieldTypes
	  {
	  // [3892]
	  type record ReferredBy {
		  FieldName fieldName(REFERRED_BY_E),
		  NameAddr nameAddr,
		  SemicolonParam_List referredbyIdParams optional
	  }
	  }//end group RFC3892HeaderFieldTypes

	  group RFC4028HeaderFieldTypes
	  {
	  // [4028]				
	  type record MinSE {
		FieldName fieldName(MIN_SE_E),
		DeltaSec deltaSec,
		SemicolonParam_List minSeParam optional
	  }
	  // [4028]
	  type record SessionExpires {
		FieldName fieldName(SESSION_EXPIRES_E),
		DeltaSec deltaSec,
		SemicolonParam_List seParam optional
	  }
	  }//end group RFC4028HeaderFieldTypes
	  
	  group RFC4244HeaderFieldTypes
	  {
	  // [4244]
	  type record HistoryInfo {
		  FieldName fieldName(HISTORY_INFO_E),
		  HistoryInfo_List historyInfoList
	  }

	  type record of HistoryInfoEntry HistoryInfo_List;

	  type record of integer IntegerList;

	  type record HistoryInfoEntry {
		  NameAddr nameAddr,
		  IntegerList hiIndex optional,
		  SemicolonParam_List hiExtention optional
	  }
	  }//end group RFC4244HeaderFieldTypes
	  
	  group RFC5009PEarlyMediaHeader
	  {
	  // [5009]
	  type record PEarlyMedia {
		  FieldName fieldName(P_EARLY_MEDIA_E),
		  EM_List em_param
	  }
	  type record of charstring EM_List; 
	  }//end group RFC5009PEarlyMediaHeader

      //http://tools.ietf.org/html/draft-johnston-sipping-cc-uui-07, expires 16.Aug.2009
      //Transporting User to User Call Control Information in SIP for ISDN Interworking
      //type definition of SIP header mechanism 
      group UserToUser_PreliminaryRFCDraft
      {
      	type record UserToUser{
			FieldName fieldName (USER_TO_USER_E),
			charstring  uuiData length(256), /*length limitation due to ISDN, max of allowed 128 hex digits are represented by 256 characters*/
			GenericParam uuiParam
      	}

      }//end group UserToUser_PreliminaryRFCDraft

	  type record PAssertedService {
		  FieldName fieldName(P_ASSERTED_SERVICE_E),
		  PAssertedServiceValue pAssertedServiceValue
	  }

    } // end group HeaderFieldTypes
    
    group MessageHeaderTypes
    {
      
      // Message-Header for all SIP requests and responses [20]
      type set MessageHeader
      {
        Accept				accept optional,
		AcceptContact		acceptContact optional,
        AcceptEncoding		acceptEncoding optional,
        AcceptLanguage		acceptLanguage optional,
        AlertInfo			alertInfo optional,
        Allow				allow optional,
		AllowEvents 		allowEvents optional, // 3265/7.2
        AuthenticationInfo	authenticationInfo optional, // only in responses
        Authorization		authorization optional, // only in requests
        CallId				callId optional, // optional only in Invalid test cases mandatory otherwise
        CallInfo			callInfo optional,
        Contact				contact optional, // optional in response and all requests except INVITE where mandatory
        ContentDisposition	contentDisposition optional,
        ContentEncoding		contentEncoding optional,
        ContentLanguage		contentLanguage optional,
        ContentLength		contentLength optional, // optional in responses and all requests except ACK where mandatory
        ContentType			contentType optional,
        CSeq				cSeq optional, // optional only in Invalid test cases mandatory otherwise
        Date				date optional,
        ErrorInfo 			errorInfo optional, // only in responses
		Event 				event optional, // 3265/7.2
        Expires 			expires optional,
        From				fromField,
		HistoryInfo 		historyInfo optional, // 4244
        InReplyTo 			inReplyTo optional, // only in requests
        MaxForwards			maxForwards optional, // mandatory in requests not required in responses!
        MimeVersion			mimeVersion optional,
        MinExpires			minExpires optional, // only in responses
		MinSE 				minSE optional, // 4028
        Organization		organization optional,
		PAccessNetworkInfo 	pAccessNetworkInfo optional, // 3455
		PAssertedID 		pAssertedID optional, // 3325
		PAssertedService	pAssertedService optional,
		PAssociatedURI		pAssociatedURI optional, // 3455
		Path 				path optional, // 3327
		PCalledPartyID 		pCalledPartyID optional, // 3455
		PChargingFunctionAddresses pChargingFunctionAddresses optional, // 3455
		PChargingVector 	pChargingVector optional, // 3455
		PEarlyMedia			pEarlyMedia	optional, // 5009
		PMediaAuthorization pMediaAuthorization optional, // 3313
		PPreferredID 		pPreferredID optional, // 3325
        Priority 			priority optional,  // only in requests
		Privacy 			privacy optional, // 3323
        ProxyAuthenticate	proxyAuthenticate optional, // only in responses
        ProxyAuthorization	proxyAuthorization optional, // only in requests
        ProxyRequire		proxyRequire optional, // only in requests
		PVisitedNetworkID 	pVisitedNetworkID optional, // 3455
		RAck 				rAck optional, // 3262/7.1
		RSeq 				rSeq optional, // 3262/7.1
		Reason 				reason optional, // 3326
        RecordRoute			recordRoute optional,
		ReferredBy 			referredBy optional, // 3892 - REFER method	
		ReferTo 			referTo optional, // 3515 - REFER method
		Replaces			replaces optional, // 3891
        ReplyTo				replyTo optional, // optional in responses and INVITE requests
        Require 			require optional,
        RetryAfter			retryAfter optional, // only in responses
        Route 				route optional, // only in requests
		SecurityClient 		securityClient optional, // 3329
		SecurityServer 		securityServer optional, // 3329
		SecurityVerify 		securityVerify optional, // 3329
        Server				server optional, // only in responses
		ServiceRoute 		serviceRoute optional, // 3608
		SessionExpires 		sessionExpires optional, // 4028
        Subject				subject optional, // only in requests
		SubscriptionState 	subscriptionState optional, // 3265/7.2
        Supported 			supported optional,
        Timestamp 			timestamp optional,
        To					toField,
        Unsupported			unsupported optional, // only in responses
		UserToUser          userToUser optional,
        UserAgent 			userAgent optional,
        Via					via,
        Warning				warning optional, // only in responses
        WwwAuthenticate		wwwAuthenticate optional, // only in responses
        UndefinedHeader_List	undefinedHeader_List optional
      }
      
    } // end group MessageHeaderTypes
    
    group StartLineTypes
    {
      // Request-Line [7.1]
      type record RequestLine
      {
        Method			method,
        SipUrl			requestUri,
        charstring		sipVersion
      }
      
      // Status-Line [7.2]
      type record StatusLine
      {
        charstring		sipVersion,
        integer			statusCode,
        charstring		reasonPhrase
      }
      
    } // end group StartLineTypes
    
    
    group otherTypes{
    
    type record SipUserProfile
    {	
		/** @desc	integer for the userprofile identifier
		 */		
		integer		id,

		/** @desc	integer for Port number to exchange SIP messages
		*/
		integer     currPort,

		/** @desc	charstring for IP address to exchange SIP messages
		*/
		charstring  currIpaddr,		
		
		/** @desc	integer for Port number to exchange SIP messages
		*/
		integer     contactPort,

		/** @desc	charstring for IP address to exchange SIP messages
		*/
		charstring  contactIpaddr,

		/** @desc	charstring for IP address used by the TS to exchange media streams
		*/
		charstring  bearerIpaddr,

		/** @desc	charstring for identity of the tester local domain
		*/
		charstring  homeDomain,

		/** @desc	charstring for identity of the tester local user
		*/
		charstring  publUsername,
		
		/** @desc	charstring for RFC 2617 3.2.1 qop options:
		* Quoted string of one or more tokens indicating the "quality of protection" values supported by the server. The
		* value "auth" indicates authentication; the value "auth-int" indicates authentication with integrity protection.
		*/
		charstring qop,

		/** @desc	charstring for RFC 2617 3.2.2 username for authentication
		* The name of user in the specified realm
		*/
		charstring privUsername,

		/** @desc	charstring for RFC 2617 3.2.2.2 passwd: A known shared secret, the password of user of the specified username
		*/
		charstring passwd,

		/** @desc	charstring for registrar domain for authentication and request line
		*/
		charstring registrarDomain
    	
    }
    
    
    } // end group otherTypes
    
  }// end group Subtypes
  


  group MSGtypes{
    
    group RequestTypes
    {
      // [7.1]

	/**
	* 
	* @desc generic type of a SIP request message
	* @member statusLine contains a method name, a Request-URI, and the protocol version
	* @member msgHeader include all possible header fields that are allowed to be present according to RFCs and other standards
	* @member messageBody depends on the request method, includes e.g. SDP message.
	* @member payload  contains the whole message as it has been received in its text format
	*/	
      type record Request
      {
        RequestLine		requestLine,
        MessageHeader 	msgHeader,
		MessageBody		messageBody optional,
        Payload			payload	    optional
      } 
      
      // Note: the introduction of the following  specific types is to enable better means for logging
      //       on the other side the generic type is useful for functions dealing with multiple SIP message types
      
	  type record REGISTER_Request {
		RequestLine 	requestLine,
		MessageHeader 	msgHeader,
		MessageBody 	messageBody optional,
		Payload 		payload optional
	  }

	  type record INVITE_Request {
		RequestLine 	requestLine,
		MessageHeader 	msgHeader,
		MessageBody 	messageBody optional,
		Payload 		payload optional
	  }
	  
	  type record OPTIONS_Request {
		RequestLine 	requestLine,
		MessageHeader 	msgHeader,
		MessageBody 	messageBody optional,
		Payload 		payload optional
	  }

	  type record BYE_Request {
		RequestLine 	requestLine,
		MessageHeader 	msgHeader,
		MessageBody 	messageBody optional,
		Payload 		payload optional
	  }

	  type record CANCEL_Request {
		RequestLine 	requestLine,
		MessageHeader 	msgHeader,
		MessageBody 	messageBody optional,
		Payload 		payload optional
	  }
	  
	  type record ACK_Request {
		RequestLine 	requestLine,
		MessageHeader 	msgHeader,
		MessageBody 	messageBody optional,
		Payload 		payload optional
	  }

	  // [3262/7.1]
	  type record PRACK_Request {
		RequestLine 	requestLine,
		MessageHeader 	msgHeader,
		MessageBody 	messageBody optional,
		Payload 		payload optional
	  }

	  // [3265/7.1]
	  type record NOTIFY_Request {
		RequestLine 	requestLine,
		MessageHeader 	msgHeader,
		MessageBody 	messageBody optional,
		Payload 		payload optional
	  }

	  // [3265/7.1]
	  type record SUBSCRIBE_Request {
		RequestLine 	requestLine,
		MessageHeader 	msgHeader,
		MessageBody 	messageBody optional,
		Payload 		payload optional
	  }

	  // [3903/11.1]
	  type record PUBLISH_Request {
		RequestLine 	requestLine,
		MessageHeader 	msgHeader,
		MessageBody 	messageBody optional,
		Payload 		payload optional
	  }

	  //	[3311/7]
	  type record UPDATE_Request {
		RequestLine 	requestLine,
		MessageHeader 	msgHeader,
		MessageBody 	messageBody optional,
		Payload 		payload optional
	  }

	  //
	  type record REFER_Request {
		RequestLine 	requestLine,
		MessageHeader 	msgHeader,
		MessageBody 	messageBody optional,
		Payload 		payload optional
	  }

	  //
	  type record MESSAGE_Request {
		RequestLine 	requestLine,
		MessageHeader 	msgHeader,
		MessageBody 	messageBody optional,
		Payload 		payload optional
	  }

	  //
	  type record INFO_Request {
		RequestLine 	requestLine,
		MessageHeader 	msgHeader,
		MessageBody 	messageBody optional,
		Payload 		payload optional
	  }
	  
    }  with { encode "SIPCodec" }// end group RequestTypes
    
    group ResponseTypes
    {
      // [7.2]

	/**
	* 
	* @desc generic type of a SIP response message
	* @member statusLine consists of the protocol version followed by a numeric Status-Code and its associated textual phrase
	* @member msgHeader include all possible header fields that are allowed to be present according to RFCs and other standards
	* @member messageBody depends on the response method, includes e.g. SDP message.
	* @member payload  contains the whole message as it has been received in its text format
	*/
      type record Response
      {
        StatusLine		statusLine,
        MessageHeader 	msgHeader,
		MessageBody		messageBody optional,
        Payload			payload	    optional
      } 
    } with { encode "SIPCodec" }// end group ResponseTypes
    
    // This MSG type is defined for sending synctactic variations, ans syntactically
    // erroneous messages, and receving messages failed parsing.
    group SyntacticTypes
    {
      type charstring Raw;
    } // end group SyntacticTypes
    
	// This type is defined for particular SIP message body types like SDP

	group MessageBodyTypes
	{
	  type union MessageBody{
		SDP_Message sdpMessageBody, 	// if there is only SDP part
		XmlBody xmlBody,            	// if there is XML message body
  		XMLMessage xmlMessage,          // if there is XML with header&body
		MIME_Message mimeMessageBody, 	//if there is SDP and encapsulated ISUP part
		charstring sipfrag, 			// if content-Type is message/sipfrag (cp. NOTIFY, cp TS124147 A.4.3.1.2)
		charstring textplain			// if content type is text/plain (for testing long messages)
	  };
 
	} // end group MessageBodyTypes
		
 	group MIMETypes
  	{  	
	  group SubMIMETypes
	  {
    	
		type union MIME_Encapsulated_Parts {
		  SDP_Message 				sdpMessageBody,
		  XmlBody 					xmlBody,       	// if there is XML message body
		  XMLMessage 				xmlMessage		// if there is XML with header&body
		} 
		
		type record MIME_Encapsulated_Part {
		  charstring 				content_type,
		  charstring				content_disposition optional,
		  MIME_Encapsulated_Parts 	mime_encapsulated_part
		}
	  }//end group SubMIMETypes

	  group MessageTypes {
 
	    type record MIME_Message {
		  charstring boundary, // len: 
		  MimeEncapsulatedList mimeEncapsulatedList
	    }
	  
	    type record of MIME_Encapsulated_Part MimeEncapsulatedList;

	  } // group MessageTypes
    } // group MIMETypes
    
  }// end group MSGTypes
}// end group Types

} // end module LibSip_TypesAndValues