OpenV2G/src/service/v2g_serviceDataSerialization.c

/*
 * Copyright (C) 2007-2012 Siemens AG
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/*******************************************************************
 *
 * @author Sebastian.Kaebisch.EXT@siemens.com
 * @version 0.6
 * @contact Joerg.Heuer@siemens.com
 *
 * <p>Code generated by EXISeGen</p>
 *
 ********************************************************************/


#include "v2g_service.h"
#include "v2g_serviceDataTypes.h"

#include "EXITypes.h"
#include "EXIEncoder.h"
#include <string.h>
 
 
 
 
 

static int serialize_NotificationType(struct NotificationType* type, struct EXIService* service)
{
	
			/* element ID assignment of FaultCode*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=74;	


			/* encode start element FaultCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->FaultCode;
			
			/* encode character  FaultCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of FaultCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.FaultMsg)
		{		
					
			/* element ID assignment of FaultMsg*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=75;	


			/* encode start element FaultMsg */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->FaultMsg.arraylen.data;
			memcpy(service->val.string.codepoints, type->FaultMsg.data,type->FaultMsg.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  FaultMsg */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of FaultMsg */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_CanonicalizationMethodType(struct CanonicalizationMethodType* type, struct EXIService* service)
{
	
			/* element ID assignment of attr_Algorithm*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=0;	

			service->val.type = STRING;
			service->val.string.len = type->attr_Algorithm.arraylen.data;
			service->val.string.codepoints= type->attr_Algorithm.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}


	return 0;			
}


static int serialize_SignatureMethodType(struct SignatureMethodType* type, struct EXIService* service)
{
	
			/* element ID assignment of attr_Algorithm*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=0;	

			service->val.type = STRING;
			service->val.string.len = type->attr_Algorithm.arraylen.data;
			service->val.string.codepoints= type->attr_Algorithm.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}


	return 0;			
}


static int serialize_DigestMethodType(struct DigestMethodType* type, struct EXIService* service)
{
	
			/* element ID assignment of attr_Algorithm*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=0;	

			service->val.type = STRING;
			service->val.string.len = type->attr_Algorithm.arraylen.data;
			service->val.string.codepoints= type->attr_Algorithm.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}


	return 0;			
}


static int serialize_ReferenceType(struct ReferenceType* type, struct EXIService* service)
{


	if(type->isused.attr_URI)
		{		
					
			/* element ID assignment of attr_URI*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=7;

			service->val.type = STRING;
			service->val.string.len = type->attr_URI.arraylen.data;
			service->val.string.codepoints= type->attr_URI.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}
		}


			/* element ID assignment of DigestMethod*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=5;	


			/* encode start element DigestMethod */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DigestMethod */
			if(serialize_DigestMethodType( &(type->DigestMethod),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DigestMethod */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of DigestValue*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=7;	


			/* encode start element DigestValue */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_BASE64;
		service->val.binary.len = type->DigestValue.arraylen.data;
		memcpy(service->val.binary.data, type->DigestValue.data,type->DigestValue.arraylen.data);
		
		
		/* encode character  DigestValue */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of DigestValue */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_SignedInfoType(struct SignedInfoType* type, struct EXIService* service)
{

			/* element ID assignment of CanonicalizationMethod*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=0;	


			/* encode start element CanonicalizationMethod */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of CanonicalizationMethod */
			if(serialize_CanonicalizationMethodType( &(type->CanonicalizationMethod),service))
			{
				return -1;
			}

			
			 
			/* encode end element of CanonicalizationMethod */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of SignatureMethod*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=43;	


			/* encode start element SignatureMethod */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of SignatureMethod */
			if(serialize_SignatureMethodType( &(type->SignatureMethod),service))
			{
				return -1;
			}

			
			 
			/* encode end element of SignatureMethod */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

			
			/* element ID assignment of Reference*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=34;	


			/* encode start element Reference */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			/* encode children of Reference */
			if(serialize_ReferenceType(&(type->Reference[0]),service))
			{
				return -1;
			}
			
			 
			/* encode end element of Reference */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

				

	return 0;			
}


static int serialize_X509IssuerSerialType(struct X509IssuerSerialType* type, struct EXIService* service)
{
	
			/* element ID assignment of X509IssuerName*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=62;	


			/* encode start element X509IssuerName */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->X509IssuerName.arraylen.data;
			memcpy(service->val.string.codepoints, type->X509IssuerName.data,type->X509IssuerName.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  X509IssuerName */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of X509IssuerName */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of X509SerialNumber*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=66;	


			/* encode start element X509SerialNumber */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int64=type->X509SerialNumber;
			service->val.integer.type = INTEGER_64;
			
			/* encode character  X509SerialNumber */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of X509SerialNumber */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_X509DataType(struct X509DataType* type, struct EXIService* service)
{
	
			/* element ID assignment of X509IssuerSerial*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=63;	


			/* encode start element X509IssuerSerial */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of X509IssuerSerial */
			if(serialize_X509IssuerSerialType( &(type->X509IssuerSerial),service))
			{
				return -1;
			}

			
			 
			/* encode end element of X509IssuerSerial */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of X509SKI*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=65;	


			/* encode start element X509SKI */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_BASE64;
		service->val.binary.len = type->X509SKI.arraylen.data;
		memcpy(service->val.binary.data, type->X509SKI.data,type->X509SKI.arraylen.data);
		
		
		/* encode character  X509SKI */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of X509SKI */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of X509SubjectName*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=67;	


			/* encode start element X509SubjectName */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->X509SubjectName.arraylen.data;
			memcpy(service->val.string.codepoints, type->X509SubjectName.data,type->X509SubjectName.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  X509SubjectName */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of X509SubjectName */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of X509Certificate*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=59;	


			/* encode start element X509Certificate */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_BASE64;
		service->val.binary.len = type->X509Certificate.arraylen.data;
		memcpy(service->val.binary.data, type->X509Certificate.data,type->X509Certificate.arraylen.data);
		
		
		/* encode character  X509Certificate */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of X509Certificate */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of X509CRL*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=58;	


			/* encode start element X509CRL */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_BASE64;
		service->val.binary.len = type->X509CRL.arraylen.data;
		memcpy(service->val.binary.data, type->X509CRL.data,type->X509CRL.arraylen.data);
		
		
		/* encode character  X509CRL */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of X509CRL */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_KeyInfoType(struct KeyInfoType* type, struct EXIService* service)
{

	if(type->isused.attr_Id)
		{		
					
			/* element ID assignment of attr_Id*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=2;	

			service->val.type = STRING;
			service->val.string.len = type->attr_Id.arraylen.data;
			service->val.string.codepoints= type->attr_Id.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}
		}
	
			/* element ID assignment of X509Data*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=60;	


			/* encode start element X509Data */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of X509Data */
			if(serialize_X509DataType( &(type->X509Data),service))
			{
				return -1;
			}

			
			 
			/* encode end element of X509Data */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_SignatureType(struct SignatureType* type, struct EXIService* service)
{

	if(type->isused.attr_Id)
		{		
					
			/* element ID assignment of attr_Id*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=2;	

			service->val.type = STRING;
			service->val.string.len = type->attr_Id.arraylen.data;
			service->val.string.codepoints= type->attr_Id.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}
		}
	
			/* element ID assignment of SignedInfo*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=52;	


			/* encode start element SignedInfo */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of SignedInfo */
			if(serialize_SignedInfoType( &(type->SignedInfo),service))
			{
				return -1;
			}

			
			 
			/* encode end element of SignedInfo */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of SignatureValue*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=50;	

			/* encode start element SignatureValue */
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn)))
			{
					return -1;
			}

			service->val.type = BINARY_BASE64;
			service->val.binary.len = type->SignatureValue.arraylen.data;
			service->val.binary.data= type->SignatureValue.data;

		/* encode character  DigestValue */
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val)))
		{

				return -1;
		}



			/* encode end element of SignatureValue */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.KeyInfo)
		{		
					
			/* element ID assignment of KeyInfo*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=14;	


			/* encode start element KeyInfo */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of KeyInfo */
			if(serialize_KeyInfoType( &(type->KeyInfo),service))
			{
				return -1;
			}

			
			 
			/* encode end element of KeyInfo */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_MessageHeaderType(struct MessageHeaderType* type, struct EXIService* service)
{
	
			/* element ID assignment of SessionID*/
			service->eqn.namespaceURI=8;			
			service->eqn.localPart=2;	


			/* encode start element SessionID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_HEX;
		service->val.binary.len = type->SessionID.arraylen.data;
		memcpy(service->val.binary.data, type->SessionID.data,type->SessionID.arraylen.data);
		
		
		/* encode character  SessionID */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of SessionID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.Notification)
		{		
					
			/* element ID assignment of Notification*/
			service->eqn.namespaceURI=8;			
			service->eqn.localPart=1;	


			/* encode start element Notification */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of Notification */
			if(serialize_NotificationType( &(type->Notification),service))
			{
				return -1;
			}

			
			 
			/* encode end element of Notification */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.Signature)
		{		
					
			/* element ID assignment of Signature*/
			service->eqn.namespaceURI=4;			
			service->eqn.localPart=42;	


			/* encode start element Signature */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of Signature */
			if(serialize_SignatureType( (type->Signature),service))
			{
				return -1;
			}

			
			 
			/* encode end element of Signature */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_SessionSetupReqType(struct SessionSetupReqType* type, struct EXIService* service)
{
	
			/* element ID assignment of EVCCID*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=41;	


			/* encode start element EVCCID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_HEX;
		service->val.binary.len = type->EVCCID.arraylen.data;
		memcpy(service->val.binary.data, type->EVCCID.data,type->EVCCID.arraylen.data);
		
		
		/* encode character  EVCCID */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of EVCCID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_SessionSetupResType(struct SessionSetupResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSEID*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=47;	


			/* encode start element EVSEID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_HEX;
		service->val.binary.len = type->EVSEID.arraylen.data;
		memcpy(service->val.binary.data, type->EVSEID.data,type->EVSEID.arraylen.data);
		
		
		/* encode character  EVSEID */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of EVSEID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.DateTimeNow)
		{		
					
			/* element ID assignment of DateTimeNow*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=40;	


			/* encode start element DateTimeNow */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int64=type->DateTimeNow;
			service->val.integer.type = INTEGER_64;
			
			/* encode character  DateTimeNow */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of DateTimeNow */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_ServiceDiscoveryReqType(struct ServiceDiscoveryReqType* type, struct EXIService* service)
{

	if(type->isused.ServiceScope)
		{		
					
			/* element ID assignment of ServiceScope*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=104;	


			/* encode start element ServiceScope */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->ServiceScope.arraylen.data;
			memcpy(service->val.string.codepoints, type->ServiceScope.data,type->ServiceScope.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  ServiceScope */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of ServiceScope */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ServiceCategory)
		{		
					
			/* element ID assignment of ServiceCategory*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=88;	


			/* encode start element ServiceCategory */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ServiceCategory;
			
			/* encode character  ServiceCategory */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ServiceCategory */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_PaymentOptionsType(struct PaymentOptionsType* type, struct EXIService* service)
{

			size_t i_loop;
	
	for(i_loop=0;i_loop < type->arraylen.PaymentOption;i_loop++)
		{
			
			/* element ID assignment of PaymentOption*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=99;	


			/* encode start element PaymentOption */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->PaymentOption[i_loop];
			
			/* encode character  PaymentOption */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of PaymentOption */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_ServiceTagType(struct ServiceTagType* type, struct EXIService* service)
{
	
			/* element ID assignment of ServiceID*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=130;	


			/* encode start element ServiceID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = UNSIGNED_INTEGER;
			service->val.integer.val.uint16=type->ServiceID;
			service->val.integer.type = UNSIGNED_INTEGER_16;
			
			/* encode character  ServiceID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ServiceID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.ServiceName)
		{		
					
			/* element ID assignment of ServiceName*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=131;	


			/* encode start element ServiceName */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->ServiceName.arraylen.data;
			memcpy(service->val.string.codepoints, type->ServiceName.data,type->ServiceName.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  ServiceName */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of ServiceName */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ServiceCategory)
		{		
					
			/* element ID assignment of ServiceCategory*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=127;	


			/* encode start element ServiceCategory */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ServiceCategory;
			
			/* encode character  ServiceCategory */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ServiceCategory */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ServiceScope)
		{		
					
			/* element ID assignment of ServiceScope*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=133;	


			/* encode start element ServiceScope */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->ServiceScope.arraylen.data;
			memcpy(service->val.string.codepoints, type->ServiceScope.data,type->ServiceScope.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  ServiceScope */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of ServiceScope */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_ServiceChargeType(struct ServiceChargeType* type, struct EXIService* service)
{
	
			/* element ID assignment of ServiceTag*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=134;	


			/* encode start element ServiceTag */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ServiceTag */
			if(serialize_ServiceTagType( &(type->ServiceTag),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ServiceTag */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of FreeService*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=76;	


			/* encode start element FreeService */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->FreeService;
			
			/* encode character  FreeService */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of FreeService */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EnergyTransferType*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=71;	


			/* encode start element EnergyTransferType */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->EnergyTransferType;
			
			/* encode character  EnergyTransferType */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of EnergyTransferType */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_ServiceType(struct ServiceType* type, struct EXIService* service)
{
	
			/* element ID assignment of ServiceTag*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=134;	


			/* encode start element ServiceTag */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ServiceTag */
			if(serialize_ServiceTagType( &(type->ServiceTag),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ServiceTag */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of FreeService*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=76;	


			/* encode start element FreeService */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->FreeService;
			
			/* encode character  FreeService */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of FreeService */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_ServiceTagListType(struct ServiceTagListType* type, struct EXIService* service)
{

			size_t i_loop;
	
	for(i_loop=0;i_loop < type->arraylen.Service;i_loop++)
		{
			
			/* element ID assignment of Service*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=126;	


			/* encode start element Service */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			/* encode children of Service */
			if(serialize_ServiceType(&(type->Service[i_loop]),service))
			{
				return -1;
			}
			
			 
			/* encode end element of Service */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_ServiceDiscoveryResType(struct ServiceDiscoveryResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of PaymentOptions*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=70;	


			/* encode start element PaymentOptions */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of PaymentOptions */
			if(serialize_PaymentOptionsType( &(type->PaymentOptions),service))
			{
				return -1;
			}

			
			 
			/* encode end element of PaymentOptions */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ChargeService*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=18;	


			/* encode start element ChargeService */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ChargeService */
			if(serialize_ServiceChargeType( &(type->ChargeService),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ChargeService */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.ServiceList)
		{		
					
			/* element ID assignment of ServiceList*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=98;	


			/* encode start element ServiceList */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ServiceList */
			if(serialize_ServiceTagListType( &(type->ServiceList),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ServiceList */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_ServiceDetailReqType(struct ServiceDetailReqType* type, struct EXIService* service)
{
	
			/* element ID assignment of ServiceID*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=97;	


			/* encode start element ServiceID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = UNSIGNED_INTEGER;
			service->val.integer.val.uint16=type->ServiceID;
			service->val.integer.type = UNSIGNED_INTEGER_16;
			
			/* encode character  ServiceID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ServiceID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_PhysicalValueType(struct PhysicalValueType* type, struct EXIService* service)
{
	
			/* element ID assignment of Multiplier*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=84;	


			/* encode start element Multiplier */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = NBIT_UNSIGNED_INTEGER;
			service->val.integer.val.int8=type->Multiplier;
			service->val.integer.type = INTEGER_8;
			
			/* encode character  Multiplier */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of Multiplier */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.Unit)
		{		
					
			/* element ID assignment of Unit*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=145;	


			/* encode start element Unit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->Unit;
			
			/* encode character  Unit */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of Unit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
					
			/* element ID assignment of Value*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=146;	


			/* encode start element Value */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int16=type->Value;
			service->val.integer.type = INTEGER_16;
			
			/* encode character  Value */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of Value */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_ParameterType(struct ParameterType* type, struct EXIService* service)
{
	
			/* element ID assignment of attr_Name*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=4;	

			service->val.type = STRING;
			service->val.string.len = type->attr_Name.arraylen.data;
			service->val.string.codepoints= type->attr_Name.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}
	
			/* element ID assignment of attr_ValueType*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=8;	

			service->val.type = STRING;
			service->val.string.len = type->attr_ValueType.arraylen.data;
			service->val.string.codepoints= type->attr_ValueType.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}
	
			/* element ID assignment of boolValue*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=149;	


			/* encode start element boolValue */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->boolValue;
			
			/* encode character  boolValue */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of boolValue */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of byteValue*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=150;	


			/* encode start element byteValue */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = NBIT_UNSIGNED_INTEGER;
			service->val.integer.val.int8=type->byteValue;
			service->val.integer.type = INTEGER_8;
			
			/* encode character  byteValue */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of byteValue */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of shortValue*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=177;	


			/* encode start element shortValue */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int16=type->shortValue;
			service->val.integer.type = INTEGER_16;
			
			/* encode character  shortValue */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of shortValue */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of intValue*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=162;	


			/* encode start element intValue */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int32=type->intValue;
			service->val.integer.type = INTEGER_32;
			
			/* encode character  intValue */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of intValue */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of physicalValue*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=168;	


			/* encode start element physicalValue */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of physicalValue */
			if(serialize_PhysicalValueType( &(type->physicalValue),service))
			{
				return -1;
			}

			
			 
			/* encode end element of physicalValue */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of stringValue*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=181;	


			/* encode start element stringValue */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->stringValue.arraylen.data;
			memcpy(service->val.string.codepoints, type->stringValue.data,type->stringValue.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  stringValue */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of stringValue */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_ParameterSetType(struct ParameterSetType* type, struct EXIService* service)
{

			size_t i_loop;
		
			/* element ID assignment of ParameterSetID*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=96;	


			/* encode start element ParameterSetID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int16=type->ParameterSetID;
			service->val.integer.type = INTEGER_16;
			
			/* encode character  ParameterSetID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ParameterSetID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	for(i_loop=0;i_loop < type->arraylen.Parameter;i_loop++)
		{
			
			/* element ID assignment of Parameter*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=94;	


			/* encode start element Parameter */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			/* encode children of Parameter */
			if(serialize_ParameterType(&(type->Parameter[i_loop]),service))
			{
				return -1;
			}
			
			 
			/* encode end element of Parameter */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_ServiceParameterListType(struct ServiceParameterListType* type, struct EXIService* service)
{

			size_t i_loop;
	
	for(i_loop=0;i_loop < type->arraylen.ParameterSet;i_loop++)
		{
			
			/* element ID assignment of ParameterSet*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=95;	


			/* encode start element ParameterSet */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			/* encode children of ParameterSet */
			if(serialize_ParameterSetType(&(type->ParameterSet[i_loop]),service))
			{
				return -1;
			}
			
			 
			/* encode end element of ParameterSet */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_ServiceDetailResType(struct ServiceDetailResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ServiceID*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=97;	


			/* encode start element ServiceID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = UNSIGNED_INTEGER;
			service->val.integer.val.uint16=type->ServiceID;
			service->val.integer.type = UNSIGNED_INTEGER_16;
			
			/* encode character  ServiceID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ServiceID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.ServiceParameterList)
		{		
					
			/* element ID assignment of ServiceParameterList*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=99;	


			/* encode start element ServiceParameterList */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ServiceParameterList */
			if(serialize_ServiceParameterListType( &(type->ServiceParameterList),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ServiceParameterList */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_SelectedServiceType(struct SelectedServiceType* type, struct EXIService* service)
{
	
			/* element ID assignment of ServiceID*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=130;	


			/* encode start element ServiceID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = UNSIGNED_INTEGER;
			service->val.integer.val.uint16=type->ServiceID;
			service->val.integer.type = UNSIGNED_INTEGER_16;
			
			/* encode character  ServiceID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ServiceID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.ParameterSetID)
		{		
					
			/* element ID assignment of ParameterSetID*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=96;	


			/* encode start element ParameterSetID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int16=type->ParameterSetID;
			service->val.integer.type = INTEGER_16;
			
			/* encode character  ParameterSetID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ParameterSetID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_SelectedServiceListType(struct SelectedServiceListType* type, struct EXIService* service)
{

			size_t i_loop;
	
	for(i_loop=0;i_loop < type->arraylen.SelectedService;i_loop++)
		{
			
			/* element ID assignment of SelectedService*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=123;	


			/* encode start element SelectedService */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			/* encode children of SelectedService */
			if(serialize_SelectedServiceType(&(type->SelectedService[i_loop]),service))
			{
				return -1;
			}
			
			 
			/* encode end element of SelectedService */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_ServicePaymentSelectionReqType(struct ServicePaymentSelectionReqType* type, struct EXIService* service)
{
	
			/* element ID assignment of SelectedPaymentOption*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=86;	


			/* encode start element SelectedPaymentOption */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->SelectedPaymentOption;
			
			/* encode character  SelectedPaymentOption */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of SelectedPaymentOption */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of SelectedServiceList*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=87;	


			/* encode start element SelectedServiceList */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of SelectedServiceList */
			if(serialize_SelectedServiceListType( &(type->SelectedServiceList),service))
			{
				return -1;
			}

			
			 
			/* encode end element of SelectedServiceList */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_ServicePaymentSelectionResType(struct ServicePaymentSelectionResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_SubCertificatesType(struct SubCertificatesType* type, struct EXIService* service)
{

			size_t i_loop;
	
	for(i_loop=0;i_loop < type->arraylen.Certificate;i_loop++)
		{
			
			/* element ID assignment of Certificate*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=8;	


			/* encode start element Certificate */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_BASE64;
			service->val.binary.len = type->Certificate[i_loop].arraylen.data;
			memcpy(service->val.binary.data, type->Certificate[i_loop].data,type->Certificate[i_loop].arraylen.data);
		
		
		/* encode character  Certificate */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of Certificate */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_CertificateChainType(struct CertificateChainType* type, struct EXIService* service)
{
	
			/* element ID assignment of Certificate*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=8;	


			/* encode start element Certificate */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_BASE64;
		service->val.binary.len = type->Certificate.arraylen.data;
		memcpy(service->val.binary.data, type->Certificate.data,type->Certificate.arraylen.data);
		
		
		/* encode character  Certificate */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of Certificate */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.SubCertificates)
		{		
					
			/* element ID assignment of SubCertificates*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=141;	


			/* encode start element SubCertificates */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of SubCertificates */
			if(serialize_SubCertificatesType( &(type->SubCertificates),service))
			{
				return -1;
			}

			
			 
			/* encode end element of SubCertificates */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_PaymentDetailsReqType(struct PaymentDetailsReqType* type, struct EXIService* service)
{
	
			/* element ID assignment of ContractID*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=30;	


			/* encode start element ContractID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->ContractID.arraylen.data;
			memcpy(service->val.string.codepoints, type->ContractID.data,type->ContractID.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  ContractID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of ContractID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ContractSignatureCertChain*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=31;	


			/* encode start element ContractSignatureCertChain */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ContractSignatureCertChain */
			if(serialize_CertificateChainType( &(type->ContractSignatureCertChain),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ContractSignatureCertChain */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_PaymentDetailsResType(struct PaymentDetailsResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of GenChallenge*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=58;	


			/* encode start element GenChallenge */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->GenChallenge.arraylen.data;
			memcpy(service->val.string.codepoints, type->GenChallenge.data,type->GenChallenge.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  GenChallenge */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of GenChallenge */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of DateTimeNow*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=40;	


			/* encode start element DateTimeNow */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int64=type->DateTimeNow;
			service->val.integer.type = INTEGER_64;
			
			/* encode character  DateTimeNow */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of DateTimeNow */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_ContractAuthenticationReqType(struct ContractAuthenticationReqType* type, struct EXIService* service)
{
	
			/* element ID assignment of attr_Id*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=2;	

			service->val.type = STRING;
			service->val.string.len = type->attr_Id.arraylen.data;
			service->val.string.codepoints= type->attr_Id.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}
	
			/* element ID assignment of GenChallenge*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=58;	


			/* encode start element GenChallenge */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->GenChallenge.arraylen.data;
			memcpy(service->val.string.codepoints, type->GenChallenge.data,type->GenChallenge.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  GenChallenge */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of GenChallenge */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_ContractAuthenticationResType(struct ContractAuthenticationResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_AC_EVChargeParameterType(struct AC_EVChargeParameterType* type, struct EXIService* service)
{
	
			/* element ID assignment of DepartureTime*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=30;	


			/* encode start element DepartureTime */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = UNSIGNED_INTEGER;
			service->val.integer.val.uint32=type->DepartureTime;
			service->val.integer.type = UNSIGNED_INTEGER_32;
			
			/* encode character  DepartureTime */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of DepartureTime */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EAmount*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=31;	


			/* encode start element EAmount */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EAmount */
			if(serialize_PhysicalValueType( &(type->EAmount),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EAmount */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVMaxVoltage*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=40;	


			/* encode start element EVMaxVoltage */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVMaxVoltage */
			if(serialize_PhysicalValueType( &(type->EVMaxVoltage),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVMaxVoltage */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVMaxCurrent*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=39;	


			/* encode start element EVMaxCurrent */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVMaxCurrent */
			if(serialize_PhysicalValueType( &(type->EVMaxCurrent),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVMaxCurrent */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVMinCurrent*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=44;	


			/* encode start element EVMinCurrent */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVMinCurrent */
			if(serialize_PhysicalValueType( &(type->EVMinCurrent),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVMinCurrent */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_DC_EVStatusType(struct DC_EVStatusType* type, struct EXIService* service)
{
	
			/* element ID assignment of EVReady*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=49;	


			/* encode start element EVReady */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->EVReady;
			
			/* encode character  EVReady */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of EVReady */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.EVCabinConditioning)
		{		
					
			/* element ID assignment of EVCabinConditioning*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=33;	


			/* encode start element EVCabinConditioning */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->EVCabinConditioning;
			
			/* encode character  EVCabinConditioning */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of EVCabinConditioning */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.EVRESSConditioning)
		{		
					
			/* element ID assignment of EVRESSConditioning*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=47;	


			/* encode start element EVRESSConditioning */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->EVRESSConditioning;
			
			/* encode character  EVRESSConditioning */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of EVRESSConditioning */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
					
			/* element ID assignment of EVErrorCode*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=38;	


			/* encode start element EVErrorCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->EVErrorCode;
			
			/* encode character  EVErrorCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of EVErrorCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVRESSSOC*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=48;	


			/* encode start element EVRESSSOC */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = NBIT_UNSIGNED_INTEGER;
			service->val.integer.val.int8=type->EVRESSSOC;
			service->val.integer.type = INTEGER_8;
			
			/* encode character  EVRESSSOC */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of EVRESSSOC */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_DC_EVChargeParameterType(struct DC_EVChargeParameterType* type, struct EXIService* service)
{
	
			/* element ID assignment of DC_EVStatus*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=28;	


			/* encode start element DC_EVStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVStatus */
			if(serialize_DC_EVStatusType( &(type->DC_EVStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVMaximumCurrentLimit*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=41;	


			/* encode start element EVMaximumCurrentLimit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVMaximumCurrentLimit */
			if(serialize_PhysicalValueType( &(type->EVMaximumCurrentLimit),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVMaximumCurrentLimit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.EVMaximumPowerLimit)
		{		
					
			/* element ID assignment of EVMaximumPowerLimit*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=42;	


			/* encode start element EVMaximumPowerLimit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVMaximumPowerLimit */
			if(serialize_PhysicalValueType( &(type->EVMaximumPowerLimit),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVMaximumPowerLimit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
					
			/* element ID assignment of EVMaximumVoltageLimit*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=43;	


			/* encode start element EVMaximumVoltageLimit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVMaximumVoltageLimit */
			if(serialize_PhysicalValueType( &(type->EVMaximumVoltageLimit),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVMaximumVoltageLimit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.EVEnergyCapacity)
		{		
					
			/* element ID assignment of EVEnergyCapacity*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=36;	


			/* encode start element EVEnergyCapacity */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVEnergyCapacity */
			if(serialize_PhysicalValueType( &(type->EVEnergyCapacity),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVEnergyCapacity */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.EVEnergyRequest)
		{		
					
			/* element ID assignment of EVEnergyRequest*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=37;	


			/* encode start element EVEnergyRequest */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVEnergyRequest */
			if(serialize_PhysicalValueType( &(type->EVEnergyRequest),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVEnergyRequest */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.FullSOC)
		{		
					
			/* element ID assignment of FullSOC*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=77;	


			/* encode start element FullSOC */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = NBIT_UNSIGNED_INTEGER;
			service->val.integer.val.int8=type->FullSOC;
			service->val.integer.type = INTEGER_8;
			
			/* encode character  FullSOC */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of FullSOC */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.BulkSOC)
		{		
					
			/* element ID assignment of BulkSOC*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=7;	


			/* encode start element BulkSOC */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = NBIT_UNSIGNED_INTEGER;
			service->val.integer.val.int8=type->BulkSOC;
			service->val.integer.type = INTEGER_8;
			
			/* encode character  BulkSOC */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of BulkSOC */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_ChargeParameterDiscoveryReqType(struct ChargeParameterDiscoveryReqType* type, struct EXIService* service)
{
	
			/* element ID assignment of EVRequestedEnergyTransferType*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=45;	


			/* encode start element EVRequestedEnergyTransferType */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->EVRequestedEnergyTransferType;
			
			/* encode character  EVRequestedEnergyTransferType */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of EVRequestedEnergyTransferType */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.AC_EVChargeParameter)
		{		
					
			/* element ID assignment of AC_EVChargeParameter*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=0;	


			/* encode start element AC_EVChargeParameter */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of AC_EVChargeParameter */
			if(serialize_AC_EVChargeParameterType( (type->AC_EVChargeParameter),service))
			{
				return -1;
			}

			
			 
			/* encode end element of AC_EVChargeParameter */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.DC_EVChargeParameter)
		{		
					
			/* element ID assignment of DC_EVChargeParameter*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=18;	


			/* encode start element DC_EVChargeParameter */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVChargeParameter */
			if(serialize_DC_EVChargeParameterType( (type->DC_EVChargeParameter),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVChargeParameter */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_RelativeTimeIntervalType(struct RelativeTimeIntervalType* type, struct EXIService* service)
{
	
			/* element ID assignment of start*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=179;	


			/* encode start element start */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = UNSIGNED_INTEGER;
			service->val.integer.val.uint32=type->start;
			service->val.integer.type = UNSIGNED_INTEGER_32;
			
			/* encode character  start */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of start */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.duration)
		{		
					
			/* element ID assignment of duration*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=156;	


			/* encode start element duration */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = UNSIGNED_INTEGER;
			service->val.integer.val.uint32=type->duration;
			service->val.integer.type = UNSIGNED_INTEGER_32;
			
			/* encode character  duration */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of duration */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_PMaxScheduleEntryType(struct PMaxScheduleEntryType* type, struct EXIService* service)
{
	
			/* element ID assignment of RelativeTimeInterval*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=106;	


			/* encode start element RelativeTimeInterval */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of RelativeTimeInterval */
			if(serialize_RelativeTimeIntervalType( &(type->RelativeTimeInterval),service))
			{
				return -1;
			}

			
			 
			/* encode end element of RelativeTimeInterval */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of PMax*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=87;	


			/* encode start element PMax */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int16=type->PMax;
			service->val.integer.type = INTEGER_16;
			
			/* encode character  PMax */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of PMax */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_PMaxScheduleType(struct PMaxScheduleType* type, struct EXIService* service)
{

			size_t i_loop;
		
			/* element ID assignment of PMaxScheduleID*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=91;	


			/* encode start element PMaxScheduleID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int16=type->PMaxScheduleID;
			service->val.integer.type = INTEGER_16;
			
			/* encode character  PMaxScheduleID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of PMaxScheduleID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	for(i_loop=0;i_loop < type->arraylen.PMaxScheduleEntry;i_loop++)
		{
			
			/* element ID assignment of PMaxScheduleEntry*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=89;	


			/* encode start element PMaxScheduleEntry */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			/* encode children of PMaxScheduleEntry */
			if(serialize_PMaxScheduleEntryType(&(type->PMaxScheduleEntry[i_loop]),service))
			{
				return -1;
			}
			
			 
			/* encode end element of PMaxScheduleEntry */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_CostType(struct CostType* type, struct EXIService* service)
{
	
			/* element ID assignment of costKind*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=153;	


			/* encode start element costKind */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->costKind;
			
			/* encode character  costKind */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of costKind */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of amount*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=147;	


			/* encode start element amount */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = UNSIGNED_INTEGER;
			service->val.integer.val.uint32=type->amount;
			service->val.integer.type = UNSIGNED_INTEGER_32;
			
			/* encode character  amount */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of amount */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.amountMultiplier)
		{		
					
			/* element ID assignment of amountMultiplier*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=148;	


			/* encode start element amountMultiplier */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = NBIT_UNSIGNED_INTEGER;
			service->val.integer.val.int8=type->amountMultiplier;
			service->val.integer.type = INTEGER_8;
			
			/* encode character  amountMultiplier */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of amountMultiplier */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_ConsumptionCostType(struct ConsumptionCostType* type, struct EXIService* service)
{

			size_t i_loop;
		
			/* element ID assignment of startValue*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=180;	


			/* encode start element startValue */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = UNSIGNED_INTEGER;
			service->val.integer.val.uint32=type->startValue;
			service->val.integer.type = UNSIGNED_INTEGER_32;
			
			/* encode character  startValue */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of startValue */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.Cost)
		{		
				
	for(i_loop=0;i_loop < type->arraylen.Cost;i_loop++)
		{
			
			/* element ID assignment of Cost*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=16;	


			/* encode start element Cost */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			/* encode children of Cost */
			if(serialize_CostType(&(type->Cost[i_loop]),service))
			{
				return -1;
			}
			
			 
			/* encode end element of Cost */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				}
				

	return 0;			
}


static int serialize_SalesTariffEntryType(struct SalesTariffEntryType* type, struct EXIService* service)
{

			size_t i_loop;
		
			/* element ID assignment of RelativeTimeInterval*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=106;	


			/* encode start element RelativeTimeInterval */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of RelativeTimeInterval */
			if(serialize_RelativeTimeIntervalType( &(type->RelativeTimeInterval),service))
			{
				return -1;
			}

			
			 
			/* encode end element of RelativeTimeInterval */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EPriceLevel*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=32;	


			/* encode start element EPriceLevel */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = NBIT_UNSIGNED_INTEGER;
			service->val.integer.val.uint8=type->EPriceLevel;
			service->val.integer.type = UNSIGNED_INTEGER_8;
			
			/* encode character  EPriceLevel */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of EPriceLevel */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.ConsumptionCost)
		{		
				
	for(i_loop=0;i_loop < type->arraylen.ConsumptionCost;i_loop++)
		{
			
			/* element ID assignment of ConsumptionCost*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=14;	


			/* encode start element ConsumptionCost */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			/* encode children of ConsumptionCost */
			if(serialize_ConsumptionCostType(&(type->ConsumptionCost[i_loop]),service))
			{
				return -1;
			}
			
			 
			/* encode end element of ConsumptionCost */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				}
				

	return 0;			
}


static int serialize_SalesTariffType(struct SalesTariffType* type, struct EXIService* service)
{

			size_t i_loop;
		
			/* element ID assignment of attr_Id*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=2;	

			service->val.type = STRING;
			service->val.string.len = type->attr_Id.arraylen.data;
			service->val.string.codepoints= type->attr_Id.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}
	
			/* element ID assignment of SalesTariffID*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=121;	


			/* encode start element SalesTariffID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int16=type->SalesTariffID;
			service->val.integer.type = INTEGER_16;
			
			/* encode character  SalesTariffID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of SalesTariffID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.SalesTariffDescription)
		{		
					
			/* element ID assignment of SalesTariffDescription*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=118;	


			/* encode start element SalesTariffDescription */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->SalesTariffDescription.arraylen.data;
			memcpy(service->val.string.codepoints, type->SalesTariffDescription.data,type->SalesTariffDescription.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  SalesTariffDescription */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of SalesTariffDescription */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
					
			/* element ID assignment of NumEPriceLevels*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=86;	


			/* encode start element NumEPriceLevels */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = NBIT_UNSIGNED_INTEGER;
			service->val.integer.val.uint8=type->NumEPriceLevels;
			service->val.integer.type = UNSIGNED_INTEGER_8;
			
			/* encode character  NumEPriceLevels */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of NumEPriceLevels */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	for(i_loop=0;i_loop < type->arraylen.SalesTariffEntry;i_loop++)
		{
			
			/* element ID assignment of SalesTariffEntry*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=119;	


			/* encode start element SalesTariffEntry */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			/* encode children of SalesTariffEntry */
			if(serialize_SalesTariffEntryType(&(type->SalesTariffEntry[i_loop]),service))
			{
				return -1;
			}
			
			 
			/* encode end element of SalesTariffEntry */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_SAScheduleTupleType(struct SAScheduleTupleType* type, struct EXIService* service)
{
	
			/* element ID assignment of SAScheduleTupleID*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=113;	


			/* encode start element SAScheduleTupleID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int16=type->SAScheduleTupleID;
			service->val.integer.type = INTEGER_16;
			
			/* encode character  SAScheduleTupleID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of SAScheduleTupleID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of PMaxSchedule*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=88;	


			/* encode start element PMaxSchedule */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of PMaxSchedule */
			if(serialize_PMaxScheduleType( &(type->PMaxSchedule),service))
			{
				return -1;
			}

			
			 
			/* encode end element of PMaxSchedule */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.SalesTariff)
		{		
					
			/* element ID assignment of SalesTariff*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=117;	


			/* encode start element SalesTariff */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of SalesTariff */
			if(serialize_SalesTariffType( (type->SalesTariff),service))
			{
				return -1;
			}

			
			 
			/* encode end element of SalesTariff */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_SAScheduleListType(struct SAScheduleListType* type, struct EXIService* service)
{

			size_t i_loop;
	
	for(i_loop=0;i_loop < type->arraylen.SAScheduleTuple;i_loop++)
		{
			
			/* element ID assignment of SAScheduleTuple*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=112;	


			/* encode start element SAScheduleTuple */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			/* encode children of SAScheduleTuple */
			if(serialize_SAScheduleTupleType(&(type->SAScheduleTuple[i_loop]),service))
			{
				return -1;
			}
			
			 
			/* encode end element of SAScheduleTuple */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_AC_EVSEStatusType(struct AC_EVSEStatusType* type, struct EXIService* service)
{
	
			/* element ID assignment of PowerSwitchClosed*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=102;	


			/* encode start element PowerSwitchClosed */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->PowerSwitchClosed;
			
			/* encode character  PowerSwitchClosed */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of PowerSwitchClosed */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of RCD*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=105;	


			/* encode start element RCD */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->RCD;
			
			/* encode character  RCD */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of RCD */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ShutDownTime*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=138;	


			/* encode start element ShutDownTime */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = UNSIGNED_INTEGER;
			service->val.integer.val.uint32=type->ShutDownTime;
			service->val.integer.type = UNSIGNED_INTEGER_32;
			
			/* encode character  ShutDownTime */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ShutDownTime */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of StopCharging*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=140;	


			/* encode start element StopCharging */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->StopCharging;
			
			/* encode character  StopCharging */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of StopCharging */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_AC_EVSEChargeParameterType(struct AC_EVSEChargeParameterType* type, struct EXIService* service)
{
	
			/* element ID assignment of AC_EVSEStatus*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=4;	


			/* encode start element AC_EVSEStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of AC_EVSEStatus */
			if(serialize_AC_EVSEStatusType( &(type->AC_EVSEStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of AC_EVSEStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSEMaxVoltage*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=57;	


			/* encode start element EVSEMaxVoltage */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEMaxVoltage */
			if(serialize_PhysicalValueType( &(type->EVSEMaxVoltage),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEMaxVoltage */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSEMaxCurrent*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=56;	


			/* encode start element EVSEMaxCurrent */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEMaxCurrent */
			if(serialize_PhysicalValueType( &(type->EVSEMaxCurrent),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEMaxCurrent */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSEMinCurrent*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=61;	


			/* encode start element EVSEMinCurrent */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEMinCurrent */
			if(serialize_PhysicalValueType( &(type->EVSEMinCurrent),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEMinCurrent */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_DC_EVSEStatusType(struct DC_EVSEStatusType* type, struct EXIService* service)
{

	if(type->isused.EVSEIsolationStatus)
		{		
					
			/* element ID assignment of EVSEIsolationStatus*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=55;	


			/* encode start element EVSEIsolationStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->EVSEIsolationStatus;
			
			/* encode character  EVSEIsolationStatus */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of EVSEIsolationStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
					
			/* element ID assignment of EVSEStatusCode*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=66;	


			/* encode start element EVSEStatusCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->EVSEStatusCode;
			
			/* encode character  EVSEStatusCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of EVSEStatusCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_DC_EVSEChargeParameterType(struct DC_EVSEChargeParameterType* type, struct EXIService* service)
{
	
			/* element ID assignment of DC_EVSEStatus*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=25;	


			/* encode start element DC_EVSEStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVSEStatus */
			if(serialize_DC_EVSEStatusType( &(type->DC_EVSEStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVSEStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSEMaximumCurrentLimit*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=58;	


			/* encode start element EVSEMaximumCurrentLimit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEMaximumCurrentLimit */
			if(serialize_PhysicalValueType( &(type->EVSEMaximumCurrentLimit),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEMaximumCurrentLimit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.EVSEMaximumPowerLimit)
		{		
					
			/* element ID assignment of EVSEMaximumPowerLimit*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=59;	


			/* encode start element EVSEMaximumPowerLimit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEMaximumPowerLimit */
			if(serialize_PhysicalValueType( &(type->EVSEMaximumPowerLimit),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEMaximumPowerLimit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
					
			/* element ID assignment of EVSEMaximumVoltageLimit*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=60;	


			/* encode start element EVSEMaximumVoltageLimit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEMaximumVoltageLimit */
			if(serialize_PhysicalValueType( &(type->EVSEMaximumVoltageLimit),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEMaximumVoltageLimit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSEMinimumCurrentLimit*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=62;	


			/* encode start element EVSEMinimumCurrentLimit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEMinimumCurrentLimit */
			if(serialize_PhysicalValueType( &(type->EVSEMinimumCurrentLimit),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEMinimumCurrentLimit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSEMinimumVoltageLimit*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=63;	


			/* encode start element EVSEMinimumVoltageLimit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEMinimumVoltageLimit */
			if(serialize_PhysicalValueType( &(type->EVSEMinimumVoltageLimit),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEMinimumVoltageLimit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.EVSECurrentRegulationTolerance)
		{		
					
			/* element ID assignment of EVSECurrentRegulationTolerance*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=53;	


			/* encode start element EVSECurrentRegulationTolerance */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSECurrentRegulationTolerance */
			if(serialize_PhysicalValueType( &(type->EVSECurrentRegulationTolerance),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSECurrentRegulationTolerance */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
					
			/* element ID assignment of EVSEPeakCurrentRipple*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=64;	


			/* encode start element EVSEPeakCurrentRipple */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEPeakCurrentRipple */
			if(serialize_PhysicalValueType( &(type->EVSEPeakCurrentRipple),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEPeakCurrentRipple */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.EVSEEnergyToBeDelivered)
		{		
					
			/* element ID assignment of EVSEEnergyToBeDelivered*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=54;	


			/* encode start element EVSEEnergyToBeDelivered */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEEnergyToBeDelivered */
			if(serialize_PhysicalValueType( &(type->EVSEEnergyToBeDelivered),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEEnergyToBeDelivered */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_ChargeParameterDiscoveryResType(struct ChargeParameterDiscoveryResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.SAScheduleList)
		{		
					
			/* element ID assignment of SAScheduleList*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=110;	


			/* encode start element SAScheduleList */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of SAScheduleList */
			if(serialize_SAScheduleListType( (type->SAScheduleList),service))
			{
				return -1;
			}

			
			 
			/* encode end element of SAScheduleList */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.AC_EVSEChargeParameter)
		{		
					
			/* element ID assignment of AC_EVSEChargeParameter*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=2;	


			/* encode start element AC_EVSEChargeParameter */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of AC_EVSEChargeParameter */
			if(serialize_AC_EVSEChargeParameterType( (type->AC_EVSEChargeParameter),service))
			{
				return -1;
			}

			
			 
			/* encode end element of AC_EVSEChargeParameter */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.DC_EVSEChargeParameter)
		{		
					
			/* element ID assignment of DC_EVSEChargeParameter*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=23;	


			/* encode start element DC_EVSEChargeParameter */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVSEChargeParameter */
			if(serialize_DC_EVSEChargeParameterType( (type->DC_EVSEChargeParameter),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVSEChargeParameter */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_ProfileEntryType(struct ProfileEntryType* type, struct EXIService* service)
{
	
			/* element ID assignment of ChargingProfileEntryStart*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=12;	


			/* encode start element ChargingProfileEntryStart */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = UNSIGNED_INTEGER;
			service->val.integer.val.uint32=type->ChargingProfileEntryStart;
			service->val.integer.type = UNSIGNED_INTEGER_32;
			
			/* encode character  ChargingProfileEntryStart */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ChargingProfileEntryStart */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ChargingProfileEntryMaxPower*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=11;	


			/* encode start element ChargingProfileEntryMaxPower */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int16=type->ChargingProfileEntryMaxPower;
			service->val.integer.type = INTEGER_16;
			
			/* encode character  ChargingProfileEntryMaxPower */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ChargingProfileEntryMaxPower */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_ChargingProfileType(struct ChargingProfileType* type, struct EXIService* service)
{

			size_t i_loop;
		
			/* element ID assignment of SAScheduleTupleID*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=113;	


			/* encode start element SAScheduleTupleID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int16=type->SAScheduleTupleID;
			service->val.integer.type = INTEGER_16;
			
			/* encode character  SAScheduleTupleID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of SAScheduleTupleID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	for(i_loop=0;i_loop < type->arraylen.ProfileEntry;i_loop++)
		{
			
			/* element ID assignment of ProfileEntry*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=103;	


			/* encode start element ProfileEntry */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			/* encode children of ProfileEntry */
			if(serialize_ProfileEntryType(&(type->ProfileEntry[i_loop]),service))
			{
				return -1;
			}
			
			 
			/* encode end element of ProfileEntry */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_DC_EVPowerDeliveryParameterType(struct DC_EVPowerDeliveryParameterType* type, struct EXIService* service)
{
	
			/* element ID assignment of DC_EVStatus*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=28;	


			/* encode start element DC_EVStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVStatus */
			if(serialize_DC_EVStatusType( &(type->DC_EVStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.BulkChargingComplete)
		{		
					
			/* element ID assignment of BulkChargingComplete*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=6;	


			/* encode start element BulkChargingComplete */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->BulkChargingComplete;
			
			/* encode character  BulkChargingComplete */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of BulkChargingComplete */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
					
			/* element ID assignment of ChargingComplete*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=10;	


			/* encode start element ChargingComplete */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->ChargingComplete;
			
			/* encode character  ChargingComplete */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ChargingComplete */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_PowerDeliveryReqType(struct PowerDeliveryReqType* type, struct EXIService* service)
{
	
			/* element ID assignment of ReadyToChargeState*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=79;	


			/* encode start element ReadyToChargeState */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->ReadyToChargeState;
			
			/* encode character  ReadyToChargeState */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ReadyToChargeState */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.ChargingProfile)
		{		
					
			/* element ID assignment of ChargingProfile*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=20;	


			/* encode start element ChargingProfile */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ChargingProfile */
			if(serialize_ChargingProfileType( &(type->ChargingProfile),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ChargingProfile */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.DC_EVPowerDeliveryParameter)
		{		
					
			/* element ID assignment of DC_EVPowerDeliveryParameter*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=21;	


			/* encode start element DC_EVPowerDeliveryParameter */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVPowerDeliveryParameter */
			if(serialize_DC_EVPowerDeliveryParameterType( (type->DC_EVPowerDeliveryParameter),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVPowerDeliveryParameter */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_PowerDeliveryResType(struct PowerDeliveryResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.AC_EVSEStatus)
		{		
					
			/* element ID assignment of AC_EVSEStatus*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=4;	


			/* encode start element AC_EVSEStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of AC_EVSEStatus */
			if(serialize_AC_EVSEStatusType( (type->AC_EVSEStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of AC_EVSEStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.DC_EVSEStatus)
		{		
					
			/* element ID assignment of DC_EVSEStatus*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=25;	


			/* encode start element DC_EVSEStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVSEStatus */
			if(serialize_DC_EVSEStatusType( (type->DC_EVSEStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVSEStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_ChargingStatusReqType(struct ChargingStatusReqType* type, struct EXIService* service)
{


	return 0;			
}


static int serialize_MeterInfoType(struct MeterInfoType* type, struct EXIService* service)
{
	
			/* element ID assignment of MeterID*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=80;	


			/* encode start element MeterID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->MeterID.arraylen.data;
			memcpy(service->val.string.codepoints, type->MeterID.data,type->MeterID.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  MeterID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of MeterID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.MeterReading)
		{		
					
			/* element ID assignment of MeterReading*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=82;	


			/* encode start element MeterReading */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of MeterReading */
			if(serialize_PhysicalValueType( &(type->MeterReading),service))
			{
				return -1;
			}

			
			 
			/* encode end element of MeterReading */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.SigMeterReading)
		{		
					
			/* element ID assignment of SigMeterReading*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=139;	


			/* encode start element SigMeterReading */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_BASE64;
		service->val.binary.len = type->SigMeterReading.arraylen.data;
		memcpy(service->val.binary.data, type->SigMeterReading.data,type->SigMeterReading.arraylen.data);
		
		
		/* encode character  SigMeterReading */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of SigMeterReading */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.MeterStatus)
		{		
					
			/* element ID assignment of MeterStatus*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=83;	


			/* encode start element MeterStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int16=type->MeterStatus;
			service->val.integer.type = INTEGER_16;
			
			/* encode character  MeterStatus */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of MeterStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.TMeter)
		{		
					
			/* element ID assignment of TMeter*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=143;	


			/* encode start element TMeter */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int64=type->TMeter;
			service->val.integer.type = INTEGER_64;
			
			/* encode character  TMeter */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of TMeter */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_ChargingStatusResType(struct ChargingStatusResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSEID*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=47;	


			/* encode start element EVSEID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_HEX;
		service->val.binary.len = type->EVSEID.arraylen.data;
		memcpy(service->val.binary.data, type->EVSEID.data,type->EVSEID.arraylen.data);
		
		
		/* encode character  EVSEID */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of EVSEID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of SAScheduleTupleID*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=85;	


			/* encode start element SAScheduleTupleID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int16=type->SAScheduleTupleID;
			service->val.integer.type = INTEGER_16;
			
			/* encode character  SAScheduleTupleID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of SAScheduleTupleID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.EVSEMaxCurrent)
		{		
					
			/* element ID assignment of EVSEMaxCurrent*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=48;	


			/* encode start element EVSEMaxCurrent */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEMaxCurrent */
			if(serialize_PhysicalValueType( &(type->EVSEMaxCurrent),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEMaxCurrent */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.MeterInfo)
		{		
					
			/* element ID assignment of MeterInfo*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=60;	


			/* encode start element MeterInfo */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of MeterInfo */
			if(serialize_MeterInfoType( &(type->MeterInfo),service))
			{
				return -1;
			}

			
			 
			/* encode end element of MeterInfo */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
					
			/* element ID assignment of ReceiptRequired*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=80;	


			/* encode start element ReceiptRequired */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->ReceiptRequired;
			
			/* encode character  ReceiptRequired */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ReceiptRequired */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of AC_EVSEStatus*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=0;	


			/* encode start element AC_EVSEStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of AC_EVSEStatus */
			if(serialize_AC_EVSEStatusType( &(type->AC_EVSEStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of AC_EVSEStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_MeteringReceiptReqType(struct MeteringReceiptReqType* type, struct EXIService* service)
{

	if(type->isused.attr_Id)
		{		
					
			/* element ID assignment of attr_Id*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=2;	

			service->val.type = STRING;
			service->val.string.len = type->attr_Id.arraylen.data;
			service->val.string.codepoints= type->attr_Id.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}
		}
	
			/* element ID assignment of SessionID*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=105;	


			/* encode start element SessionID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_HEX;
		service->val.binary.len = type->SessionID.arraylen.data;
		memcpy(service->val.binary.data, type->SessionID.data,type->SessionID.arraylen.data);
		
		
		/* encode character  SessionID */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of SessionID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of SAScheduleTupleID*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=85;	


			/* encode start element SAScheduleTupleID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int16=type->SAScheduleTupleID;
			service->val.integer.type = INTEGER_16;
			
			/* encode character  SAScheduleTupleID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of SAScheduleTupleID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of MeterInfo*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=60;	


			/* encode start element MeterInfo */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of MeterInfo */
			if(serialize_MeterInfoType( &(type->MeterInfo),service))
			{
				return -1;
			}

			
			 
			/* encode end element of MeterInfo */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_MeteringReceiptResType(struct MeteringReceiptResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of AC_EVSEStatus*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=0;	


			/* encode start element AC_EVSEStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of AC_EVSEStatus */
			if(serialize_AC_EVSEStatusType( &(type->AC_EVSEStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of AC_EVSEStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_SessionStopType(struct SessionStopType* type, struct EXIService* service)
{


	return 0;			
}


static int serialize_SessionStopResType(struct SessionStopResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_ListOfRootCertificateIDsType(struct ListOfRootCertificateIDsType* type, struct EXIService* service)
{

			size_t i_loop;
	
	for(i_loop=0;i_loop < type->arraylen.RootCertificateID;i_loop++)
		{
			
			/* element ID assignment of RootCertificateID*/
			service->eqn.namespaceURI=6;			
			service->eqn.localPart=108;	


			/* encode start element RootCertificateID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->RootCertificateID[i_loop].arraylen.data;
			memcpy(service->val.string.codepoints, type->RootCertificateID[i_loop].data,type->RootCertificateID[i_loop].arraylen.data*sizeof(uint32_t));
		
			/* encode character  RootCertificateID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of RootCertificateID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_CertificateUpdateReqType(struct CertificateUpdateReqType* type, struct EXIService* service)
{

	if(type->isused.attr_Id)
		{		
					
			/* element ID assignment of attr_Id*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=2;	

			service->val.type = STRING;
			service->val.string.len = type->attr_Id.arraylen.data;
			service->val.string.codepoints= type->attr_Id.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}
		}
	
			/* element ID assignment of ContractSignatureCertChain*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=31;	


			/* encode start element ContractSignatureCertChain */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ContractSignatureCertChain */
			if(serialize_CertificateChainType( &(type->ContractSignatureCertChain),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ContractSignatureCertChain */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ContractID*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=30;	


			/* encode start element ContractID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->ContractID.arraylen.data;
			memcpy(service->val.string.codepoints, type->ContractID.data,type->ContractID.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  ContractID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of ContractID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ListOfRootCertificateIDs*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=59;	


			/* encode start element ListOfRootCertificateIDs */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ListOfRootCertificateIDs */
			if(serialize_ListOfRootCertificateIDsType( &(type->ListOfRootCertificateIDs),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ListOfRootCertificateIDs */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_CertificateUpdateResType(struct CertificateUpdateResType* type, struct EXIService* service)
{
	
			/* element ID assignment of attr_Id*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=2;	

			service->val.type = STRING;
			service->val.string.len = type->attr_Id.arraylen.data;
			service->val.string.codepoints= type->attr_Id.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ContractSignatureCertChain*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=31;	


			/* encode start element ContractSignatureCertChain */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ContractSignatureCertChain */
			if(serialize_CertificateChainType( &(type->ContractSignatureCertChain),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ContractSignatureCertChain */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ContractSignatureEncryptedPrivateKey*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=32;	


			/* encode start element ContractSignatureEncryptedPrivateKey */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_BASE64;
		service->val.binary.len = type->ContractSignatureEncryptedPrivateKey.arraylen.data;
		memcpy(service->val.binary.data, type->ContractSignatureEncryptedPrivateKey.data,type->ContractSignatureEncryptedPrivateKey.arraylen.data);
		
		
		/* encode character  ContractSignatureEncryptedPrivateKey */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of ContractSignatureEncryptedPrivateKey */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ContractEncryptionEncryptedPrivateKey*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=29;	


			/* encode start element ContractEncryptionEncryptedPrivateKey */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_BASE64;
		service->val.binary.len = type->ContractEncryptionEncryptedPrivateKey.arraylen.data;
		memcpy(service->val.binary.data, type->ContractEncryptionEncryptedPrivateKey.data,type->ContractEncryptionEncryptedPrivateKey.arraylen.data);
		
		
		/* encode character  ContractEncryptionEncryptedPrivateKey */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of ContractEncryptionEncryptedPrivateKey */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of DHParams*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=39;	


			/* encode start element DHParams */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_BASE64;
		service->val.binary.len = type->DHParams.arraylen.data;
		memcpy(service->val.binary.data, type->DHParams.data,type->DHParams.arraylen.data);
		
		
		/* encode character  DHParams */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of DHParams */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ContractID*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=30;	


			/* encode start element ContractID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->ContractID.arraylen.data;
			memcpy(service->val.string.codepoints, type->ContractID.data,type->ContractID.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  ContractID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of ContractID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of RetryCounter*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=84;	


			/* encode start element RetryCounter */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = INTEGER;
			service->val.integer.val.int16=type->RetryCounter;
			service->val.integer.type = INTEGER_16;
			
			/* encode character  RetryCounter */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of RetryCounter */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_CertificateInstallationReqType(struct CertificateInstallationReqType* type, struct EXIService* service)
{

	if(type->isused.attr_Id)
		{		
					
			/* element ID assignment of attr_Id*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=2;	

			service->val.type = STRING;
			service->val.string.len = type->attr_Id.arraylen.data;
			service->val.string.codepoints= type->attr_Id.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}
		}
	
			/* element ID assignment of OEMProvisioningCert*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=65;	


			/* encode start element OEMProvisioningCert */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_BASE64;
		service->val.binary.len = type->OEMProvisioningCert.arraylen.data;
		memcpy(service->val.binary.data, type->OEMProvisioningCert.data,type->OEMProvisioningCert.arraylen.data);
		
		
		/* encode character  OEMProvisioningCert */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of OEMProvisioningCert */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ListOfRootCertificateIDs*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=59;	


			/* encode start element ListOfRootCertificateIDs */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ListOfRootCertificateIDs */
			if(serialize_ListOfRootCertificateIDsType( &(type->ListOfRootCertificateIDs),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ListOfRootCertificateIDs */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_CertificateInstallationResType(struct CertificateInstallationResType* type, struct EXIService* service)
{
	
			/* element ID assignment of attr_Id*/
			service->eqn.namespaceURI=0;			
			service->eqn.localPart=2;	

			service->val.type = STRING;
			service->val.string.len = type->attr_Id.arraylen.data;
			service->val.string.codepoints= type->attr_Id.data;
			if (exiEncodeAttribute(&(service->outStream), &(service->stateEncode), &(service->eqn),&(service->val)))
			{
					return -1;
			}
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ContractSignatureCertChain*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=31;	


			/* encode start element ContractSignatureCertChain */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ContractSignatureCertChain */
			if(serialize_CertificateChainType( &(type->ContractSignatureCertChain),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ContractSignatureCertChain */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ContractSignatureEncryptedPrivateKey*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=32;	


			/* encode start element ContractSignatureEncryptedPrivateKey */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_BASE64;
		service->val.binary.len = type->ContractSignatureEncryptedPrivateKey.arraylen.data;
		memcpy(service->val.binary.data, type->ContractSignatureEncryptedPrivateKey.data,type->ContractSignatureEncryptedPrivateKey.arraylen.data);
		
		
		/* encode character  ContractSignatureEncryptedPrivateKey */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of ContractSignatureEncryptedPrivateKey */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ContractEncryptionEncryptedPrivateKey*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=29;	


			/* encode start element ContractEncryptionEncryptedPrivateKey */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_BASE64;
		service->val.binary.len = type->ContractEncryptionEncryptedPrivateKey.arraylen.data;
		memcpy(service->val.binary.data, type->ContractEncryptionEncryptedPrivateKey.data,type->ContractEncryptionEncryptedPrivateKey.arraylen.data);
		
		
		/* encode character  ContractEncryptionEncryptedPrivateKey */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of ContractEncryptionEncryptedPrivateKey */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of DHParams*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=39;	


			/* encode start element DHParams */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			service->val.type = BINARY_BASE64;
		service->val.binary.len = type->DHParams.arraylen.data;
		memcpy(service->val.binary.data, type->DHParams.data,type->DHParams.arraylen.data);
		
		
		/* encode character  DHParams */	
		if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
		{
				 
				return -1;
		}

			
			 
			/* encode end element of DHParams */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of ContractID*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=30;	


			/* encode start element ContractID */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = STRING;
			service->val.string.len = type->ContractID.arraylen.data;
			memcpy(service->val.string.codepoints, type->ContractID.data,type->ContractID.arraylen.data*sizeof(uint32_t));
						
		
			/* encode character  ContractID */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
					return -1;
			}
			
			 
			/* encode end element of ContractID */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_CableCheckReqType(struct CableCheckReqType* type, struct EXIService* service)
{
	
			/* element ID assignment of DC_EVStatus*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=38;	


			/* encode start element DC_EVStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVStatus */
			if(serialize_DC_EVStatusType( &(type->DC_EVStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_CableCheckResType(struct CableCheckResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of DC_EVSEStatus*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=37;	


			/* encode start element DC_EVSEStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVSEStatus */
			if(serialize_DC_EVSEStatusType( &(type->DC_EVSEStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVSEStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_PreChargeReqType(struct PreChargeReqType* type, struct EXIService* service)
{
	
			/* element ID assignment of DC_EVStatus*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=38;	


			/* encode start element DC_EVStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVStatus */
			if(serialize_DC_EVStatusType( &(type->DC_EVStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVTargetVoltage*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=57;	


			/* encode start element EVTargetVoltage */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVTargetVoltage */
			if(serialize_PhysicalValueType( &(type->EVTargetVoltage),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVTargetVoltage */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVTargetCurrent*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=56;	


			/* encode start element EVTargetCurrent */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVTargetCurrent */
			if(serialize_PhysicalValueType( &(type->EVTargetCurrent),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVTargetCurrent */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_PreChargeResType(struct PreChargeResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of DC_EVSEStatus*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=37;	


			/* encode start element DC_EVSEStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVSEStatus */
			if(serialize_DC_EVSEStatusType( &(type->DC_EVSEStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVSEStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSEPresentVoltage*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=54;	


			/* encode start element EVSEPresentVoltage */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEPresentVoltage */
			if(serialize_PhysicalValueType( &(type->EVSEPresentVoltage),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEPresentVoltage */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_CurrentDemandReqType(struct CurrentDemandReqType* type, struct EXIService* service)
{
	
			/* element ID assignment of DC_EVStatus*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=38;	


			/* encode start element DC_EVStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVStatus */
			if(serialize_DC_EVStatusType( &(type->DC_EVStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVTargetCurrent*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=56;	


			/* encode start element EVTargetCurrent */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVTargetCurrent */
			if(serialize_PhysicalValueType( &(type->EVTargetCurrent),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVTargetCurrent */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.EVMaximumVoltageLimit)
		{		
					
			/* element ID assignment of EVMaximumVoltageLimit*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=44;	


			/* encode start element EVMaximumVoltageLimit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVMaximumVoltageLimit */
			if(serialize_PhysicalValueType( &(type->EVMaximumVoltageLimit),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVMaximumVoltageLimit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.EVMaximumCurrentLimit)
		{		
					
			/* element ID assignment of EVMaximumCurrentLimit*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=42;	


			/* encode start element EVMaximumCurrentLimit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVMaximumCurrentLimit */
			if(serialize_PhysicalValueType( &(type->EVMaximumCurrentLimit),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVMaximumCurrentLimit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.EVMaximumPowerLimit)
		{		
					
			/* element ID assignment of EVMaximumPowerLimit*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=43;	


			/* encode start element EVMaximumPowerLimit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVMaximumPowerLimit */
			if(serialize_PhysicalValueType( &(type->EVMaximumPowerLimit),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVMaximumPowerLimit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.BulkChargingComplete)
		{		
					
			/* element ID assignment of BulkChargingComplete*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=1;	


			/* encode start element BulkChargingComplete */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->BulkChargingComplete;
			
			/* encode character  BulkChargingComplete */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of BulkChargingComplete */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
					
			/* element ID assignment of ChargingComplete*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=19;	


			/* encode start element ChargingComplete */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->ChargingComplete;
			
			/* encode character  ChargingComplete */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ChargingComplete */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.RemainingTimeToFullSoC)
		{		
					
			/* element ID assignment of RemainingTimeToFullSoC*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=82;	


			/* encode start element RemainingTimeToFullSoC */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of RemainingTimeToFullSoC */
			if(serialize_PhysicalValueType( &(type->RemainingTimeToFullSoC),service))
			{
				return -1;
			}

			
			 
			/* encode end element of RemainingTimeToFullSoC */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.RemainingTimeToBulkSoC)
		{		
					
			/* element ID assignment of RemainingTimeToBulkSoC*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=81;	


			/* encode start element RemainingTimeToBulkSoC */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of RemainingTimeToBulkSoC */
			if(serialize_PhysicalValueType( &(type->RemainingTimeToBulkSoC),service))
			{
				return -1;
			}

			
			 
			/* encode end element of RemainingTimeToBulkSoC */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
					
			/* element ID assignment of EVTargetVoltage*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=57;	


			/* encode start element EVTargetVoltage */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVTargetVoltage */
			if(serialize_PhysicalValueType( &(type->EVTargetVoltage),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVTargetVoltage */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_CurrentDemandResType(struct CurrentDemandResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of DC_EVSEStatus*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=37;	


			/* encode start element DC_EVSEStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVSEStatus */
			if(serialize_DC_EVSEStatusType( &(type->DC_EVSEStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVSEStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSEPresentVoltage*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=54;	


			/* encode start element EVSEPresentVoltage */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEPresentVoltage */
			if(serialize_PhysicalValueType( &(type->EVSEPresentVoltage),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEPresentVoltage */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSEPresentCurrent*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=53;	


			/* encode start element EVSEPresentCurrent */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEPresentCurrent */
			if(serialize_PhysicalValueType( &(type->EVSEPresentCurrent),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEPresentCurrent */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSECurrentLimitAchieved*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=46;	


			/* encode start element EVSECurrentLimitAchieved */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->EVSECurrentLimitAchieved;
			
			/* encode character  EVSECurrentLimitAchieved */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of EVSECurrentLimitAchieved */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSEVoltageLimitAchieved*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=55;	


			/* encode start element EVSEVoltageLimitAchieved */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->EVSEVoltageLimitAchieved;
			
			/* encode character  EVSEVoltageLimitAchieved */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of EVSEVoltageLimitAchieved */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSEPowerLimitAchieved*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=52;	


			/* encode start element EVSEPowerLimitAchieved */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = BOOLEAN;
			service->val.boolean=type->EVSEPowerLimitAchieved;
			
			/* encode character  EVSEPowerLimitAchieved */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of EVSEPowerLimitAchieved */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		
	if(type->isused.EVSEMaximumVoltageLimit)
		{		
					
			/* element ID assignment of EVSEMaximumVoltageLimit*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=51;	


			/* encode start element EVSEMaximumVoltageLimit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEMaximumVoltageLimit */
			if(serialize_PhysicalValueType( &(type->EVSEMaximumVoltageLimit),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEMaximumVoltageLimit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.EVSEMaximumCurrentLimit)
		{		
					
			/* element ID assignment of EVSEMaximumCurrentLimit*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=49;	


			/* encode start element EVSEMaximumCurrentLimit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEMaximumCurrentLimit */
			if(serialize_PhysicalValueType( &(type->EVSEMaximumCurrentLimit),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEMaximumCurrentLimit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.EVSEMaximumPowerLimit)
		{		
					
			/* element ID assignment of EVSEMaximumPowerLimit*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=50;	


			/* encode start element EVSEMaximumPowerLimit */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEMaximumPowerLimit */
			if(serialize_PhysicalValueType( &(type->EVSEMaximumPowerLimit),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEMaximumPowerLimit */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_WeldingDetectionReqType(struct WeldingDetectionReqType* type, struct EXIService* service)
{
	
			/* element ID assignment of DC_EVStatus*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=38;	


			/* encode start element DC_EVStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVStatus */
			if(serialize_DC_EVStatusType( &(type->DC_EVStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_WeldingDetectionResType(struct WeldingDetectionResType* type, struct EXIService* service)
{
	
			/* element ID assignment of ResponseCode*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=83;	


			/* encode start element ResponseCode */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
			
			service->val.type = ENUMERATION;
			service->val.enumeration=type->ResponseCode;
			
			/* encode character  ResponseCode */	
			if (exiEncodeCharacters(&(service->outStream), &(service->stateEncode), &(service->val))) 
			{
				 
				return -1;
			}
				
			 
			/* encode end element of ResponseCode */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of DC_EVSEStatus*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=37;	


			/* encode start element DC_EVSEStatus */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of DC_EVSEStatus */
			if(serialize_DC_EVSEStatusType( &(type->DC_EVSEStatus),service))
			{
				return -1;
			}

			
			 
			/* encode end element of DC_EVSEStatus */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of EVSEPresentVoltage*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=54;	


			/* encode start element EVSEPresentVoltage */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of EVSEPresentVoltage */
			if(serialize_PhysicalValueType( &(type->EVSEPresentVoltage),service))
			{
				return -1;
			}

			
			 
			/* encode end element of EVSEPresentVoltage */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_BodyType(struct BodyType* type, struct EXIService* service)
{

	if(type->isused.SessionSetupReq)
		{		
					
			/* element ID assignment of SessionSetupReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=106;	


			/* encode start element SessionSetupReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of SessionSetupReq */
			if(serialize_SessionSetupReqType( (type->SessionSetupReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of SessionSetupReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.SessionSetupRes)
		{		
					
			/* element ID assignment of SessionSetupRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=108;	


			/* encode start element SessionSetupRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of SessionSetupRes */
			if(serialize_SessionSetupResType( (type->SessionSetupRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of SessionSetupRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ServiceDiscoveryReq)
		{		
					
			/* element ID assignment of ServiceDiscoveryReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=93;	


			/* encode start element ServiceDiscoveryReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ServiceDiscoveryReq */
			if(serialize_ServiceDiscoveryReqType( (type->ServiceDiscoveryReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ServiceDiscoveryReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ServiceDiscoveryRes)
		{		
					
			/* element ID assignment of ServiceDiscoveryRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=95;	


			/* encode start element ServiceDiscoveryRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ServiceDiscoveryRes */
			if(serialize_ServiceDiscoveryResType( (type->ServiceDiscoveryRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ServiceDiscoveryRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ServiceDetailReq)
		{		
					
			/* element ID assignment of ServiceDetailReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=89;	


			/* encode start element ServiceDetailReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ServiceDetailReq */
			if(serialize_ServiceDetailReqType( (type->ServiceDetailReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ServiceDetailReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ServiceDetailRes)
		{		
					
			/* element ID assignment of ServiceDetailRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=91;	


			/* encode start element ServiceDetailRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ServiceDetailRes */
			if(serialize_ServiceDetailResType( (type->ServiceDetailRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ServiceDetailRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ServicePaymentSelectionReq)
		{		
					
			/* element ID assignment of ServicePaymentSelectionReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=100;	


			/* encode start element ServicePaymentSelectionReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ServicePaymentSelectionReq */
			if(serialize_ServicePaymentSelectionReqType( (type->ServicePaymentSelectionReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ServicePaymentSelectionReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ServicePaymentSelectionRes)
		{		
					
			/* element ID assignment of ServicePaymentSelectionRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=102;	


			/* encode start element ServicePaymentSelectionRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ServicePaymentSelectionRes */
			if(serialize_ServicePaymentSelectionResType( (type->ServicePaymentSelectionRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ServicePaymentSelectionRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.PaymentDetailsReq)
		{		
					
			/* element ID assignment of PaymentDetailsReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=66;	


			/* encode start element PaymentDetailsReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of PaymentDetailsReq */
			if(serialize_PaymentDetailsReqType( (type->PaymentDetailsReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of PaymentDetailsReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.PaymentDetailsRes)
		{		
					
			/* element ID assignment of PaymentDetailsRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=68;	


			/* encode start element PaymentDetailsRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of PaymentDetailsRes */
			if(serialize_PaymentDetailsResType( (type->PaymentDetailsRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of PaymentDetailsRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ContractAuthenticationReq)
		{		
					
			/* element ID assignment of ContractAuthenticationReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=25;	


			/* encode start element ContractAuthenticationReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ContractAuthenticationReq */
			if(serialize_ContractAuthenticationReqType( (type->ContractAuthenticationReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ContractAuthenticationReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ContractAuthenticationRes)
		{		
					
			/* element ID assignment of ContractAuthenticationRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=27;	


			/* encode start element ContractAuthenticationRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ContractAuthenticationRes */
			if(serialize_ContractAuthenticationResType( (type->ContractAuthenticationRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ContractAuthenticationRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ChargeParameterDiscoveryReq)
		{		
					
			/* element ID assignment of ChargeParameterDiscoveryReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=14;	


			/* encode start element ChargeParameterDiscoveryReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ChargeParameterDiscoveryReq */
			if(serialize_ChargeParameterDiscoveryReqType( (type->ChargeParameterDiscoveryReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ChargeParameterDiscoveryReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ChargeParameterDiscoveryRes)
		{		
					
			/* element ID assignment of ChargeParameterDiscoveryRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=16;	


			/* encode start element ChargeParameterDiscoveryRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ChargeParameterDiscoveryRes */
			if(serialize_ChargeParameterDiscoveryResType( (type->ChargeParameterDiscoveryRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ChargeParameterDiscoveryRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.PowerDeliveryReq)
		{		
					
			/* element ID assignment of PowerDeliveryReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=71;	


			/* encode start element PowerDeliveryReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of PowerDeliveryReq */
			if(serialize_PowerDeliveryReqType( (type->PowerDeliveryReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of PowerDeliveryReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.PowerDeliveryRes)
		{		
					
			/* element ID assignment of PowerDeliveryRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=73;	


			/* encode start element PowerDeliveryRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of PowerDeliveryRes */
			if(serialize_PowerDeliveryResType( (type->PowerDeliveryRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of PowerDeliveryRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ChargingStatusReq)
		{		
					
			/* element ID assignment of ChargingStatusReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=21;	


			/* encode start element ChargingStatusReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ChargingStatusReq */
			if(serialize_ChargingStatusReqType( (type->ChargingStatusReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ChargingStatusReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.ChargingStatusRes)
		{		
					
			/* element ID assignment of ChargingStatusRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=23;	


			/* encode start element ChargingStatusRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of ChargingStatusRes */
			if(serialize_ChargingStatusResType( (type->ChargingStatusRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of ChargingStatusRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.MeteringReceiptReq)
		{		
					
			/* element ID assignment of MeteringReceiptReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=61;	


			/* encode start element MeteringReceiptReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of MeteringReceiptReq */
			if(serialize_MeteringReceiptReqType( (type->MeteringReceiptReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of MeteringReceiptReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.MeteringReceiptRes)
		{		
					
			/* element ID assignment of MeteringReceiptRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=63;	


			/* encode start element MeteringReceiptRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of MeteringReceiptRes */
			if(serialize_MeteringReceiptResType( (type->MeteringReceiptRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of MeteringReceiptRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.SessionStopReq)
		{		
					
			/* element ID assignment of SessionStopReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=110;	


			/* encode start element SessionStopReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of SessionStopReq */
			if(serialize_SessionStopType( (type->SessionStopReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of SessionStopReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.SessionStopRes)
		{		
					
			/* element ID assignment of SessionStopRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=111;	


			/* encode start element SessionStopRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of SessionStopRes */
			if(serialize_SessionStopResType( (type->SessionStopRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of SessionStopRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.CertificateUpdateReq)
		{		
					
			/* element ID assignment of CertificateUpdateReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=10;	


			/* encode start element CertificateUpdateReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of CertificateUpdateReq */
			if(serialize_CertificateUpdateReqType( (type->CertificateUpdateReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of CertificateUpdateReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.CertificateUpdateRes)
		{		
					
			/* element ID assignment of CertificateUpdateRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=12;	


			/* encode start element CertificateUpdateRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of CertificateUpdateRes */
			if(serialize_CertificateUpdateResType( (type->CertificateUpdateRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of CertificateUpdateRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.CertificateInstallationReq)
		{		
					
			/* element ID assignment of CertificateInstallationReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=6;	


			/* encode start element CertificateInstallationReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of CertificateInstallationReq */
			if(serialize_CertificateInstallationReqType( (type->CertificateInstallationReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of CertificateInstallationReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.CertificateInstallationRes)
		{		
					
			/* element ID assignment of CertificateInstallationRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=8;	


			/* encode start element CertificateInstallationRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of CertificateInstallationRes */
			if(serialize_CertificateInstallationResType( (type->CertificateInstallationRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of CertificateInstallationRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.CableCheckReq)
		{		
					
			/* element ID assignment of CableCheckReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=2;	


			/* encode start element CableCheckReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of CableCheckReq */
			if(serialize_CableCheckReqType( (type->CableCheckReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of CableCheckReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.CableCheckRes)
		{		
					
			/* element ID assignment of CableCheckRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=4;	


			/* encode start element CableCheckRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of CableCheckRes */
			if(serialize_CableCheckResType( (type->CableCheckRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of CableCheckRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.PreChargeReq)
		{		
					
			/* element ID assignment of PreChargeReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=75;	


			/* encode start element PreChargeReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of PreChargeReq */
			if(serialize_PreChargeReqType( (type->PreChargeReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of PreChargeReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.PreChargeRes)
		{		
					
			/* element ID assignment of PreChargeRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=77;	


			/* encode start element PreChargeRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of PreChargeRes */
			if(serialize_PreChargeResType( (type->PreChargeRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of PreChargeRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.CurrentDemandReq)
		{		
					
			/* element ID assignment of CurrentDemandReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=33;	


			/* encode start element CurrentDemandReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of CurrentDemandReq */
			if(serialize_CurrentDemandReqType( (type->CurrentDemandReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of CurrentDemandReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.CurrentDemandRes)
		{		
					
			/* element ID assignment of CurrentDemandRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=35;	


			/* encode start element CurrentDemandRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of CurrentDemandRes */
			if(serialize_CurrentDemandResType( (type->CurrentDemandRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of CurrentDemandRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.WeldingDetectionReq)
		{		
					
			/* element ID assignment of WeldingDetectionReq*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=114;	


			/* encode start element WeldingDetectionReq */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of WeldingDetectionReq */
			if(serialize_WeldingDetectionReqType( (type->WeldingDetectionReq),service))
			{
				return -1;
			}

			
			 
			/* encode end element of WeldingDetectionReq */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				
	if(type->isused.WeldingDetectionRes)
		{		
					
			/* element ID assignment of WeldingDetectionRes*/
			service->eqn.namespaceURI=5;			
			service->eqn.localPart=116;	


			/* encode start element WeldingDetectionRes */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of WeldingDetectionRes */
			if(serialize_WeldingDetectionResType( (type->WeldingDetectionRes),service))
			{
				return -1;
			}

			
			 
			/* encode end element of WeldingDetectionRes */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		}
				

	return 0;			
}


static int serialize_AnonType_V2G_Message(struct AnonType_V2G_Message* type, struct EXIService* service)
{
	
			/* element ID assignment of Header*/
			service->eqn.namespaceURI=7;			
			service->eqn.localPart=4;	


			/* encode start element Header */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of Header */
			if(serialize_MessageHeaderType( (type->Header),service))
			{
				return -1;
			}

			
			 
			/* encode end element of Header */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

			
			/* element ID assignment of Body*/
			service->eqn.namespaceURI=7;			
			service->eqn.localPart=0;	


			/* encode start element Body */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of Body */
			if(serialize_BodyType( &(type->Body),service))
			{
				return -1;
			}

			
			 
			/* encode end element of Body */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}


static int serialize_EXIDocumentType(struct EXIDocumentType* type, struct EXIService* service)
{
	
			/* element ID assignment of V2G_Message*/
			service->eqn.namespaceURI=7;			
			service->eqn.localPart=5;	


			/* encode start element V2G_Message */	
			if (exiEncodeStartElement(&(service->outStream), &(service->stateEncode), &(service->eqn))) 
			{
					return -1;
			}
						
			/* encode children of V2G_Message */
			if(serialize_AnonType_V2G_Message( &(type->V2G_Message),service))
			{
				return -1;
			}

			
			 
			/* encode end element of V2G_Message */
			exiEncodeEndElement(&(service->outStream), &(service->stateEncode));

		

	return 0;			
}

 
 
 
 
 
 /* marshal data to EXI stream */
static int serialize_message(struct EXIService* service)
 {
	

	/* encode start document */ 	
	if (exiEncodeStartDocument(&(service->outStream), &(service->stateEncode)) ) 
	{
	 
		return -1;
	}

	/* encode root element of V2G_Message */
	if (serialize_EXIDocumentType(&(service->exiMsg), service)) 
	{
			 
		return -1;
	}


	/* encode end document */
	if (exiEncodeEndDocument(&(service->outStream), &(service->stateEncode))) {
	 
	return -1;
	}	
 	
 	return 0;
 	
 }