LibSip_SIPTypesAndValues.ttcn

                    // [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
                    }

                    type set of InfoPackage_Type InfoPackage_List;
                    
                    type record InfoPackage_Type {
                        charstring  infoPackageName,
                        SemicolonParam_List infoPackageParams optional
                        
                    }
                    
                    //[6086]
                    type record RecvInfo {
                        FieldName fieldName(RECV_INFO_E),
                        InfoPackage_List infoPackageList
                    }

                    //[6086]
                    type record InfoPackage {
                        FieldName fieldName(INFO_PACKAGE_E),
                        InfoPackage_Type infoPackageType
                    }

                    // [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
                    }
                    // draft-drage-sipping-service-identification-01 (July 2007)
                    type record PPreferredService {
                        FieldName fieldName (P_PREFERRED_SERVICE_E) ,
                        charstring serviceId
                    }


                } // 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 RFC4488HeaderFieldTypes {
                    // [4488 ]
                    type record ReferSub {
                        FieldName fieldName (REFER_SUB_E) ,
                        boolean referSubValue,
                        SemicolonParam_List referSubParams optional
                    }

                } // end group RFC4488HeaderFieldTypes

                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) ,
                        charstring icidValue,
                        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
                    }
                    // [RFC 3841 ]
                    type charstring Directive;
                    type set of Directive Directive_List;
                    type record RequestDisposition {
                        FieldName fieldName (REQUEST_DISPOSITION_E) ,
                        Directive_List directives
                    }


                } // end group RFC3841HeaderFieldTypes

                group RFC3891HeaderFieldTypes {
                    // [3891 ]
                    type record Replaces {
                        FieldName fieldName (REPLACES_E) ,
                        CallidString callid,
                        SemicolonParam_List replacesParams optional
                    }

                } // 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
                    }

                    type record of charstring StringList;

                } // end group RFC4244HeaderFieldTypes

                group RFC5009PEarlyMediaHeader {
                    // [5009 ]
                    type record PEarlyMedia {
                        FieldName fieldName (P_EARLY_MEDIA_E) ,
                        EM_Param_List em_param
                    }
                    type charstring EM_Param;
                    type set of EM_Param EM_Param_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
                }

                group RFC6442GeolocationConveyance {
                    // [6442 ]
                    type record Geolocation {
                        // RFC6442 clause 4.1
                        FieldName fieldName (GEOLOCATION_E) ,
                        SipUrl addrSpec,
                        SemicolonParam_List geolocParam optional
                    }
                    type enumerated GeolocationRoutingState {
                        GEOLOCATION_ROUTING_YES_E, GEOLOCATION_ROUTING_NO_E, GEOLOCATION_ROUTING_OTHER_E
                    }
                    type record GeolocationRouting {
                        // RFC6442 clause 4.2
                        FieldName fieldName (GEOLOCATION_ROUTING_E) ,
                        GeolocationRoutingState state,
                        GenericParam genericValue optional
                    }

                } // end group RFC6442GeolocationConveyance

                type charstring SessIdString  length(32);

                type record SessionId {
                    FieldName fieldName (SESSION_ID_E) ,
                    SessIdString sessid,
                    GenericParam sessidParam optional
                }

                type charstring EntityTag;

                type record SIP_ETag {
                    FieldName fieldName (SIP_ETAG_E) ,
                    EntityTag entityTag
                }

                type record SIP_If_Match {
                    FieldName fieldName (SIP_IF_MATCH_E) ,
                    EntityTag entityTag
                }

                // RFC4412
                type record ResourcePriority {
                    FieldName fieldName (RESOURCE_PRIORITY_E) ,
                    ResourcePriority_List resourcePriorityList
                }
                type set of R_Value ResourcePriority_List;
                type record R_Value {
                    charstring namespace,
                    charstring rPriority
                }
                
                // RFC5373
                type record AnswerMode {
                    FieldName fieldName (ANSWER_MODE_E),
                    AnswerMode_Value answerMode_Value,
                    SemicolonParam_List answerModeParams optional
                }
                type record PrivAnswerMode {
                    FieldName fieldName (PRIV_ANSWER_MODE_E),
                    AnswerMode_Value answerMode_Value,
                    SemicolonParam_List answerModeParams optional
                }                
                type charstring AnswerMode_Value;
               
                 // RFC4538
                type record TargetDialog {
                      FieldName fieldName (TARGET_DIALOG_E),
                      CallidString callid,
                      TdParam tdParam optional
                }
                type record TdParam {
                        charstring remoteParam optional,
                        charstring localParam optional,                        
                        SemicolonParam_List genericParams optional
                    }  

                 // RFC4964
                type record PAnswerState {
                      FieldName fieldName (P_ANSWER_STATE_E),
                      charstring answerType,
                      SemicolonParam_List genericParams optional
                }


            } // 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,
                    FeatureCaps featureCaps optional,  // 6809
                    From fromField,
                    Geolocation geolocation optional,
                    // 6442
                    GeolocationRouting geolocationRouting optional,
                    // 6442
                    HistoryInfo historyInfo optional,
                    // 4244
                    InfoPackage infoPackage optional,
                    // 6086
                    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
                    PPreferredService pPreferredService optional,
                    // draft-drage-sipping-service-identification-01 (July 2007)
                    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,
                    RecvInfo recvInfo optional,
                    // 6086
                    RequestDisposition requestDisposition optional,
                    // 3841
                    ReferredBy referredBy optional,
                    // 3892 - REFER method
                    ReferTo referTo optional,
                    // 3515 - REFER method
                    ReferSub referSub optional,
                    // 4488 - 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
                    SessionId sessionId optional,
                    SIP_ETag sipETag optional,
                    SIP_If_Match sipIfMatch optional,
                    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,
                    WwwAuthenticate wwwAuthenticate optional,
                    ResourcePriority resourcePriority optional,
                    // RFC4412
                    AnswerMode answerMode optional,
                    // RFC5373
                    PrivAnswerMode privAnswerMode optional,
                    // RFC5373
                    TargetDialog targetDialog optional,
                    // RFC4538
                    PAnswerState pAnswerState optional,
                    // RFC4964
                    // 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
                }

                type union RequestUnion {
                    REGISTER_Request Register,
                    INVITE_Request Invite,
                    OPTIONS_Request Options,
                    BYE_Request Bye,
                    CANCEL_Request Cancel,
                    ACK_Request Ack,
                    PRACK_Request Prack,
                    NOTIFY_Request Notify,
                    SUBSCRIBE_Request Subscribe,
                    PUBLISH_Request Publish,
                    UPDATE_Request Update,
                    REFER_Request Refer,
                    MESSAGE_Request Message,
                    INFO_Request Info// [2976 ]
                }

            } // 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
                }

            } // 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
        } // end group MSGTypes

    } // end group Types
}
with {
    encode "SIPCodec"; variant "";