-- IDL module extracted from ITU-T Z.166 (03/2011)

// ******************************************************************************
// * Interface definitions for the TTCN3 Control Interfaces
// ******************************************************************************

module tciInterface {

  /* Forward declaration */
  interface Value;
  interface Type;

  // ******************************************************************************
  // * Data types taken from the TRI definitions
  // ******************************************************************************

  // Connection
  native TriPortIdType ;
  native TriPortIdListType;  native TriComponentIdType ;
  native TriComponentIdListType;

  // Communications 
  native TriMessageType;
  native TriParameterType;
  native TriParameterListType;
  native TriAddressType;
  native TriAddressListType;
  native TriExceptionType;
  native TriSignatureIdType;

  // Miscellaneous
  native TriStatusType;
  native TriTimerIdType;
native TriTimerDurationType;

native TciStatusType;

  // *******************************************************************************
  // * General Abstract Data Types
  // *******************************************************************************

  // Basic definitions
  native TBoolean;
  native TFloat;
  native TChar;
  native TInteger;
  native TString;
  native TUniversalChar;
  typedef sequence <TString> TStringSeq;

  struct QualifiedName {
    TString moduleName;
    TString baseName;
  };

  // General TCI abstract data types
  typedef QualifiedName TciBehaviourIdType;
  typedef QualifiedName TciModuleIdType;
  typedef QualifiedName TciModuleParameterIdType;
  typedef QualifiedName TciTestCaseIdType;

  enum TciParameterPassingModeType {
    IN_MODE,
    OUT_MODE,
    INOUT_MODE	
  };

  struct TciParameterType {
	TciModuleParameterIdType parameterName;
    Value parameterValue;
    TciParameterPassingModeType mode;
  };

  typedef sequence <TciParameterType> TciParameterListType;

  struct TciParameterTypeType {
    Type parameterType;
    TciParameterPassingModeType mode;
  };

  typedef sequence <TciParameterTypeType> TciParameterTypeListType;

  struct TciModuleParameterType {
    TciModuleParameterIdType parameterName;
    Value defaultValue;
  };

  typedef sequence <TciModuleIdType> TciModuleIdListType ;

  typedef sequence <TciModuleParameterType> TciModuleParameterListType;

  typedef sequence <TciTestCaseIdType> TciTestCaseIdListType;


  enum TciTestComponentKindType {
    CONTROL,
    MTC,
    PTC,
    SYSTEM,
    PTC_ALIVE
  };

  enum ComponentStatusType{
    inactiveC, 
    runningC,
    stoppedC,    killedC,
    nullC

};

  enum TimerStatusType{
    runningT,
    inactiveT,
    expiredT,
    nullT
  };

  enum PortStatusType{
    startedP,
    haltedP, 
    stoppedP
  };

  enum TciTypeClassType {
    ADDRESS_CLASS,
    ANYTYPE_CLASS,
    BITSTRING_CLASS,
    BOOLEAN_CLASS,
    CHARSTRING_CLASS,
    COMPONENT_CLASS,
    ENUMERATED_CLASS,
    FLOAT_CLASS,
    HEXSTRING_CLASS,
    INTEGER_CLASS,
    OCTETSTRING_CLASS,
    RECORD_CLASS,
    RECORDOF_CLASS,
    ARRAY_CLASS,
    SET_CLASS,
    SETOF_CLASS,
    UNION_CLASS,
    UNIVERSALCHARSTRING_CLASS,
    VERDICT_CLASS	
  };

  // **************************************************************************
  // * Abstract TTCN3 Data Types And Values
  // **************************************************************************

  // Abstract data type "Type"
  interface Type {
    TciModuleIdType  getDefiningModule ();
    TString          getName ();
    TciTypeClassType getTypeClass ();
    Value            newInstance ();
    TString          getTypeEncoding ();
    TString          getTypeEncodingVariant ();
    TStringSeq       getTypextension ();
  };

  // Abstract TTCN3 Values 
  interface Value {
    TString  getValueEncoding ();
    TString  getValueEncodingVariant ();
    Type     getType ();
    TBoolean  notPresent ();
  };

  interface RecordOfValue : Value {
    Value    getField (in TInteger position);
    void     setField (
			 in TInteger position,
			 in Value value
		       );
    void     appendField (in Value value);
    Type     getElementType ();
    TInteger getLength ();
    void     setLength (in TInteger len); 
    TInteger getOffset ();
  };

  interface RecordValue : Value {
    Value      getField (in TString fieldName);
    void       setField (
			 in TString fieldName,
			 in Value value
			 );
    TStringSeq getFieldNames ();
    void       setFieldOmitted (in TString fieldName);
  };
  
  interface VerdictValue : Value {
    TInteger getVerdict ();
    void     setVerdict (in TInteger verdict);
  };

  interface BitstringValue : Value {
    TString   getString ();
    void      setString (in TString value);
    TInteger  getBit (in TInteger position);
    void      setBit (
		     in TInteger position,
		     in TInteger value
		     );
    TInteger  getLength ();
    void      setLength (in TInteger len);
  };
  
  interface OctetstringValue : Value {
    TString  getString ();
    void     setString (in TString value);
    TInteger getOctet (in TInteger position);
    void     setOctet (
		     in TInteger position,
		     in TInteger value
		     );
    TInteger getLength ();
    void     setLength (in TInteger len);
  };
  
  interface FloatValue : Value {
    TFloat getFloat ();
    void  setFloat (in TFloat value);
  };
  
  interface HexstringValue : Value {
    TString  getString ();
    void     setString (in TString value);
    TInteger getHex (in TInteger position);
    void     setHex (
		     in TInteger position,
		     in TInteger value
		     );
    TInteger getLength ();
    void     setLength (in TInteger len);
  };
  
  interface EnumeratedValue : Value {
    void    setEnum (in TString enumValue);
    TString getEnum ();
  };
  
  interface IntegerValue : Value {
    TInteger getInt ();
    void     setInt (in TInteger value);
  };
  
  interface CharValue : Value {
    TChar getChar ();
    void  setChar (in TChar value);
  };
  
  interface CharstringValue : Value {
    TString  getString ();
    void     setString (in TString value);
    TChar    getChar   (in TInteger position);
    void     setChar   (
			 in TInteger position,
			 in TChar value
			 );
    TInteger getLength ();
    void     setLength (in TInteger len);
  };
  
  interface BooleanValue : Value {
    TBoolean getBoolean ();
    void    setBoolean (in TBoolean value);
  };
  
  interface UniversalCharValue : Value {
    TUniversalChar getUniversalChar ();
    void           setUniversalChar (in TUniversalChar value);
    
  };
  
  interface UniversalCharstringValue : Value {
    TString        getString ();
    void           setString (in TString value);
    TUniversalChar getChar   (in TInteger position);
    void           setChar   (
			 in TInteger position,
			 in TUniversalChar value
			 );
    TInteger       getLength ();
    void           setLength (in TInteger len);
  };
  
  interface UnionValue : Value {
    Value      getVariant  (in TString variantName);
    void       setVariant  (
			 in TString variantName,
			 in Value value
			 );
    TString    getPresentVariantName ();
    TStringSeq getVariantNames ();
    
  };
  // **************************************************************************
  // * Abstract Logging Types
  // **************************************************************************

  interface TciValueTemplate : Value {
	  TBoolean isOmit (); 
	  TBoolean isAny(); 
	  TBoolean isAnyOrOmit(); 
      TString getTemplateDef();
  };

  interface TciNonValueTemplate {
	  TBoolean isAny(); 
	  TBoolean isAll(); 
      TString getTemplateDef();
  };

  typedef sequence <Value> TciValueListType;

  struct TciValueDifferenceType
  {
  	TString desc;
  	Value val;
  	TciValueTemplate tmpl;
  };
  
  typedef sequence <TciValueDifferenceType> TciValueDifferenceListType;

  interface TciValueList {
    attribute TciValueListType inst;
	TInteger size();	
	TBoolean isEmpty();
	Value get(in TInteger index);
  };

  interface TciValueDifference {
    attribute TciValueDifferenceType inst;
    Value getValue();
    TciValueTemplate getTciValueTemplate();
    TString getDescription();
  };

  interface TciValueDifferenceList {
    attribute TciValueDifferenceListType inst;
    TInteger size();	
    TBoolean isEmpty();
    TciValueDifference get(in TInteger index);
  };
	
  // *******************************************************************************
  // Coding Decoding Interface 
  // –  Required
  // *******************************************************************************

  interface TCI_CD_Required {
    Type getTypeForName (in TString typeName);
    Type getInteger ();
    Type getFloat ();
    Type getBoolean ();
    Type getChar ();
    Type getUniversalChar ();
    Type getCharstring ();
    Type getUniversalCharstring ();
    Type getHexstring ();
    Type getBitstring ();
    Type getOctetstring ();
    Type getVerdict ();
    void tciErrorReq (in TString message);
  };

  // *******************************************************************************
  // Coding Decoding interface 
  // –  Provided
  // *******************************************************************************

  interface TCI_CD_Provided {
    Value decode (
		  in TriMessageType message,
		  in Type decodingHypothesis
		  );
    TriMessageType encode (in Value value);
  };
  

  // *******************************************************************************
  // Test Management Interface 
  // –  Required
  // *******************************************************************************

  interface TCI_TM_Required : TCI_CD_Required {
    void tciRootModule (in TciModuleIdType moduleName);
    TciModuleIdListType tciGetImportedModules();
    TciModuleParameterListType tciGetModuleParameters (in TciModuleIdType moduleName);
    TciTestCaseIdListType tciGetTestCases ();
    TciParameterTypeListType tciGetTestCaseParameters (
			in TciTestCaseIdType testCaseId
			);
    TriPortIdListType tciGetTestCaseTSI (
			in TciTestCaseIdType testCaseId
			);
    void tciStartTestCase (
			in TciTestCaseIdType testCaseId,
			in TciParameterListType parameterList
			);
    void tciStopTestCase ();
    TriComponentIdType tciStartControl ();
    void tciStopControl ();
  };
  
  // *******************************************************************************
  // Test Management Interface 
  // –  Provided
  // *******************************************************************************

  interface TCI_TM_Provided {
    void tciTestCaseStarted (
			in TciTestCaseIdType testCaseId,
			in TciParameterListType parameterList,
			in TFloat timer
			);
    void tciTestCaseTerminated (
			in VerdictValue verdict,
			in TciParameterListType parameterList
			);
    void tciControlTerminated ();
    Value tciGetModulePar (
			in TciModuleParameterIdType parameterId
			);
    void tciLog (
		 in TriComponentIdType testComponentId,
		 in TString message
		 );
    void tciError (in TString message);
  };
  
  
  // *******************************************************************************
  // Component Handling Interface 
  // –  Required
  // *******************************************************************************

  interface TCI_CH_Required : TCI_CD_Required {
    void tciEnqueueMsgConnected (
			in TriPortIdType sender,
			in TriComponentIdType receiver,
			in Value receivedMessage
			);
    void tciEnqueueCallConnected (
			in TriPortIdType sender,
			in TriComponentIdType receiver,
			in TriSignatureIdType signature,
			in TciParameterListType parameterList
			);
    void tciEnqueueReplyConnected (
			in TriPortIdType sender,
			in TriComponentIdType receiver,
			in TriSignatureIdType signature,
			in TciParameterListType parameterList,
			in Value returnValue
			);
    void tciEnqueueRaiseConnected (
			in TriPortIdType sender,
			in TriComponentIdType receiver,
			in TriSignatureIdType signature,
			in Value except
			);
    TriComponentIdType tciCreateTestComponent (
			in TciTestComponentKindType kind,
			in Type componentType,
			in TString name
			);
    void tciStartTestComponent (
			in TriComponentIdType comp,
			in TciBehaviourIdType behavior,
			in TciParameterListType parameterList
			);
    void tciStopTestComponent (
			in TriComponentIdType comp
			);
    void tciConnect (
		   in TriPortIdType fromPort,
		   in TriPortIdType toPort
		   );
    void tciDisconnect (
		   in TriPortIdType fromPort,
		   in TriPortIdType toPort
		   );
    void tciTestComponentTerminated (
		   in TriComponentIdType comp,
		   in VerdictValue verdict
		   );
    TBoolean tciTestComponentRunning (
		   in TriComponentIdType comp
		   );
    TriComponentIdType tciGetMTC ();
    void tciMap (
		   in TriPortIdType fromPort,
		   in TriPortIdType toPort
		   );
    void tciUnmap (
		   in TriPortIdType fromPort,
		   in TriPortIdType toPort
		   );
    void tciExecuteTestCase (
		   in TciTestCaseIdType testCaseId,
		   in TriPortIdListType tsiPortList
		   );
    TBoolean tciTestComponentDone (
		   in TriComponentIdType comp
		   );
    void tciReset ();
  };

  // *******************************************************************************
  // Component Handling Interface 
  // –  Provided
  // *******************************************************************************

  interface TCI_CH_Provided {
    void tciSendConnected (
			in TriPortIdType sender,
			in TriComponentIdType receiver,
			in Value sendMessage
			);
    void tciSendConnectedBC (
           in TriPortIdType sender,
           in Value sendMessage
           );
    void tciSendConnectedMC (
           in TriPortIdType sender,
           in TriComponentIdListType receivers,
           in Value sendMessage
           );

    void tciCallConnected (
			in TriPortIdType sender,
			in TriComponentIdType receiver,
			in TriSignatureIdType signature,
			in TciParameterListType parameterList
			);
    void tciCallConnectedBC (
          in TriPortIdType sender,
          in TriSignatureIdType signature,
          in TciParameterListType parameterList
          );
    void tciCallConnectedMC (
          in TriPortIdType sender,
          in TriComponentIdListType receivers,
          in TriSignatureIdType signature,
          in TciParameterListType parameterList
          );

    void tciReplyConnected (
			in TriPortIdType sender,
			in TriComponentIdType receiver,
			in TriSignatureIdType signature,
			in TciParameterListType parameterList,
			in Value returnValue
			);
    void tciReplyConnectedBC (
           in TriPortIdType sender,
           in TriSignatureIdType signature,
           in TciParameterListType parameterList,
           in Value returnValue
           );
    void tciReplyConnectedMC (
           in TriPortIdType sender,
           in TriComponentIdListType receivers,
           in TriSignatureIdType signature,
           in TciParameterListType parameterList,
           in Value returnValue
           );

    void tciRaiseConnected (
			in TriPortIdType      sender,
			in TriComponentIdType receiver,
			in TriSignatureIdType signature,
			in Value except
			);
    void tciRaiseConnectedBC (
          in TriPortIdType sender,
          in TriSignatureIdType signature,
          in Value except
          );
    void tciRaiseConnectedMC (
          in TriPortIdType sender,
          in TriComponentIdListType receivers,
          in TriSignatureIdType signature,
          in Value except
          );

    TriComponentIdType tciCreateTestComponentReq (
			in TciTestComponentKindType kind,
			in Type componentType,
			in TString name
			);
    void tciStartTestComponentReq (
			in TriComponentIdType comp,
			in TciBehaviourIdType behavior,
			in TciParameterListType parameterList
			);
    void tciStopTestComponentReq (
			in TriComponentIdType comp
			);
    void tciConnectReq (
			in TriPortIdType fromPort,
			in TriPortIdType toPort
			);
    void tciDisconnectReq (
			in TriPortIdType fromPort,
			in TriPortIdType toPort
			);
    void tciTestComponentTerminatedReq (
			in TriComponentIdType comp,
			in VerdictValue verdict
			);
    TBoolean tciTestComponentRunningReq (
			in TriComponentIdType comp
			);
    TriComponentIdType tciGetMTCReq ();
    void tciMapReq (
		   in TriPortIdType fromPort,
		   in TriPortIdType toPort
		   );
    void tciUnmapReq (
		   in TriPortIdType fromPort,
		   in TriPortIdType toPort
		   );
    void tciExecuteTestCaseReq (
			in TciTestCaseIdType testCaseId,
			in TriPortIdListType tsiPortList
			);
    void tciResetReq ();
    TBoolean tciTestComponentDoneReq (
			in TriComponentIdType comp
			);
  };

  // *******************************************************************************
  // Test Logging Interface 
  // –  Provided
  // *******************************************************************************

  interface TCI_TL_Provided {
    void tliTcExecute(
           in TString am, in TInteger ts, in TString src, in TInteger line,
           in TriComponentIdType c, in TciTestCaseIdType tcId,
           in TciParameterListType tciPars, in TriTimerDurationType dur
           );
    void tliTcStart(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TciTestCaseIdType tcId, 
           in TciParameterListType tciPars, in TriTimerDurationType dur
           );
    void tliTcStop(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c
           );
    void tliTcStarted(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TciTestCaseIdType tcId, 
           in TciParameterListType tciPars, in TriTimerDurationType dur
           );
    void tliTcTerminated(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TciTestCaseIdType tcId, 
           in TciParameterListType tciPars, in VerdictValue verdict);

    void tliCtrlStart(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c
           );
    void tliCtrlStop(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c
           );
    void tliCtrlTerminated(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c);

    void tliMSend_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to, in Value msgValue, 
           in Value addrValue, in TciStatusType encoderFailure, 
           in TriMessageType msg, in TriAddressType address, in TriStatusType transmissionFailure
           );
	 void tliMSend_m_BC(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to, in Value msgValue, 
           in TciStatusType encoderFailure, in TriMessageType msg,
           in TriStatusType transmissionFailure
           );
     void tliMSend_m_MC(
           in TString am, in TInteger ts, in TString src, in TInteger line,
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to, in Value msgValue,
           in TciValueList addrValues, in TciStatusType encoderFailure, 
           in TriMessageType msg, in TriAddressListType addresses, 
           in TriStatusType transmissionFailure
           );

    void tliMSend_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to, in Value msgValue, 
           in TriStatusType transmissionFailure
           );
	 void tliMSend_c_BC(
           in TString am, in TInteger ts, in TString src, in TInteger line,
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdListType to, in Value msgValue,
           in TriStatusType transmissionFailure
           );
	 void tliMSend_c_MC(
           in TString am, in TInteger ts, in TString src, in TInteger line,
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdListType to, in Value msgValue,
           in TriStatusType transmissionFailure);

    void tliMDetected_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType from, in TriMessageType msg, 
           in TriAddressType address
           );
    void tliMDetected_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType from, in Value msgValue
           );
    void tliMMismatch_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in Value msgValue, 
           in TciValueTemplate msgTmpl, in TciValueDifferenceList diffs,
		   in Value addrValue, in TciValueTemplate addressTmpl
           );
    void tliMMismatch_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in Value msgValue, 
           in TciValueTemplate msgTmpl, in TciValueDifferenceList diffs, 
		   in TriComponentIdType from, in TciNonValueTemplate fromTmpl
           );
    void tliMReceive_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in Value msgValue, 
           in TciValueTemplate msgTmpl, in Value addrValue, 
           in TciValueTemplate addressTmpl
           );
    void tliMReceive_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in Value msgValue, 
           in TciValueTemplate msgTmpl, in TriComponentIdType from, 
           in TciNonValueTemplate fromTmpl
           );

    void tliPrCall_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in Value addrValue, in TciStatusType encoderFailure, 
           in TriParameterListType triPars, in TriAddressType address,
           in TriStatusType transmissionFailure
           );
	 void tliPrCall_m_BC(
           in TString am, in TInteger ts, in TString src, in TInteger line,
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to,
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in TciStatusType encoderFailure, in TriParameterListType triPars,
           in TriStatusType transmissionFailure
           );
	 void tliPrCall_m_MC(
           in TString am, in TInteger ts, in TString src, in TInteger line,
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to,
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in TciValueList addrValues, in TciStatusType encoderFailure, 
           in TriParameterListType triPars, in TriAddressListType addresses, 
           in TriStatusType transmissionFailure
           );

    void tliPrCall_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in TriStatusType transmissionFailure
           );
	 void tliPrCall_c_BC(
           in TString am, in TInteger ts, in TString src, in TInteger line,
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdListType to,
           in TriSignatureIdType signature, in TciParameterListType tciPars,
           in TriStatusType transmissionFailure
           );
	    void tliPrCall_c_MC(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdListType to, 
           in TriSignatureIdType signature, in TciParameterListType tciPars,  
           in TriStatusType transmissionFailure
           );

    void tliPrGetCallDetected_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType from, 
           in TriSignatureIdType signature, in TriParameterListType triPars, 
           in TriAddressType address
           );
    void tliPrGetCallDetected_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType from, 
           in TriSignatureIdType signature, in TciParameterListType tciPars
           );
    void tliPrGetCallMismatch_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in TciValueTemplate parsTmpl, in TciValueDifferenceList diffs, 
           in Value addrValue, in TciValueTemplate addressTmpl
           );
    void tliPrGetCallMismatch_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in TciValueTemplate parsTmpl, in TciValueDifferenceList diffs, 
           in TriComponentIdType from, in TciNonValueTemplate fromTmpl
           );
    void tliPrGetCall_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in TciValueTemplate parsTmpl, in Value addrValue, 
           in TciValueTemplate addressTmpl
           );
    void tliPrGetCall_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in TciValueTemplate parsTmpl, in TriComponentIdType from, 
           in TciNonValueTemplate fromTmpl
           );

    void tliPrReply_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in Value replValue, in Value addrValue, 
           in TciStatusType encoderFailure, in TriParameterListType triPars, 
           in TriParameterType repl, in TriAddressType address, in TriStatusType transmissionFailure
           );
	 void tliPrReply_m_BC(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, in Value replValue, 
           in TciStatusType encoderFailure, in TriParameterListType triPars, 
           in TriParameterType repl, in TriStatusType transmissionFailure
           );
	 void tliPrReply_m_MC(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, in Value replValue, 
           in TciValueListType addrValues, in TciStatusType encoderFailure, 
           in TriParameterListType triPars, in TriParameterType repl, 
           in TriAddressListType addresses, in TriStatusType transmissionFailure
           );

    void tliPrReply_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in Value replValue, in TriStatusType transmissionFailure
           );
	 void tliPrReply_c_BC(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdListType to, 
           in TriSignatureIdType signature, in Value parsValue, in Value replValue, 
           in TriStatusType transmissionFailure
           );
	 void tliPrReply_c_MC(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdListType to, 
           in TriSignatureIdType signature, in Value parsValue, in Value replValue, 
           in TriStatusType transmissionFailure
           );

    void tliPrGetReplyDetected_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType from, 
           in TriSignatureIdType signature, in TriParameterListType triPars,
           in TriParameterType repl, in TriAddressType address
           );
    void tliPrGetReplyDetected_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType from, 
           in TriSignatureIdType signature, in TciParameterListType tciPars,
           in Value replValue
           );
    void tliPrGetReplyMismatch_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, 
           in TriSignatureIdType signature,
           in TciParameterListType tciPars, in TciValueTemplate parsTmpl,
           in Value replValue, in TciValueTemplate replyTmpl,  
           in TciValueDifferenceList diffs, in Value addrValue, 
           in TciValueTemplate addressTmpl
           );
    void tliPrGetReplyMismatch_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, 
           in TriSignatureIdType signature, 
           in TciParameterListType tciPars, in TciValueTemplate parsTmpl,
           in Value replValue, in TciValueTemplate replyTmpl,  
           in TciValueDifferenceList diffs, in TriComponentIdType from, 
           in TciNonValueTemplate fromTmpl
           );
    void tliPrGetReply_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, 
           in TriSignatureIdType signature, 
           in TciParameterListType tciPars, in TciValueTemplate parsTmpl,
           in Value replValue, in TciValueTemplate replyTmpl, 
           in Value addrValue, in TciValueTemplate addressTmpl
           );
    void tliPrGetReply_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, 
           in TriSignatureIdType signature,
           in TciParameterListType tciPars, in TciValueTemplate parsTmpl,
           in Value replValue, in TciValueTemplate replyTmpl,  
           in TriComponentIdType from, in TciNonValueTemplate fromTmpl
           );

    void tliPrRaise_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in Value excValue, in Value addrValue, in TciStatusType encoderFailure, 
           in TriExceptionType exc, in TriAddressType address, in TriStatusType transmissionFailure
           );
	 void tliPrRaise_m_BC(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in Value excValue, in TciStatusType encoderFailure, in TriExceptionType exc, 
           in TriStatusType transmissionFailure
           );
	 void tliPrRaise_m_MC(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in Value excValue, in TciValueListType addrValues, 
           in TciStatusType encoderFailure, in TriExceptionType exc, 
           in TriAddressListType addresses, in TriStatusType transmissionFailure
           );

    void tliPrRaise_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType to, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in Value excValue, in TriStatusType transmissionFailure
           );
	 void tliPrRaise_c_BC(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdListType to, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in Value excValue, in TriStatusType transmissionFailure
           );
	 void tliPrRaise_c_MC(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdListType to, 
           in TriSignatureIdType signature, in TciParameterListType tciPars, 
           in Value excValue, in TriStatusType transmissionFailure
           );

    void tliPrCatchDetected_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType from, 
           in TriSignatureIdType signature, 
           in TriExceptionType exc, in TriAddressType address
           );
    void tliPrCatchDetected_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, in TriPortIdType from, 
           in TriSignatureIdType signature, in Value excValue
           );
    void tliPrCatchMismatch_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, 
           in TriSignatureIdType signature, 
           in Value excValue, in TciValueTemplate excTmpl,  
           in TciValueDifferenceList diffs, in Value addrValue, 
           in TciValueTemplate addressTmpl
           );
    void tliPrCatchMismatch_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, 
           in TriSignatureIdType signature, 
           in Value excValue, in TciValueTemplate excTmpl,  
           in TciValueDifferenceList diffs, in TriComponentIdType from, 
           in TciNonValueTemplate fromTmpl
           );
    void tliPrCatch_m(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, 
           in TriSignatureIdType signature, 
           in Value excValue, in TciValueTemplate excTmpl,  
           in Value addrValue, in TciValueTemplate addressTmpl);

    void tliPrCatch_c(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, 
           in TriSignatureIdType signature, 
           in Value excValue, in TciValueTemplate excTmpl,  
           in TriComponentIdType from, in TciNonValueTemplate fromTmpl
           );
    void tliPrCatchTimeoutDetected(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, 
           in TriSignatureIdType signature
           );
    void tliPrCatchTimeout(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType at, 
           in TriSignatureIdType signature
           );
    void tliCCreate(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriComponentIdType comp,
           in TString name, in TBoolean alive
           );
    void tliCStart(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriComponentIdType comp, 
           in TciBehaviourIdType name, in TciParameterListType tciPars
           );
    void tliCRunning(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriComponentIdType comp, in ComponentStatusType status
           );
	 void tliCAlive(
			 in TString am, in TInteger ts, in TString src, in TInteger line, 
   			 in TriComponentIdType c,
	    	 in TriComponentIdType comp, in ComponentStatusType status
			 );
	 void tliCStop(
			 in TString am, in TInteger ts, in TString src, in TInteger line, 
			 in TriComponentIdType c, in TriComponentIdType comp
			 );
     void tliCKill(
			 in TString am, in TInteger ts, in TString src, in TInteger line, 
			 in TriComponentIdType c, in TriComponentIdType comp
			 );
     void tliCDoneMismatch(
			 in TString am, in TInteger ts, in TString src, in TInteger line, 
     		 in TriComponentIdType c, in TriComponentIdType comp, in TciNonValueTemplate compTmpl
			 );
     void tliCKilledMismatch(
			 in TString am, in TInteger ts, in TString src, in TInteger line, 
			 in TriComponentIdType c, in TriComponentIdType comp, in TciNonValueTemplate compTmpl
			 );
     void tliCDone(in TString am, in TInteger ts, in TString src, in TInteger line, 
   			 in TriComponentIdType c, in TciNonValueTemplate compTmpl
	  		 );
     void tliCKilled(
			 in TString am, in TInteger ts, in TString src, in TInteger line, 
			 in TriComponentIdType c, in TciNonValueTemplate compTmpl
			 );
    void tliCTerminated(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in VerdictValue verdict
           );
    void tliPConnect(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType port1, in TriPortIdType port2
           );
    void tliPDisconnect(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType port1, 
           in TriPortIdType port2
           );
    void tliPMap(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType port1, in TriPortIdType port2
           );
    void tliPUnmap(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType port1, 
           in TriPortIdType port2
           );
    void tliPClear(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType port
           );
    void tliPStart(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType port
           );
    void tliPStop(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType port
           );
    void tliPHalt(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriPortIdType port
           );
    void tliEncode(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in Value val, in TciStatusType encoderFailure, 
           in TriMessageType msg, in TString codec
           );
    void tliDecode(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriMessageType msg, 
           in TciStatusType decoderFailure, in Value val, in TString codec
           );
    void tliTTimeoutDetected(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriTimerIdType timer
           );
    void tliTTimeoutMismatch(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriTimerIdType timer, in TciNonValueTemplate timerTmpl
           );
    void tliTTimeout(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriTimerIdType timer, in TciNonValueTemplate timerTmpl
           );
    void tliTStart(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriTimerIdType timer, 
           in TriTimerDurationType dur
           );
    void tliTStop(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriTimerIdType timer, in TriTimerDurationType dur
           );
    void tliTRead(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriTimerIdType timer, 
           in TriTimerDurationType elapsed
           );
    void tliTRunning(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TriTimerIdType timer, in TimerStatusType status
           );
    void tliSEnter(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in QualifiedName name, in TciParameterListType tciPars, 
           in TString kind
           );
    void tliSLeave(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in QualifiedName name, in TciParameterListType tciPars,
           in Value returnValue, in TString kind
           );
    void tliVar(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in QualifiedName name, in Value varValue
           );
    void tliModulePar(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in QualifiedName name, in Value parValue
           );
    void tliGetVerdict(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in VerdictValue verdict
           );
    void tliSetVerdict(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in VerdictValue verdict, in TString reason
           );
    void tliLog(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TString log
           );
    void tliAEnter(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c
           );
    void tliALeave(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c
           );
    void tliADefaults(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c
           );
    void tliAActivate(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in QualifiedName name, in TciParameterListType tciPars, 
           in Value ref
           );
    void tliADeactivate(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in Value ref
           );
    void tliANomatch(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c
           );
    void tliARepeat(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c
           );
    void tliAWait(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c
           );
    void tliAction(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in TString action
	   );
    void tliMatch(
           in TString am, in TInteger ts, in TString src, in TInteger line, 
           in TriComponentIdType c, in Value expr, in TciValueTemplate tmpl
	   );
    void tliMatchMismatch(
           in TString am, in TInteger ts, in TString src, 
           in TInteger line, in TriComponentIdType c, in Value expr,   
           in TciValueTemplate tmpl, in TciValueDifferenceList diffs
           );
    void tliInfo(
           in TString am, in TInteger ts, in TString src, 
           in TInteger line, in TriComponentIdType c, 
           in TInteger level, in TString info
           );
	};
};

Annex B

XML Mapping for TCI-TL Provided
(This annex forms an integral part of this Recommendation)
This annex defines a mapping for the logging interface of TCI using eXtended Markup Language (XML) schema definitions.
B.1	TCITL XML Schema for Simple Types

<?xml version="1.0" encoding="UTF8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            targetNamespace="http://uri.etsi.org/ttcn3/tci/SimpleTypes_v4_2_1.xsd" 
            xmlns:SimpleTypes="http://uri.etsi.org/ttcn3/tci/SimpleTypes_v4_2_1.xsd"
            elementFormDefault="qualified">
    
    <! Basic definitions >
    <xsd:simpleType name="xpath">
        <! this string should be XPATH complient >
        <xsd:restriction base="xsd:string"/>
    </xsd:simpleType>       

    <xsd:simpleType name="TBoolean">
        <xsd:restriction base="xsd:boolean"/>
    </xsd:simpleType>       
    
    <xsd:simpleType name="TString">
        <xsd:restriction base="xsd:string"/>
    </xsd:simpleType>       
    
    <xsd:simpleType name="TInteger">
        <xsd:restriction base="xsd:integer"/>
    </xsd:simpleType>       
        
    <! Miscellaneous >
    <xsd:simpleType name="TriTimerDurationType">
        <xsd:restriction base="xsd:float"/>
    </xsd:simpleType>
    
    <xsd:simpleType name="TciParameterPassingModeType">
        <xsd:restriction base="xsd:string">
            <xsd:enumeration value="in"/>
            <xsd:enumeration value="inout"/>
            <xsd:enumeration value="out"/>
        </xsd:restriction>
    </xsd:simpleType>
    
    <xsd:simpleType name="TriStatusType">
        <xsd:restriction base="xsd:string">
            <xsd:enumeration value="TRI_Ok"/>
            <xsd:enumeration value="TRI_Error"/>
        </xsd:restriction>
    </xsd:simpleType>

    <xsd:simpleType name="TciStatusType">
        <xsd:restriction base="xsd:string">
            <xsd:enumeration value="TCI_Ok"/>
            <xsd:enumeration value="TCI_Error"/>
        </xsd:restriction>
    </xsd:simpleType>

    <xsd:simpleType name="ComponentStatusType">
        <xsd:restriction base="xsd:string">
            <xsd:enumeration value="inactiveC"/>
            <xsd:enumeration value="runningC"/>
            <xsd:enumeration value="stoppedC"/>
            <xsd:enumeration value="killedC"/>
            <xsd:enumeration value="nullC"/>
        </xsd:restriction>
    </xsd:simpleType>
	
	<xsd:simpleType name="TimerStatusType">
        <xsd:restriction base="xsd:string">
            <xsd:enumeration value="runningT"/>
            <xsd:enumeration value="inactiveT"/>
            <xsd:enumeration value="expiredT"/>
            <xsd:enumeration value="nullT"/>
        </xsd:restriction>
    </xsd:simpleType>

	<xsd:simpleType name="PortStatusType">
        <xsd:restriction base="xsd:string">
            <xsd:enumeration value="startedP"/>
            <xsd:enumeration value="haltedP"/>
            <xsd:enumeration value="stoppedP"/>
        </xsd:restriction>
    </xsd:simpleType>
</xsd:schema>

B.2	TCITL XML Schema for Types

<?xml version="1.0" encoding="UTF8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
    targetNamespace="http://uri.etsi.org/ttcn3/tci/Types_v4_2_1.xsd"
    xmlns:Types="http://uri.etsi.org/ttcn3/tci/Types_v4_2_1.xsd"
    xmlns:SimpleTypes="http://uri.etsi.org/ttcn3/tci/SimpleTypes_v4_2_1.xsd" 
    xmlns:Values="http://uri.etsi.org/ttcn3/tci/Values_v4_2_1.xsd" 
    xmlns:Templates="http://uri.etsi.org/ttcn3/tci/Templates_v4_2_1.xsd" 
		elementFormDefault="qualified">
    
    <xsd:import namespace="http://uri.etsi.org/ttcn3/tci/Values_v4_2_1.xsd"        
     schemaLocation="Values_v4_2_1.xsd"/>
    <xsd:import namespace="http://uri.etsi.org/ttcn3/tci/SimpleTypes_v4_2_1.xsd" 
     schemaLocation="SimpleTypes_v4_2_1.xsd"/>
    <xsd:import namespace="http://uri.etsi.org/ttcn3/tci/Templates_v4_2_1.xsd"        
     schemaLocation="Templates_v4_2_1.xsd"/>

    <! Connection >
    <xsd:complexType name="TriPortIdType">
        <xsd:sequence>
            <xsd:element name="comp" type="Types:TriComponentIdType" />
            <xsd:element name="port" type="Types:Port" />
        </xsd:sequence>
    </xsd:complexType>

    <xsd:complexType name="TriPortIdListType">
        <xsd:sequence>
            <xsd:element name="comp" type="Types:TriPortIdType" minOccurs="0"  
             maxOccurs="unbounded"/>
        </xsd:sequence>
    </xsd:complexType>

    <xsd:complexType name="Port">
        <xsd:sequence>
            <xsd:element name="id" type="Types:Id"  />
            <xsd:element name="index" type="xsd:int" minOccurs="0" />
        </xsd:sequence>
    </xsd:complexType>

    <xsd:complexType name="TriComponentIdType">
        <xsd:sequence>
            <xsd:choice>
                <xsd:element name="null" type="Templates:null"/>
                <xsd:element name="id" type="Types:Id"  />
            </xsd:choice>
        </xsd:sequence>
    </xsd:complexType>

    <xsd:complexType name="TriComponentIdListType">
        <xsd:sequence>
            <xsd:element name="comp" type="Types:TriComponentIdType" minOccurs="0"  
             maxOccurs="unbounded"/>
        </xsd:sequence>
    </xsd:complexType>

    <! Communication >
    <xsd:complexType name="TriMessageType">
        <xsd:attribute name="val" type="xsd:hexBinary"/>
    </xsd:complexType>

    <xsd:complexType name="TriParameterType">
        <xsd:sequence>
            <xsd:element name="val" type="xsd:hexBinary"  />
        </xsd:sequence>
        <xsd:attribute name="name" type="SimpleTypes:TString"/>
        <xsd:attribute name="mode" type="SimpleTypes:TciParameterPassingModeType"/>
    </xsd:complexType>

    <xsd:complexType name="TriParameterListType">
        <xsd:sequence>
            <xsd:element name="par" type="Types:TriParameterType" minOccurs="0" maxOccurs="unbounded"/>
        </xsd:sequence>
    </xsd:complexType>
    
    <xsd:complexType name="TriExceptionType">
        <xsd:attribute name="val" type="xsd:hexBinary"/>
    </xsd:complexType>

    <xsd:complexType name="TciValueList">
        <xsd:complexContent>
            <xsd:extension base="Values:RecordValue"/>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="TriSignatureIdType">
        <xsd:attribute name="val" type="SimpleTypes:TString" use="required"/>
    </xsd:complexType>

    <xsd:complexType name="TriAddressType">
        <xsd:attribute name="val" type="xsd:hexBinary"/>
    </xsd:complexType>

    <xsd:complexType name="TriAddressListType">
        <xsd:sequence>
            <xsd:element name="addr" type="Types:TriAddressType" minOccurs="0"   
             maxOccurs="unbounded"/>
        </xsd:sequence>
    </xsd:complexType>


    <! Miscellaneous >
    <xsd:complexType name="TriTimerIdType">
        <xsd:sequence>
            <xsd:element name="id" type="Types:Id"  />
        </xsd:sequence>
    </xsd:complexType>

    <! Basic definitions >
    <xsd:complexType name="QualifiedName">
        <xsd:attribute name="moduleName" type="SimpleTypes:TString" use="required"/>
        <xsd:attribute name="baseName" type="SimpleTypes:TString" use="required"/>
    </xsd:complexType>

    <! general TCI abstract data types >
    <xsd:complexType name="TciBehaviourIdType">
        <xsd:sequence>
            <xsd:element name="name" type="Types:QualifiedName"  />
        </xsd:sequence>
    </xsd:complexType>
    
    <xsd:complexType name="TciTestCaseIdType">
        <xsd:sequence>
            <xsd:element name="name" type="Types:QualifiedName"  />
        </xsd:sequence>
    </xsd:complexType>    

    <xsd:complexType name="TciParameterType">
        <xsd:sequence>
            <xsd:element name="val" type="Values:Value"  />
        </xsd:sequence>
        <xsd:attribute name="name" type="SimpleTypes:TString"/>
        <xsd:attribute name="mode" type="SimpleTypes:TciParameterPassingModeType"/>
    </xsd:complexType>
    
    <xsd:complexType name="TciParameterListType">
        <xsd:sequence>
            <xsd:element name="par" type="Types:TciParameterType" minOccurs="0" maxOccurs="unbounded"/>
        </xsd:sequence>
    </xsd:complexType>

    <! general identifier structure for test components, ports and timer >    
    <xsd:complexType name="Id">
        <xsd:sequence>
           <xsd:element name="name" type="SimpleTypes:TString" />
           <xsd:element name="id" type="SimpleTypes:TString" minOccurs="0"/>
           <xsd:element name="type" type="SimpleTypes:TString" minOccurs="0"/>
        </xsd:sequence>
    </xsd:complexType>

</xsd:schema>

B.3	TCI-TL XML Schema for Values

<?xml version="1.0" encoding="UTF8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
	targetNamespace="http://uri.etsi.org/ttcn3/tci/Values_v4_2_1.xsd" 
	xmlns:Values="http://uri.etsi.org/ttcn3/tci/Values_v4_2_1.xsd" 
	xmlns:Templates="http://uri.etsi.org/ttcn3/tci/Templates_v4_2_1.xsd" 
	xmlns:SimpleTypes="http://uri.etsi.org/ttcn3/tci/SimpleTypes_v4_2_1.xsd" elementFormDefault="qualified">

	<xsd:import namespace="http://uri.etsi.org/ttcn3/tci/Templates_v4_2_1.xsd" 
     schemaLocation="Templates_v4_2_1.xsd"/>
	<xsd:import namespace="http://uri.etsi.org/ttcn3/tci/SimpleTypes_v4_2_1.xsd" 
     schemaLocation="SimpleTypes_v4_2_1.xsd"/>
		
 	<xsd:attributeGroup name="ValueAtts">
		<xsd:attribute name="name" type="SimpleTypes:TString" use="optional"/>
		<xsd:attribute name="type" type="SimpleTypes:TString" use="optional"/>
		<xsd:attribute name="module" type="SimpleTypes:TString" use="optional"/>
		<xsd:attribute name="annotation" type="SimpleTypes:TString" use="optional"/> 	</xsd:attributeGroup>

	<xsd:complexType name="Value" mixed="true">
		<xsd:choice>
			<xsd:element name="integer" type="Values:IntegerValue"/>
			<xsd:element name="float" type="Values:FloatValue"/>
			<xsd:element name="boolean" type="Values:BooleanValue"/>
			<xsd:element name="verdicttype" type="Values:VerdictValue"/>
			<xsd:element name="bitstring" type="Values:BitstringValue"/>
			<xsd:element name="hexstring" type="Values:HexstringValue"/>
			<xsd:element name="octetstring" type="Values:OctetstringValue"/>
			<xsd:element name="charstring" type="Values:CharstringValue"/>
			<xsd:element name="universal_charstring" type="Values:UniversalCharstringValue"/>
			<xsd:element name="record" type="Values:RecordValue"/>
			<xsd:element name="record_of" type="Values:RecordOfValue"/>
			<xsd:element name="array" type="Values:ArrayValue"/>
			<xsd:element name="set" type="Values:SetValue"/>
			<xsd:element name="set_of" type="Values:SetOfValue"/>
			<xsd:element name="enumerated" type="Values:EnumeratedValue"/>
			<xsd:element name="union" type="Values:UnionValue"/>
			<xsd:element name="anytype" type="Values:AnytypeValue"/>
			<xsd:element name="address" type="Values:AddressValue"/>
    	</xsd:choice>
    	<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

    <! general event elements >    
	<xsd:complexType name="IntegerValue">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="FloatValue">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="BooleanValue">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="VerdictValue">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="BitstringValue">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="HexstringValue">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="OctetstringValue">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="CharstringValue">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="UniversalCharstringValue">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="RecordValue">
		<xsd:choice>
			<xsd:choice minOccurs="0" maxOccurs="unbounded">
				<xsd:element name="integer" type="Values:IntegerValue"/>
				<xsd:element name="float" type="Values:FloatValue"/>
				<xsd:element name="boolean" type="Values:BooleanValue"/>
				<xsd:element name="verdicttype" type="Values:VerdictValue"/>
				<xsd:element name="bitstring" type="Values:BitstringValue"/>
				<xsd:element name="hexstring" type="Values:HexstringValue"/>
				<xsd:element name="octetstring" type="Values:OctetstringValue"/>
				<xsd:element name="charstring" type="Values:CharstringValue"/>
				<xsd:element name="universal_charstring" 
					type="Values:UniversalCharstringValue"/>
				<xsd:element name="record" type="Values:RecordValue"/>
				<xsd:element name="record_of" type="Values:RecordOfValue"/>
				<xsd:element name="array" type="Values:ArrayValue"/>
				<xsd:element name="set" type="Values:SetValue"/>
				<xsd:element name="set_of" type="Values:SetOfValue"/>
				<xsd:element name="enumerated" type="Values:EnumeratedValue"/>
				<xsd:element name="union" type="Values:UnionValue"/>
				<xsd:element name="anytype" type="Values:AnytypeValue"/>
				<xsd:element name="address" type="Values:AddressValue"/>
			</xsd:choice>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="RecordOfValue">
		<xsd:choice>
			<xsd:element name="integer" type="Values:IntegerValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="float" type="Values:FloatValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="boolean" type="Values:BooleanValue" minOccurs="0" 
				maxOccurs="unbounded"/>
            <xsd:element name="verdicttype" type="Values:VerdictValue" minOccurs="0" 
                    maxOccurs="unbounded"/>
			<xsd:element name="bitstring" type="Values:BitstringValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="hexstring" type="Values:HexstringValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="octetstring" type="Values:OctetstringValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="charstring" type="Values:CharstringValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="universal_charstring" 
				type="Values:UniversalCharstringValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="record" type="Values:RecordValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="record_of" type="Values:RecordOfValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="array" type="Values:ArrayValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="set" type="Values:SetValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="set_of" type="Values:SetOfValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="enumerated" type="Values:EnumeratedValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="union" type="Values:UnionValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="anytype" type="Values:AnytypeValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="address" type="Values:AddressValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>


	<xsd:complexType name="ArrayValue">
		<xsd:choice>
			<xsd:element name="integer" type="Values:IntegerValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="float" type="Values:FloatValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="boolean" type="Values:BooleanValue" minOccurs="0" 
				maxOccurs="unbounded"/>
            <xsd:element name="verdicttype" type="Values:VerdictValue" minOccurs="0" 
                    maxOccurs="unbounded"/>
			<xsd:element name="bitstring" type="Values:BitstringValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="hexstring" type="Values:HexstringValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="octetstring" type="Values:OctetstringValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="charstring" type="Values:CharstringValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="universal_charstring" 
				type="Values:UniversalCharstringValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="record" type="Values:RecordValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="record_of" type="Values:RecordOfValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="array" type="Values:ArrayValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="set" type="Values:SetValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="set_of" type="Values:SetOfValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="enumerated" type="Values:EnumeratedValue" 
				minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="union" type="Values:UnionValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="anytype" type="Values:AnytypeValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="address" type="Values:AddressValue" minOccurs="0" 
				maxOccurs="unbounded"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="SetValue">
		<xsd:choice>
			<xsd:choice minOccurs="0" maxOccurs="unbounded">
				<xsd:element name="integer" type="Values:IntegerValue"/>
				<xsd:element name="float" type="Values:FloatValue"/>
				<xsd:element name="boolean" type="Values:BooleanValue"/>
				<xsd:element name="verdicttype" type="Values:VerdictValue"/>
				<xsd:element name="bitstring" type="Values:BitstringValue"/>
				<xsd:element name="hexstring" type="Values:HexstringValue"/>
				<xsd:element name="octetstring" type="Values:OctetstringValue"/>
				<xsd:element name="charstring" type="Values:CharstringValue"/>
				<xsd:element name="universal_charstring" 
					type="Values:UniversalCharstringValue"/>
				<xsd:element name="record" type="Values:RecordValue"/>
				<xsd:element name="record_of" type="Values:RecordOfValue"/>
				<xsd:element name="array" type="Values:ArrayValue"/>
				<xsd:element name="set" type="Values:SetValue"/>
				<xsd:element name="set_of" type="Values:SetOfValue"/>
				<xsd:element name="enumerated" type="Values:EnumeratedValue"/>
				<xsd:element name="union" type="Values:UnionValue"/>
				<xsd:element name="anytype" type="Values:AnytypeValue"/>
				<xsd:element name="address" type="Values:AddressValue"/>
			</xsd:choice>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="SetOfValue">
		<xsd:choice>
				<xsd:element name="integer" type="Values:IntegerValue" minOccurs="0" 
					maxOccurs="unbounded"/>
				<xsd:element name="float" type="Values:FloatValue" minOccurs="0" 
					maxOccurs="unbounded"/>
				<xsd:element name="boolean" type="Values:BooleanValue" minOccurs="0" 
					maxOccurs="unbounded"/>
                <xsd:element name="verdicttype" type="Values:VerdictValue" minOccurs="0" 
                    maxOccurs="unbounded"/>
				<xsd:element name="bitstring" type="Values:BitstringValue" 
					minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element name="hexstring" type="Values:HexstringValue" 
					minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element name="octetstring" type="Values:OctetstringValue" 
					minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element name="charstring" type="Values:CharstringValue" 
					minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element name="universal_charstring" 
					type="Values:UniversalCharstringValue" minOccurs="0" 
					maxOccurs="unbounded"/>
				<xsd:element name="record" type="Values:RecordValue" minOccurs="0" 
					maxOccurs="unbounded"/>
				<xsd:element name="record_of" type="Values:RecordOfValue" 
					minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element name="array" type="Values:ArrayValue" 
					minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element name="set" type="Values:SetValue" minOccurs="0" 
					maxOccurs="unbounded"/>
				<xsd:element name="set_of" type="Values:SetOfValue" 
					minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element name="enumerated" type="Values:EnumeratedValue" 
					minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element name="union" type="Values:UnionValue" minOccurs="0" 
					maxOccurs="unbounded"/>
				<xsd:element name="anytype" type="Values:AnytypeValue" minOccurs="0" 
					maxOccurs="unbounded"/>
				<xsd:element name="address" type="Values:AddressValue" minOccurs="0" 
					maxOccurs="unbounded"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="EnumeratedValue">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="UnionValue">
		<xsd:choice>
			<xsd:element name="integer" type="Values:IntegerValue"/>
			<xsd:element name="float" type="Values:FloatValue"/>
			<xsd:element name="boolean" type="Values:BooleanValue"/>
			<xsd:element name="verdicttype" type="Values:VerdictValue"/>
			<xsd:element name="bitstring" type="Values:BitstringValue"/>
			<xsd:element name="hexstring" type="Values:HexstringValue"/>
			<xsd:element name="octetstring" type="Values:OctetstringValue"/>
			<xsd:element name="charstring" type="Values:CharstringValue"/>
			<xsd:element name="universal_charstring" 
				type="Values:UniversalCharstringValue"/>
			<xsd:element name="record" type="Values:RecordValue"/>
			<xsd:element name="record_of" type="Values:RecordOfValue"/>
			<xsd:element name="array" type="Values:ArrayValue"/>
			<xsd:element name="set" type="Values:SetValue"/>
			<xsd:element name="set_of" type="Values:SetOfValue"/>
			<xsd:element name="enumerated" type="Values:EnumeratedValue"/>
			<xsd:element name="union" type="Values:UnionValue"/>
			<xsd:element name="anytype" type="Values:AnytypeValue"/>
			<xsd:element name="address" type="Values:AddressValue"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="AnytypeValue">
		<xsd:choice minOccurs="0" maxOccurs="unbounded">
			<xsd:element name="integer" type="Values:IntegerValue"/>
			<xsd:element name="float" type="Values:FloatValue"/>
			<xsd:element name="boolean" type="Values:BooleanValue"/>
			<xsd:element name="verdicttype" type="Values:VerdictValue"/>
			<xsd:element name="bitstring" type="Values:BitstringValue"/>
			<xsd:element name="hexstring" type="Values:HexstringValue"/>
			<xsd:element name="octetstring" type="Values:OctetstringValue"/>
			<xsd:element name="charstring" type="Values:OctetstringValue"/>
			<xsd:element name="universal_charstring" 
				type="Values:UniversalCharstringValue"/>
			<xsd:element name="record" type="Values:RecordValue"/>
			<xsd:element name="record_of" type="Values:RecordOfValue"/>
			<xsd:element name="array" type="Values:ArrayValue"/>
			<xsd:element name="set" type="Values:SetValue"/>
			<xsd:element name="set_of" type="Values:SetOfValue"/>
			<xsd:element name="enumerated" type="Values:EnumeratedValue"/>
			<xsd:element name="union" type="Values:UnionValue"/>
			<xsd:element name="address" type="Values:AddressValue"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="AddressValue">
		<xsd:choice minOccurs="0" maxOccurs="unbounded">
			<xsd:element name="integer" type="Values:IntegerValue"/>
			<xsd:element name="float" type="Values:FloatValue"/>
			<xsd:element name="boolean" type="Values:BooleanValue"/>
			<xsd:element name="verdicttype" type="Values:VerdictValue"/>
			<xsd:element name="bitstring" type="Values:BitstringValue"/>
			<xsd:element name="hexstring" type="Values:HexstringValue"/>
			<xsd:element name="octetstring" type="Values:OctetstringValue"/>
			<xsd:element name="charstring" type="Values:OctetstringValue"/>
			<xsd:element name="universal_charstring" 
				type="Values:UniversalCharstringValue"/>
			<xsd:element name="record" type="Values:RecordValue"/>
			<xsd:element name="record_of" type="Values:RecordOfValue"/>
			<xsd:element name="array" type="Values:ArrayValue"/>
			<xsd:element name="set" type="Values:SetValue"/>
			<xsd:element name="set_of" type="Values:SetOfValue"/>
			<xsd:element name="enumerated" type="Values:EnumeratedValue"/>
			<xsd:element name="union" type="Values:UnionValue"/>
			<xsd:element name="anytype" type="Values:AnytypeValue"/>
			<xsd:element name="null" type="Templates:null"/>
			<xsd:element name="omit" type="Templates:omit"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>
</xsd:schema>

B.4	TCI-TL XML Schema for Templates

<?xml version="1.0" encoding="UTF8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
	targetNamespace="http://uri.etsi.org/ttcn3/tci/Templates_v4_2_1.xsd" 
	xmlns:Templates="http://uri.etsi.org/ttcn3/tci/Templates_v4_2_1.xsd" 
	xmlns:Values="http://uri.etsi.org/ttcn3/tci/Values_v4_2_1.xsd" 
	xmlns:Types="http://uri.etsi.org/ttcn3/tci/Types_v4_2_1.xsd" 
	xmlns:SimpleTypes="http://uri.etsi.org/ttcn3/tci/SimpleTypes_v4_2_1.xsd" elementFormDefault="qualified">
	
	<xsd:import namespace="http://uri.etsi.org/ttcn3/tci/Values_v4_2_1.xsd" 
     schemaLocation="Values_v4_2_1.xsd"/>
	<xsd:import namespace="http://uri.etsi.org/ttcn3/tci/Types_v4_2_1.xsd" schemaLocation="Types_v4_2_1.xsd"/>
	<xsd:import namespace="http://uri.etsi.org/ttcn3/tci/SimpleTypes_v4_2_1.xsd" 
     schemaLocation="SimpleTypes_v4_2_1.xsd"/>
		
	<xsd:complexType name="TciValueTemplate">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Values:Value">   
        	<xsd:choice>
        		<xsd:element name="integer" type="Templates:IntegerTemplate"/>
        		<xsd:element name="float" type="Templates:FloatTemplate"/>
        		<xsd:element name="boolean" type="Templates:BooleanTemplate"/>
                <xsd:element name="verdicttype" type="Templates:VerdictTemplate"/>
        		<xsd:element name="bitstring" type="Templates:BitstringTemplate"/>
        		<xsd:element name="hexstring" type="Templates:HexstringTemplate"/>
        		<xsd:element name="octetstring" type="Templates:OctetstringTemplate"/>
        		<xsd:element name="charstring" type="Templates:CharstringTemplate"/>
        		<xsd:element name="universal_charstring" 
                        type="Templates:UniversalCharstringTemplate"/>
			    <xsd:element name="record" type="Templates:RecordTemplate"/>
			    <xsd:element name="record_of" type="Templates:RecordOfTemplate"/>
			    <xsd:element name="array" type="Values:ArrayValue"/>
			    <xsd:element name="set" type="Templates:SetTemplate"/>
			    <xsd:element name="set_of" type="Templates:SetOfTemplate"/>
			    <xsd:element name="enumerated" type="Templates:EnumeratedTemplate"/>
			    <xsd:element name="union" type="Templates:UnionTemplate"/>
			    <xsd:element name="anytype" type="Templates:AnytypeTemplate"/>
			    <xsd:element name="address" type="Templates:AddressTemplate"/>
            	<xsd:element name="omit" type="Templates:omit"/>
            	<xsd:element name="any" type="Templates:any"/>
            	<xsd:element name="anyoromit" type="Templates:anyoromit"/>
        		<xsd:element name="templateDef" type="SimpleTypes:TString"/>
           	</xsd:choice>
            </xsd:extension>
        </xsd:complexContent>
	</xsd:complexType>

	<xsd:complexType name="omit">
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="any">
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="anyoromit">
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>


	<xsd:complexType name="TciNonValueTemplate">
	    <xsd:sequence>
    		<xsd:choice>
    			<xsd:element name="any" type="Templates:any"/>
    			<xsd:element name="all" type="Templates:all"/>
        		<xsd:element name="templateDef" type="SimpleTypes:TString"/>
    			<xsd:element name="null" type="Templates:null"/>
    		</xsd:choice>
        </xsd:sequence>
	</xsd:complexType>

	<xsd:complexType name="all">
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="null">
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>
	
    <xsd:complexType name="TciValueDifference">
        <xsd:sequence>
          	<xsd:element name="val" type="SimpleTypes:xpath"/>
          	<xsd:element name="tmpl" type="SimpleTypes:xpath"/>
        </xsd:sequence>
    	<xsd:attributeGroup ref="Values:ValueAtts"/>
        <xsd:attribute name="desc" type="SimpleTypes:TString" use="optional"/>
  	</xsd:complexType>

  	<xsd:complexType name="TciValueDifferenceList">
        	<xsd:sequence>
            		<xsd:element name="diff" type="Templates:TciValueDifference"  maxOccurs="unbounded"/>
        	</xsd:sequence>
    	</xsd:complexType>

	<xsd:complexType name="IntegerTemplate">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="templateDef" type="SimpleTypes:TString"/>
			<xsd:element name="omit" type="Templates:omit"/>
			<xsd:element name="any" type="Templates:any"/>
			<xsd:element name="anyoromit" type="Templates:anyoromit"/>
			<xsd:element name="null" type="Templates:null"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="FloatTemplate">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="templateDef" type="SimpleTypes:TString"/>
			<xsd:element name="omit" type="Templates:omit"/>
			<xsd:element name="any" type="Templates:any"/>
			<xsd:element name="anyoromit" type="Templates:anyoromit"/>
			<xsd:element name="null" type="Templates:null"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="BooleanTemplate">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="templateDef" type="SimpleTypes:TString"/>
			<xsd:element name="omit" type="Templates:omit"/>
			<xsd:element name="any" type="Templates:any"/>
			<xsd:element name="anyoromit" type="Templates:anyoromit"/>
			<xsd:element name="null" type="Templates:null"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="BitstringTemplate">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="templateDef" type="SimpleTypes:TString"/>
			<xsd:element name="omit" type="Templates:omit"/>
			<xsd:element name="any" type="Templates:any"/>
			<xsd:element name="anyoromit" type="Templates:anyoromit"/>
			<xsd:element name="null" type="Templates:null"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="HexstringTemplate">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="templateDef" type="SimpleTypes:TString"/>
			<xsd:element name="omit" type="Templates:omit"/>
			<xsd:element name="any" type="Templates:any"/>
			<xsd:element name="anyoromit" type="Templates:anyoromit"/>
			<xsd:element name="null" type="Templates:null"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="OctetstringTemplate">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="templateDef" type="SimpleTypes:TString"/>
			<xsd:element name="omit" type="Templates:omit"/>
			<xsd:element name="any" type="Templates:any"/>
			<xsd:element name="anyoromit" type="Templates:anyoromit"/>
			<xsd:element name="null" type="Templates:null"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="CharstringTemplate">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="templateDef" type="SimpleTypes:TString"/>
			<xsd:element name="omit" type="Templates:omit"/>
			<xsd:element name="any" type="Templates:any"/>
			<xsd:element name="anyoromit" type="Templates:anyoromit"/>
			<xsd:element name="null" type="Templates:null"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="UniversalCharstringTemplate">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
			<xsd:element name="templateDef" type="SimpleTypes:TString"/>
			<xsd:element name="omit" type="Templates:omit"/>
			<xsd:element name="any" type="Templates:any"/>
			<xsd:element name="anyoromit" type="Templates:anyoromit"/>
			<xsd:element name="null" type="Templates:null"/>
		</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="VerdictTemplate">
		<xsd:choice>
			<xsd:element name="value" type="SimpleTypes:TString"/>
				<xsd:element name="templateDef" type="SimpleTypes:TString"/>
                <xsd:element name="omit" type="Templates:omit"/>
                <xsd:element name="any" type="Templates:any"/>
                <xsd:element name="anyoromit" type="Templates:anyoromit"/>
				<xsd:element name="null" type="Templates:null"/>
			</xsd:choice>
		<xsd:attributeGroup ref="Values:ValueAtts"/>
	</xsd:complexType>

	<xsd:complexType name="RecordTemplate">
        <xsd:complexContent>
            <xsd:extension base="Values:RecordValue">   
        		<xsd:choice>
        			<xsd:choice minOccurs="0">
        				<xsd:element name="integer" type="Templates:IntegerTemplate"/>
        				<xsd:element name="float" type="Templates:FloatTemplate"/>
        				<xsd:element name="boolean" type="Templates:BooleanTemplate"/>
                		<xsd:element name="verdicttype" type="Templates:VerdictTemplate"/>
        				<xsd:element name="bitstring" type="Templates:BitstringTemplate"/>
        				<xsd:element name="hexstring" type="Templates:HexstringTemplate"/>
        				<xsd:element name="octetstring" type="Templates:OctetstringTemplate"/>
        				<xsd:element name="charstring" type="Templates:CharstringTemplate"/>
        				<xsd:element name="universal_charstring" 
        					type="Templates:UniversalCharstringTemplate"/>
        				<xsd:element name="record" type="Templates:RecordTemplate"/>
        				<xsd:element name="record_of" type="Templates:RecordOfTemplate"/>
						<xsd:element name="array" type="Values:ArrayValue"/>
        				<xsd:element name="set" type="Templates:SetTemplate"/>
        				<xsd:element name="set_of" type="Templates:SetOfTemplate"/>
        				<xsd:element name="enumerated" type="Templates:EnumeratedTemplate"/>
        				<xsd:element name="union" type="Templates:UnionTemplate"/>
        				<xsd:element name="anytype" type="Templates:AnytypeTemplate"/>
        				<xsd:element name="address" type="Templates:AddressTemplate"/>
        			</xsd:choice>
                	<xsd:element name="omit" type="Templates:omit"/>
               		<xsd:element name="any" type="Templates:any"/>
               		<xsd:element name="anyoromit" type="Templates:anyoromit"/>
       				<xsd:element name="templateDef" type="SimpleTypes:TString"/>
       				<xsd:element name="null" type="Templates:null"/>
        		</xsd:choice>
   		</xsd:extension>
   		</xsd:complexContent>
	</xsd:complexType>

	<xsd:complexType name="RecordOfTemplate">
        <xsd:complexContent>
            <xsd:extension base="Values:RecordOfValue">   
        		<xsd:choice minOccurs="0" maxOccurs="unbounded">
        			<xsd:element name="integer" type="Templates:IntegerTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="float" type="Templates:FloatTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="boolean" type="Templates:BooleanTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
                	<xsd:element name="verdicttype" type="Templates:VerdictTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="bitstring" type="Templates:BitstringTemplate" 
        					minOccurs="0" maxOccurs="unbounded"/>
        			<xsd:element name="hexstring" type="Templates:HexstringTemplate" 
        					minOccurs="0" maxOccurs="unbounded"/>
        			<xsd:element name="octetstring" type="Templates:OctetstringTemplate" 
        					minOccurs="0" maxOccurs="unbounded"/>
        			<xsd:element name="charstring" type="Templates:CharstringTemplate" 
        					minOccurs="0" maxOccurs="unbounded"/>
        			<xsd:element name="universal_charstring" 
        					type="Templates:UniversalCharstringTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="record" type="Templates:RecordTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="record_of" type="Templates:RecordOfTemplate" 
        					minOccurs="0" maxOccurs="unbounded"/>
        			<xsd:element name="array" type="Templates:ArrayTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="set" type="Templates:SetTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="set_of" type="Templates:SetOfTemplate" 
        					minOccurs="0" maxOccurs="unbounded"/>
        			<xsd:element name="enumerated" type="Templates:EnumeratedTemplate" 
        					minOccurs="0" maxOccurs="unbounded"/>
        			<xsd:element name="union" type="Templates:UnionTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="anytype" type="Templates:AnytypeTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="address" type="Templates:AddressTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
                	<xsd:element name="omit" type="Templates:omit"/>
                	<xsd:element name="any" type="Templates:any"/>
                	<xsd:element name="anyoromit" type="Templates:anyoromit"/>
					<xsd:element name="templateDef" type="SimpleTypes:TString"/>
         			<xsd:element name="null" type="Templates:null"/>
        		</xsd:choice>
    		</xsd:extension>
   		</xsd:complexContent>
	</xsd:complexType>

	<xsd:complexType name="SetTemplate">
        <xsd:complexContent>
            <xsd:extension base="Values:SetValue">   
        		<xsd:choice>
        			<xsd:choice minOccurs="0">
        				<xsd:element name="integer" type="Templates:IntegerTemplate"/>
        				<xsd:element name="float" type="Templates:FloatTemplate"/>
        				<xsd:element name="boolean" type="Templates:BooleanTemplate"/>
        				<xsd:element name="verdicttype" type="Templates:VerdictTemplate"/>
        				<xsd:element name="bitstring" type="Templates:BitstringTemplate"/>
        				<xsd:element name="hexstring" type="Templates:HexstringTemplate"/>
        				<xsd:element name="octetstring" type="Templates:OctetstringTemplate"/>
        				<xsd:element name="charstring" type="Templates:CharstringTemplate"/>
        				<xsd:element name="universal_charstring" 
        					type="Templates:UniversalCharstringTemplate"/>
        				<xsd:element name="record" type="Templates:RecordTemplate"/>
        				<xsd:element name="record_of" type="Templates:RecordOfTemplate"/>
        				<xsd:element name="array" type="Templates:ArrayTemplate"/>
        				<xsd:element name="set" type="Templates:SetTemplate"/>
        				<xsd:element name="set_of" type="Templates:SetOfTemplate"/>
        				<xsd:element name="enumerated" type="Templates:EnumeratedTemplate"/>
        				<xsd:element name="union" type="Templates:UnionTemplate"/>
        				<xsd:element name="anytype" type="Templates:AnytypeTemplate"/>
        				<xsd:element name="address" type="Templates:AddressTemplate"/>
        			</xsd:choice>
              		<xsd:element name="omit" type="Templates:omit"/>
               		<xsd:element name="any" type="Templates:any"/>
               		<xsd:element name="anyoromit" type="Templates:anyoromit"/>
       				<xsd:element name="templateDef" type="SimpleTypes:TString"/>
       				<xsd:element name="null" type="Templates:null"/>
        		</xsd:choice>
    		</xsd:extension>
   		</xsd:complexContent>
	</xsd:complexType>

	<xsd:complexType name="SetOfTemplate">
        <xsd:complexContent>
            <xsd:extension base="Values:SetOfValue">   
        		<xsd:choice minOccurs="0" maxOccurs="unbounded">
        			<xsd:element name="integer" type="Templates:IntegerTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="float" type="Templates:FloatTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="boolean" type="Templates:BooleanTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
            		<xsd:element name="verdicttype" type="Templates:VerdictTemplate" minOccurs="0"
							maxOccurs="unbounded"/>
        			<xsd:element name="bitstring" type="Templates:BitstringTemplate" 
        					minOccurs="0" maxOccurs="unbounded"/>
        			<xsd:element name="hexstring" type="Templates:HexstringTemplate" 
        					minOccurs="0" maxOccurs="unbounded"/>
        			<xsd:element name="octetstring" type="Templates:OctetstringTemplate" 
        					minOccurs="0" maxOccurs="unbounded"/>
        			<xsd:element name="charstring" type="Templates:CharstringTemplate" 
        					minOccurs="0" maxOccurs="unbounded"/>
        			<xsd:element name="universal_charstring" 
        					type="Templates:UniversalCharstringTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="record" type="Templates:RecordTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="record_of" type="Templates:RecordOfTemplate" 
        					minOccurs="0" maxOccurs="unbounded"/>
        			<xsd:element name="array" type="Templates:ArrayTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="set" type="Templates:SetTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="set_of" type="Templates:SetOfTemplate" 
        					minOccurs="0" maxOccurs="unbounded"/>
        			<xsd:element name="enumerated" type="Templates:EnumeratedTemplate" 
        					minOccurs="0" maxOccurs="unbounded"/>
        			<xsd:element name="union" type="Templates:UnionTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="anytype" type="Templates:AnytypeTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
        			<xsd:element name="address" type="Templates:AddressTemplate" minOccurs="0" 
        					maxOccurs="unbounded"/>
                	<xsd:element name="omit" type="Templates:omit"/>
                	<xsd:element name="any" type="Templates:any"/>
                	<xsd:element name="anyoromit" type="Templates:anyoromit"/>
         			<xsd:element name="templateDef" type="SimpleTypes:TString"/>
         			<xsd:element name="null" type="Templates:null"/>
        		</xsd:choice>
    		</xsd:extension>
   		</xsd:complexContent>
	</xsd:complexType>

	<xsd:complexType name="EnumeratedTemplate">	    
        <xsd:complexContent>
            <xsd:extension base="Values:EnumeratedValue">   
        		<xsd:choice minOccurs="0">
                	<xsd:element name="value" type="SimpleTypes:TString"/>
                	<xsd:element name="templateDef" type="SimpleTypes:TString"/>
                	<xsd:element name="omit" type="Templates:omit"/>
                	<xsd:element name="any" type="Templates:any"/>
                	<xsd:element name="anyoromit" type="Templates:anyoromit"/>
                	<xsd:element name="null" type="Templates:null"/>
        		</xsd:choice>
    		</xsd:extension>
   		</xsd:complexContent>
	</xsd:complexType>

	<xsd:complexType name="UnionTemplate">
        <xsd:complexContent>
            <xsd:extension base="Values:UnionValue">   
        		<xsd:choice minOccurs="0">
        			<xsd:element name="integer" type="Templates:IntegerTemplate"/>
        			<xsd:element name="float" type="Templates:FloatTemplate"/>
        			<xsd:element name="boolean" type="Templates:BooleanTemplate"/>
            		<xsd:element name="verdicttype" type="Templates:VerdictTemplate"/>
        			<xsd:element name="bitstring" type="Templates:BitstringTemplate"/>
        			<xsd:element name="hexstring" type="Templates:HexstringTemplate"/>
        			<xsd:element name="octetstring" type="Templates:OctetstringTemplate"/>
        			<xsd:element name="charstring" type="Templates:CharstringTemplate"/>
        			<xsd:element name="universal_charstring" 
        				type="Templates:UniversalCharstringTemplate"/>
					<xsd:element name="record" type="Templates:RecordTemplate"/>
					<xsd:element name="record_of" type="Templates:RecordOfTemplate"/>
					<xsd:element name="array" type="Templates:ArrayTemplate"/>
					<xsd:element name="set" type="Templates:SetTemplate"/>
					<xsd:element name="set_of" type="Templates:SetOfTemplate"/>
					<xsd:element name="enumerated" type="Templates:EnumeratedTemplate"/>
					<xsd:element name="union" type="Templates:UnionTemplate"/>
					<xsd:element name="anytype" type="Templates:AnytypeTemplate"/>
					<xsd:element name="address" type="Templates:AddressTemplate"/>
                	<xsd:element name="omit" type="Templates:omit"/>
                	<xsd:element name="any" type="Templates:any"/>
                	<xsd:element name="anyoromit" type="Templates:anyoromit"/>
					<xsd:element name="templateDef" type="SimpleTypes:TString"/>
                	<xsd:element name="null" type="Templates:null"/>
      			</xsd:choice>
    		</xsd:extension>
   		</xsd:complexContent>
	</xsd:complexType>

	<xsd:complexType name="AnytypeTemplate">
        <xsd:complexContent>
            <xsd:extension base="Values:AnytypeValue">   
        		<xsd:choice minOccurs="0">
        			<xsd:element name="integer" type="Templates:IntegerTemplate"/>
        			<xsd:element name="float" type="Templates:FloatTemplate"/>
        			<xsd:element name="boolean" type="Templates:BooleanTemplate"/>
            		<xsd:element name="verdicttype" type="Templates:VerdictTemplate"/>
        			<xsd:element name="bitstring" type="Templates:BitstringTemplate"/>
        			<xsd:element name="hexstring" type="Templates:HexstringTemplate"/>
        			<xsd:element name="octetstring" type="Templates:OctetstringTemplate"/>
        			<xsd:element name="charstring" type="Templates:CharstringTemplate"/>
        			<xsd:element name="universal_charstring" 
        				type="Templates:UniversalCharstringTemplate"/>
					<xsd:element name="record" type="Templates:RecordTemplate"/>
					<xsd:element name="record_of" type="Templates:RecordOfTemplate"/>
					<xsd:element name="array" type="Templates:ArrayTemplate"/>
					<xsd:element name="set" type="Templates:SetTemplate"/>
					<xsd:element name="set_of" type="Templates:SetOfTemplate"/>
					<xsd:element name="enumerated" type="Templates:EnumeratedTemplate"/>
					<xsd:element name="union" type="Templates:UnionTemplate"/>
					<xsd:element name="address" type="Templates:AddressTemplate"/>
                	<xsd:element name="omit" type="Templates:omit"/>
                	<xsd:element name="any" type="Templates:any"/>
                	<xsd:element name="anyoromit" type="Templates:anyoromit"/>
					<xsd:element name="templateDef" type="SimpleTypes:TString"/>
                	<xsd:element name="null" type="Templates:null"/>
        		</xsd:choice>
    		</xsd:extension>
   		</xsd:complexContent>
	</xsd:complexType>
	
	<xsd:complexType name="AddressTemplate">
        <xsd:complexContent>
            <xsd:extension base="Values:AnytypeValue">   
        		<xsd:choice minOccurs="0">
        			<xsd:element name="integer" type="Templates:IntegerTemplate"/>
        			<xsd:element name="float" type="Templates:FloatTemplate"/>
        			<xsd:element name="boolean" type="Templates:BooleanTemplate"/>
        			<xsd:element name="bitstring" type="Templates:BitstringTemplate"/>
        			<xsd:element name="hexstring" type="Templates:HexstringTemplate"/>
        			<xsd:element name="octetstring" type="Templates:OctetstringTemplate"/>
        			<xsd:element name="charstring" type="Templates:CharstringTemplate"/>
        			<xsd:element name="universal_charstring" 
        				type="Templates:UniversalCharstringTemplate"/>
					<xsd:element name="record" type="Templates:RecordTemplate"/>
					<xsd:element name="record_of" type="Templates:RecordOfTemplate"/>
					<xsd:element name="array" type="Templates:ArrayTemplate"/>
					<xsd:element name="set" type="Templates:SetTemplate"/>
					<xsd:element name="set_of" type="Templates:SetOfTemplate"/>
					<xsd:element name="enumerated" type="Templates:EnumeratedTemplate"/>
					<xsd:element name="union" type="Templates:UnionTemplate"/>
					<xsd:element name="anytype" type="Templates:AnytypeTemplate"/>
                	<xsd:element name="omit" type="Templates:omit"/>
                	<xsd:element name="any" type="Templates:any"/>
                	<xsd:element name="anyoromit" type="Templates:anyoromit"/>
					<xsd:element name="templateDef" type="SimpleTypes:TString"/>
                	<xsd:element name="null" type="Templates:null"/>
        		</xsd:choice>
    		</xsd:extension>
   		</xsd:complexContent>
	</xsd:complexType>
</xsd:schema>

B.5	TCI-TL XML Schema for Events

<?xml version="1.0" encoding="UTF8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    targetNamespace="http://uri.etsi.org/ttcn3/tci/Events_v4_2_1.xsd"
    xmlns:Events="http://uri.etsi.org/ttcn3/tci/Events_v4_2_1.xsd"
    xmlns:Types="http://uri.etsi.org/ttcn3/tci/Types_v4_2_1.xsd"
    xmlns:Templates="http://uri.etsi.org/ttcn3/tci/Templates_v4_2_1.xsd"
    xmlns:SimpleTypes="http://uri.etsi.org/ttcn3/tci/SimpleTypes_v4_2_1.xsd"
    xmlns:Values="http://uri.etsi.org/ttcn3/tci/Values_v4_2_1.xsd"
    elementFormDefault="qualified">

    <xsd:import namespace="http://uri.etsi.org/ttcn3/tci/SimpleTypes_v4_2_1.xsd" 
     schemaLocation="SimpleTypes_v4_2_1.xsd"/>
    <xsd:import namespace="http://uri.etsi.org/ttcn3/tci/Types_v4_2_1.xsd" schemaLocation="Types_v4_2_1.xsd"/>
    <xsd:import namespace="http://uri.etsi.org/ttcn3/tci/Values_v4_2_1.xsd" 
     schemaLocation="Values_v4_2_1.xsd"/>
    <xsd:import namespace="http://uri.etsi.org/ttcn3/tci/Templates_v4_2_1.xsd" 
     schemaLocation="Templates_v4_2_1.xsd"/>

    <! common definition for all events >
    <xsd:complexType name="Event" mixed="true">
        <xsd:sequence>
            <xsd:element name="am" type="SimpleTypes:TString"/>
        </xsd:sequence>
        <xsd:attribute name="ts" type="xsd:long" use="required"/>
        <xsd:attribute name="src" type="SimpleTypes:TString" use="optional"/>
        <xsd:attribute name="line" type="SimpleTypes:TInteger" use="optional"/>

    	<! general identifier structure for test components, ports and timer >    
        <xsd:attribute name="name" type="SimpleTypes:TString" use="required"/>
        <xsd:attribute name="id" type="SimpleTypes:TString" use="required"/>
        <xsd:attribute name="type" type="SimpleTypes:TString" use="required"/>
    </xsd:complexType>
    
    <! this event is extended by all port configuration events >
    <xsd:complexType name="PortConfiguration">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="port1" type="Types:TriPortIdType"  />
                    <xsd:element name="port2" type="Types:TriPortIdType"  />
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <! this event is extended by all port status events >
    <xsd:complexType name="PortStatus">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="port" type="Types:TriPortIdType"/>
                    <xsd:element name="stat" type="SimpleTypes:PortStatusType"  minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <! testcases > 
    <xsd:complexType name="tliTcExecute">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="tcId" type="Types:TciTestCaseIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="dur" type="SimpleTypes:TriTimerDurationType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliTcStart">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="tcId" type="Types:TciTestCaseIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="dur" type="SimpleTypes:TriTimerDurationType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliTcStop">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event"/>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliTcStarted">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="tcId" type="Types:TciTestCaseIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="dur" type="SimpleTypes:TriTimerDurationType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliTcTerminated">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="tcId" type="Types:TciTestCaseIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="verdict" type="Values:VerdictValue"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <! control >
    <xsd:complexType name="tliCtrlStart">
        <xsd:complexContent>
            <xsd:extension base="Events:Event"/>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliCtrlStop">
        <xsd:complexContent>
            <xsd:extension base="Events:Event"/>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliCtrlTerminated">
        <xsd:complexContent>
            <xsd:extension base="Events:Event"/>
        </xsd:complexContent>
    </xsd:complexType>

    <! asynchronous communication >
    <xsd:complexType name="tliMSend_m">
         <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="msgValue" type="Values:Value"/>
                    <xsd:element name="addrValue " type="Values:Value" minOccurs="0"/>
                    <xsd:choice>
                        <xsd:element name="encoderfailure" type="SimpleTypes:TciStatusType" minOccurs="0"/>
                        <xsd:sequence>
                            <xsd:element name="msg" type="Types:TriMessageType" minOccurs="0"/>
                    		<xsd:element name="address" type="Types:TriAddressType" minOccurs="0"/>
                            <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                        </xsd:sequence>
                    </xsd:choice>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliMSend_m_BC">
         <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="msgValue" type="Values:Value"/>
                    <xsd:choice>
                        <xsd:element name="encoderfailure" type="SimpleTypes:TciStatusType" minOccurs="0"/>
                        <xsd:sequence>
                            <xsd:element name="msg" type="Types:TriMessageType" minOccurs="0"/>
                            <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                        </xsd:sequence>
                    </xsd:choice>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliMSend_m_MC">
         <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="msgValue" type="Values:Value"/>
                    <xsd:element name="addrValues" type="Types:TciValueListType" minOccurs="0"/>
                    <xsd:choice>
                        <xsd:element name="encoderfailure" type="SimpleTypes:TciStatusType" minOccurs="0"/>
                        <xsd:sequence>
                            <xsd:element name="msg" type="Types:TriMessageType" minOccurs="0"/>
                            <xsd:element name="addresses" type="Types:TriAddressListType" minOccurs="0"/>
                            <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                        </xsd:sequence>
                    </xsd:choice>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliMSend_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="msgValue" type="Values:Value"/>
                    <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliMSend_c_BC">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdListType" minOccurs="0"/>
                    <xsd:element name="msgValue" type="Values:Value"/>
                    <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliMSend_c_MC">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdListType" minOccurs="0"/>
                    <xsd:element name="msgValue" type="Values:Value"/>
                    <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliMDetected_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="from" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="msgValue" type="Types:TriMessageType"/>
                    <xsd:element name="address" type="Types:TriAddressType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliMDetected_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                    <xsd:sequence>
                        <xsd:element name="at" type="Types:TriPortIdType"/>
                        <xsd:element name="from" type="Types:TriPortIdType" minOccurs="0"/>
                        <xsd:element name="msgValue" type="Values:Value"/>
                    </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliMMismatch_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                    <xsd:sequence>
                        <xsd:element name="at" type="Types:TriPortIdType"/>
                        <xsd:element name="msgValue" type="Values:Value"/>
                        <xsd:element name="msgTmpl" type="Templates:TciValueTemplate"/>
                        <xsd:element name="diffs" type="Templates:TciValueDifferenceList"/>
                        <xsd:element name="addrValue" type="Values:Value" minOccurs="0"/>
                        <xsd:element name="addressTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliMMismatch_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                    <xsd:sequence>
                        <xsd:element name="at" type="Types:TriPortIdType"/>
                        <xsd:element name="msgValue" type="Values:Value"/>
                        <xsd:element name="msgTmpl" type="Templates:TciValueTemplate"/>
                        <xsd:element name="diffs" type="Templates:TciValueDifferenceList"/>
                        <xsd:element name="from" type="Types:TriComponentIdType" minOccurs="0"/>
                        <xsd:element name="fromTmpl" type="Templates:TciNonValueTemplate" minOccurs="0"/>
                    </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliMReceive_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                    <xsd:sequence>
                        <xsd:element name="at" type="Types:TriPortIdType"/>
                        <xsd:element name="msgValue" type="Values:Value" minOccurs="0"/>
                        <xsd:element name="msgTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                        <xsd:element name="addrValue" type="Values:Value" minOccurs="0"/> 
                        <xsd:element name="addressTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>

    <xsd:complexType name="tliMReceive_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                    <xsd:sequence>
                        <xsd:element name="at" type="Types:TriPortIdType"/>
                        <xsd:element name="msgValue" type="Values:Value" minOccurs="0"/>
                        <xsd:element name="msgTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                        <xsd:element name="from" type="Types:TriComponentIdType" minOccurs="0"/>
                        <xsd:element name="fromTmpl" type="Templates:TciNonValueTemplate" minOccurs="0"/>
                    </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>

     <! synchronous communication >
    <xsd:complexType name="tliPrCall_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="addrValue" type="Values:Value" minOccurs="0"/>
                    <xsd:choice>
                        <xsd:element name="encoderfailure" type="SimpleTypes:TciStatusType" minOccurs="0"/>
                        <xsd:sequence>
                            <xsd:element name="triPars" type="Types:TriParameterListType" minOccurs="0"/>
                            <xsd:element name="address" type="Types:TriAddressType" minOccurs="0"/>
                            <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                        </xsd:sequence>
                    </xsd:choice>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrCall_m_BC">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:choice>
                        <xsd:element name="encoderfailure" type="SimpleTypes:TciStatusType" minOccurs="0"/>
                        <xsd:sequence>
                            <xsd:element name="triPars" type="Types:TriParameterListType" minOccurs="0"/>
                            <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                        </xsd:sequence>
                    </xsd:choice>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrCall_m_MC">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="addrValues" type="Types:TciValueListType" minOccurs="0"/>
                    <xsd:choice>
                        <xsd:element name="encoderfailure" type="SimpleTypes:TciStatusType" minOccurs="0"/>
                        <xsd:sequence>
                            <xsd:element name="triPars" type="Types:TriParameterListType" minOccurs="0"/>
                            <xsd:element name="addresses" type="Types:TriAddressListType" minOccurs="0"/>
                            <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                        </xsd:sequence>
                    </xsd:choice>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrCall_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrCall_c_BC">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdListType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrCall_c_MC">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdListType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrGetCallDetected_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="from" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="triPars" type="Types:TriParameterListType" minOccurs="0"/>
                    <xsd:element name="address" type="Types:TriAddressType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrGetCallDetected_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="from" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrGetCallMismatch_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="parsTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="diffs" type="Templates:TciValueDifferenceList"/>		
                    <xsd:element name="addrValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="addressTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>

    <xsd:complexType name="tliPrGetCallMismatch_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="parsTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="diffs" type="Templates:TciValueDifferenceList"/>		
                    <xsd:element name="from" type="Types:TriComponentIdType" minOccurs="0"/>
                    <xsd:element name="fromTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>

    <xsd:complexType name="tliPrGetCall_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="parsTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="addrValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="addressTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
        
    <xsd:complexType name="tliPrGetCall_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="parsTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="from" type="Types:TriComponentIdType" minOccurs="0"/>
                    <xsd:element name="fromTmpl" type="Templates:TciNonValueTemplate" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
        
    <xsd:complexType name="tliPrReply_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="replValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="addrValue" type="Values:Value" minOccurs="0"/>
                    <xsd:choice>
                        <xsd:element name="encoderfailure" type="SimpleTypes:TciStatusType"
                             minOccurs="0"/>
                        <xsd:sequence>
                            <xsd:element name="triPars" type="Types:TriParameterListType" minOccurs="0"/>
                            <xsd:element name="repl" type="Types:TriParameterType" minOccurs="0"/>
                            <xsd:element name="address" type="Types:TriAddressType" minOccurs="0"/>
                            <xsd:element name="transmissionfailure"  
                                 type="SimpleTypes:TriStatusType" minOccurs="0"/>
                        </xsd:sequence>
                    </xsd:choice>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrReply_m_BC">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="replValue" type="Values:Value" minOccurs="0"/>
                    <xsd:choice>
                        <xsd:element name="encoderfailure" type="SimpleTypes:TciStatusType"
                             minOccurs="0"/>
                        <xsd:sequence>
                            <xsd:element name="triPars" type="Types:TriParameterListType" minOccurs="0"/>
                            <xsd:element name="repl" type="Types:TriParameterType" minOccurs="0"/>
                            <xsd:element name="transmissionfailure"  
                                 type="SimpleTypes:TriStatusType" minOccurs="0"/>
                        </xsd:sequence>
                    </xsd:choice>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrReply_m_MC">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="replValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="addrValues" type="Types:TciValueListType" minOccurs="0"/>
                    <xsd:choice>
                        <xsd:element name="encoderfailure" type="SimpleTypes:TciStatusType"
                             minOccurs="0"/>
                        <xsd:sequence>
                            <xsd:element name="triPars" type="Types:TriParameterListType" minOccurs="0"/>
                            <xsd:element name="repl" type="Types:TriParameterType" minOccurs="0"/>
                            <xsd:element name="addresses" type="Types:TriAddressListType" minOccurs="0"/>
                            <xsd:element name="transmissionfailure"  
                                 type="SimpleTypes:TriStatusType" minOccurs="0"/>
                        </xsd:sequence>
                    </xsd:choice>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrReply_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="replValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrReply_c_BC">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdListType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="replValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrReply_c_MC">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdListType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="replValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrGetReplyDetected_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="from" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="triPars" type="Types:TriParameterListType" minOccurs="0"/>
                    <xsd:element name="repl" type="Types:TriParameterType" minOccurs="0"/>
                    <xsd:element name="address" type="Types:TriAddressType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrGetReplyDetected_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="from" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="replValue" type="Values:Value" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrGetReplyMismatch_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="parsTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="replValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="replTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="diffs" type="Templates:TciValueDifferenceList"/>
                    <xsd:element name="addrValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="addressTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrGetReplyMismatch_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="parsTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="replValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="replTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="diffs" type="Templates:TciValueDifferenceList"/>
                    <xsd:element name="from" type="Types:TriComponentIdType" minOccurs="0"/>
                    <xsd:element name="fromTmpl" type="Templates:TciNonValueTemplate" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrGetReply_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="parsTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="replValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="replTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="addrValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="addressTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrGetReply_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="parsTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="replValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="replTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="from" type="Types:TriComponentIdType" minOccurs="0"/>
                    <xsd:element name="fromTmpl" type="Templates:TciNonValueTemplate" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrRaise_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="excValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="addrValue" type="Values:Value" minOccurs="0"/>
                    <xsd:choice>
                        <xsd:element name="encoderfailure" type="SimpleTypes:TciStatusType" minOccurs="0"/>
                        <xsd:sequence>
                            <xsd:element name="exc" type="Types:TriExceptionType" minOccurs="0"/>
                            <xsd:element name="address" type="Types:TriAddressType" minOccurs="0"/>
                            <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                        </xsd:sequence>
                    </xsd:choice>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrRaise_m_BC">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="excValue" type="Values:Value" minOccurs="0"/>
                    <xsd:choice>
                        <xsd:element name="encoderfailure" type="SimpleTypes:TciStatusType" minOccurs="0"/>
                        <xsd:sequence>
                            <xsd:element name="exc" type="Types:TriExceptionType" minOccurs="0"/>
                            <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                        </xsd:sequence>
                    </xsd:choice>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrRaise_m_MC">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="excValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="addrValues" type="Types:TciValueListType" minOccurs="0"/>
                    <xsd:choice>
                        <xsd:element name="encoderfailure" type="SimpleTypes:TciStatusType" minOccurs="0"/>
                        <xsd:sequence>
                            <xsd:element name="exc" type="Types:TriExceptionType" minOccurs="0"/>
                            <xsd:element name="addresses" type="Types:TriAddressListType" minOccurs="0"/>
                            <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                        </xsd:sequence>
                    </xsd:choice>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrRaise_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="excValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrRaise_c_BC">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdListType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="excValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrRaise_c_MC">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="to" type="Types:TriPortIdListType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="excValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="transmissionfailure" type="SimpleTypes:TriStatusType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrCatchDetected_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="from" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="exc" type="Types:TriExceptionType" minOccurs="0"/>
                    <xsd:element name="address" type="Types:TriAddressType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrCatchDetected_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="from" type="Types:TriPortIdType" minOccurs="0"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="excValue" type="Values:Value" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrCatchMismatch_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="excValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="excTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="diffs" type="Templates:TciValueDifferenceList"/>
                    <xsd:element name="addrValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="addressTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrCatchMismatch_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="excValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="excTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="diffs" type="Templates:TciValueDifferenceList"/>
                    <xsd:element name="from" type="Types:TriComponentIdType" minOccurs="0"/>
                    <xsd:element name="fromTmpl" type="Templates:TciNonValueTemplate" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrCatch_m">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="excValue" type="Values:Value"/>
                    <xsd:element name="excTmpl" type="Templates:TciValueTemplate"/>
					<xsd:element name="addrValue" type="Values:Value" minOccurs="0"/>
					<xsd:element name="addressTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrCatch_c">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                    <xsd:element name="excValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="excTmpl" type="Templates:TciValueTemplate" minOccurs="0"/>
                    <xsd:element name="from" type="Types:TriComponentIdType" minOccurs="0"/>
                    <xsd:element name="fromTmpl" type="Templates:TciNonValueTemplate" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>
    
    <xsd:complexType name="tliPrCatchTimeoutDetected">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>

    <xsd:complexType name="tliPrCatchTimeout">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="at" type="Types:TriPortIdType"/>
                    <xsd:element name="signature" type="Types:TriSignatureIdType"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>            
    </xsd:complexType>

    <! components >
    <xsd:complexType name="tliCCreate">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="comp" type="Types:TriComponentIdType"/>
                    <xsd:element name="name" type="SimpleTypes:TString"/>
                    <xsd:element name="alive" type="SimpleTypes:TBoolean"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliCStart">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="comp" type="Types:TriComponentIdType"/>
                    <xsd:element name="name" type="Types:TciBehaviourIdType"/>
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="tliCRunning">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="comp" type="Types:TriComponentIdType"/>
                    <xsd:element name="status" type="SimpleTypes:ComponentStatusType"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>


    <xsd:complexType name="tliCAlive">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="comp" type="Types:TriComponentIdType"/>
                    <xsd:element name="status" type="SimpleTypes:ComponentStatusType"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="tliCStop">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="comp" type="Types:TriComponentIdType"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliCKill">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="comp" type="Types:TriComponentIdType"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliCDoneMismatch">
       <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="comp" type="Types:TriComponentIdType"/>
                    <xsd:element name="compTmpl" type="Templates:TciNonValueTemplate"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="tliCKilledMismatch">
       <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="comp" type="Types:TriComponentIdType"/>
                    <xsd:element name="compTmpl" type="Templates:TciNonValueTemplate"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="tliCDone">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="compTmpl" type="Templates:TciNonValueTemplate"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

     <xsd:complexType name="tliCKilled">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="compTmpl" type="Templates:TciNonValueTemplate"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="tliCTerminated">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="verdict" type="Values:VerdictValue" />
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <! ports >
    <xsd:complexType name="tliPConnect">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:PortConfiguration"/>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliPDisconnect">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:PortConfiguration"/>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliPMap">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:PortConfiguration"/>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliPUnmap">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:PortConfiguration"/>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliPClear">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:PortStatus"/>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="tliPStart">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:PortStatus"/>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="tliPStop">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:PortStatus"/>
        </xsd:complexContent>
    </xsd:complexType>
  
    <xsd:complexType name="tliPHalt">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:PortStatus"/>
        </xsd:complexContent>
    </xsd:complexType>
  
    <! codec >
    <xsd:complexType name="tliEncode">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="val" type="Values:Value"/>
                    <xsd:choice>
                        <xsd:element name="msg" type="Types:TriMessageType"/>
                        <xsd:element name="encoderfailure" type="SimpleTypes:TciStatusType" minOccurs="0"/>
                    </xsd:choice>
					<xsd:element name="codec" type="SimpleTypes:TString"
						 minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="tliDecode" mixed="true">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="msg" type="Types:TriMessageType"/>
                    <xsd:choice>
                        <xsd:element name="decoderfailure" type="SimpleTypes:TciStatusType" minOccurs="0"/>
                        <xsd:element name="val" type="Values:Value"/>
                    </xsd:choice>
					<xsd:element name="codec" type="SimpleTypes:TString"
						 minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <! timers > 
    <xsd:complexType name="tliTTimeoutDetected">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="timer" type="Types:TriTimerIdType"  />
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="tliTTimeoutMismatch">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="timer" type="Types:TriTimerIdType"  />
                    <xsd:element name="timerTmpl" type="Templates:TciNonValueTemplate"  />
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="tliTTimeout">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="timer" type="Types:TriTimerIdType"  />
                    <xsd:element name="timerTmpl" type="Templates:TciNonValueTemplate"  />
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="tliTStart">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="timer" type="Types:TriTimerIdType"/>
                    <xsd:element name="dur" type="SimpleTypes:TriTimerDurationType"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="tliTStop">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="timer" type="Types:TriTimerIdType"/>
                    <xsd:element name="dur" type="SimpleTypes:TriTimerDurationType"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="tliTRead">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="timer" type="Types:TriTimerIdType"/>
                    <xsd:element name="elapsed" type="SimpleTypes:TriTimerDurationType"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliTRunning">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="timer" type="Types:TriTimerIdType"/>
                </xsd:sequence>
                <xsd:attribute name="status" type="SimpleTypes:TimerStatusType"/>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <! scope >    
    <xsd:complexType name="tliSEnter">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="name" type="Types:QualifiedName"  />
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="kind" type="SimpleTypes:TString"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="tliSLeave">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="name" type="Types:QualifiedName"  />
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="returnValue" type="Values:Value" minOccurs="0"/>
                    <xsd:element name="kind" type="SimpleTypes:TString"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
        
    <! variables and module parameter >
    <xsd:complexType name="tliVar">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="name" type="Types:QualifiedName"  />
                    <xsd:element name="val" type="Values:Value" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliModulePar">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="name" type="Types:QualifiedName"  />
                    <xsd:element name="val" type="Values:Value" minOccurs="0"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>

    <! verdicts >
    <xsd:complexType name="tliGetVerdict">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="verdict" type="Values:VerdictValue"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliSetVerdict">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="verdict" type="Values:VerdictValue"/>
                    <xsd:element name="reason" type="SimpleTypes:TString" minOccurs="0"/>                        
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <! log >
    <xsd:complexType name="tliLog">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="log" type="SimpleTypes:TString"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <! alt >
    <xsd:complexType name="tliAEnter">
        <xsd:complexContent>
            <xsd:extension base="Events:Event"/>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliALeave">
        <xsd:complexContent>
            <xsd:extension base="Events:Event"/>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliADefaults">
        <xsd:complexContent>
            <xsd:extension base="Events:Event"/>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliAActivate">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="name" type="Types:QualifiedName"  />
                    <xsd:element name="tciPars" type="Types:TciParameterListType" minOccurs="0"/>
                    <xsd:element name="ref" type="Values:Value"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliADeactivate">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event">
                <xsd:sequence>
                    <xsd:element name="ref" type="Values:Value"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliANomatch">
        <xsd:complexContent mixed="true">
            <xsd:extension base="Events:Event"/>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliARepeat">
        <xsd:complexContent>
            <xsd:extension base="Events:Event"/>
        </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:complexType name="tliAWait">
        <xsd:complexContent>
            <xsd:extension base="Events:Event"/>
        </xsd:complexContent>
    </xsd:complexType>
    
	<xsd:complexType name="tliAction">
		<xsd:complexContent mixed="true">
			<xsd:extension base="Events:Event">
				<xsd:sequence>
					<xsd:element name="action" type="SimpleTypes:TString"/>
				</xsd:sequence>
			</xsd:extension>
		</xsd:complexContent>
	</xsd:complexType>
	
	<xsd:complexType name="tliMatch">
		<xsd:complexContent mixed="true">
			<xsd:extension base="Events:Event">
				<xsd:sequence>
					<xsd:element name="expr" type="Values:Value"/>
					<xsd:element name="tmpl" type="Templates:TciValueTemplate"/>
				</xsd:sequence>
			</xsd:extension>
		</xsd:complexContent>
	</xsd:complexType>
	
	<xsd:complexType name="tliMatchMismatch">
		<xsd:complexContent mixed="true">
			<xsd:extension base="Events:Event">
				<xsd:sequence>
					<xsd:element name="expr" type="Values:Value"/>
					<xsd:element name="tmpl" type="Templates:TciValueTemplate"/>
					<xsd:element name="diffs" type="Templates:TciValueDifferenceList"/>
				</xsd:sequence>
			</xsd:extension>
		</xsd:complexContent>
	</xsd:complexType> 

	<xsd:complexType name="tliInfo">
		<xsd:complexContent mixed="true">
			<xsd:extension base="Events:Event">
				<xsd:sequence>
					<xsd:element name="level" type="SimpleTypes:TInteger"/>
					<xsd:element name="info" type="SimpleTypes:TString"/>
				</xsd:sequence>
			</xsd:extension>
		</xsd:complexContent>
	</xsd:complexType>
</xsd:schema>

B.6	TCI-TL XML Schema for a Log

<?xml version="1.0" encoding="UTF8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    targetNamespace="http://uri.etsi.org/ttcn3/tci/TLI_v4_2_1.xsd"
    xmlns:TLI="http://uri.etsi.org/ttcn3/tci/TLI_v4_2_1.xsd"
    xmlns:Types="http://uri.etsi.org/ttcn3/tci/Types_v4_2_1.xsd"
    xmlns:Values="http://uri.etsi.org/ttcn3/tci/Values_v4_2_1.xsd"
    xmlns:Events="http://uri.etsi.org/ttcn3/tci/Events_v4_2_1.xsd"
    elementFormDefault="qualified">
  
    <xsd:import namespace="http://uri.etsi.org/ttcn3/tci/Types_v4_2_1.xsd" schemaLocation="Types_v4_2_1.xsd"/>
    <xsd:import namespace="http://uri.etsi.org/ttcn3/tci/Values_v4_2_1.xsd" 
     schemaLocation="Values_v4_2_1.xsd"/>
    <xsd:import namespace="http://uri.etsi.org/ttcn3/tci/Events_v4_2_1.xsd" 
     schemaLocation="Events_v4_2_1.xsd"/>
  
    <xsd:element name="logfile" type="TLI:LogModule"/>
    <xsd:complexType name="LogModule">
        <xsd:sequence>
            <xsd:element name="header" type="TLI:Header"/>
            <xsd:element name="body" type="TLI:Body"/>
            <xsd:element name="trailer" type="TLI:Trailer" minOccurs="0"/>
        </xsd:sequence>
    </xsd:complexType>
    <xsd:complexType name="Header">
        <xsd:sequence>
           <! logging version >
           <xsd:element name="version" type="xsd:string"/>
          <! begin of the log >
            <xsd:element name="ts" type="xsd:long"/>
        </xsd:sequence>
    </xsd:complexType>
    <xsd:complexType name="Trailer">
		<xsd:choice>
			<xsd:any namespace="##any" processContents="skip" minOccurs="0" maxOccurs="unbounded"/>
		</xsd:choice>		
    </xsd:complexType>
    
    <xsd:complexType name="Body">
        <xsd:choice maxOccurs="unbounded">

            <! test cases operations >
            <xsd:element name="tliTcExecute" type="Events:tliTcExecute"/>  
            <xsd:element name="tliTcStart" type="Events:tliTcStart"/>
            <xsd:element name="tliTcStop" type="Events:tliTcStop"/>
            <xsd:element name="tliTcStarted" type="Events:tliTcStarted"/>
            <xsd:element name="tliTcTerminated" type="Events:tliTcTerminated"/>
            
            <! control operations >
            <xsd:element name="tliCtrlStart" type="Events:tliCtrlStart"/>
            <xsd:element name="tliCtrlStop" type="Events:tliCtrlStop"/>
            <xsd:element name="tliCtrlTerminated" type="Events:tliCtrlTerminated"/>
            
            <! asynchronous communication >
            <xsd:element name="tliMSend_m" type="Events:tliMSend_m"/>
            <xsd:element name="tliMSend_c" type="Events:tliMSend_c"/>
            <xsd:element name="tliMSend_m_BC" type="Events:tliMSend_m_BC"/>
            <xsd:element name="tliMSend_c_BC" type="Events:tliMSend_c_BC"/>
            <xsd:element name="tliMSend_m_MC" type="Events:tliMSend_m_MC"/>
            <xsd:element name="tliMSend_c_MC" type="Events:tliMSend_c_MC"/>
            <xsd:element name="tliMDetected_m" type="Events:tliMDetected_m"/>
            <xsd:element name="tliMDetected_c" type="Events:tliMDetected_c"/>
            <xsd:element name="tliMMismatch_m" type="Events:tliMMismatch_m"/>
            <xsd:element name="tliMMismatch_c" type="Events:tliMMismatch_c"/>
            <xsd:element name="tliMReceive_m" type="Events:tliMReceive_m"/>
            <xsd:element name="tliMReceive_c" type="Events:tliMReceive_c"/>
            
            <! synchronous communication >
            <xsd:element name="tliPrCall_m" type="Events:tliPrCall_m"/>
            <xsd:element name="tliPrCall_c" type="Events:tliPrCall_c"/>
            <xsd:element name="tliPrCall_m_BC" type="Events:tliPrCall_m_BC"/>
            <xsd:element name="tliPrCall_c_BC" type="Events:tliPrCall_c_BC"/>
            <xsd:element name="tliPrCall_m_MC" type="Events:tliPrCall_m_MC"/>
            <xsd:element name="tliPrCall_c_MC" type="Events:tliPrCall_c_MC"/>
            
            <xsd:element name="tliPrGetCallDetected_m" type="Events:tliPrGetCallDetected_m"/>
            <xsd:element name="tliPrGetCallDetected_c" type="Events:tliPrGetCallDetected_c"/>
            <xsd:element name="tliPrGetCallMismatch_m" type="Events:tliPrGetCallMismatch_m"/>
            <xsd:element name="tliPrGetCallMismatch_c" type="Events:tliPrGetCallMismatch_c"/>
            <xsd:element name="tliPrGetCall_m"     type="Events:tliPrGetCall_m"/>
            <xsd:element name="tliPrGetCall_c"     type="Events:tliPrGetCall_c"/>
            
            <xsd:element name="tliPrReply_m"    type="Events:tliPrReply_m"/>
            <xsd:element name="tliPrReply_c"    type="Events:tliPrReply_c"/>
            <xsd:element name="tliPrReply_m_BC" type="Events:tliPrReply_m_BC"/>
            <xsd:element name="tliPrReply_c_BC" type="Events:tliPrReply_c_BC"/>
            <xsd:element name="tliPrReply_m_MC" type="Events:tliPrReply_m_MC"/>
            <xsd:element name="tliPrReply_c_MC" type="Events:tliPrReply_c_MC"/>
            
            <xsd:element name="tliPrGetReplyDetected_m" type="Events:tliPrGetReplyDetected_m"/>
            <xsd:element name="tliPrGetReplyDetected_c" type="Events:tliPrGetReplyDetected_c"/>
            <xsd:element name="tliPrGetReplyMismatch_m" type="Events:tliPrGetReplyMismatch_m"/>
            <xsd:element name="tliPrGetReplyMismatch_c" type="Events:tliPrGetReplyMismatch_c"/>
            <xsd:element name="tliPrGetReply_m"     type="Events:tliPrGetReply_m"/>
            <xsd:element name="tliPrGetReply_c"     type="Events:tliPrGetReply_c"/>
            
            <xsd:element name="tliPrRaise_m"    type="Events:tliPrRaise_m"/>
            <xsd:element name="tliPrRaise_c"    type="Events:tliPrRaise_c"/>
            <xsd:element name="tliPrRaise_m_BC" type="Events:tliPrRaise_m_BC"/>
            <xsd:element name="tliPrRaise_c_BC" type="Events:tliPrRaise_c_BC"/>			
            <xsd:element name="tliPrRaise_m_MC" type="Events:tliPrRaise_m_MC"/>
            <xsd:element name="tliPrRaise_c_MC" type="Events:tliPrRaise_c_MC"/>
            
            <xsd:element name="tliPrCatchDetected_m"    type="Events:tliPrCatchDetected_m"/>
            <xsd:element name="tliPrCatchDetected_c"    type="Events:tliPrCatchDetected_c"/>
            <xsd:element name="tliPrCatchMismatch_m"    type="Events:tliPrCatchMismatch_m"/>
            <xsd:element name="tliPrCatchMismatch_c"    type="Events:tliPrCatchMismatch_c"/>
            <xsd:element name="tliPrCatch_m"    type="Events:tliPrCatch_m"/>
            <xsd:element name="tliPrCatch_c"    type="Events:tliPrCatch_c"/>

            <xsd:element name="tliPrCatchTimeoutDetected"    
											type="Events:tliPrCatchTimeoutDetected "/>
            <xsd:element name="tliPrCatchTimeout"    type="Events:tliPrCatchTimeout"/>
            
            <! components >
            <xsd:element name="tliCCreate" type="Events:tliCCreate"/>
            <xsd:element name="tliCStart" type="Events:tliCStart"/>
            <xsd:element name="tliCRunning" type="Events:tliCRunning"/>
            <xsd:element name="tliCAlive" type="Events:tliCAlive"/>
            <xsd:element name="tliCStop" type="Events:tliCStop"/>
            <xsd:element name="tliCKill" type="Events:tliCKill"/>
            <xsd:element name="tliCDoneMismatch" type="Events:tliCDoneMismatch"/>
            <xsd:element name="tliCDone" type="Events:tliCDone"/>
            <xsd:element name="tliCKilledMismatch" type="Events:tliCKilledMismatch"/>
            <xsd:element name="tliCKilled" type="Events:tliCKilled"/>
            <xsd:element name="tliCTerminated" type="Events:tliCTerminated"/>
            
            <! ports >
            <xsd:element name="tliPConnect" type="Events:tliPConnect"/>
            <xsd:element name="tliPDisconnect" type="Events:tliPDisconnect"/>
            <xsd:element name="tliPMap" type="Events:tliPMap"/>
            <xsd:element name="tliPUnmap" type="Events:tliPUnmap"/>
            <xsd:element name="tliPClear" type="Events:tliPClear"/>
            <xsd:element name="tliPStart" type="Events:tliPStart"/>
            <xsd:element name="tliPStop" type="Events:tliPStop"/>
            <xsd:element name="tliPHalt" type="Events:tliPHalt"/>
            
            <! codec >
            <xsd:element name="tliDecode" type="Events:tliDecode"/>
            <xsd:element name="tliEncode" type="Events:tliEncode"/>
            
            <! timers >
            <xsd:element name="tliTTimeoutDetected" type="Events:tliTTimeoutDetected"/>
            <xsd:element name="tliTTimeoutMismatch" type="Events:tliTTimeoutMismatch"/>
            <xsd:element name="tliTTimeout" type="Events:tliTTimeout"/>
            <xsd:element name="tliTStart" type="Events:tliTStart"/>
            <xsd:element name="tliTStop" type="Events:tliTStop"/>
            <xsd:element name="tliTRead" type="Events:tliTRead"/>
            <xsd:element name="tliTRunning" type="Events:tliTRunning"/>
            
            <! scopes >
            <xsd:element name="tliSEnter" type="Events:tliSEnter"/>
            <xsd:element name="tliSLeave" type="Events:tliSLeave"/>
            
            <! statements >
            <xsd:element name="tliVar" type="Events:tliVar"/>
            <xsd:element name="tliModulePar" type="Events:tliModulePar"/>
            <xsd:element name="tliGetVerdict" type="Events:tliGetVerdict"/>
            <xsd:element name="tliSetVerdict" type="Events:tliSetVerdict"/>
            <xsd:element name="tliLog" type="Events:tliLog"/>
            
            <! alt  >
            <xsd:element name="tliAEnter" type="Events:tliAEnter"/>
            <xsd:element name="tliALeave" type="Events:tliALeave"/>
            <xsd:element name="tliADefaults" type="Events:tliADefaults"/>
            <xsd:element name="tliAActivate" type="Events:tliAActivate"/>
            <xsd:element name="tliADeactivate" type="Events:tliADeactivate"/>
            <xsd:element name="tliANomatch" type="Events:tliANomatch"/>
            <xsd:element name="tliARepeat" type="Events:tliARepeat"/>
            <xsd:element name="tliAWait" type="Events:tliAWait"/>
            
            <! action  >
            <xsd:element name="tliAction" type="Events:tliAction"/>

            <! match  >
            <xsd:element name="tliMatch" type="Events:tliMatch"/>
            <xsd:element name="tliMatchMismatch" type="Events:tliMatchMismatch"/>
            
            <! info  >
            <xsd:element name="tliInfo" type="Events:tliInfo"/>
        </xsd:choice>
    </xsd:complexType>
</xsd:schema>


Annex C

Use scenarios
(This annex does not form an integral part of this Recommendation)
This annex contains use scenarios that should help users of the TCI and tool vendors providing the TCI understand the semantics of the operations defined within this Recommendation. 
The scenarios are defined in terms of UML sequence diagrams. The sequence diagram shows the interactions between the TCI entities. The scenarios are explained and where applicable underpinned with a TTCN3 fragment corresponding to the scenario.
C.1	Initialization, collecting information, logging
C.1.1	Use scenario: initialization
The scenario in Figure C.1 shows the initialization phase for a test system when a TTCN3 module is to be selected for execution. At first, a root module has to be set with tciRootModule. The module parameters of the root module can be obtained with tciGetModuleParameters. Module parameter information can be used to ask the test system user for concrete values for each module parameter. The list of test cases available in the root module can be retrieved with tciGetTestCases. These test cases can be directly executed from the test management. Their parameters and their test system interface can be obtained with tciGetTestCaseParameters and tciGetTestCaseTSI, respectively.
C.1.1.1	Sequence diagram

Figure C.1 – Use scenario – initialization
C.1.1.2	TTCN3 fragment
The initialization is outside the scope of TTCN3.
C.1.2	Use scenario: requesting module parameters
The scenario in Figure C.2 shows how a test component requests the actual value of a module parameter needed for the execution of its test behaviour. At first, the type of a module parameter is requested, then the value can be constructed by the TM and given to the TE.
C.1.2.1	Sequence diagram

Figure C.2 – Use scenario – requesting module Pars
C.1.2.2	TTCN3 fragment

module AModule {
	…
	modulepar {
		integer AModulePar
	}
	…
	function AFunction (…) … {
		integer x;
		…
		x:= 2+AModulePar; // an expression with a module parameter
		…
	}
	…
}

C.1.3	Use scenario: logging
The scenario in Figure C.3 shows logging of information during the execution of a test behaviour by a test component. The message to be logged is propagated to the test logging.
C.1.3.1	Sequence diagram

Figure C.3 – Use scenario – logging
C.1.3.2	TTCN3 fragment

module AModule {
	…
	function AFunction (…) … {
		…
		log(''AMessage'');
		…
	}
	…
}

C.2	Execution of test cases and control
C.2.1	Use scenario: execution of control
The scenario in Figure C.4 shows the sequence of operations to execute the control part of a TTCN3 module. The module containing the control part is selected first, then the control is started, then it is executed until the execution is terminated by TE.
C.2.1.1	Sequence diagram

Figure C.4 – Use scenario – execution of control
C.2.1.2	TTCN3 fragment

module AModule {
	…
	control {
		…
	}
	…
}

C.2.2	Use scenario: test case execution within control
The scenario in Figure C.5 shows how a test case is executed within the control part.
C.2.2.1	Sequence diagram

Figure C.5 – Use scenario – test case execution within control
C.2.2.2	TTCN3 fragment

module AModule {
	…
	testcase ATestCase(…)… {
		… //the test case behaviour
	}
	…
	control {
		…
		execute(ATestCase(…));
		…
	}
	…
}

C.2.3	Use scenario: direct test case execution
The scenario in Figure C.6 shows how a test case can be directly executed from the test management outside the control part. After selecting the TTCN3 module containing the test case to be executed, the start of the test case is requested. When the test case completes its execution, the test management is informed by the TE of the test case termination.
C.2.3.1	Sequence diagram

Figure C.6 – Use scenario – direct test case execution
C.2.3.2	TTCN3 fragment
The direct execution of a test case is outside the scope of TTCN3.
C.2.4	Use scenario: execute test case to TRI
The scenario in Figure C.7 shows how the TRI is informed about the execution of a test case so that it can set up and initialize system ports when needed. The execute test case request has to be issued before the test behaviour on the MTC of the current test case is started.
C.2.4.1	Sequence diagram

Figure C.7 – Use scenario – execute test case to TRI
C.2.4.2	TTCN3 fragment

module AModule {
	…
	testcase ATestCase(…)… {
		… //the test case behaviour
	}
	…
	control {
		…
		execute(ATestCase(…));
		…
	}
	…
}

C.3	Component handling
C.3.1	Use scenario: local control component creation
The scenario in Figure C.8 demonstrates the creation of the control component on the same node where the user interface to the test management TCITM resides. A control component is created whenever the control part of a TTCN3 module is executed. Whenever the test management TCITM issues the start of the control part, a create test component request is sent to the TCICH, which propagates it to the TE where the control component should be created. In this case it is the TE on the same node. The identifier for the control component is returned and given to the TCITM. The identifier is then used to start the behaviour of the control part on the control component.
C.3.1.1	Sequence diagram

Figure C.8 – Use scenario – local control component creation
C.3.1.2	TTCN3 fragment

module AModule {
	…
	control {
		…
	}
	…
}

C.3.2	Use scenario: remote control component creation
The scenario in Figure C.9 demonstrates the creation of the control component on another node than where the user interface to the test management TCITM resides. A control component is created whenever the control part of a TTCN3 module is executed. Whenever the test management TCITM issues the start of the control part, a create test component request is sent to the TCICH, which propagates it to the TE where the control component should be created. In this case it is the TE on another remote node. The identifier for the control component is returned and given to the TCITM. The identifier is then used to start the behaviour of the control part on the control component.
C.3.2.1	Sequence diagram

Figure C.9 – Use scenario – remote control component creation
C.3.2.2	TTCN3 fragment

module AModule {
	…
	control {
		…
	}
	…
}
C.3.3	Use scenario: local MTC creation
The scenario in Figure C.10 demonstrates the local creation of the main test component. Local is meant for two cases:
1)	on the same node where the user interface to the test management TCITM resides (when a test case is started directly); or
2)	on the same node where the control component resides (when a test case is executed from a control part).
A main test component is created whenever a test case is executed: a create test component request is sent to the TCICH, which propagates it to the TE where the main test component should be created. In this case it is the TE on the same node. The identifier for the main test component is returned and given to the TCITM. The identifier is then used to start the test case behaviour on the main test component (this is not shown here, but handled the same way as in the scenarios described in clauses C.2.2 and C.2.3).
C.3.3.1	Sequence diagram

Figure C.10 – Use scenario – local MTC creation
C.3.3.2	TTCN3 fragment

module AModule {
	…
	testcase ATestCase (…)runs on MTCType… {
		… //the test case behaviour
	}
	…
}

C.3.4	Use scenario: remote MTC creation
The scenario in Figure C.11 demonstrates the remote creation of the main test component. Remote is meant for two cases:
1)	on another node than where the user interface to the test management TCITM resides (when a test case is started directly); or
2)	on another node than where the control component resides (when a test case is executed from a control part).
A main test component is created whenever a test case is executed: a create test component request is sent to the TCICH, which propagates it to the TE where the main test component should be created. In this case it is the TE on another node. The identifier for the main test component is returned and given to the TCITM. The identifier is then used to start the test case behaviour on the main test component (this is not shown here, but handled the same way as in the scenarios described in clauses C.2.2 and C.2.3).
C.3.4.1	Sequence diagram

Figure C.11 – Use scenario – remote MTC creation
C.3.4.2	TTCN3 fragment

module AModule {
	…
	testcase ATestCase(…)runs on MTCType … {
		… //the test case behaviour
	}
	…
}

C.3.5	Use scenario: component handling for test case execution within control
The scenario in Figure C.12 demonstrates the handling of components for the test case execution within a control part. When the control part is started, a control component is created and its component identifier returned to the test management. For each test case to be executed within the control part, a main test component is created and the component identifier returned to the control component. Afterwards, the test case behaviour is started on the main test component and the test management is informed about the start of the test case. When the main test component terminates, a request for the main test component termination together with the local verdict of the main test component is propagated to enable the derivation of the global test verdict and to enable the information about the test case termination.
C.3.5.1	Sequence diagram

Figure C.12 – Use scenario – component handling for test case execution within control
C.3.5.2	TTCN3 fragment

module AModule {
	…
	testcase ATestCase(…)… {
		… //the test case behaviour
	}
	…
	control {
		…
		execute(ATestCase(…));
		…
	}
	…
}

C.3.6	Use scenario: component handling for direct test case execution
The scenario in Figure C.13 shows how test components are handled when a test case is executed directly, i.e., outside a control part. When a test case is started, the main test component is created and the test case behaviour started on this main test component at first. Whenever a parallel test component is used within a test case, it is handled the same: the parallel test component is started first: giving a test component create request to the TCICH entity, which propagates the test component create to the TE in which the parallel test component is to be created. The identifier for the created parallel test component is returned. The identifier is then used to start the PTC behaviour for the start operation. When the PTC terminates its execution, a test component terminate request together with the local test verdict is issued to inform TCICH about this termination. The same is done when the main test component terminates. In addition, the termination of the main test component leads to the overall termination of the test case.
C.3.6.1	Sequence diagram

Figure C.13 – Use scenario – component handling for direct test case execution
C.3.6.2	TTCN3 fragment

module AModule {
	…
	function APTCBehaviour(…) runs on APTCType {
		… //the PTC behaviour
	}
	…
	testcase ATestCase(…)… {
		… //the test case behaviour
		var APTCType PTC:= APTCType.create;
		…
		PTC.start(APTCBehaviour(…));
		…
	}
	…
}
C.3.7	Use scenario: propagation of map/connect
The scenario in Figure C.14 shows how ports are mapped. The request to map a port is propagated to the TE where the map is finally performed. The propagation of connect requests works analogously.
C.3.7.1	Sequence diagram

Figure C.14 – Use scenario – propagation of map
C.3.7.2	TTCN3 fragment

module AModule {
	…
	type port A { … }
	type component CA { port A a }
		type component CB { port A a }
	…
	testcase ATestCase(…)runs on CA system CB {
		var CA ptc := CA.create;
		… //the test case behaviour
		map(ptc:a, System:a);
		…
	}
	…
}

C.3.8	Use scenario: propagation of unmap/disconnect
The scenario in Figure C.15 shows how ports are unmapped. The request to unmap a port is propagated to the TE where the unmap is finally performed. The propagation of disconnect requests works analogously.
C.3.8.1	Sequence diagram

Figure C.15 – Use scenario – propagation of map
C.3.8.2	TTCN3 fragment

module AModule {
	…
	type port A { … }
	type component CA { port A a }
	type component CB { port A a }
	…
	testcase ATestCase(…)runs on CA system CB {
		var CA ptc := CA.create;
		… //the test case behaviour
		unmap(ptc:a,system:a);
		…
	}
	…
}

C.4	Termination of test cases and control
C.4.1	Use scenario: stop a test case
The scenario in Figure C.16 shows how a test case is stopped from the test management during test case execution. Once the TM has received information about a started test case, a stop test case can be requested up until receiving the information that the test case has been terminated. Upon stopping a test case, all parallel test components will be stopped and the test system will be reset.
C.4.1.1	Sequence diagram

Figure C.16 – Use scenario – stop a test case
C.4.1.2	TTCN3 fragment
There is no TTCN3 code related to how the TM chooses to implement test case termination. This is outside the scope of TTCN3.
C.4.2	Use scenario: stop control
The scenario in Figure C.17 shows how a control part is stopped from the test management during control part execution. A control part can be stopped in between starting the control and its termination. If the control part receives a stop test case request while a test case is executing, the executing test case is to be stopped. Furthermore, the test system is to be reset as described in Figure C.16.
C.4.2.1	Sequence diagram

Figure C.17 – Use scenario – stop control
C.4.2.2	TTCN3 fragment
Stopping a control part from the test management is outside the scope of TTCN3 so that no TTCN3 fragment exists.
C.4.3	Use scenario: termination of control after error
The scenario in Figure C.18 shows the handling of error situations during the execution of a control part when no test case is being executed. The test management is informed about the error situation and has then to terminate the execution of the control part explicitly. Upon termination of the control part, the test system will be reset.
C.4.3.1	Sequence diagram

Figure C.18 – Use scenario – termination of control after error
C.4.3.2	TTCN3 fragment
There is no TTCN3 fragment for this scenario since error situations are exceptional cases in a test system and not a TTCN3 concept as such. Rather, the TTCN3 semantics describes various potential error situations in a test system.
C.4.4	Use scenario: termination of a test case after error
The scenario in Figure C.19 shows the handling of error situations during the direct execution of a test case. The test management is informed about the error situation. The TM has then to explicitly terminate test case execution. Upon stopping a test case, the parallel test components will be stopped and the test system is to be reset.

C.4.4.1	Sequence diagram

Figure C.19 – Use scenario – termination of a test case after error

C.4.4.2	TTCN3 fragment
There is no TTCN3 fragment for this scenario since error situations are exceptional cases in a test system and not a TTCN3 concept as such. Rather, the TTCN3 semantics describes various potential error situations in a test system.
C.4.5	Use scenario: reset
The scenario in Figure C.20 shows the reset of the test system. In that case all involved TEs together with their TRI System Adaptors (SA) and Platform Adaptors (PA) are reset.
C.4.5.1	Sequence diagram

Figure C.20 – Use scenario – reset
C.4.5.2	TTCN3 fragment
There is no TTCN3 fragment for this scenario since reset as required after error situations are exceptional cases in a test system and not a TTCN3 concept as such.
C.5	Communication
C.5.1	Use scenario: local intercomponent communication
The scenario in Figure C.21 shows the communication between test components (main test component or parallel test components), which reside on the same node. A communication request is given to the TCICH, which then decide where to enqueue this communication template. In this case, the communication is done locally via the TE on the same node. The scenario shows a messagebased communication using the send operation – the scenario is the same for call, reply, and raise operations.
C.5.1.1	Sequence diagram

Figure C.21 – Use scenario – local intercomponent communication
C.5.1.2	TTCN3 fragment

module AModule {
	…
	type port APortType message { … }
	…
	type component ATCType {
		…
		APortType APort;
		…
	}
	…
	template AType AMessageTemplate { … }
	…
	function APTCBehaviour(…) runs on APTCType {
		… //the PTC behaviour
	…
	}
	…
	testcase ATestCase(…) runs on ATCType… {
		… //the test case behaviour
		var ATCType PTC1:= ATCType.create;
		connect(PTC1:APort,mtc:APort);
		…
		PTC1.start(APTCBehaviour(…));
		APort.send(AMessageTemplate); //sending data to a test component
		…
	}
	…
}

C.5.2	Use scenario: internode communication between test components
The scenario in Figure C.22 shows the communication between test components (main test component or parallel test components), which reside on different nodes. A communication request is given to the TCICH, which then decides where to enqueue this communication template. In this case, the communication is done remotely via the TE on another node. The scenario shows a message based communication using the send operation – the scenario is the same for call, reply, and raise operations.
C.5.2.1	Sequence diagram

Figure C.22 – Use scenario – internode communication between test components
C.5.2.2	TTCN3 fragment

module AModule {
	…
	type port APortType message { … }
	…
	type component ATCType {
		…
		APortType APort;
		…
	}
	…
	template AType AMessageTemplate { … }
	…
	function APTCBehaviour(…) runs on APTCType {
		… //the PTC behaviour
	…
	}
	…
	testcase ATestCase(…) runs on ATCType… {
		… //the test case behaviour
		var ATCType PTC1:= ATCType.create;
		connect(PTC1:APort,mtc:APort);
		…
		PTC1.start(APTCBehaviour(…));
		APort.send(AMessageTemplate); //sending data to a test component
		…
	}
	…
}

C.5.3	Use scenario: encoding
The scenario in Figure C.23 shows the encoding of data, which is sent to the SUT. The encoded data is received from the coding/decoding entity via the TCICD. The encoded value is sent to the SUT via the TRISA. The scenario is the same for the call, the reply, and the raise operations.
C.5.3.1	Sequence diagram

Figure C.23 – Use scenario – encoding
C.5.3.2	TTCN3 fragment

module AModule {
	…
	type port APortType message { … }
	…
	type component APTCType {
		…
		APortType APort;
		…
	}
	…
	template AType AMessageTemplate { … }
	…
	testcase ATestCase(…) runs on APTCType system APTCType {
		… //the test case behaviour
		map(mtc:APort,system:APort);
		…
		APort.send(AMessageTemplate); //sending data to the SUT
		…
	}
	…
} with { encoding = ''…'' }

C.5.4	Use scenario: decoding
The scenario in Figure C.24 shows the decoding of data, which is received from the SUT via the TRISA. The decoded data is received from the coding/decoding entity via the TCICD. The scenario is the same for the receive, the getcall, the getreply, the catch, and the check operations.
C.5.4.1	Sequence diagram

Figure C.24 – Use scenario – decoding
C.5.4.2	TTCN3 fragment

module AModule {
	…
	type port APortType message { … }
	…
	type component APTCType {
		…
		APortType APort;
		…
	}
	…
	template AType AMessageTemplate { … }
	…
	testcase ATestCase(…) runs on APTCType system APTCType {
		… //the test case behaviour
		map(mtc:APort,system:APort);
		…
		APort.receive(AMessageTemplate); //receiving data from the SUT
		…
	}
	…
} with { encoding = ''…'' }





SERIES OF ITU-T RECOMMENDATIONS
Series A
Organization of the work of ITU-T
Series D
General tariff principles
Series E
Overall network operation, telephone service, service operation and human factors
Series F
Non-telephone telecommunication services
Series G
Transmission systems and media, digital systems and networks
Series H
Audiovisual and multimedia systems
Series I
Integrated services digital network
Series J
Cable networks and transmission of television, sound programme and other multimedia signals
Series K
Protection against interference
Series L
Construction, installation and protection of cables and other elements of outside plant
Series M
Telecommunication management, including TMN and network maintenance
Series N
Maintenance: international sound programme and television transmission circuits
Series O
Specifications of measuring equipment
Series P
Terminals and subjective and objective assessment methods
Series Q
Switching and signalling
Series R
Telegraph transmission
Series S
Telegraph services terminal equipment
Series T
Terminals for telematic services
Series U
Telegraph switching
Series V
Data communication over the telephone network
Series X
Data networks, open system communications and security
Series Y
Global information infrastructure, Internet protocol aspects and next-generation networks
Series Z
Languages and general software aspects for telecommunication systems







		Rec. ITUT Z.166 (03/2011)	1

					Rec. ITUT Z.166 (03/2011)	69

		Rec. ITUT Z.166 (03/2011)	73













Printed in Switzerland
Geneva, 2011

Printed in Switzerland
Geneva,