/* soapH.h
   Generated by gSOAP 2.8.135 for ../onvif_head/onvif.h

gSOAP XML Web services tools
Copyright (C) 2000,2024, Robert van Engelen, Genivia Inc. All Rights Reserved.
The soapcpp2 tool and its generated software are released under the GPL.
This program is released under the GPL with the additional exemption that
compiling, linking, and/or using OpenSSL is allowed.
--------------------------------------------------------------------------------
A commercial use license is available from Genivia Inc., contact@genivia.com
--------------------------------------------------------------------------------
*/

#ifndef soapH_H
#define soapH_H
#include "soapStub.h"
#ifndef WITH_NOIDREF

#ifdef __cplusplus
extern "C" {
#endif
SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap*, const void*, int);

#ifdef __cplusplus
}
#endif
SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap*);
SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap*);
#endif

#ifdef __cplusplus
extern "C" {
#endif
SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap*, const char*, int*);
SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap*, const void*, const char*, int, int);
SOAP_FMAC3 void * SOAP_FMAC4 soap_dupelement(struct soap*, const void*, int);
SOAP_FMAC3 void SOAP_FMAC4 soap_delelement(const void*, int);

#ifdef __cplusplus
}
#endif
SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap*);
SOAP_FMAC3 void * SOAP_FMAC4 soap_instantiate(struct soap*, int, const char*, const char*, size_t*);
SOAP_FMAC3 int SOAP_FMAC4 soap_fdelete(struct soap *soap, struct soap_clist*);
SOAP_FMAC3 int SOAP_FMAC4 soap_fbase(int, int);
SOAP_FMAC3 void SOAP_FMAC4 soap_finsert(struct soap*, int, int, void*, size_t, const void*, void**);

#ifndef SOAP_TYPE_byte_DEFINED
#define SOAP_TYPE_byte_DEFINED

inline void soap_default_byte(struct soap *soap, char *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_byte
	*a = SOAP_DEFAULT_byte;
#else
	*a = (char)0;
#endif
}
SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap*, const char*, int, const char *, const char*);
SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap*, const char*, char *, const char*);

SOAP_FMAC3 char * SOAP_FMAC4 soap_new_byte(struct soap *soap, int n = -1);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap*, const char *, const char*, const char*);

inline int soap_write_byte(struct soap *soap, char const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put_byte(soap, p, "byte", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT_byte(struct soap *soap, const char *URL, char const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_byte(soap, p, "byte", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_byte(struct soap *soap, const char *URL, char const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_byte(soap, p, "byte", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_byte(struct soap *soap, const char *URL, char const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_byte(soap, p, "byte", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap*, char *, const char*, const char*);

inline int soap_read_byte(struct soap *soap, char *p)
{
	if (p)
	{	if (soap_begin_recv(soap) || ::soap_get_byte(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_byte(struct soap *soap, const char *URL, char *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_byte(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_byte(struct soap *soap, char *p)
{
	if (::soap_read_byte(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_int_DEFINED
#define SOAP_TYPE_int_DEFINED

inline void soap_default_int(struct soap *soap, int *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_int
	*a = SOAP_DEFAULT_int;
#else
	*a = (int)0;
#endif
}
SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap*, const char*, int, const int *, const char*);
SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap*, const char*, int *, const char*);

SOAP_FMAC3 int * SOAP_FMAC4 soap_new_int(struct soap *soap, int n = -1);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap*, const int *, const char*, const char*);

inline int soap_write_int(struct soap *soap, int const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put_int(soap, p, "int", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT_int(struct soap *soap, const char *URL, int const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_int(soap, p, "int", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_int(struct soap *soap, const char *URL, int const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_int(soap, p, "int", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_int(struct soap *soap, const char *URL, int const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_int(soap, p, "int", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap*, int *, const char*, const char*);

inline int soap_read_int(struct soap *soap, int *p)
{
	if (p)
	{	if (soap_begin_recv(soap) || ::soap_get_int(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_int(struct soap *soap, const char *URL, int *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_int(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_int(struct soap *soap, int *p)
{
	if (::soap_read_int(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif
/* _wsdd__MetadataVersion is a typedef synonym of unsignedInt */

#ifndef SOAP_TYPE__wsdd__MetadataVersion_DEFINED
#define SOAP_TYPE__wsdd__MetadataVersion_DEFINED

#define soap_default__wsdd__MetadataVersion soap_default_unsignedInt


#define soap__wsdd__MetadataVersion2s soap_unsignedInt2s


#define soap_out__wsdd__MetadataVersion soap_out_unsignedInt


#define soap_s2_wsdd__MetadataVersion soap_s2unsignedInt


#define soap_in__wsdd__MetadataVersion soap_in_unsignedInt


#define soap_instantiate__wsdd__MetadataVersion soap_instantiate_unsignedInt


#define soap_new__wsdd__MetadataVersion soap_new_unsignedInt

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsdd__MetadataVersion(struct soap*, const unsigned int *, const char*, const char*);

inline int soap_write__wsdd__MetadataVersion(struct soap *soap, unsigned int const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put__wsdd__MetadataVersion(soap, p, "wsdd:MetadataVersion", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT__wsdd__MetadataVersion(struct soap *soap, const char *URL, unsigned int const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsdd__MetadataVersion(soap, p, "wsdd:MetadataVersion", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsdd__MetadataVersion(struct soap *soap, const char *URL, unsigned int const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsdd__MetadataVersion(soap, p, "wsdd:MetadataVersion", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsdd__MetadataVersion(struct soap *soap, const char *URL, unsigned int const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsdd__MetadataVersion(soap, p, "wsdd:MetadataVersion", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsdd__MetadataVersion soap_get_unsignedInt


#define soap_read__wsdd__MetadataVersion soap_read_unsignedInt


#define soap_GET__wsdd__MetadataVersion soap_GET_unsignedInt


#define soap_POST_recv__wsdd__MetadataVersion soap_POST_recv_unsignedInt

#endif
/* _wsa__ReplyAfter is a typedef synonym of unsignedInt */

#ifndef SOAP_TYPE__wsa__ReplyAfter_DEFINED
#define SOAP_TYPE__wsa__ReplyAfter_DEFINED

#define soap_default__wsa__ReplyAfter soap_default_unsignedInt


#define soap__wsa__ReplyAfter2s soap_unsignedInt2s


#define soap_out__wsa__ReplyAfter soap_out_unsignedInt


#define soap_s2_wsa__ReplyAfter soap_s2unsignedInt


#define soap_in__wsa__ReplyAfter soap_in_unsignedInt


#define soap_instantiate__wsa__ReplyAfter soap_instantiate_unsignedInt


#define soap_new__wsa__ReplyAfter soap_new_unsignedInt

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsa__ReplyAfter(struct soap*, const unsigned int *, const char*, const char*);

inline int soap_write__wsa__ReplyAfter(struct soap *soap, unsigned int const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put__wsa__ReplyAfter(soap, p, "wsa:ReplyAfter", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT__wsa__ReplyAfter(struct soap *soap, const char *URL, unsigned int const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsa__ReplyAfter(soap, p, "wsa:ReplyAfter", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsa__ReplyAfter(struct soap *soap, const char *URL, unsigned int const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsa__ReplyAfter(soap, p, "wsa:ReplyAfter", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsa__ReplyAfter(struct soap *soap, const char *URL, unsigned int const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsa__ReplyAfter(soap, p, "wsa:ReplyAfter", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsa__ReplyAfter soap_get_unsignedInt


#define soap_read__wsa__ReplyAfter soap_read_unsignedInt


#define soap_GET__wsa__ReplyAfter soap_GET_unsignedInt


#define soap_POST_recv__wsa__ReplyAfter soap_POST_recv_unsignedInt

#endif

#ifndef SOAP_TYPE_unsignedInt_DEFINED
#define SOAP_TYPE_unsignedInt_DEFINED

inline void soap_default_unsignedInt(struct soap *soap, unsigned int *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_unsignedInt
	*a = SOAP_DEFAULT_unsignedInt;
#else
	*a = (unsigned int)0;
#endif
}
SOAP_FMAC3 int SOAP_FMAC4 soap_out_unsignedInt(struct soap*, const char*, int, const unsigned int *, const char*);
SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_unsignedInt(struct soap*, const char*, unsigned int *, const char*);

SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_new_unsignedInt(struct soap *soap, int n = -1);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_unsignedInt(struct soap*, const unsigned int *, const char*, const char*);

inline int soap_write_unsignedInt(struct soap *soap, unsigned int const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put_unsignedInt(soap, p, "unsignedInt", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT_unsignedInt(struct soap *soap, const char *URL, unsigned int const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_unsignedInt(soap, p, "unsignedInt", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_unsignedInt(struct soap *soap, const char *URL, unsigned int const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_unsignedInt(soap, p, "unsignedInt", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_unsignedInt(struct soap *soap, const char *URL, unsigned int const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_unsignedInt(soap, p, "unsignedInt", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_unsignedInt(struct soap*, unsigned int *, const char*, const char*);

inline int soap_read_unsignedInt(struct soap *soap, unsigned int *p)
{
	if (p)
	{	if (soap_begin_recv(soap) || ::soap_get_unsignedInt(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_unsignedInt(struct soap *soap, const char *URL, unsigned int *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_unsignedInt(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_unsignedInt(struct soap *soap, unsigned int *p)
{
	if (::soap_read_unsignedInt(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsdd__FaultCodeType_DEFINED
#define SOAP_TYPE_wsdd__FaultCodeType_DEFINED

inline void soap_default_wsdd__FaultCodeType(struct soap *soap, enum wsdd__FaultCodeType *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_wsdd__FaultCodeType
	*a = SOAP_DEFAULT_wsdd__FaultCodeType;
#else
	*a = (enum wsdd__FaultCodeType)0;
#endif
}
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__FaultCodeType(struct soap*, const char*, int, const enum wsdd__FaultCodeType *, const char*);
SOAP_FMAC3S const char* SOAP_FMAC4S soap_wsdd__FaultCodeType2s(struct soap*, enum wsdd__FaultCodeType);
SOAP_FMAC3 enum wsdd__FaultCodeType * SOAP_FMAC4 soap_in_wsdd__FaultCodeType(struct soap*, const char*, enum wsdd__FaultCodeType *, const char*);
SOAP_FMAC3S int SOAP_FMAC4S soap_s2wsdd__FaultCodeType(struct soap*, const char*, enum wsdd__FaultCodeType *);

SOAP_FMAC3 enum wsdd__FaultCodeType * SOAP_FMAC4 soap_new_wsdd__FaultCodeType(struct soap *soap, int n = -1);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__FaultCodeType(struct soap*, const enum wsdd__FaultCodeType *, const char*, const char*);

inline int soap_write_wsdd__FaultCodeType(struct soap *soap, enum wsdd__FaultCodeType const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put_wsdd__FaultCodeType(soap, p, "wsdd:FaultCodeType", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT_wsdd__FaultCodeType(struct soap *soap, const char *URL, enum wsdd__FaultCodeType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsdd__FaultCodeType(soap, p, "wsdd:FaultCodeType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__FaultCodeType(struct soap *soap, const char *URL, enum wsdd__FaultCodeType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsdd__FaultCodeType(soap, p, "wsdd:FaultCodeType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__FaultCodeType(struct soap *soap, const char *URL, enum wsdd__FaultCodeType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsdd__FaultCodeType(soap, p, "wsdd:FaultCodeType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 enum wsdd__FaultCodeType * SOAP_FMAC4 soap_get_wsdd__FaultCodeType(struct soap*, enum wsdd__FaultCodeType *, const char*, const char*);

inline int soap_read_wsdd__FaultCodeType(struct soap *soap, enum wsdd__FaultCodeType *p)
{
	if (p)
	{	if (soap_begin_recv(soap) || ::soap_get_wsdd__FaultCodeType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__FaultCodeType(struct soap *soap, const char *URL, enum wsdd__FaultCodeType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__FaultCodeType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__FaultCodeType(struct soap *soap, enum wsdd__FaultCodeType *p)
{
	if (::soap_read_wsdd__FaultCodeType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsa__FaultSubcodeValues_DEFINED
#define SOAP_TYPE_wsa__FaultSubcodeValues_DEFINED

inline void soap_default_wsa__FaultSubcodeValues(struct soap *soap, enum wsa__FaultSubcodeValues *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_wsa__FaultSubcodeValues
	*a = SOAP_DEFAULT_wsa__FaultSubcodeValues;
#else
	*a = (enum wsa__FaultSubcodeValues)0;
#endif
}
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsa__FaultSubcodeValues(struct soap*, const char*, int, const enum wsa__FaultSubcodeValues *, const char*);
SOAP_FMAC3S const char* SOAP_FMAC4S soap_wsa__FaultSubcodeValues2s(struct soap*, enum wsa__FaultSubcodeValues);
SOAP_FMAC3 enum wsa__FaultSubcodeValues * SOAP_FMAC4 soap_in_wsa__FaultSubcodeValues(struct soap*, const char*, enum wsa__FaultSubcodeValues *, const char*);
SOAP_FMAC3S int SOAP_FMAC4S soap_s2wsa__FaultSubcodeValues(struct soap*, const char*, enum wsa__FaultSubcodeValues *);

SOAP_FMAC3 enum wsa__FaultSubcodeValues * SOAP_FMAC4 soap_new_wsa__FaultSubcodeValues(struct soap *soap, int n = -1);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsa__FaultSubcodeValues(struct soap*, const enum wsa__FaultSubcodeValues *, const char*, const char*);

inline int soap_write_wsa__FaultSubcodeValues(struct soap *soap, enum wsa__FaultSubcodeValues const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put_wsa__FaultSubcodeValues(soap, p, "wsa:FaultSubcodeValues", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT_wsa__FaultSubcodeValues(struct soap *soap, const char *URL, enum wsa__FaultSubcodeValues const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsa__FaultSubcodeValues(soap, p, "wsa:FaultSubcodeValues", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsa__FaultSubcodeValues(struct soap *soap, const char *URL, enum wsa__FaultSubcodeValues const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsa__FaultSubcodeValues(soap, p, "wsa:FaultSubcodeValues", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsa__FaultSubcodeValues(struct soap *soap, const char *URL, enum wsa__FaultSubcodeValues const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsa__FaultSubcodeValues(soap, p, "wsa:FaultSubcodeValues", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 enum wsa__FaultSubcodeValues * SOAP_FMAC4 soap_get_wsa__FaultSubcodeValues(struct soap*, enum wsa__FaultSubcodeValues *, const char*, const char*);

inline int soap_read_wsa__FaultSubcodeValues(struct soap *soap, enum wsa__FaultSubcodeValues *p)
{
	if (p)
	{	if (soap_begin_recv(soap) || ::soap_get_wsa__FaultSubcodeValues(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsa__FaultSubcodeValues(struct soap *soap, const char *URL, enum wsa__FaultSubcodeValues *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsa__FaultSubcodeValues(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsa__FaultSubcodeValues(struct soap *soap, enum wsa__FaultSubcodeValues *p)
{
	if (::soap_read_wsa__FaultSubcodeValues(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsa__RelationshipTypeValues_DEFINED
#define SOAP_TYPE_wsa__RelationshipTypeValues_DEFINED

inline void soap_default_wsa__RelationshipTypeValues(struct soap *soap, enum wsa__RelationshipTypeValues *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_wsa__RelationshipTypeValues
	*a = SOAP_DEFAULT_wsa__RelationshipTypeValues;
#else
	*a = (enum wsa__RelationshipTypeValues)0;
#endif
}
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsa__RelationshipTypeValues(struct soap*, const char*, int, const enum wsa__RelationshipTypeValues *, const char*);
SOAP_FMAC3S const char* SOAP_FMAC4S soap_wsa__RelationshipTypeValues2s(struct soap*, enum wsa__RelationshipTypeValues);
SOAP_FMAC3 enum wsa__RelationshipTypeValues * SOAP_FMAC4 soap_in_wsa__RelationshipTypeValues(struct soap*, const char*, enum wsa__RelationshipTypeValues *, const char*);
SOAP_FMAC3S int SOAP_FMAC4S soap_s2wsa__RelationshipTypeValues(struct soap*, const char*, enum wsa__RelationshipTypeValues *);

SOAP_FMAC3 enum wsa__RelationshipTypeValues * SOAP_FMAC4 soap_new_wsa__RelationshipTypeValues(struct soap *soap, int n = -1);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsa__RelationshipTypeValues(struct soap*, const enum wsa__RelationshipTypeValues *, const char*, const char*);

inline int soap_write_wsa__RelationshipTypeValues(struct soap *soap, enum wsa__RelationshipTypeValues const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put_wsa__RelationshipTypeValues(soap, p, "wsa:RelationshipTypeValues", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT_wsa__RelationshipTypeValues(struct soap *soap, const char *URL, enum wsa__RelationshipTypeValues const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsa__RelationshipTypeValues(soap, p, "wsa:RelationshipTypeValues", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsa__RelationshipTypeValues(struct soap *soap, const char *URL, enum wsa__RelationshipTypeValues const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsa__RelationshipTypeValues(soap, p, "wsa:RelationshipTypeValues", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsa__RelationshipTypeValues(struct soap *soap, const char *URL, enum wsa__RelationshipTypeValues const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsa__RelationshipTypeValues(soap, p, "wsa:RelationshipTypeValues", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 enum wsa__RelationshipTypeValues * SOAP_FMAC4 soap_get_wsa__RelationshipTypeValues(struct soap*, enum wsa__RelationshipTypeValues *, const char*, const char*);

inline int soap_read_wsa__RelationshipTypeValues(struct soap *soap, enum wsa__RelationshipTypeValues *p)
{
	if (p)
	{	if (soap_begin_recv(soap) || ::soap_get_wsa__RelationshipTypeValues(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsa__RelationshipTypeValues(struct soap *soap, const char *URL, enum wsa__RelationshipTypeValues *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsa__RelationshipTypeValues(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsa__RelationshipTypeValues(struct soap *soap, enum wsa__RelationshipTypeValues *p)
{
	if (::soap_read_wsa__RelationshipTypeValues(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___tdn__Probe_DEFINED
#define SOAP_TYPE___tdn__Probe_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___tdn__Probe(struct soap*, struct __tdn__Probe *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___tdn__Probe(struct soap*, const struct __tdn__Probe *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___tdn__Probe(struct soap*, const char*, int, const struct __tdn__Probe *, const char*);
SOAP_FMAC3 struct __tdn__Probe * SOAP_FMAC4 soap_in___tdn__Probe(struct soap*, const char*, struct __tdn__Probe *, const char*);
SOAP_FMAC1 struct __tdn__Probe * SOAP_FMAC2 soap_instantiate___tdn__Probe(struct soap*, int, const char*, const char*, size_t*);

inline struct __tdn__Probe * soap_new___tdn__Probe(struct soap *soap, int n = -1)
{
	return soap_instantiate___tdn__Probe(soap, n, NULL, NULL, NULL);
}

inline struct __tdn__Probe * soap_new_req___tdn__Probe(
	struct soap *soap,
	const struct wsdd__ProbeType& tdn__Probe)
{
	struct __tdn__Probe *_p = ::soap_new___tdn__Probe(soap);
	if (_p)
	{	::soap_default___tdn__Probe(soap, _p);
		_p->tdn__Probe = tdn__Probe;
	}
	return _p;
}

inline struct __tdn__Probe * soap_new_set___tdn__Probe(
	struct soap *soap,
	const struct wsdd__ProbeType& tdn__Probe)
{
	struct __tdn__Probe *_p = ::soap_new___tdn__Probe(soap);
	if (_p)
	{	::soap_default___tdn__Probe(soap, _p);
		_p->tdn__Probe = tdn__Probe;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___tdn__Probe(struct soap*, const struct __tdn__Probe *, const char*, const char*);

inline int soap_write___tdn__Probe(struct soap *soap, struct __tdn__Probe const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___tdn__Probe(soap, p), 0) || ::soap_put___tdn__Probe(soap, p, "-tdn:Probe", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___tdn__Probe(struct soap *soap, const char *URL, struct __tdn__Probe const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___tdn__Probe(soap, p), 0) || ::soap_put___tdn__Probe(soap, p, "-tdn:Probe", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___tdn__Probe(struct soap *soap, const char *URL, struct __tdn__Probe const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___tdn__Probe(soap, p), 0) || ::soap_put___tdn__Probe(soap, p, "-tdn:Probe", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___tdn__Probe(struct soap *soap, const char *URL, struct __tdn__Probe const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___tdn__Probe(soap, p), 0) || ::soap_put___tdn__Probe(soap, p, "-tdn:Probe", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __tdn__Probe * SOAP_FMAC4 soap_get___tdn__Probe(struct soap*, struct __tdn__Probe *, const char*, const char*);

inline int soap_read___tdn__Probe(struct soap *soap, struct __tdn__Probe *p)
{
	if (p)
	{	::soap_default___tdn__Probe(soap, p);
		if (soap_begin_recv(soap) || ::soap_get___tdn__Probe(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET___tdn__Probe(struct soap *soap, const char *URL, struct __tdn__Probe *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read___tdn__Probe(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv___tdn__Probe(struct soap *soap, struct __tdn__Probe *p)
{
	if (::soap_read___tdn__Probe(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___tdn__Bye_DEFINED
#define SOAP_TYPE___tdn__Bye_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___tdn__Bye(struct soap*, struct __tdn__Bye *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___tdn__Bye(struct soap*, const struct __tdn__Bye *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___tdn__Bye(struct soap*, const char*, int, const struct __tdn__Bye *, const char*);
SOAP_FMAC3 struct __tdn__Bye * SOAP_FMAC4 soap_in___tdn__Bye(struct soap*, const char*, struct __tdn__Bye *, const char*);
SOAP_FMAC1 struct __tdn__Bye * SOAP_FMAC2 soap_instantiate___tdn__Bye(struct soap*, int, const char*, const char*, size_t*);

inline struct __tdn__Bye * soap_new___tdn__Bye(struct soap *soap, int n = -1)
{
	return soap_instantiate___tdn__Bye(soap, n, NULL, NULL, NULL);
}

inline struct __tdn__Bye * soap_new_req___tdn__Bye(
	struct soap *soap,
	const struct wsdd__ByeType& tdn__Bye)
{
	struct __tdn__Bye *_p = ::soap_new___tdn__Bye(soap);
	if (_p)
	{	::soap_default___tdn__Bye(soap, _p);
		_p->tdn__Bye = tdn__Bye;
	}
	return _p;
}

inline struct __tdn__Bye * soap_new_set___tdn__Bye(
	struct soap *soap,
	const struct wsdd__ByeType& tdn__Bye)
{
	struct __tdn__Bye *_p = ::soap_new___tdn__Bye(soap);
	if (_p)
	{	::soap_default___tdn__Bye(soap, _p);
		_p->tdn__Bye = tdn__Bye;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___tdn__Bye(struct soap*, const struct __tdn__Bye *, const char*, const char*);

inline int soap_write___tdn__Bye(struct soap *soap, struct __tdn__Bye const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___tdn__Bye(soap, p), 0) || ::soap_put___tdn__Bye(soap, p, "-tdn:Bye", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___tdn__Bye(struct soap *soap, const char *URL, struct __tdn__Bye const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___tdn__Bye(soap, p), 0) || ::soap_put___tdn__Bye(soap, p, "-tdn:Bye", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___tdn__Bye(struct soap *soap, const char *URL, struct __tdn__Bye const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___tdn__Bye(soap, p), 0) || ::soap_put___tdn__Bye(soap, p, "-tdn:Bye", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___tdn__Bye(struct soap *soap, const char *URL, struct __tdn__Bye const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___tdn__Bye(soap, p), 0) || ::soap_put___tdn__Bye(soap, p, "-tdn:Bye", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __tdn__Bye * SOAP_FMAC4 soap_get___tdn__Bye(struct soap*, struct __tdn__Bye *, const char*, const char*);

inline int soap_read___tdn__Bye(struct soap *soap, struct __tdn__Bye *p)
{
	if (p)
	{	::soap_default___tdn__Bye(soap, p);
		if (soap_begin_recv(soap) || ::soap_get___tdn__Bye(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET___tdn__Bye(struct soap *soap, const char *URL, struct __tdn__Bye *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read___tdn__Bye(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv___tdn__Bye(struct soap *soap, struct __tdn__Bye *p)
{
	if (::soap_read___tdn__Bye(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___tdn__Hello_DEFINED
#define SOAP_TYPE___tdn__Hello_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___tdn__Hello(struct soap*, struct __tdn__Hello *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___tdn__Hello(struct soap*, const struct __tdn__Hello *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___tdn__Hello(struct soap*, const char*, int, const struct __tdn__Hello *, const char*);
SOAP_FMAC3 struct __tdn__Hello * SOAP_FMAC4 soap_in___tdn__Hello(struct soap*, const char*, struct __tdn__Hello *, const char*);
SOAP_FMAC1 struct __tdn__Hello * SOAP_FMAC2 soap_instantiate___tdn__Hello(struct soap*, int, const char*, const char*, size_t*);

inline struct __tdn__Hello * soap_new___tdn__Hello(struct soap *soap, int n = -1)
{
	return soap_instantiate___tdn__Hello(soap, n, NULL, NULL, NULL);
}

inline struct __tdn__Hello * soap_new_req___tdn__Hello(
	struct soap *soap,
	const struct wsdd__HelloType& tdn__Hello)
{
	struct __tdn__Hello *_p = ::soap_new___tdn__Hello(soap);
	if (_p)
	{	::soap_default___tdn__Hello(soap, _p);
		_p->tdn__Hello = tdn__Hello;
	}
	return _p;
}

inline struct __tdn__Hello * soap_new_set___tdn__Hello(
	struct soap *soap,
	const struct wsdd__HelloType& tdn__Hello)
{
	struct __tdn__Hello *_p = ::soap_new___tdn__Hello(soap);
	if (_p)
	{	::soap_default___tdn__Hello(soap, _p);
		_p->tdn__Hello = tdn__Hello;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___tdn__Hello(struct soap*, const struct __tdn__Hello *, const char*, const char*);

inline int soap_write___tdn__Hello(struct soap *soap, struct __tdn__Hello const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___tdn__Hello(soap, p), 0) || ::soap_put___tdn__Hello(soap, p, "-tdn:Hello", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___tdn__Hello(struct soap *soap, const char *URL, struct __tdn__Hello const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___tdn__Hello(soap, p), 0) || ::soap_put___tdn__Hello(soap, p, "-tdn:Hello", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___tdn__Hello(struct soap *soap, const char *URL, struct __tdn__Hello const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___tdn__Hello(soap, p), 0) || ::soap_put___tdn__Hello(soap, p, "-tdn:Hello", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___tdn__Hello(struct soap *soap, const char *URL, struct __tdn__Hello const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___tdn__Hello(soap, p), 0) || ::soap_put___tdn__Hello(soap, p, "-tdn:Hello", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __tdn__Hello * SOAP_FMAC4 soap_get___tdn__Hello(struct soap*, struct __tdn__Hello *, const char*, const char*);

inline int soap_read___tdn__Hello(struct soap *soap, struct __tdn__Hello *p)
{
	if (p)
	{	::soap_default___tdn__Hello(soap, p);
		if (soap_begin_recv(soap) || ::soap_get___tdn__Hello(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET___tdn__Hello(struct soap *soap, const char *URL, struct __tdn__Hello *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read___tdn__Hello(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv___tdn__Hello(struct soap *soap, struct __tdn__Hello *p)
{
	if (::soap_read___tdn__Hello(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___wsdd__ResolveMatches_DEFINED
#define SOAP_TYPE___wsdd__ResolveMatches_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___wsdd__ResolveMatches(struct soap*, struct __wsdd__ResolveMatches *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wsdd__ResolveMatches(struct soap*, const struct __wsdd__ResolveMatches *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___wsdd__ResolveMatches(struct soap*, const char*, int, const struct __wsdd__ResolveMatches *, const char*);
SOAP_FMAC3 struct __wsdd__ResolveMatches * SOAP_FMAC4 soap_in___wsdd__ResolveMatches(struct soap*, const char*, struct __wsdd__ResolveMatches *, const char*);
SOAP_FMAC1 struct __wsdd__ResolveMatches * SOAP_FMAC2 soap_instantiate___wsdd__ResolveMatches(struct soap*, int, const char*, const char*, size_t*);

inline struct __wsdd__ResolveMatches * soap_new___wsdd__ResolveMatches(struct soap *soap, int n = -1)
{
	return soap_instantiate___wsdd__ResolveMatches(soap, n, NULL, NULL, NULL);
}

inline struct __wsdd__ResolveMatches * soap_new_req___wsdd__ResolveMatches(
	struct soap *soap)
{
	struct __wsdd__ResolveMatches *_p = ::soap_new___wsdd__ResolveMatches(soap);
	if (_p)
	{	::soap_default___wsdd__ResolveMatches(soap, _p);
	}
	return _p;
}

inline struct __wsdd__ResolveMatches * soap_new_set___wsdd__ResolveMatches(
	struct soap *soap,
	struct wsdd__ResolveMatchesType *wsdd__ResolveMatches)
{
	struct __wsdd__ResolveMatches *_p = ::soap_new___wsdd__ResolveMatches(soap);
	if (_p)
	{	::soap_default___wsdd__ResolveMatches(soap, _p);
		_p->wsdd__ResolveMatches = wsdd__ResolveMatches;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___wsdd__ResolveMatches(struct soap*, const struct __wsdd__ResolveMatches *, const char*, const char*);

inline int soap_write___wsdd__ResolveMatches(struct soap *soap, struct __wsdd__ResolveMatches const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___wsdd__ResolveMatches(soap, p), 0) || ::soap_put___wsdd__ResolveMatches(soap, p, "-wsdd:ResolveMatches", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___wsdd__ResolveMatches(struct soap *soap, const char *URL, struct __wsdd__ResolveMatches const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__ResolveMatches(soap, p), 0) || ::soap_put___wsdd__ResolveMatches(soap, p, "-wsdd:ResolveMatches", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___wsdd__ResolveMatches(struct soap *soap, const char *URL, struct __wsdd__ResolveMatches const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__ResolveMatches(soap, p), 0) || ::soap_put___wsdd__ResolveMatches(soap, p, "-wsdd:ResolveMatches", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___wsdd__ResolveMatches(struct soap *soap, const char *URL, struct __wsdd__ResolveMatches const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__ResolveMatches(soap, p), 0) || ::soap_put___wsdd__ResolveMatches(soap, p, "-wsdd:ResolveMatches", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __wsdd__ResolveMatches * SOAP_FMAC4 soap_get___wsdd__ResolveMatches(struct soap*, struct __wsdd__ResolveMatches *, const char*, const char*);

inline int soap_read___wsdd__ResolveMatches(struct soap *soap, struct __wsdd__ResolveMatches *p)
{
	if (p)
	{	::soap_default___wsdd__ResolveMatches(soap, p);
		if (soap_begin_recv(soap) || ::soap_get___wsdd__ResolveMatches(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET___wsdd__ResolveMatches(struct soap *soap, const char *URL, struct __wsdd__ResolveMatches *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read___wsdd__ResolveMatches(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv___wsdd__ResolveMatches(struct soap *soap, struct __wsdd__ResolveMatches *p)
{
	if (::soap_read___wsdd__ResolveMatches(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___wsdd__Resolve_DEFINED
#define SOAP_TYPE___wsdd__Resolve_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___wsdd__Resolve(struct soap*, struct __wsdd__Resolve *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wsdd__Resolve(struct soap*, const struct __wsdd__Resolve *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___wsdd__Resolve(struct soap*, const char*, int, const struct __wsdd__Resolve *, const char*);
SOAP_FMAC3 struct __wsdd__Resolve * SOAP_FMAC4 soap_in___wsdd__Resolve(struct soap*, const char*, struct __wsdd__Resolve *, const char*);
SOAP_FMAC1 struct __wsdd__Resolve * SOAP_FMAC2 soap_instantiate___wsdd__Resolve(struct soap*, int, const char*, const char*, size_t*);

inline struct __wsdd__Resolve * soap_new___wsdd__Resolve(struct soap *soap, int n = -1)
{
	return soap_instantiate___wsdd__Resolve(soap, n, NULL, NULL, NULL);
}

inline struct __wsdd__Resolve * soap_new_req___wsdd__Resolve(
	struct soap *soap)
{
	struct __wsdd__Resolve *_p = ::soap_new___wsdd__Resolve(soap);
	if (_p)
	{	::soap_default___wsdd__Resolve(soap, _p);
	}
	return _p;
}

inline struct __wsdd__Resolve * soap_new_set___wsdd__Resolve(
	struct soap *soap,
	struct wsdd__ResolveType *wsdd__Resolve)
{
	struct __wsdd__Resolve *_p = ::soap_new___wsdd__Resolve(soap);
	if (_p)
	{	::soap_default___wsdd__Resolve(soap, _p);
		_p->wsdd__Resolve = wsdd__Resolve;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___wsdd__Resolve(struct soap*, const struct __wsdd__Resolve *, const char*, const char*);

inline int soap_write___wsdd__Resolve(struct soap *soap, struct __wsdd__Resolve const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___wsdd__Resolve(soap, p), 0) || ::soap_put___wsdd__Resolve(soap, p, "-wsdd:Resolve", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___wsdd__Resolve(struct soap *soap, const char *URL, struct __wsdd__Resolve const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__Resolve(soap, p), 0) || ::soap_put___wsdd__Resolve(soap, p, "-wsdd:Resolve", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___wsdd__Resolve(struct soap *soap, const char *URL, struct __wsdd__Resolve const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__Resolve(soap, p), 0) || ::soap_put___wsdd__Resolve(soap, p, "-wsdd:Resolve", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___wsdd__Resolve(struct soap *soap, const char *URL, struct __wsdd__Resolve const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__Resolve(soap, p), 0) || ::soap_put___wsdd__Resolve(soap, p, "-wsdd:Resolve", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __wsdd__Resolve * SOAP_FMAC4 soap_get___wsdd__Resolve(struct soap*, struct __wsdd__Resolve *, const char*, const char*);

inline int soap_read___wsdd__Resolve(struct soap *soap, struct __wsdd__Resolve *p)
{
	if (p)
	{	::soap_default___wsdd__Resolve(soap, p);
		if (soap_begin_recv(soap) || ::soap_get___wsdd__Resolve(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET___wsdd__Resolve(struct soap *soap, const char *URL, struct __wsdd__Resolve *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read___wsdd__Resolve(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv___wsdd__Resolve(struct soap *soap, struct __wsdd__Resolve *p)
{
	if (::soap_read___wsdd__Resolve(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___wsdd__ProbeMatches_DEFINED
#define SOAP_TYPE___wsdd__ProbeMatches_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___wsdd__ProbeMatches(struct soap*, struct __wsdd__ProbeMatches *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wsdd__ProbeMatches(struct soap*, const struct __wsdd__ProbeMatches *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___wsdd__ProbeMatches(struct soap*, const char*, int, const struct __wsdd__ProbeMatches *, const char*);
SOAP_FMAC3 struct __wsdd__ProbeMatches * SOAP_FMAC4 soap_in___wsdd__ProbeMatches(struct soap*, const char*, struct __wsdd__ProbeMatches *, const char*);
SOAP_FMAC1 struct __wsdd__ProbeMatches * SOAP_FMAC2 soap_instantiate___wsdd__ProbeMatches(struct soap*, int, const char*, const char*, size_t*);

inline struct __wsdd__ProbeMatches * soap_new___wsdd__ProbeMatches(struct soap *soap, int n = -1)
{
	return soap_instantiate___wsdd__ProbeMatches(soap, n, NULL, NULL, NULL);
}

inline struct __wsdd__ProbeMatches * soap_new_req___wsdd__ProbeMatches(
	struct soap *soap)
{
	struct __wsdd__ProbeMatches *_p = ::soap_new___wsdd__ProbeMatches(soap);
	if (_p)
	{	::soap_default___wsdd__ProbeMatches(soap, _p);
	}
	return _p;
}

inline struct __wsdd__ProbeMatches * soap_new_set___wsdd__ProbeMatches(
	struct soap *soap,
	struct wsdd__ProbeMatchesType *wsdd__ProbeMatches)
{
	struct __wsdd__ProbeMatches *_p = ::soap_new___wsdd__ProbeMatches(soap);
	if (_p)
	{	::soap_default___wsdd__ProbeMatches(soap, _p);
		_p->wsdd__ProbeMatches = wsdd__ProbeMatches;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___wsdd__ProbeMatches(struct soap*, const struct __wsdd__ProbeMatches *, const char*, const char*);

inline int soap_write___wsdd__ProbeMatches(struct soap *soap, struct __wsdd__ProbeMatches const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___wsdd__ProbeMatches(soap, p), 0) || ::soap_put___wsdd__ProbeMatches(soap, p, "-wsdd:ProbeMatches", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___wsdd__ProbeMatches(struct soap *soap, const char *URL, struct __wsdd__ProbeMatches const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__ProbeMatches(soap, p), 0) || ::soap_put___wsdd__ProbeMatches(soap, p, "-wsdd:ProbeMatches", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___wsdd__ProbeMatches(struct soap *soap, const char *URL, struct __wsdd__ProbeMatches const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__ProbeMatches(soap, p), 0) || ::soap_put___wsdd__ProbeMatches(soap, p, "-wsdd:ProbeMatches", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___wsdd__ProbeMatches(struct soap *soap, const char *URL, struct __wsdd__ProbeMatches const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__ProbeMatches(soap, p), 0) || ::soap_put___wsdd__ProbeMatches(soap, p, "-wsdd:ProbeMatches", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __wsdd__ProbeMatches * SOAP_FMAC4 soap_get___wsdd__ProbeMatches(struct soap*, struct __wsdd__ProbeMatches *, const char*, const char*);

inline int soap_read___wsdd__ProbeMatches(struct soap *soap, struct __wsdd__ProbeMatches *p)
{
	if (p)
	{	::soap_default___wsdd__ProbeMatches(soap, p);
		if (soap_begin_recv(soap) || ::soap_get___wsdd__ProbeMatches(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET___wsdd__ProbeMatches(struct soap *soap, const char *URL, struct __wsdd__ProbeMatches *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read___wsdd__ProbeMatches(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv___wsdd__ProbeMatches(struct soap *soap, struct __wsdd__ProbeMatches *p)
{
	if (::soap_read___wsdd__ProbeMatches(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___wsdd__Probe_DEFINED
#define SOAP_TYPE___wsdd__Probe_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___wsdd__Probe(struct soap*, struct __wsdd__Probe *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wsdd__Probe(struct soap*, const struct __wsdd__Probe *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___wsdd__Probe(struct soap*, const char*, int, const struct __wsdd__Probe *, const char*);
SOAP_FMAC3 struct __wsdd__Probe * SOAP_FMAC4 soap_in___wsdd__Probe(struct soap*, const char*, struct __wsdd__Probe *, const char*);
SOAP_FMAC1 struct __wsdd__Probe * SOAP_FMAC2 soap_instantiate___wsdd__Probe(struct soap*, int, const char*, const char*, size_t*);

inline struct __wsdd__Probe * soap_new___wsdd__Probe(struct soap *soap, int n = -1)
{
	return soap_instantiate___wsdd__Probe(soap, n, NULL, NULL, NULL);
}

inline struct __wsdd__Probe * soap_new_req___wsdd__Probe(
	struct soap *soap)
{
	struct __wsdd__Probe *_p = ::soap_new___wsdd__Probe(soap);
	if (_p)
	{	::soap_default___wsdd__Probe(soap, _p);
	}
	return _p;
}

inline struct __wsdd__Probe * soap_new_set___wsdd__Probe(
	struct soap *soap,
	struct wsdd__ProbeType *wsdd__Probe)
{
	struct __wsdd__Probe *_p = ::soap_new___wsdd__Probe(soap);
	if (_p)
	{	::soap_default___wsdd__Probe(soap, _p);
		_p->wsdd__Probe = wsdd__Probe;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___wsdd__Probe(struct soap*, const struct __wsdd__Probe *, const char*, const char*);

inline int soap_write___wsdd__Probe(struct soap *soap, struct __wsdd__Probe const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___wsdd__Probe(soap, p), 0) || ::soap_put___wsdd__Probe(soap, p, "-wsdd:Probe", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___wsdd__Probe(struct soap *soap, const char *URL, struct __wsdd__Probe const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__Probe(soap, p), 0) || ::soap_put___wsdd__Probe(soap, p, "-wsdd:Probe", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___wsdd__Probe(struct soap *soap, const char *URL, struct __wsdd__Probe const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__Probe(soap, p), 0) || ::soap_put___wsdd__Probe(soap, p, "-wsdd:Probe", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___wsdd__Probe(struct soap *soap, const char *URL, struct __wsdd__Probe const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__Probe(soap, p), 0) || ::soap_put___wsdd__Probe(soap, p, "-wsdd:Probe", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __wsdd__Probe * SOAP_FMAC4 soap_get___wsdd__Probe(struct soap*, struct __wsdd__Probe *, const char*, const char*);

inline int soap_read___wsdd__Probe(struct soap *soap, struct __wsdd__Probe *p)
{
	if (p)
	{	::soap_default___wsdd__Probe(soap, p);
		if (soap_begin_recv(soap) || ::soap_get___wsdd__Probe(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET___wsdd__Probe(struct soap *soap, const char *URL, struct __wsdd__Probe *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read___wsdd__Probe(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv___wsdd__Probe(struct soap *soap, struct __wsdd__Probe *p)
{
	if (::soap_read___wsdd__Probe(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___wsdd__Bye_DEFINED
#define SOAP_TYPE___wsdd__Bye_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___wsdd__Bye(struct soap*, struct __wsdd__Bye *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wsdd__Bye(struct soap*, const struct __wsdd__Bye *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___wsdd__Bye(struct soap*, const char*, int, const struct __wsdd__Bye *, const char*);
SOAP_FMAC3 struct __wsdd__Bye * SOAP_FMAC4 soap_in___wsdd__Bye(struct soap*, const char*, struct __wsdd__Bye *, const char*);
SOAP_FMAC1 struct __wsdd__Bye * SOAP_FMAC2 soap_instantiate___wsdd__Bye(struct soap*, int, const char*, const char*, size_t*);

inline struct __wsdd__Bye * soap_new___wsdd__Bye(struct soap *soap, int n = -1)
{
	return soap_instantiate___wsdd__Bye(soap, n, NULL, NULL, NULL);
}

inline struct __wsdd__Bye * soap_new_req___wsdd__Bye(
	struct soap *soap)
{
	struct __wsdd__Bye *_p = ::soap_new___wsdd__Bye(soap);
	if (_p)
	{	::soap_default___wsdd__Bye(soap, _p);
	}
	return _p;
}

inline struct __wsdd__Bye * soap_new_set___wsdd__Bye(
	struct soap *soap,
	struct wsdd__ByeType *wsdd__Bye)
{
	struct __wsdd__Bye *_p = ::soap_new___wsdd__Bye(soap);
	if (_p)
	{	::soap_default___wsdd__Bye(soap, _p);
		_p->wsdd__Bye = wsdd__Bye;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___wsdd__Bye(struct soap*, const struct __wsdd__Bye *, const char*, const char*);

inline int soap_write___wsdd__Bye(struct soap *soap, struct __wsdd__Bye const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___wsdd__Bye(soap, p), 0) || ::soap_put___wsdd__Bye(soap, p, "-wsdd:Bye", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___wsdd__Bye(struct soap *soap, const char *URL, struct __wsdd__Bye const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__Bye(soap, p), 0) || ::soap_put___wsdd__Bye(soap, p, "-wsdd:Bye", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___wsdd__Bye(struct soap *soap, const char *URL, struct __wsdd__Bye const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__Bye(soap, p), 0) || ::soap_put___wsdd__Bye(soap, p, "-wsdd:Bye", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___wsdd__Bye(struct soap *soap, const char *URL, struct __wsdd__Bye const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__Bye(soap, p), 0) || ::soap_put___wsdd__Bye(soap, p, "-wsdd:Bye", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __wsdd__Bye * SOAP_FMAC4 soap_get___wsdd__Bye(struct soap*, struct __wsdd__Bye *, const char*, const char*);

inline int soap_read___wsdd__Bye(struct soap *soap, struct __wsdd__Bye *p)
{
	if (p)
	{	::soap_default___wsdd__Bye(soap, p);
		if (soap_begin_recv(soap) || ::soap_get___wsdd__Bye(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET___wsdd__Bye(struct soap *soap, const char *URL, struct __wsdd__Bye *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read___wsdd__Bye(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv___wsdd__Bye(struct soap *soap, struct __wsdd__Bye *p)
{
	if (::soap_read___wsdd__Bye(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___wsdd__Hello_DEFINED
#define SOAP_TYPE___wsdd__Hello_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___wsdd__Hello(struct soap*, struct __wsdd__Hello *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wsdd__Hello(struct soap*, const struct __wsdd__Hello *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___wsdd__Hello(struct soap*, const char*, int, const struct __wsdd__Hello *, const char*);
SOAP_FMAC3 struct __wsdd__Hello * SOAP_FMAC4 soap_in___wsdd__Hello(struct soap*, const char*, struct __wsdd__Hello *, const char*);
SOAP_FMAC1 struct __wsdd__Hello * SOAP_FMAC2 soap_instantiate___wsdd__Hello(struct soap*, int, const char*, const char*, size_t*);

inline struct __wsdd__Hello * soap_new___wsdd__Hello(struct soap *soap, int n = -1)
{
	return soap_instantiate___wsdd__Hello(soap, n, NULL, NULL, NULL);
}

inline struct __wsdd__Hello * soap_new_req___wsdd__Hello(
	struct soap *soap)
{
	struct __wsdd__Hello *_p = ::soap_new___wsdd__Hello(soap);
	if (_p)
	{	::soap_default___wsdd__Hello(soap, _p);
	}
	return _p;
}

inline struct __wsdd__Hello * soap_new_set___wsdd__Hello(
	struct soap *soap,
	struct wsdd__HelloType *wsdd__Hello)
{
	struct __wsdd__Hello *_p = ::soap_new___wsdd__Hello(soap);
	if (_p)
	{	::soap_default___wsdd__Hello(soap, _p);
		_p->wsdd__Hello = wsdd__Hello;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___wsdd__Hello(struct soap*, const struct __wsdd__Hello *, const char*, const char*);

inline int soap_write___wsdd__Hello(struct soap *soap, struct __wsdd__Hello const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___wsdd__Hello(soap, p), 0) || ::soap_put___wsdd__Hello(soap, p, "-wsdd:Hello", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___wsdd__Hello(struct soap *soap, const char *URL, struct __wsdd__Hello const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__Hello(soap, p), 0) || ::soap_put___wsdd__Hello(soap, p, "-wsdd:Hello", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___wsdd__Hello(struct soap *soap, const char *URL, struct __wsdd__Hello const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__Hello(soap, p), 0) || ::soap_put___wsdd__Hello(soap, p, "-wsdd:Hello", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___wsdd__Hello(struct soap *soap, const char *URL, struct __wsdd__Hello const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___wsdd__Hello(soap, p), 0) || ::soap_put___wsdd__Hello(soap, p, "-wsdd:Hello", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __wsdd__Hello * SOAP_FMAC4 soap_get___wsdd__Hello(struct soap*, struct __wsdd__Hello *, const char*, const char*);

inline int soap_read___wsdd__Hello(struct soap *soap, struct __wsdd__Hello *p)
{
	if (p)
	{	::soap_default___wsdd__Hello(soap, p);
		if (soap_begin_recv(soap) || ::soap_get___wsdd__Hello(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET___wsdd__Hello(struct soap *soap, const char *URL, struct __wsdd__Hello *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read___wsdd__Hello(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv___wsdd__Hello(struct soap *soap, struct __wsdd__Hello *p)
{
	if (::soap_read___wsdd__Hello(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif
/* _wsdd__AppSequence is a typedef synonym of wsdd__AppSequenceType */

#ifndef SOAP_TYPE__wsdd__AppSequence_DEFINED
#define SOAP_TYPE__wsdd__AppSequence_DEFINED

#define soap_default__wsdd__AppSequence soap_default_wsdd__AppSequenceType

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__AppSequenceType(struct soap*, const struct wsdd__AppSequenceType *);

#define soap_serialize__wsdd__AppSequence soap_serialize_wsdd__AppSequenceType


#define soap__wsdd__AppSequence2s soap_wsdd__AppSequenceType2s


#define soap_out__wsdd__AppSequence soap_out_wsdd__AppSequenceType


#define soap_s2_wsdd__AppSequence soap_s2wsdd__AppSequenceType


#define soap_in__wsdd__AppSequence soap_in_wsdd__AppSequenceType


#define soap_instantiate__wsdd__AppSequence soap_instantiate_wsdd__AppSequenceType


#define soap_new__wsdd__AppSequence soap_new_wsdd__AppSequenceType


#define soap_new_req__wsdd__AppSequence soap_new_req_wsdd__AppSequenceType


#define soap_new_set__wsdd__AppSequence soap_new_set_wsdd__AppSequenceType

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsdd__AppSequence(struct soap*, const struct wsdd__AppSequenceType *, const char*, const char*);

inline int soap_write__wsdd__AppSequence(struct soap *soap, struct wsdd__AppSequenceType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsdd__AppSequence(soap, p), 0) || ::soap_put__wsdd__AppSequence(soap, p, "wsdd:AppSequence", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsdd__AppSequence(struct soap *soap, const char *URL, struct wsdd__AppSequenceType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__AppSequence(soap, p), 0) || ::soap_put__wsdd__AppSequence(soap, p, "wsdd:AppSequence", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsdd__AppSequence(struct soap *soap, const char *URL, struct wsdd__AppSequenceType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__AppSequence(soap, p), 0) || ::soap_put__wsdd__AppSequence(soap, p, "wsdd:AppSequence", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsdd__AppSequence(struct soap *soap, const char *URL, struct wsdd__AppSequenceType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__AppSequence(soap, p), 0) || ::soap_put__wsdd__AppSequence(soap, p, "wsdd:AppSequence", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsdd__AppSequence soap_get_wsdd__AppSequenceType


#define soap_read__wsdd__AppSequence soap_read_wsdd__AppSequenceType


#define soap_GET__wsdd__AppSequence soap_GET_wsdd__AppSequenceType


#define soap_POST_recv__wsdd__AppSequence soap_POST_recv_wsdd__AppSequenceType

#endif
/* _wsdd__Sig is a typedef synonym of wsdd__SigType */

#ifndef SOAP_TYPE__wsdd__Sig_DEFINED
#define SOAP_TYPE__wsdd__Sig_DEFINED

#define soap_default__wsdd__Sig soap_default_wsdd__SigType

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__SigType(struct soap*, const struct wsdd__SigType *);

#define soap_serialize__wsdd__Sig soap_serialize_wsdd__SigType


#define soap__wsdd__Sig2s soap_wsdd__SigType2s


#define soap_out__wsdd__Sig soap_out_wsdd__SigType


#define soap_s2_wsdd__Sig soap_s2wsdd__SigType


#define soap_in__wsdd__Sig soap_in_wsdd__SigType


#define soap_instantiate__wsdd__Sig soap_instantiate_wsdd__SigType


#define soap_new__wsdd__Sig soap_new_wsdd__SigType


#define soap_new_req__wsdd__Sig soap_new_req_wsdd__SigType


#define soap_new_set__wsdd__Sig soap_new_set_wsdd__SigType

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsdd__Sig(struct soap*, const struct wsdd__SigType *, const char*, const char*);

inline int soap_write__wsdd__Sig(struct soap *soap, struct wsdd__SigType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsdd__Sig(soap, p), 0) || ::soap_put__wsdd__Sig(soap, p, "wsdd:Sig", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsdd__Sig(struct soap *soap, const char *URL, struct wsdd__SigType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Sig(soap, p), 0) || ::soap_put__wsdd__Sig(soap, p, "wsdd:Sig", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsdd__Sig(struct soap *soap, const char *URL, struct wsdd__SigType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Sig(soap, p), 0) || ::soap_put__wsdd__Sig(soap, p, "wsdd:Sig", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsdd__Sig(struct soap *soap, const char *URL, struct wsdd__SigType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Sig(soap, p), 0) || ::soap_put__wsdd__Sig(soap, p, "wsdd:Sig", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsdd__Sig soap_get_wsdd__SigType


#define soap_read__wsdd__Sig soap_read_wsdd__SigType


#define soap_GET__wsdd__Sig soap_GET_wsdd__SigType


#define soap_POST_recv__wsdd__Sig soap_POST_recv_wsdd__SigType

#endif
/* _wsdd__Security is a typedef synonym of wsdd__SecurityType */

#ifndef SOAP_TYPE__wsdd__Security_DEFINED
#define SOAP_TYPE__wsdd__Security_DEFINED

#define soap_default__wsdd__Security soap_default_wsdd__SecurityType

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__SecurityType(struct soap*, const struct wsdd__SecurityType *);

#define soap_serialize__wsdd__Security soap_serialize_wsdd__SecurityType


#define soap__wsdd__Security2s soap_wsdd__SecurityType2s


#define soap_out__wsdd__Security soap_out_wsdd__SecurityType


#define soap_s2_wsdd__Security soap_s2wsdd__SecurityType


#define soap_in__wsdd__Security soap_in_wsdd__SecurityType


#define soap_instantiate__wsdd__Security soap_instantiate_wsdd__SecurityType


#define soap_new__wsdd__Security soap_new_wsdd__SecurityType


#define soap_new_req__wsdd__Security soap_new_req_wsdd__SecurityType


#define soap_new_set__wsdd__Security soap_new_set_wsdd__SecurityType

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsdd__Security(struct soap*, const struct wsdd__SecurityType *, const char*, const char*);

inline int soap_write__wsdd__Security(struct soap *soap, struct wsdd__SecurityType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsdd__Security(soap, p), 0) || ::soap_put__wsdd__Security(soap, p, "wsdd:Security", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsdd__Security(struct soap *soap, const char *URL, struct wsdd__SecurityType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Security(soap, p), 0) || ::soap_put__wsdd__Security(soap, p, "wsdd:Security", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsdd__Security(struct soap *soap, const char *URL, struct wsdd__SecurityType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Security(soap, p), 0) || ::soap_put__wsdd__Security(soap, p, "wsdd:Security", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsdd__Security(struct soap *soap, const char *URL, struct wsdd__SecurityType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Security(soap, p), 0) || ::soap_put__wsdd__Security(soap, p, "wsdd:Security", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsdd__Security soap_get_wsdd__SecurityType


#define soap_read__wsdd__Security soap_read_wsdd__SecurityType


#define soap_GET__wsdd__Security soap_GET_wsdd__SecurityType


#define soap_POST_recv__wsdd__Security soap_POST_recv_wsdd__SecurityType

#endif
/* _wsdd__Scopes is a typedef synonym of wsdd__ScopesType */

#ifndef SOAP_TYPE__wsdd__Scopes_DEFINED
#define SOAP_TYPE__wsdd__Scopes_DEFINED

#define soap_default__wsdd__Scopes soap_default_wsdd__ScopesType

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__ScopesType(struct soap*, const struct wsdd__ScopesType *);

#define soap_serialize__wsdd__Scopes soap_serialize_wsdd__ScopesType


#define soap__wsdd__Scopes2s soap_wsdd__ScopesType2s


#define soap_out__wsdd__Scopes soap_out_wsdd__ScopesType


#define soap_s2_wsdd__Scopes soap_s2wsdd__ScopesType


#define soap_in__wsdd__Scopes soap_in_wsdd__ScopesType


#define soap_instantiate__wsdd__Scopes soap_instantiate_wsdd__ScopesType


#define soap_new__wsdd__Scopes soap_new_wsdd__ScopesType


#define soap_new_req__wsdd__Scopes soap_new_req_wsdd__ScopesType


#define soap_new_set__wsdd__Scopes soap_new_set_wsdd__ScopesType

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsdd__Scopes(struct soap*, const struct wsdd__ScopesType *, const char*, const char*);

inline int soap_write__wsdd__Scopes(struct soap *soap, struct wsdd__ScopesType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsdd__Scopes(soap, p), 0) || ::soap_put__wsdd__Scopes(soap, p, "wsdd:Scopes", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsdd__Scopes(struct soap *soap, const char *URL, struct wsdd__ScopesType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Scopes(soap, p), 0) || ::soap_put__wsdd__Scopes(soap, p, "wsdd:Scopes", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsdd__Scopes(struct soap *soap, const char *URL, struct wsdd__ScopesType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Scopes(soap, p), 0) || ::soap_put__wsdd__Scopes(soap, p, "wsdd:Scopes", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsdd__Scopes(struct soap *soap, const char *URL, struct wsdd__ScopesType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Scopes(soap, p), 0) || ::soap_put__wsdd__Scopes(soap, p, "wsdd:Scopes", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsdd__Scopes soap_get_wsdd__ScopesType


#define soap_read__wsdd__Scopes soap_read_wsdd__ScopesType


#define soap_GET__wsdd__Scopes soap_GET_wsdd__ScopesType


#define soap_POST_recv__wsdd__Scopes soap_POST_recv_wsdd__ScopesType

#endif
/* _wsdd__ResolveMatches is a typedef synonym of wsdd__ResolveMatchesType */

#ifndef SOAP_TYPE__wsdd__ResolveMatches_DEFINED
#define SOAP_TYPE__wsdd__ResolveMatches_DEFINED

#define soap_default__wsdd__ResolveMatches soap_default_wsdd__ResolveMatchesType

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__ResolveMatchesType(struct soap*, const struct wsdd__ResolveMatchesType *);

#define soap_serialize__wsdd__ResolveMatches soap_serialize_wsdd__ResolveMatchesType


#define soap__wsdd__ResolveMatches2s soap_wsdd__ResolveMatchesType2s


#define soap_out__wsdd__ResolveMatches soap_out_wsdd__ResolveMatchesType


#define soap_s2_wsdd__ResolveMatches soap_s2wsdd__ResolveMatchesType


#define soap_in__wsdd__ResolveMatches soap_in_wsdd__ResolveMatchesType


#define soap_instantiate__wsdd__ResolveMatches soap_instantiate_wsdd__ResolveMatchesType


#define soap_new__wsdd__ResolveMatches soap_new_wsdd__ResolveMatchesType


#define soap_new_req__wsdd__ResolveMatches soap_new_req_wsdd__ResolveMatchesType


#define soap_new_set__wsdd__ResolveMatches soap_new_set_wsdd__ResolveMatchesType

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsdd__ResolveMatches(struct soap*, const struct wsdd__ResolveMatchesType *, const char*, const char*);

inline int soap_write__wsdd__ResolveMatches(struct soap *soap, struct wsdd__ResolveMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsdd__ResolveMatches(soap, p), 0) || ::soap_put__wsdd__ResolveMatches(soap, p, "wsdd:ResolveMatches", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsdd__ResolveMatches(struct soap *soap, const char *URL, struct wsdd__ResolveMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__ResolveMatches(soap, p), 0) || ::soap_put__wsdd__ResolveMatches(soap, p, "wsdd:ResolveMatches", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsdd__ResolveMatches(struct soap *soap, const char *URL, struct wsdd__ResolveMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__ResolveMatches(soap, p), 0) || ::soap_put__wsdd__ResolveMatches(soap, p, "wsdd:ResolveMatches", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsdd__ResolveMatches(struct soap *soap, const char *URL, struct wsdd__ResolveMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__ResolveMatches(soap, p), 0) || ::soap_put__wsdd__ResolveMatches(soap, p, "wsdd:ResolveMatches", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsdd__ResolveMatches soap_get_wsdd__ResolveMatchesType


#define soap_read__wsdd__ResolveMatches soap_read_wsdd__ResolveMatchesType


#define soap_GET__wsdd__ResolveMatches soap_GET_wsdd__ResolveMatchesType


#define soap_POST_recv__wsdd__ResolveMatches soap_POST_recv_wsdd__ResolveMatchesType

#endif
/* _wsdd__Resolve is a typedef synonym of wsdd__ResolveType */

#ifndef SOAP_TYPE__wsdd__Resolve_DEFINED
#define SOAP_TYPE__wsdd__Resolve_DEFINED

#define soap_default__wsdd__Resolve soap_default_wsdd__ResolveType

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__ResolveType(struct soap*, const struct wsdd__ResolveType *);

#define soap_serialize__wsdd__Resolve soap_serialize_wsdd__ResolveType


#define soap__wsdd__Resolve2s soap_wsdd__ResolveType2s


#define soap_out__wsdd__Resolve soap_out_wsdd__ResolveType


#define soap_s2_wsdd__Resolve soap_s2wsdd__ResolveType


#define soap_in__wsdd__Resolve soap_in_wsdd__ResolveType


#define soap_instantiate__wsdd__Resolve soap_instantiate_wsdd__ResolveType


#define soap_new__wsdd__Resolve soap_new_wsdd__ResolveType


#define soap_new_req__wsdd__Resolve soap_new_req_wsdd__ResolveType


#define soap_new_set__wsdd__Resolve soap_new_set_wsdd__ResolveType

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsdd__Resolve(struct soap*, const struct wsdd__ResolveType *, const char*, const char*);

inline int soap_write__wsdd__Resolve(struct soap *soap, struct wsdd__ResolveType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsdd__Resolve(soap, p), 0) || ::soap_put__wsdd__Resolve(soap, p, "wsdd:Resolve", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsdd__Resolve(struct soap *soap, const char *URL, struct wsdd__ResolveType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Resolve(soap, p), 0) || ::soap_put__wsdd__Resolve(soap, p, "wsdd:Resolve", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsdd__Resolve(struct soap *soap, const char *URL, struct wsdd__ResolveType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Resolve(soap, p), 0) || ::soap_put__wsdd__Resolve(soap, p, "wsdd:Resolve", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsdd__Resolve(struct soap *soap, const char *URL, struct wsdd__ResolveType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Resolve(soap, p), 0) || ::soap_put__wsdd__Resolve(soap, p, "wsdd:Resolve", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsdd__Resolve soap_get_wsdd__ResolveType


#define soap_read__wsdd__Resolve soap_read_wsdd__ResolveType


#define soap_GET__wsdd__Resolve soap_GET_wsdd__ResolveType


#define soap_POST_recv__wsdd__Resolve soap_POST_recv_wsdd__ResolveType

#endif
/* _wsdd__ProbeMatches is a typedef synonym of wsdd__ProbeMatchesType */

#ifndef SOAP_TYPE__wsdd__ProbeMatches_DEFINED
#define SOAP_TYPE__wsdd__ProbeMatches_DEFINED

#define soap_default__wsdd__ProbeMatches soap_default_wsdd__ProbeMatchesType

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__ProbeMatchesType(struct soap*, const struct wsdd__ProbeMatchesType *);

#define soap_serialize__wsdd__ProbeMatches soap_serialize_wsdd__ProbeMatchesType


#define soap__wsdd__ProbeMatches2s soap_wsdd__ProbeMatchesType2s


#define soap_out__wsdd__ProbeMatches soap_out_wsdd__ProbeMatchesType


#define soap_s2_wsdd__ProbeMatches soap_s2wsdd__ProbeMatchesType


#define soap_in__wsdd__ProbeMatches soap_in_wsdd__ProbeMatchesType


#define soap_instantiate__wsdd__ProbeMatches soap_instantiate_wsdd__ProbeMatchesType


#define soap_new__wsdd__ProbeMatches soap_new_wsdd__ProbeMatchesType


#define soap_new_req__wsdd__ProbeMatches soap_new_req_wsdd__ProbeMatchesType


#define soap_new_set__wsdd__ProbeMatches soap_new_set_wsdd__ProbeMatchesType

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsdd__ProbeMatches(struct soap*, const struct wsdd__ProbeMatchesType *, const char*, const char*);

inline int soap_write__wsdd__ProbeMatches(struct soap *soap, struct wsdd__ProbeMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsdd__ProbeMatches(soap, p), 0) || ::soap_put__wsdd__ProbeMatches(soap, p, "wsdd:ProbeMatches", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsdd__ProbeMatches(struct soap *soap, const char *URL, struct wsdd__ProbeMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__ProbeMatches(soap, p), 0) || ::soap_put__wsdd__ProbeMatches(soap, p, "wsdd:ProbeMatches", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsdd__ProbeMatches(struct soap *soap, const char *URL, struct wsdd__ProbeMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__ProbeMatches(soap, p), 0) || ::soap_put__wsdd__ProbeMatches(soap, p, "wsdd:ProbeMatches", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsdd__ProbeMatches(struct soap *soap, const char *URL, struct wsdd__ProbeMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__ProbeMatches(soap, p), 0) || ::soap_put__wsdd__ProbeMatches(soap, p, "wsdd:ProbeMatches", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsdd__ProbeMatches soap_get_wsdd__ProbeMatchesType


#define soap_read__wsdd__ProbeMatches soap_read_wsdd__ProbeMatchesType


#define soap_GET__wsdd__ProbeMatches soap_GET_wsdd__ProbeMatchesType


#define soap_POST_recv__wsdd__ProbeMatches soap_POST_recv_wsdd__ProbeMatchesType

#endif
/* _wsdd__Probe is a typedef synonym of wsdd__ProbeType */

#ifndef SOAP_TYPE__wsdd__Probe_DEFINED
#define SOAP_TYPE__wsdd__Probe_DEFINED

#define soap_default__wsdd__Probe soap_default_wsdd__ProbeType

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__ProbeType(struct soap*, const struct wsdd__ProbeType *);

#define soap_serialize__wsdd__Probe soap_serialize_wsdd__ProbeType


#define soap__wsdd__Probe2s soap_wsdd__ProbeType2s


#define soap_out__wsdd__Probe soap_out_wsdd__ProbeType


#define soap_s2_wsdd__Probe soap_s2wsdd__ProbeType


#define soap_in__wsdd__Probe soap_in_wsdd__ProbeType


#define soap_instantiate__wsdd__Probe soap_instantiate_wsdd__ProbeType


#define soap_new__wsdd__Probe soap_new_wsdd__ProbeType


#define soap_new_req__wsdd__Probe soap_new_req_wsdd__ProbeType


#define soap_new_set__wsdd__Probe soap_new_set_wsdd__ProbeType

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsdd__Probe(struct soap*, const struct wsdd__ProbeType *, const char*, const char*);

inline int soap_write__wsdd__Probe(struct soap *soap, struct wsdd__ProbeType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsdd__Probe(soap, p), 0) || ::soap_put__wsdd__Probe(soap, p, "wsdd:Probe", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsdd__Probe(struct soap *soap, const char *URL, struct wsdd__ProbeType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Probe(soap, p), 0) || ::soap_put__wsdd__Probe(soap, p, "wsdd:Probe", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsdd__Probe(struct soap *soap, const char *URL, struct wsdd__ProbeType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Probe(soap, p), 0) || ::soap_put__wsdd__Probe(soap, p, "wsdd:Probe", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsdd__Probe(struct soap *soap, const char *URL, struct wsdd__ProbeType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Probe(soap, p), 0) || ::soap_put__wsdd__Probe(soap, p, "wsdd:Probe", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsdd__Probe soap_get_wsdd__ProbeType


#define soap_read__wsdd__Probe soap_read_wsdd__ProbeType


#define soap_GET__wsdd__Probe soap_GET_wsdd__ProbeType


#define soap_POST_recv__wsdd__Probe soap_POST_recv_wsdd__ProbeType

#endif
/* _wsdd__Bye is a typedef synonym of wsdd__ByeType */

#ifndef SOAP_TYPE__wsdd__Bye_DEFINED
#define SOAP_TYPE__wsdd__Bye_DEFINED

#define soap_default__wsdd__Bye soap_default_wsdd__ByeType

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__ByeType(struct soap*, const struct wsdd__ByeType *);

#define soap_serialize__wsdd__Bye soap_serialize_wsdd__ByeType


#define soap__wsdd__Bye2s soap_wsdd__ByeType2s


#define soap_out__wsdd__Bye soap_out_wsdd__ByeType


#define soap_s2_wsdd__Bye soap_s2wsdd__ByeType


#define soap_in__wsdd__Bye soap_in_wsdd__ByeType


#define soap_instantiate__wsdd__Bye soap_instantiate_wsdd__ByeType


#define soap_new__wsdd__Bye soap_new_wsdd__ByeType


#define soap_new_req__wsdd__Bye soap_new_req_wsdd__ByeType


#define soap_new_set__wsdd__Bye soap_new_set_wsdd__ByeType

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsdd__Bye(struct soap*, const struct wsdd__ByeType *, const char*, const char*);

inline int soap_write__wsdd__Bye(struct soap *soap, struct wsdd__ByeType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsdd__Bye(soap, p), 0) || ::soap_put__wsdd__Bye(soap, p, "wsdd:Bye", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsdd__Bye(struct soap *soap, const char *URL, struct wsdd__ByeType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Bye(soap, p), 0) || ::soap_put__wsdd__Bye(soap, p, "wsdd:Bye", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsdd__Bye(struct soap *soap, const char *URL, struct wsdd__ByeType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Bye(soap, p), 0) || ::soap_put__wsdd__Bye(soap, p, "wsdd:Bye", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsdd__Bye(struct soap *soap, const char *URL, struct wsdd__ByeType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Bye(soap, p), 0) || ::soap_put__wsdd__Bye(soap, p, "wsdd:Bye", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsdd__Bye soap_get_wsdd__ByeType


#define soap_read__wsdd__Bye soap_read_wsdd__ByeType


#define soap_GET__wsdd__Bye soap_GET_wsdd__ByeType


#define soap_POST_recv__wsdd__Bye soap_POST_recv_wsdd__ByeType

#endif
/* _wsdd__Hello is a typedef synonym of wsdd__HelloType */

#ifndef SOAP_TYPE__wsdd__Hello_DEFINED
#define SOAP_TYPE__wsdd__Hello_DEFINED

#define soap_default__wsdd__Hello soap_default_wsdd__HelloType

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__HelloType(struct soap*, const struct wsdd__HelloType *);

#define soap_serialize__wsdd__Hello soap_serialize_wsdd__HelloType


#define soap__wsdd__Hello2s soap_wsdd__HelloType2s


#define soap_out__wsdd__Hello soap_out_wsdd__HelloType


#define soap_s2_wsdd__Hello soap_s2wsdd__HelloType


#define soap_in__wsdd__Hello soap_in_wsdd__HelloType


#define soap_instantiate__wsdd__Hello soap_instantiate_wsdd__HelloType


#define soap_new__wsdd__Hello soap_new_wsdd__HelloType


#define soap_new_req__wsdd__Hello soap_new_req_wsdd__HelloType


#define soap_new_set__wsdd__Hello soap_new_set_wsdd__HelloType

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsdd__Hello(struct soap*, const struct wsdd__HelloType *, const char*, const char*);

inline int soap_write__wsdd__Hello(struct soap *soap, struct wsdd__HelloType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsdd__Hello(soap, p), 0) || ::soap_put__wsdd__Hello(soap, p, "wsdd:Hello", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsdd__Hello(struct soap *soap, const char *URL, struct wsdd__HelloType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Hello(soap, p), 0) || ::soap_put__wsdd__Hello(soap, p, "wsdd:Hello", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsdd__Hello(struct soap *soap, const char *URL, struct wsdd__HelloType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Hello(soap, p), 0) || ::soap_put__wsdd__Hello(soap, p, "wsdd:Hello", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsdd__Hello(struct soap *soap, const char *URL, struct wsdd__HelloType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsdd__Hello(soap, p), 0) || ::soap_put__wsdd__Hello(soap, p, "wsdd:Hello", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsdd__Hello soap_get_wsdd__HelloType


#define soap_read__wsdd__Hello soap_read_wsdd__HelloType


#define soap_GET__wsdd__Hello soap_GET_wsdd__HelloType


#define soap_POST_recv__wsdd__Hello soap_POST_recv_wsdd__HelloType

#endif

#ifndef SOAP_TYPE_wsdd__AppSequenceType_DEFINED
#define SOAP_TYPE_wsdd__AppSequenceType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsdd__AppSequenceType(struct soap*, struct wsdd__AppSequenceType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__AppSequenceType(struct soap*, const struct wsdd__AppSequenceType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__AppSequenceType(struct soap*, const char*, int, const struct wsdd__AppSequenceType *, const char*);
SOAP_FMAC3 struct wsdd__AppSequenceType * SOAP_FMAC4 soap_in_wsdd__AppSequenceType(struct soap*, const char*, struct wsdd__AppSequenceType *, const char*);
SOAP_FMAC1 struct wsdd__AppSequenceType * SOAP_FMAC2 soap_instantiate_wsdd__AppSequenceType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsdd__AppSequenceType * soap_new_wsdd__AppSequenceType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsdd__AppSequenceType(soap, n, NULL, NULL, NULL);
}

inline struct wsdd__AppSequenceType * soap_new_req_wsdd__AppSequenceType(
	struct soap *soap,
	unsigned int InstanceId,
	unsigned int MessageNumber)
{
	struct wsdd__AppSequenceType *_p = ::soap_new_wsdd__AppSequenceType(soap);
	if (_p)
	{	::soap_default_wsdd__AppSequenceType(soap, _p);
		_p->InstanceId = InstanceId;
		_p->MessageNumber = MessageNumber;
	}
	return _p;
}

inline struct wsdd__AppSequenceType * soap_new_set_wsdd__AppSequenceType(
	struct soap *soap,
	unsigned int InstanceId,
	char *SequenceId,
	unsigned int MessageNumber)
{
	struct wsdd__AppSequenceType *_p = ::soap_new_wsdd__AppSequenceType(soap);
	if (_p)
	{	::soap_default_wsdd__AppSequenceType(soap, _p);
		_p->InstanceId = InstanceId;
		_p->SequenceId = SequenceId;
		_p->MessageNumber = MessageNumber;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__AppSequenceType(struct soap*, const struct wsdd__AppSequenceType *, const char*, const char*);

inline int soap_write_wsdd__AppSequenceType(struct soap *soap, struct wsdd__AppSequenceType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsdd__AppSequenceType(soap, p), 0) || ::soap_put_wsdd__AppSequenceType(soap, p, "wsdd:AppSequenceType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsdd__AppSequenceType(struct soap *soap, const char *URL, struct wsdd__AppSequenceType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__AppSequenceType(soap, p), 0) || ::soap_put_wsdd__AppSequenceType(soap, p, "wsdd:AppSequenceType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__AppSequenceType(struct soap *soap, const char *URL, struct wsdd__AppSequenceType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__AppSequenceType(soap, p), 0) || ::soap_put_wsdd__AppSequenceType(soap, p, "wsdd:AppSequenceType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__AppSequenceType(struct soap *soap, const char *URL, struct wsdd__AppSequenceType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__AppSequenceType(soap, p), 0) || ::soap_put_wsdd__AppSequenceType(soap, p, "wsdd:AppSequenceType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsdd__AppSequenceType * SOAP_FMAC4 soap_get_wsdd__AppSequenceType(struct soap*, struct wsdd__AppSequenceType *, const char*, const char*);

inline int soap_read_wsdd__AppSequenceType(struct soap *soap, struct wsdd__AppSequenceType *p)
{
	if (p)
	{	::soap_default_wsdd__AppSequenceType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsdd__AppSequenceType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__AppSequenceType(struct soap *soap, const char *URL, struct wsdd__AppSequenceType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__AppSequenceType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__AppSequenceType(struct soap *soap, struct wsdd__AppSequenceType *p)
{
	if (::soap_read_wsdd__AppSequenceType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsdd__SigType_DEFINED
#define SOAP_TYPE_wsdd__SigType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsdd__SigType(struct soap*, struct wsdd__SigType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__SigType(struct soap*, const struct wsdd__SigType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__SigType(struct soap*, const char*, int, const struct wsdd__SigType *, const char*);
SOAP_FMAC3 struct wsdd__SigType * SOAP_FMAC4 soap_in_wsdd__SigType(struct soap*, const char*, struct wsdd__SigType *, const char*);
SOAP_FMAC1 struct wsdd__SigType * SOAP_FMAC2 soap_instantiate_wsdd__SigType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsdd__SigType * soap_new_wsdd__SigType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsdd__SigType(soap, n, NULL, NULL, NULL);
}

inline struct wsdd__SigType * soap_new_req_wsdd__SigType(
	struct soap *soap,
	char *Scheme,
	char *Refs,
	char *Sig)
{
	struct wsdd__SigType *_p = ::soap_new_wsdd__SigType(soap);
	if (_p)
	{	::soap_default_wsdd__SigType(soap, _p);
		_p->Scheme = Scheme;
		_p->Refs = Refs;
		_p->Sig = Sig;
	}
	return _p;
}

inline struct wsdd__SigType * soap_new_set_wsdd__SigType(
	struct soap *soap,
	char *Scheme,
	char *KeyId,
	char *Refs,
	char *Sig)
{
	struct wsdd__SigType *_p = ::soap_new_wsdd__SigType(soap);
	if (_p)
	{	::soap_default_wsdd__SigType(soap, _p);
		_p->Scheme = Scheme;
		_p->KeyId = KeyId;
		_p->Refs = Refs;
		_p->Sig = Sig;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__SigType(struct soap*, const struct wsdd__SigType *, const char*, const char*);

inline int soap_write_wsdd__SigType(struct soap *soap, struct wsdd__SigType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsdd__SigType(soap, p), 0) || ::soap_put_wsdd__SigType(soap, p, "wsdd:SigType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsdd__SigType(struct soap *soap, const char *URL, struct wsdd__SigType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__SigType(soap, p), 0) || ::soap_put_wsdd__SigType(soap, p, "wsdd:SigType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__SigType(struct soap *soap, const char *URL, struct wsdd__SigType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__SigType(soap, p), 0) || ::soap_put_wsdd__SigType(soap, p, "wsdd:SigType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__SigType(struct soap *soap, const char *URL, struct wsdd__SigType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__SigType(soap, p), 0) || ::soap_put_wsdd__SigType(soap, p, "wsdd:SigType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsdd__SigType * SOAP_FMAC4 soap_get_wsdd__SigType(struct soap*, struct wsdd__SigType *, const char*, const char*);

inline int soap_read_wsdd__SigType(struct soap *soap, struct wsdd__SigType *p)
{
	if (p)
	{	::soap_default_wsdd__SigType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsdd__SigType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__SigType(struct soap *soap, const char *URL, struct wsdd__SigType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__SigType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__SigType(struct soap *soap, struct wsdd__SigType *p)
{
	if (::soap_read_wsdd__SigType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsdd__SecurityType_DEFINED
#define SOAP_TYPE_wsdd__SecurityType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsdd__SecurityType(struct soap*, struct wsdd__SecurityType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__SecurityType(struct soap*, const struct wsdd__SecurityType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__SecurityType(struct soap*, const char*, int, const struct wsdd__SecurityType *, const char*);
SOAP_FMAC3 struct wsdd__SecurityType * SOAP_FMAC4 soap_in_wsdd__SecurityType(struct soap*, const char*, struct wsdd__SecurityType *, const char*);
SOAP_FMAC1 struct wsdd__SecurityType * SOAP_FMAC2 soap_instantiate_wsdd__SecurityType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsdd__SecurityType * soap_new_wsdd__SecurityType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsdd__SecurityType(soap, n, NULL, NULL, NULL);
}

inline struct wsdd__SecurityType * soap_new_req_wsdd__SecurityType(
	struct soap *soap)
{
	struct wsdd__SecurityType *_p = ::soap_new_wsdd__SecurityType(soap);
	if (_p)
	{	::soap_default_wsdd__SecurityType(soap, _p);
	}
	return _p;
}

inline struct wsdd__SecurityType * soap_new_set_wsdd__SecurityType(
	struct soap *soap,
	struct wsdd__SigType *Sig)
{
	struct wsdd__SecurityType *_p = ::soap_new_wsdd__SecurityType(soap);
	if (_p)
	{	::soap_default_wsdd__SecurityType(soap, _p);
		_p->Sig = Sig;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__SecurityType(struct soap*, const struct wsdd__SecurityType *, const char*, const char*);

inline int soap_write_wsdd__SecurityType(struct soap *soap, struct wsdd__SecurityType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsdd__SecurityType(soap, p), 0) || ::soap_put_wsdd__SecurityType(soap, p, "wsdd:SecurityType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsdd__SecurityType(struct soap *soap, const char *URL, struct wsdd__SecurityType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__SecurityType(soap, p), 0) || ::soap_put_wsdd__SecurityType(soap, p, "wsdd:SecurityType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__SecurityType(struct soap *soap, const char *URL, struct wsdd__SecurityType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__SecurityType(soap, p), 0) || ::soap_put_wsdd__SecurityType(soap, p, "wsdd:SecurityType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__SecurityType(struct soap *soap, const char *URL, struct wsdd__SecurityType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__SecurityType(soap, p), 0) || ::soap_put_wsdd__SecurityType(soap, p, "wsdd:SecurityType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsdd__SecurityType * SOAP_FMAC4 soap_get_wsdd__SecurityType(struct soap*, struct wsdd__SecurityType *, const char*, const char*);

inline int soap_read_wsdd__SecurityType(struct soap *soap, struct wsdd__SecurityType *p)
{
	if (p)
	{	::soap_default_wsdd__SecurityType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsdd__SecurityType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__SecurityType(struct soap *soap, const char *URL, struct wsdd__SecurityType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__SecurityType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__SecurityType(struct soap *soap, struct wsdd__SecurityType *p)
{
	if (::soap_read_wsdd__SecurityType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsdd__ScopesType_DEFINED
#define SOAP_TYPE_wsdd__ScopesType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsdd__ScopesType(struct soap*, struct wsdd__ScopesType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__ScopesType(struct soap*, const struct wsdd__ScopesType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__ScopesType(struct soap*, const char*, int, const struct wsdd__ScopesType *, const char*);
SOAP_FMAC3 struct wsdd__ScopesType * SOAP_FMAC4 soap_in_wsdd__ScopesType(struct soap*, const char*, struct wsdd__ScopesType *, const char*);
SOAP_FMAC1 struct wsdd__ScopesType * SOAP_FMAC2 soap_instantiate_wsdd__ScopesType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsdd__ScopesType * soap_new_wsdd__ScopesType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsdd__ScopesType(soap, n, NULL, NULL, NULL);
}

inline struct wsdd__ScopesType * soap_new_req_wsdd__ScopesType(
	struct soap *soap)
{
	struct wsdd__ScopesType *_p = ::soap_new_wsdd__ScopesType(soap);
	if (_p)
	{	::soap_default_wsdd__ScopesType(soap, _p);
	}
	return _p;
}

inline struct wsdd__ScopesType * soap_new_set_wsdd__ScopesType(
	struct soap *soap,
	char *__item,
	char *MatchBy)
{
	struct wsdd__ScopesType *_p = ::soap_new_wsdd__ScopesType(soap);
	if (_p)
	{	::soap_default_wsdd__ScopesType(soap, _p);
		_p->__item = __item;
		_p->MatchBy = MatchBy;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__ScopesType(struct soap*, const struct wsdd__ScopesType *, const char*, const char*);

inline int soap_write_wsdd__ScopesType(struct soap *soap, struct wsdd__ScopesType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsdd__ScopesType(soap, p), 0) || ::soap_put_wsdd__ScopesType(soap, p, "wsdd:ScopesType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsdd__ScopesType(struct soap *soap, const char *URL, struct wsdd__ScopesType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ScopesType(soap, p), 0) || ::soap_put_wsdd__ScopesType(soap, p, "wsdd:ScopesType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__ScopesType(struct soap *soap, const char *URL, struct wsdd__ScopesType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ScopesType(soap, p), 0) || ::soap_put_wsdd__ScopesType(soap, p, "wsdd:ScopesType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__ScopesType(struct soap *soap, const char *URL, struct wsdd__ScopesType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ScopesType(soap, p), 0) || ::soap_put_wsdd__ScopesType(soap, p, "wsdd:ScopesType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsdd__ScopesType * SOAP_FMAC4 soap_get_wsdd__ScopesType(struct soap*, struct wsdd__ScopesType *, const char*, const char*);

inline int soap_read_wsdd__ScopesType(struct soap *soap, struct wsdd__ScopesType *p)
{
	if (p)
	{	::soap_default_wsdd__ScopesType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsdd__ScopesType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__ScopesType(struct soap *soap, const char *URL, struct wsdd__ScopesType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__ScopesType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__ScopesType(struct soap *soap, struct wsdd__ScopesType *p)
{
	if (::soap_read_wsdd__ScopesType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsdd__ResolveMatchType_DEFINED
#define SOAP_TYPE_wsdd__ResolveMatchType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsdd__ResolveMatchType(struct soap*, struct wsdd__ResolveMatchType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__ResolveMatchType(struct soap*, const struct wsdd__ResolveMatchType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__ResolveMatchType(struct soap*, const char*, int, const struct wsdd__ResolveMatchType *, const char*);
SOAP_FMAC3 struct wsdd__ResolveMatchType * SOAP_FMAC4 soap_in_wsdd__ResolveMatchType(struct soap*, const char*, struct wsdd__ResolveMatchType *, const char*);
SOAP_FMAC1 struct wsdd__ResolveMatchType * SOAP_FMAC2 soap_instantiate_wsdd__ResolveMatchType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsdd__ResolveMatchType * soap_new_wsdd__ResolveMatchType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsdd__ResolveMatchType(soap, n, NULL, NULL, NULL);
}

inline struct wsdd__ResolveMatchType * soap_new_req_wsdd__ResolveMatchType(
	struct soap *soap,
	const struct wsa__EndpointReferenceType& wsa__EndpointReference,
	unsigned int MetadataVersion)
{
	struct wsdd__ResolveMatchType *_p = ::soap_new_wsdd__ResolveMatchType(soap);
	if (_p)
	{	::soap_default_wsdd__ResolveMatchType(soap, _p);
		_p->wsa__EndpointReference = wsa__EndpointReference;
		_p->MetadataVersion = MetadataVersion;
	}
	return _p;
}

inline struct wsdd__ResolveMatchType * soap_new_set_wsdd__ResolveMatchType(
	struct soap *soap,
	const struct wsa__EndpointReferenceType& wsa__EndpointReference,
	char *Types,
	struct wsdd__ScopesType *Scopes,
	char *XAddrs,
	unsigned int MetadataVersion)
{
	struct wsdd__ResolveMatchType *_p = ::soap_new_wsdd__ResolveMatchType(soap);
	if (_p)
	{	::soap_default_wsdd__ResolveMatchType(soap, _p);
		_p->wsa__EndpointReference = wsa__EndpointReference;
		_p->Types = Types;
		_p->Scopes = Scopes;
		_p->XAddrs = XAddrs;
		_p->MetadataVersion = MetadataVersion;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__ResolveMatchType(struct soap*, const struct wsdd__ResolveMatchType *, const char*, const char*);

inline int soap_write_wsdd__ResolveMatchType(struct soap *soap, struct wsdd__ResolveMatchType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsdd__ResolveMatchType(soap, p), 0) || ::soap_put_wsdd__ResolveMatchType(soap, p, "wsdd:ResolveMatchType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsdd__ResolveMatchType(struct soap *soap, const char *URL, struct wsdd__ResolveMatchType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ResolveMatchType(soap, p), 0) || ::soap_put_wsdd__ResolveMatchType(soap, p, "wsdd:ResolveMatchType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__ResolveMatchType(struct soap *soap, const char *URL, struct wsdd__ResolveMatchType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ResolveMatchType(soap, p), 0) || ::soap_put_wsdd__ResolveMatchType(soap, p, "wsdd:ResolveMatchType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__ResolveMatchType(struct soap *soap, const char *URL, struct wsdd__ResolveMatchType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ResolveMatchType(soap, p), 0) || ::soap_put_wsdd__ResolveMatchType(soap, p, "wsdd:ResolveMatchType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsdd__ResolveMatchType * SOAP_FMAC4 soap_get_wsdd__ResolveMatchType(struct soap*, struct wsdd__ResolveMatchType *, const char*, const char*);

inline int soap_read_wsdd__ResolveMatchType(struct soap *soap, struct wsdd__ResolveMatchType *p)
{
	if (p)
	{	::soap_default_wsdd__ResolveMatchType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsdd__ResolveMatchType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__ResolveMatchType(struct soap *soap, const char *URL, struct wsdd__ResolveMatchType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__ResolveMatchType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__ResolveMatchType(struct soap *soap, struct wsdd__ResolveMatchType *p)
{
	if (::soap_read_wsdd__ResolveMatchType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsdd__ResolveMatchesType_DEFINED
#define SOAP_TYPE_wsdd__ResolveMatchesType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsdd__ResolveMatchesType(struct soap*, struct wsdd__ResolveMatchesType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__ResolveMatchesType(struct soap*, const struct wsdd__ResolveMatchesType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__ResolveMatchesType(struct soap*, const char*, int, const struct wsdd__ResolveMatchesType *, const char*);
SOAP_FMAC3 struct wsdd__ResolveMatchesType * SOAP_FMAC4 soap_in_wsdd__ResolveMatchesType(struct soap*, const char*, struct wsdd__ResolveMatchesType *, const char*);
SOAP_FMAC1 struct wsdd__ResolveMatchesType * SOAP_FMAC2 soap_instantiate_wsdd__ResolveMatchesType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsdd__ResolveMatchesType * soap_new_wsdd__ResolveMatchesType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsdd__ResolveMatchesType(soap, n, NULL, NULL, NULL);
}

inline struct wsdd__ResolveMatchesType * soap_new_req_wsdd__ResolveMatchesType(
	struct soap *soap)
{
	struct wsdd__ResolveMatchesType *_p = ::soap_new_wsdd__ResolveMatchesType(soap);
	if (_p)
	{	::soap_default_wsdd__ResolveMatchesType(soap, _p);
	}
	return _p;
}

inline struct wsdd__ResolveMatchesType * soap_new_set_wsdd__ResolveMatchesType(
	struct soap *soap,
	struct wsdd__ResolveMatchType *ResolveMatch)
{
	struct wsdd__ResolveMatchesType *_p = ::soap_new_wsdd__ResolveMatchesType(soap);
	if (_p)
	{	::soap_default_wsdd__ResolveMatchesType(soap, _p);
		_p->ResolveMatch = ResolveMatch;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__ResolveMatchesType(struct soap*, const struct wsdd__ResolveMatchesType *, const char*, const char*);

inline int soap_write_wsdd__ResolveMatchesType(struct soap *soap, struct wsdd__ResolveMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsdd__ResolveMatchesType(soap, p), 0) || ::soap_put_wsdd__ResolveMatchesType(soap, p, "wsdd:ResolveMatchesType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsdd__ResolveMatchesType(struct soap *soap, const char *URL, struct wsdd__ResolveMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ResolveMatchesType(soap, p), 0) || ::soap_put_wsdd__ResolveMatchesType(soap, p, "wsdd:ResolveMatchesType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__ResolveMatchesType(struct soap *soap, const char *URL, struct wsdd__ResolveMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ResolveMatchesType(soap, p), 0) || ::soap_put_wsdd__ResolveMatchesType(soap, p, "wsdd:ResolveMatchesType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__ResolveMatchesType(struct soap *soap, const char *URL, struct wsdd__ResolveMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ResolveMatchesType(soap, p), 0) || ::soap_put_wsdd__ResolveMatchesType(soap, p, "wsdd:ResolveMatchesType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsdd__ResolveMatchesType * SOAP_FMAC4 soap_get_wsdd__ResolveMatchesType(struct soap*, struct wsdd__ResolveMatchesType *, const char*, const char*);

inline int soap_read_wsdd__ResolveMatchesType(struct soap *soap, struct wsdd__ResolveMatchesType *p)
{
	if (p)
	{	::soap_default_wsdd__ResolveMatchesType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsdd__ResolveMatchesType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__ResolveMatchesType(struct soap *soap, const char *URL, struct wsdd__ResolveMatchesType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__ResolveMatchesType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__ResolveMatchesType(struct soap *soap, struct wsdd__ResolveMatchesType *p)
{
	if (::soap_read_wsdd__ResolveMatchesType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsdd__ResolveType_DEFINED
#define SOAP_TYPE_wsdd__ResolveType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsdd__ResolveType(struct soap*, struct wsdd__ResolveType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__ResolveType(struct soap*, const struct wsdd__ResolveType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__ResolveType(struct soap*, const char*, int, const struct wsdd__ResolveType *, const char*);
SOAP_FMAC3 struct wsdd__ResolveType * SOAP_FMAC4 soap_in_wsdd__ResolveType(struct soap*, const char*, struct wsdd__ResolveType *, const char*);
SOAP_FMAC1 struct wsdd__ResolveType * SOAP_FMAC2 soap_instantiate_wsdd__ResolveType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsdd__ResolveType * soap_new_wsdd__ResolveType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsdd__ResolveType(soap, n, NULL, NULL, NULL);
}

inline struct wsdd__ResolveType * soap_new_req_wsdd__ResolveType(
	struct soap *soap,
	const struct wsa__EndpointReferenceType& wsa__EndpointReference)
{
	struct wsdd__ResolveType *_p = ::soap_new_wsdd__ResolveType(soap);
	if (_p)
	{	::soap_default_wsdd__ResolveType(soap, _p);
		_p->wsa__EndpointReference = wsa__EndpointReference;
	}
	return _p;
}

inline struct wsdd__ResolveType * soap_new_set_wsdd__ResolveType(
	struct soap *soap,
	const struct wsa__EndpointReferenceType& wsa__EndpointReference)
{
	struct wsdd__ResolveType *_p = ::soap_new_wsdd__ResolveType(soap);
	if (_p)
	{	::soap_default_wsdd__ResolveType(soap, _p);
		_p->wsa__EndpointReference = wsa__EndpointReference;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__ResolveType(struct soap*, const struct wsdd__ResolveType *, const char*, const char*);

inline int soap_write_wsdd__ResolveType(struct soap *soap, struct wsdd__ResolveType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsdd__ResolveType(soap, p), 0) || ::soap_put_wsdd__ResolveType(soap, p, "wsdd:ResolveType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsdd__ResolveType(struct soap *soap, const char *URL, struct wsdd__ResolveType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ResolveType(soap, p), 0) || ::soap_put_wsdd__ResolveType(soap, p, "wsdd:ResolveType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__ResolveType(struct soap *soap, const char *URL, struct wsdd__ResolveType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ResolveType(soap, p), 0) || ::soap_put_wsdd__ResolveType(soap, p, "wsdd:ResolveType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__ResolveType(struct soap *soap, const char *URL, struct wsdd__ResolveType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ResolveType(soap, p), 0) || ::soap_put_wsdd__ResolveType(soap, p, "wsdd:ResolveType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsdd__ResolveType * SOAP_FMAC4 soap_get_wsdd__ResolveType(struct soap*, struct wsdd__ResolveType *, const char*, const char*);

inline int soap_read_wsdd__ResolveType(struct soap *soap, struct wsdd__ResolveType *p)
{
	if (p)
	{	::soap_default_wsdd__ResolveType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsdd__ResolveType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__ResolveType(struct soap *soap, const char *URL, struct wsdd__ResolveType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__ResolveType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__ResolveType(struct soap *soap, struct wsdd__ResolveType *p)
{
	if (::soap_read_wsdd__ResolveType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsdd__ProbeMatchType_DEFINED
#define SOAP_TYPE_wsdd__ProbeMatchType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsdd__ProbeMatchType(struct soap*, struct wsdd__ProbeMatchType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__ProbeMatchType(struct soap*, const struct wsdd__ProbeMatchType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__ProbeMatchType(struct soap*, const char*, int, const struct wsdd__ProbeMatchType *, const char*);
SOAP_FMAC3 struct wsdd__ProbeMatchType * SOAP_FMAC4 soap_in_wsdd__ProbeMatchType(struct soap*, const char*, struct wsdd__ProbeMatchType *, const char*);
SOAP_FMAC1 struct wsdd__ProbeMatchType * SOAP_FMAC2 soap_instantiate_wsdd__ProbeMatchType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsdd__ProbeMatchType * soap_new_wsdd__ProbeMatchType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsdd__ProbeMatchType(soap, n, NULL, NULL, NULL);
}

inline struct wsdd__ProbeMatchType * soap_new_req_wsdd__ProbeMatchType(
	struct soap *soap,
	const struct wsa__EndpointReferenceType& wsa__EndpointReference,
	unsigned int MetadataVersion)
{
	struct wsdd__ProbeMatchType *_p = ::soap_new_wsdd__ProbeMatchType(soap);
	if (_p)
	{	::soap_default_wsdd__ProbeMatchType(soap, _p);
		_p->wsa__EndpointReference = wsa__EndpointReference;
		_p->MetadataVersion = MetadataVersion;
	}
	return _p;
}

inline struct wsdd__ProbeMatchType * soap_new_set_wsdd__ProbeMatchType(
	struct soap *soap,
	const struct wsa__EndpointReferenceType& wsa__EndpointReference,
	char *Types,
	struct wsdd__ScopesType *Scopes,
	char *XAddrs,
	unsigned int MetadataVersion)
{
	struct wsdd__ProbeMatchType *_p = ::soap_new_wsdd__ProbeMatchType(soap);
	if (_p)
	{	::soap_default_wsdd__ProbeMatchType(soap, _p);
		_p->wsa__EndpointReference = wsa__EndpointReference;
		_p->Types = Types;
		_p->Scopes = Scopes;
		_p->XAddrs = XAddrs;
		_p->MetadataVersion = MetadataVersion;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__ProbeMatchType(struct soap*, const struct wsdd__ProbeMatchType *, const char*, const char*);

inline int soap_write_wsdd__ProbeMatchType(struct soap *soap, struct wsdd__ProbeMatchType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsdd__ProbeMatchType(soap, p), 0) || ::soap_put_wsdd__ProbeMatchType(soap, p, "wsdd:ProbeMatchType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsdd__ProbeMatchType(struct soap *soap, const char *URL, struct wsdd__ProbeMatchType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ProbeMatchType(soap, p), 0) || ::soap_put_wsdd__ProbeMatchType(soap, p, "wsdd:ProbeMatchType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__ProbeMatchType(struct soap *soap, const char *URL, struct wsdd__ProbeMatchType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ProbeMatchType(soap, p), 0) || ::soap_put_wsdd__ProbeMatchType(soap, p, "wsdd:ProbeMatchType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__ProbeMatchType(struct soap *soap, const char *URL, struct wsdd__ProbeMatchType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ProbeMatchType(soap, p), 0) || ::soap_put_wsdd__ProbeMatchType(soap, p, "wsdd:ProbeMatchType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsdd__ProbeMatchType * SOAP_FMAC4 soap_get_wsdd__ProbeMatchType(struct soap*, struct wsdd__ProbeMatchType *, const char*, const char*);

inline int soap_read_wsdd__ProbeMatchType(struct soap *soap, struct wsdd__ProbeMatchType *p)
{
	if (p)
	{	::soap_default_wsdd__ProbeMatchType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsdd__ProbeMatchType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__ProbeMatchType(struct soap *soap, const char *URL, struct wsdd__ProbeMatchType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__ProbeMatchType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__ProbeMatchType(struct soap *soap, struct wsdd__ProbeMatchType *p)
{
	if (::soap_read_wsdd__ProbeMatchType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsdd__ProbeMatchesType_DEFINED
#define SOAP_TYPE_wsdd__ProbeMatchesType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsdd__ProbeMatchesType(struct soap*, struct wsdd__ProbeMatchesType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__ProbeMatchesType(struct soap*, const struct wsdd__ProbeMatchesType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__ProbeMatchesType(struct soap*, const char*, int, const struct wsdd__ProbeMatchesType *, const char*);
SOAP_FMAC3 struct wsdd__ProbeMatchesType * SOAP_FMAC4 soap_in_wsdd__ProbeMatchesType(struct soap*, const char*, struct wsdd__ProbeMatchesType *, const char*);
SOAP_FMAC1 struct wsdd__ProbeMatchesType * SOAP_FMAC2 soap_instantiate_wsdd__ProbeMatchesType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsdd__ProbeMatchesType * soap_new_wsdd__ProbeMatchesType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsdd__ProbeMatchesType(soap, n, NULL, NULL, NULL);
}

inline struct wsdd__ProbeMatchesType * soap_new_req_wsdd__ProbeMatchesType(
	struct soap *soap,
	int __sizeProbeMatch,
	struct wsdd__ProbeMatchType *ProbeMatch)
{
	struct wsdd__ProbeMatchesType *_p = ::soap_new_wsdd__ProbeMatchesType(soap);
	if (_p)
	{	::soap_default_wsdd__ProbeMatchesType(soap, _p);
		_p->__sizeProbeMatch = __sizeProbeMatch;
		_p->ProbeMatch = ProbeMatch;
	}
	return _p;
}

inline struct wsdd__ProbeMatchesType * soap_new_set_wsdd__ProbeMatchesType(
	struct soap *soap,
	int __sizeProbeMatch,
	struct wsdd__ProbeMatchType *ProbeMatch)
{
	struct wsdd__ProbeMatchesType *_p = ::soap_new_wsdd__ProbeMatchesType(soap);
	if (_p)
	{	::soap_default_wsdd__ProbeMatchesType(soap, _p);
		_p->__sizeProbeMatch = __sizeProbeMatch;
		_p->ProbeMatch = ProbeMatch;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__ProbeMatchesType(struct soap*, const struct wsdd__ProbeMatchesType *, const char*, const char*);

inline int soap_write_wsdd__ProbeMatchesType(struct soap *soap, struct wsdd__ProbeMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsdd__ProbeMatchesType(soap, p), 0) || ::soap_put_wsdd__ProbeMatchesType(soap, p, "wsdd:ProbeMatchesType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsdd__ProbeMatchesType(struct soap *soap, const char *URL, struct wsdd__ProbeMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ProbeMatchesType(soap, p), 0) || ::soap_put_wsdd__ProbeMatchesType(soap, p, "wsdd:ProbeMatchesType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__ProbeMatchesType(struct soap *soap, const char *URL, struct wsdd__ProbeMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ProbeMatchesType(soap, p), 0) || ::soap_put_wsdd__ProbeMatchesType(soap, p, "wsdd:ProbeMatchesType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__ProbeMatchesType(struct soap *soap, const char *URL, struct wsdd__ProbeMatchesType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ProbeMatchesType(soap, p), 0) || ::soap_put_wsdd__ProbeMatchesType(soap, p, "wsdd:ProbeMatchesType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsdd__ProbeMatchesType * SOAP_FMAC4 soap_get_wsdd__ProbeMatchesType(struct soap*, struct wsdd__ProbeMatchesType *, const char*, const char*);

inline int soap_read_wsdd__ProbeMatchesType(struct soap *soap, struct wsdd__ProbeMatchesType *p)
{
	if (p)
	{	::soap_default_wsdd__ProbeMatchesType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsdd__ProbeMatchesType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__ProbeMatchesType(struct soap *soap, const char *URL, struct wsdd__ProbeMatchesType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__ProbeMatchesType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__ProbeMatchesType(struct soap *soap, struct wsdd__ProbeMatchesType *p)
{
	if (::soap_read_wsdd__ProbeMatchesType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsdd__ProbeType_DEFINED
#define SOAP_TYPE_wsdd__ProbeType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsdd__ProbeType(struct soap*, struct wsdd__ProbeType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__ProbeType(struct soap*, const struct wsdd__ProbeType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__ProbeType(struct soap*, const char*, int, const struct wsdd__ProbeType *, const char*);
SOAP_FMAC3 struct wsdd__ProbeType * SOAP_FMAC4 soap_in_wsdd__ProbeType(struct soap*, const char*, struct wsdd__ProbeType *, const char*);
SOAP_FMAC1 struct wsdd__ProbeType * SOAP_FMAC2 soap_instantiate_wsdd__ProbeType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsdd__ProbeType * soap_new_wsdd__ProbeType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsdd__ProbeType(soap, n, NULL, NULL, NULL);
}

inline struct wsdd__ProbeType * soap_new_req_wsdd__ProbeType(
	struct soap *soap)
{
	struct wsdd__ProbeType *_p = ::soap_new_wsdd__ProbeType(soap);
	if (_p)
	{	::soap_default_wsdd__ProbeType(soap, _p);
	}
	return _p;
}

inline struct wsdd__ProbeType * soap_new_set_wsdd__ProbeType(
	struct soap *soap,
	char *Types,
	struct wsdd__ScopesType *Scopes)
{
	struct wsdd__ProbeType *_p = ::soap_new_wsdd__ProbeType(soap);
	if (_p)
	{	::soap_default_wsdd__ProbeType(soap, _p);
		_p->Types = Types;
		_p->Scopes = Scopes;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__ProbeType(struct soap*, const struct wsdd__ProbeType *, const char*, const char*);

inline int soap_write_wsdd__ProbeType(struct soap *soap, struct wsdd__ProbeType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsdd__ProbeType(soap, p), 0) || ::soap_put_wsdd__ProbeType(soap, p, "wsdd:ProbeType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsdd__ProbeType(struct soap *soap, const char *URL, struct wsdd__ProbeType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ProbeType(soap, p), 0) || ::soap_put_wsdd__ProbeType(soap, p, "wsdd:ProbeType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__ProbeType(struct soap *soap, const char *URL, struct wsdd__ProbeType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ProbeType(soap, p), 0) || ::soap_put_wsdd__ProbeType(soap, p, "wsdd:ProbeType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__ProbeType(struct soap *soap, const char *URL, struct wsdd__ProbeType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ProbeType(soap, p), 0) || ::soap_put_wsdd__ProbeType(soap, p, "wsdd:ProbeType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsdd__ProbeType * SOAP_FMAC4 soap_get_wsdd__ProbeType(struct soap*, struct wsdd__ProbeType *, const char*, const char*);

inline int soap_read_wsdd__ProbeType(struct soap *soap, struct wsdd__ProbeType *p)
{
	if (p)
	{	::soap_default_wsdd__ProbeType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsdd__ProbeType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__ProbeType(struct soap *soap, const char *URL, struct wsdd__ProbeType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__ProbeType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__ProbeType(struct soap *soap, struct wsdd__ProbeType *p)
{
	if (::soap_read_wsdd__ProbeType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsdd__ByeType_DEFINED
#define SOAP_TYPE_wsdd__ByeType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsdd__ByeType(struct soap*, struct wsdd__ByeType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__ByeType(struct soap*, const struct wsdd__ByeType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__ByeType(struct soap*, const char*, int, const struct wsdd__ByeType *, const char*);
SOAP_FMAC3 struct wsdd__ByeType * SOAP_FMAC4 soap_in_wsdd__ByeType(struct soap*, const char*, struct wsdd__ByeType *, const char*);
SOAP_FMAC1 struct wsdd__ByeType * SOAP_FMAC2 soap_instantiate_wsdd__ByeType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsdd__ByeType * soap_new_wsdd__ByeType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsdd__ByeType(soap, n, NULL, NULL, NULL);
}

inline struct wsdd__ByeType * soap_new_req_wsdd__ByeType(
	struct soap *soap,
	const struct wsa__EndpointReferenceType& wsa__EndpointReference)
{
	struct wsdd__ByeType *_p = ::soap_new_wsdd__ByeType(soap);
	if (_p)
	{	::soap_default_wsdd__ByeType(soap, _p);
		_p->wsa__EndpointReference = wsa__EndpointReference;
	}
	return _p;
}

inline struct wsdd__ByeType * soap_new_set_wsdd__ByeType(
	struct soap *soap,
	const struct wsa__EndpointReferenceType& wsa__EndpointReference,
	char *Types,
	struct wsdd__ScopesType *Scopes,
	char *XAddrs,
	unsigned int *MetadataVersion)
{
	struct wsdd__ByeType *_p = ::soap_new_wsdd__ByeType(soap);
	if (_p)
	{	::soap_default_wsdd__ByeType(soap, _p);
		_p->wsa__EndpointReference = wsa__EndpointReference;
		_p->Types = Types;
		_p->Scopes = Scopes;
		_p->XAddrs = XAddrs;
		_p->MetadataVersion = MetadataVersion;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__ByeType(struct soap*, const struct wsdd__ByeType *, const char*, const char*);

inline int soap_write_wsdd__ByeType(struct soap *soap, struct wsdd__ByeType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsdd__ByeType(soap, p), 0) || ::soap_put_wsdd__ByeType(soap, p, "wsdd:ByeType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsdd__ByeType(struct soap *soap, const char *URL, struct wsdd__ByeType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ByeType(soap, p), 0) || ::soap_put_wsdd__ByeType(soap, p, "wsdd:ByeType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__ByeType(struct soap *soap, const char *URL, struct wsdd__ByeType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ByeType(soap, p), 0) || ::soap_put_wsdd__ByeType(soap, p, "wsdd:ByeType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__ByeType(struct soap *soap, const char *URL, struct wsdd__ByeType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__ByeType(soap, p), 0) || ::soap_put_wsdd__ByeType(soap, p, "wsdd:ByeType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsdd__ByeType * SOAP_FMAC4 soap_get_wsdd__ByeType(struct soap*, struct wsdd__ByeType *, const char*, const char*);

inline int soap_read_wsdd__ByeType(struct soap *soap, struct wsdd__ByeType *p)
{
	if (p)
	{	::soap_default_wsdd__ByeType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsdd__ByeType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__ByeType(struct soap *soap, const char *URL, struct wsdd__ByeType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__ByeType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__ByeType(struct soap *soap, struct wsdd__ByeType *p)
{
	if (::soap_read_wsdd__ByeType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsdd__HelloType_DEFINED
#define SOAP_TYPE_wsdd__HelloType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsdd__HelloType(struct soap*, struct wsdd__HelloType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__HelloType(struct soap*, const struct wsdd__HelloType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__HelloType(struct soap*, const char*, int, const struct wsdd__HelloType *, const char*);
SOAP_FMAC3 struct wsdd__HelloType * SOAP_FMAC4 soap_in_wsdd__HelloType(struct soap*, const char*, struct wsdd__HelloType *, const char*);
SOAP_FMAC1 struct wsdd__HelloType * SOAP_FMAC2 soap_instantiate_wsdd__HelloType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsdd__HelloType * soap_new_wsdd__HelloType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsdd__HelloType(soap, n, NULL, NULL, NULL);
}

inline struct wsdd__HelloType * soap_new_req_wsdd__HelloType(
	struct soap *soap,
	const struct wsa__EndpointReferenceType& wsa__EndpointReference,
	unsigned int MetadataVersion)
{
	struct wsdd__HelloType *_p = ::soap_new_wsdd__HelloType(soap);
	if (_p)
	{	::soap_default_wsdd__HelloType(soap, _p);
		_p->wsa__EndpointReference = wsa__EndpointReference;
		_p->MetadataVersion = MetadataVersion;
	}
	return _p;
}

inline struct wsdd__HelloType * soap_new_set_wsdd__HelloType(
	struct soap *soap,
	const struct wsa__EndpointReferenceType& wsa__EndpointReference,
	char *Types,
	struct wsdd__ScopesType *Scopes,
	char *XAddrs,
	unsigned int MetadataVersion)
{
	struct wsdd__HelloType *_p = ::soap_new_wsdd__HelloType(soap);
	if (_p)
	{	::soap_default_wsdd__HelloType(soap, _p);
		_p->wsa__EndpointReference = wsa__EndpointReference;
		_p->Types = Types;
		_p->Scopes = Scopes;
		_p->XAddrs = XAddrs;
		_p->MetadataVersion = MetadataVersion;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__HelloType(struct soap*, const struct wsdd__HelloType *, const char*, const char*);

inline int soap_write_wsdd__HelloType(struct soap *soap, struct wsdd__HelloType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsdd__HelloType(soap, p), 0) || ::soap_put_wsdd__HelloType(soap, p, "wsdd:HelloType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsdd__HelloType(struct soap *soap, const char *URL, struct wsdd__HelloType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__HelloType(soap, p), 0) || ::soap_put_wsdd__HelloType(soap, p, "wsdd:HelloType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__HelloType(struct soap *soap, const char *URL, struct wsdd__HelloType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__HelloType(soap, p), 0) || ::soap_put_wsdd__HelloType(soap, p, "wsdd:HelloType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__HelloType(struct soap *soap, const char *URL, struct wsdd__HelloType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsdd__HelloType(soap, p), 0) || ::soap_put_wsdd__HelloType(soap, p, "wsdd:HelloType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsdd__HelloType * SOAP_FMAC4 soap_get_wsdd__HelloType(struct soap*, struct wsdd__HelloType *, const char*, const char*);

inline int soap_read_wsdd__HelloType(struct soap *soap, struct wsdd__HelloType *p)
{
	if (p)
	{	::soap_default_wsdd__HelloType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsdd__HelloType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__HelloType(struct soap *soap, const char *URL, struct wsdd__HelloType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__HelloType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__HelloType(struct soap *soap, struct wsdd__HelloType *p)
{
	if (::soap_read_wsdd__HelloType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_SOAP_ENV__Fault_DEFINED
#define SOAP_TYPE_SOAP_ENV__Fault_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap*, struct SOAP_ENV__Fault *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap*, const struct SOAP_ENV__Fault *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Fault(struct soap*, const char*, int, const struct SOAP_ENV__Fault *, const char*);
SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_in_SOAP_ENV__Fault(struct soap*, const char*, struct SOAP_ENV__Fault *, const char*);
SOAP_FMAC1 struct SOAP_ENV__Fault * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Fault(struct soap*, int, const char*, const char*, size_t*);

inline struct SOAP_ENV__Fault * soap_new_SOAP_ENV__Fault(struct soap *soap, int n = -1)
{
	return soap_instantiate_SOAP_ENV__Fault(soap, n, NULL, NULL, NULL);
}

inline struct SOAP_ENV__Fault * soap_new_req_SOAP_ENV__Fault(
	struct soap *soap)
{
	struct SOAP_ENV__Fault *_p = ::soap_new_SOAP_ENV__Fault(soap);
	if (_p)
	{	::soap_default_SOAP_ENV__Fault(soap, _p);
	}
	return _p;
}

inline struct SOAP_ENV__Fault * soap_new_set_SOAP_ENV__Fault(
	struct soap *soap,
	char *faultcode,
	char *faultstring,
	char *faultactor,
	struct SOAP_ENV__Detail *detail,
	struct SOAP_ENV__Code *SOAP_ENV__Code,
	struct SOAP_ENV__Reason *SOAP_ENV__Reason,
	char *SOAP_ENV__Node,
	char *SOAP_ENV__Role,
	struct SOAP_ENV__Detail *SOAP_ENV__Detail)
{
	struct SOAP_ENV__Fault *_p = ::soap_new_SOAP_ENV__Fault(soap);
	if (_p)
	{	::soap_default_SOAP_ENV__Fault(soap, _p);
		_p->faultcode = faultcode;
		_p->faultstring = faultstring;
		_p->faultactor = faultactor;
		_p->detail = detail;
		_p->SOAP_ENV__Code = SOAP_ENV__Code;
		_p->SOAP_ENV__Reason = SOAP_ENV__Reason;
		_p->SOAP_ENV__Node = SOAP_ENV__Node;
		_p->SOAP_ENV__Role = SOAP_ENV__Role;
		_p->SOAP_ENV__Detail = SOAP_ENV__Detail;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Fault(struct soap*, const struct SOAP_ENV__Fault *, const char*, const char*);

inline int soap_write_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_SOAP_ENV__Fault(soap, p), 0) || ::soap_put_SOAP_ENV__Fault(soap, p, "SOAP-ENV:Fault", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_SOAP_ENV__Fault(struct soap *soap, const char *URL, struct SOAP_ENV__Fault const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Fault(soap, p), 0) || ::soap_put_SOAP_ENV__Fault(soap, p, "SOAP-ENV:Fault", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_SOAP_ENV__Fault(struct soap *soap, const char *URL, struct SOAP_ENV__Fault const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Fault(soap, p), 0) || ::soap_put_SOAP_ENV__Fault(soap, p, "SOAP-ENV:Fault", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_SOAP_ENV__Fault(struct soap *soap, const char *URL, struct SOAP_ENV__Fault const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Fault(soap, p), 0) || ::soap_put_SOAP_ENV__Fault(soap, p, "SOAP-ENV:Fault", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_get_SOAP_ENV__Fault(struct soap*, struct SOAP_ENV__Fault *, const char*, const char*);

inline int soap_read_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *p)
{
	if (p)
	{	::soap_default_SOAP_ENV__Fault(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_SOAP_ENV__Fault(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_SOAP_ENV__Fault(struct soap *soap, const char *URL, struct SOAP_ENV__Fault *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_SOAP_ENV__Fault(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *p)
{
	if (::soap_read_SOAP_ENV__Fault(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_SOAP_ENV__Reason_DEFINED
#define SOAP_TYPE_SOAP_ENV__Reason_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap*, const struct SOAP_ENV__Reason *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Reason(struct soap*, const char*, int, const struct SOAP_ENV__Reason *, const char*);
SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_in_SOAP_ENV__Reason(struct soap*, const char*, struct SOAP_ENV__Reason *, const char*);
SOAP_FMAC1 struct SOAP_ENV__Reason * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Reason(struct soap*, int, const char*, const char*, size_t*);

inline struct SOAP_ENV__Reason * soap_new_SOAP_ENV__Reason(struct soap *soap, int n = -1)
{
	return soap_instantiate_SOAP_ENV__Reason(soap, n, NULL, NULL, NULL);
}

inline struct SOAP_ENV__Reason * soap_new_req_SOAP_ENV__Reason(
	struct soap *soap)
{
	struct SOAP_ENV__Reason *_p = ::soap_new_SOAP_ENV__Reason(soap);
	if (_p)
	{	::soap_default_SOAP_ENV__Reason(soap, _p);
	}
	return _p;
}

inline struct SOAP_ENV__Reason * soap_new_set_SOAP_ENV__Reason(
	struct soap *soap,
	char *SOAP_ENV__Text)
{
	struct SOAP_ENV__Reason *_p = ::soap_new_SOAP_ENV__Reason(soap);
	if (_p)
	{	::soap_default_SOAP_ENV__Reason(soap, _p);
		_p->SOAP_ENV__Text = SOAP_ENV__Text;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Reason(struct soap*, const struct SOAP_ENV__Reason *, const char*, const char*);

inline int soap_write_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_SOAP_ENV__Reason(soap, p), 0) || ::soap_put_SOAP_ENV__Reason(soap, p, "SOAP-ENV:Reason", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_SOAP_ENV__Reason(struct soap *soap, const char *URL, struct SOAP_ENV__Reason const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Reason(soap, p), 0) || ::soap_put_SOAP_ENV__Reason(soap, p, "SOAP-ENV:Reason", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_SOAP_ENV__Reason(struct soap *soap, const char *URL, struct SOAP_ENV__Reason const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Reason(soap, p), 0) || ::soap_put_SOAP_ENV__Reason(soap, p, "SOAP-ENV:Reason", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_SOAP_ENV__Reason(struct soap *soap, const char *URL, struct SOAP_ENV__Reason const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Reason(soap, p), 0) || ::soap_put_SOAP_ENV__Reason(soap, p, "SOAP-ENV:Reason", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_get_SOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *, const char*, const char*);

inline int soap_read_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *p)
{
	if (p)
	{	::soap_default_SOAP_ENV__Reason(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_SOAP_ENV__Reason(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_SOAP_ENV__Reason(struct soap *soap, const char *URL, struct SOAP_ENV__Reason *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_SOAP_ENV__Reason(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *p)
{
	if (::soap_read_SOAP_ENV__Reason(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_SOAP_ENV__Code_DEFINED
#define SOAP_TYPE_SOAP_ENV__Code_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap*, const struct SOAP_ENV__Code *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Code(struct soap*, const char*, int, const struct SOAP_ENV__Code *, const char*);
SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_in_SOAP_ENV__Code(struct soap*, const char*, struct SOAP_ENV__Code *, const char*);
SOAP_FMAC1 struct SOAP_ENV__Code * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Code(struct soap*, int, const char*, const char*, size_t*);

inline struct SOAP_ENV__Code * soap_new_SOAP_ENV__Code(struct soap *soap, int n = -1)
{
	return soap_instantiate_SOAP_ENV__Code(soap, n, NULL, NULL, NULL);
}

inline struct SOAP_ENV__Code * soap_new_req_SOAP_ENV__Code(
	struct soap *soap)
{
	struct SOAP_ENV__Code *_p = ::soap_new_SOAP_ENV__Code(soap);
	if (_p)
	{	::soap_default_SOAP_ENV__Code(soap, _p);
	}
	return _p;
}

inline struct SOAP_ENV__Code * soap_new_set_SOAP_ENV__Code(
	struct soap *soap,
	char *SOAP_ENV__Value,
	struct SOAP_ENV__Code *SOAP_ENV__Subcode)
{
	struct SOAP_ENV__Code *_p = ::soap_new_SOAP_ENV__Code(soap);
	if (_p)
	{	::soap_default_SOAP_ENV__Code(soap, _p);
		_p->SOAP_ENV__Value = SOAP_ENV__Value;
		_p->SOAP_ENV__Subcode = SOAP_ENV__Subcode;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Code(struct soap*, const struct SOAP_ENV__Code *, const char*, const char*);

inline int soap_write_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_SOAP_ENV__Code(soap, p), 0) || ::soap_put_SOAP_ENV__Code(soap, p, "SOAP-ENV:Code", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_SOAP_ENV__Code(struct soap *soap, const char *URL, struct SOAP_ENV__Code const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Code(soap, p), 0) || ::soap_put_SOAP_ENV__Code(soap, p, "SOAP-ENV:Code", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_SOAP_ENV__Code(struct soap *soap, const char *URL, struct SOAP_ENV__Code const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Code(soap, p), 0) || ::soap_put_SOAP_ENV__Code(soap, p, "SOAP-ENV:Code", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_SOAP_ENV__Code(struct soap *soap, const char *URL, struct SOAP_ENV__Code const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Code(soap, p), 0) || ::soap_put_SOAP_ENV__Code(soap, p, "SOAP-ENV:Code", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_get_SOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *, const char*, const char*);

inline int soap_read_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *p)
{
	if (p)
	{	::soap_default_SOAP_ENV__Code(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_SOAP_ENV__Code(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_SOAP_ENV__Code(struct soap *soap, const char *URL, struct SOAP_ENV__Code *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_SOAP_ENV__Code(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *p)
{
	if (::soap_read_SOAP_ENV__Code(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_SOAP_ENV__Detail_DEFINED
#define SOAP_TYPE_SOAP_ENV__Detail_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap*, const struct SOAP_ENV__Detail *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Detail(struct soap*, const char*, int, const struct SOAP_ENV__Detail *, const char*);
SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_in_SOAP_ENV__Detail(struct soap*, const char*, struct SOAP_ENV__Detail *, const char*);
SOAP_FMAC1 struct SOAP_ENV__Detail * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Detail(struct soap*, int, const char*, const char*, size_t*);

inline struct SOAP_ENV__Detail * soap_new_SOAP_ENV__Detail(struct soap *soap, int n = -1)
{
	return soap_instantiate_SOAP_ENV__Detail(soap, n, NULL, NULL, NULL);
}

inline struct SOAP_ENV__Detail * soap_new_req_SOAP_ENV__Detail(
	struct soap *soap,
	int __type,
	void *fault)
{
	struct SOAP_ENV__Detail *_p = ::soap_new_SOAP_ENV__Detail(soap);
	if (_p)
	{	::soap_default_SOAP_ENV__Detail(soap, _p);
		_p->__type = __type;
		_p->fault = fault;
	}
	return _p;
}

inline struct SOAP_ENV__Detail * soap_new_set_SOAP_ENV__Detail(
	struct soap *soap,
	char *__any,
	int __type,
	void *fault)
{
	struct SOAP_ENV__Detail *_p = ::soap_new_SOAP_ENV__Detail(soap);
	if (_p)
	{	::soap_default_SOAP_ENV__Detail(soap, _p);
		_p->__any = __any;
		_p->__type = __type;
		_p->fault = fault;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Detail(struct soap*, const struct SOAP_ENV__Detail *, const char*, const char*);

inline int soap_write_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_SOAP_ENV__Detail(soap, p), 0) || ::soap_put_SOAP_ENV__Detail(soap, p, "SOAP-ENV:Detail", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_SOAP_ENV__Detail(struct soap *soap, const char *URL, struct SOAP_ENV__Detail const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Detail(soap, p), 0) || ::soap_put_SOAP_ENV__Detail(soap, p, "SOAP-ENV:Detail", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_SOAP_ENV__Detail(struct soap *soap, const char *URL, struct SOAP_ENV__Detail const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Detail(soap, p), 0) || ::soap_put_SOAP_ENV__Detail(soap, p, "SOAP-ENV:Detail", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_SOAP_ENV__Detail(struct soap *soap, const char *URL, struct SOAP_ENV__Detail const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Detail(soap, p), 0) || ::soap_put_SOAP_ENV__Detail(soap, p, "SOAP-ENV:Detail", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_get_SOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *, const char*, const char*);

inline int soap_read_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *p)
{
	if (p)
	{	::soap_default_SOAP_ENV__Detail(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_SOAP_ENV__Detail(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_SOAP_ENV__Detail(struct soap *soap, const char *URL, struct SOAP_ENV__Detail *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_SOAP_ENV__Detail(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *p)
{
	if (::soap_read_SOAP_ENV__Detail(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_SOAP_ENV__Header_DEFINED
#define SOAP_TYPE_SOAP_ENV__Header_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap*, struct SOAP_ENV__Header *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap*, const struct SOAP_ENV__Header *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Header(struct soap*, const char*, int, const struct SOAP_ENV__Header *, const char*);
SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_in_SOAP_ENV__Header(struct soap*, const char*, struct SOAP_ENV__Header *, const char*);
SOAP_FMAC1 struct SOAP_ENV__Header * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Header(struct soap*, int, const char*, const char*, size_t*);

inline struct SOAP_ENV__Header * soap_new_SOAP_ENV__Header(struct soap *soap, int n = -1)
{
	return soap_instantiate_SOAP_ENV__Header(soap, n, NULL, NULL, NULL);
}

inline struct SOAP_ENV__Header * soap_new_req_SOAP_ENV__Header(
	struct soap *soap)
{
	struct SOAP_ENV__Header *_p = ::soap_new_SOAP_ENV__Header(soap);
	if (_p)
	{	::soap_default_SOAP_ENV__Header(soap, _p);
	}
	return _p;
}

inline struct SOAP_ENV__Header * soap_new_set_SOAP_ENV__Header(
	struct soap *soap,
	char *wsa__MessageID,
	struct wsa__Relationship *wsa__RelatesTo,
	struct wsa__EndpointReferenceType *wsa__From,
	struct wsa__EndpointReferenceType *wsa__ReplyTo,
	struct wsa__EndpointReferenceType *wsa__FaultTo,
	char *wsa__To,
	char *wsa__Action,
	struct wsdd__AppSequenceType *wsdd__AppSequence)
{
	struct SOAP_ENV__Header *_p = ::soap_new_SOAP_ENV__Header(soap);
	if (_p)
	{	::soap_default_SOAP_ENV__Header(soap, _p);
		_p->wsa__MessageID = wsa__MessageID;
		_p->wsa__RelatesTo = wsa__RelatesTo;
		_p->wsa__From = wsa__From;
		_p->wsa__ReplyTo = wsa__ReplyTo;
		_p->wsa__FaultTo = wsa__FaultTo;
		_p->wsa__To = wsa__To;
		_p->wsa__Action = wsa__Action;
		_p->wsdd__AppSequence = wsdd__AppSequence;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Header(struct soap*, const struct SOAP_ENV__Header *, const char*, const char*);

inline int soap_write_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_SOAP_ENV__Header(soap, p), 0) || ::soap_put_SOAP_ENV__Header(soap, p, "SOAP-ENV:Header", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_SOAP_ENV__Header(struct soap *soap, const char *URL, struct SOAP_ENV__Header const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Header(soap, p), 0) || ::soap_put_SOAP_ENV__Header(soap, p, "SOAP-ENV:Header", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_SOAP_ENV__Header(struct soap *soap, const char *URL, struct SOAP_ENV__Header const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Header(soap, p), 0) || ::soap_put_SOAP_ENV__Header(soap, p, "SOAP-ENV:Header", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_SOAP_ENV__Header(struct soap *soap, const char *URL, struct SOAP_ENV__Header const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_SOAP_ENV__Header(soap, p), 0) || ::soap_put_SOAP_ENV__Header(soap, p, "SOAP-ENV:Header", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_get_SOAP_ENV__Header(struct soap*, struct SOAP_ENV__Header *, const char*, const char*);

inline int soap_read_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *p)
{
	if (p)
	{	::soap_default_SOAP_ENV__Header(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_SOAP_ENV__Header(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_SOAP_ENV__Header(struct soap *soap, const char *URL, struct SOAP_ENV__Header *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_SOAP_ENV__Header(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *p)
{
	if (::soap_read_SOAP_ENV__Header(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#endif
/* _wsa__FaultTo is a typedef synonym of wsa__EndpointReferenceType */

#ifndef SOAP_TYPE__wsa__FaultTo_DEFINED
#define SOAP_TYPE__wsa__FaultTo_DEFINED

#define soap_default__wsa__FaultTo soap_default_wsa__EndpointReferenceType

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsa__EndpointReferenceType(struct soap*, const struct wsa__EndpointReferenceType *);

#define soap_serialize__wsa__FaultTo soap_serialize_wsa__EndpointReferenceType


#define soap__wsa__FaultTo2s soap_wsa__EndpointReferenceType2s


#define soap_out__wsa__FaultTo soap_out_wsa__EndpointReferenceType


#define soap_s2_wsa__FaultTo soap_s2wsa__EndpointReferenceType


#define soap_in__wsa__FaultTo soap_in_wsa__EndpointReferenceType


#define soap_instantiate__wsa__FaultTo soap_instantiate_wsa__EndpointReferenceType


#define soap_new__wsa__FaultTo soap_new_wsa__EndpointReferenceType


#define soap_new_req__wsa__FaultTo soap_new_req_wsa__EndpointReferenceType


#define soap_new_set__wsa__FaultTo soap_new_set_wsa__EndpointReferenceType

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsa__FaultTo(struct soap*, const struct wsa__EndpointReferenceType *, const char*, const char*);

inline int soap_write__wsa__FaultTo(struct soap *soap, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsa__FaultTo(soap, p), 0) || ::soap_put__wsa__FaultTo(soap, p, "wsa:FaultTo", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsa__FaultTo(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__FaultTo(soap, p), 0) || ::soap_put__wsa__FaultTo(soap, p, "wsa:FaultTo", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsa__FaultTo(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__FaultTo(soap, p), 0) || ::soap_put__wsa__FaultTo(soap, p, "wsa:FaultTo", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsa__FaultTo(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__FaultTo(soap, p), 0) || ::soap_put__wsa__FaultTo(soap, p, "wsa:FaultTo", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsa__FaultTo soap_get_wsa__EndpointReferenceType


#define soap_read__wsa__FaultTo soap_read_wsa__EndpointReferenceType


#define soap_GET__wsa__FaultTo soap_GET_wsa__EndpointReferenceType


#define soap_POST_recv__wsa__FaultTo soap_POST_recv_wsa__EndpointReferenceType

#endif
/* _wsa__ReplyTo is a typedef synonym of wsa__EndpointReferenceType */

#ifndef SOAP_TYPE__wsa__ReplyTo_DEFINED
#define SOAP_TYPE__wsa__ReplyTo_DEFINED

#define soap_default__wsa__ReplyTo soap_default_wsa__EndpointReferenceType

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsa__EndpointReferenceType(struct soap*, const struct wsa__EndpointReferenceType *);

#define soap_serialize__wsa__ReplyTo soap_serialize_wsa__EndpointReferenceType


#define soap__wsa__ReplyTo2s soap_wsa__EndpointReferenceType2s


#define soap_out__wsa__ReplyTo soap_out_wsa__EndpointReferenceType


#define soap_s2_wsa__ReplyTo soap_s2wsa__EndpointReferenceType


#define soap_in__wsa__ReplyTo soap_in_wsa__EndpointReferenceType


#define soap_instantiate__wsa__ReplyTo soap_instantiate_wsa__EndpointReferenceType


#define soap_new__wsa__ReplyTo soap_new_wsa__EndpointReferenceType


#define soap_new_req__wsa__ReplyTo soap_new_req_wsa__EndpointReferenceType


#define soap_new_set__wsa__ReplyTo soap_new_set_wsa__EndpointReferenceType

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsa__ReplyTo(struct soap*, const struct wsa__EndpointReferenceType *, const char*, const char*);

inline int soap_write__wsa__ReplyTo(struct soap *soap, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsa__ReplyTo(soap, p), 0) || ::soap_put__wsa__ReplyTo(soap, p, "wsa:ReplyTo", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsa__ReplyTo(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__ReplyTo(soap, p), 0) || ::soap_put__wsa__ReplyTo(soap, p, "wsa:ReplyTo", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsa__ReplyTo(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__ReplyTo(soap, p), 0) || ::soap_put__wsa__ReplyTo(soap, p, "wsa:ReplyTo", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsa__ReplyTo(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__ReplyTo(soap, p), 0) || ::soap_put__wsa__ReplyTo(soap, p, "wsa:ReplyTo", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsa__ReplyTo soap_get_wsa__EndpointReferenceType


#define soap_read__wsa__ReplyTo soap_read_wsa__EndpointReferenceType


#define soap_GET__wsa__ReplyTo soap_GET_wsa__EndpointReferenceType


#define soap_POST_recv__wsa__ReplyTo soap_POST_recv_wsa__EndpointReferenceType

#endif
/* _wsa__From is a typedef synonym of wsa__EndpointReferenceType */

#ifndef SOAP_TYPE__wsa__From_DEFINED
#define SOAP_TYPE__wsa__From_DEFINED

#define soap_default__wsa__From soap_default_wsa__EndpointReferenceType

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsa__EndpointReferenceType(struct soap*, const struct wsa__EndpointReferenceType *);

#define soap_serialize__wsa__From soap_serialize_wsa__EndpointReferenceType


#define soap__wsa__From2s soap_wsa__EndpointReferenceType2s


#define soap_out__wsa__From soap_out_wsa__EndpointReferenceType


#define soap_s2_wsa__From soap_s2wsa__EndpointReferenceType


#define soap_in__wsa__From soap_in_wsa__EndpointReferenceType


#define soap_instantiate__wsa__From soap_instantiate_wsa__EndpointReferenceType


#define soap_new__wsa__From soap_new_wsa__EndpointReferenceType


#define soap_new_req__wsa__From soap_new_req_wsa__EndpointReferenceType


#define soap_new_set__wsa__From soap_new_set_wsa__EndpointReferenceType

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsa__From(struct soap*, const struct wsa__EndpointReferenceType *, const char*, const char*);

inline int soap_write__wsa__From(struct soap *soap, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsa__From(soap, p), 0) || ::soap_put__wsa__From(soap, p, "wsa:From", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsa__From(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__From(soap, p), 0) || ::soap_put__wsa__From(soap, p, "wsa:From", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsa__From(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__From(soap, p), 0) || ::soap_put__wsa__From(soap, p, "wsa:From", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsa__From(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__From(soap, p), 0) || ::soap_put__wsa__From(soap, p, "wsa:From", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsa__From soap_get_wsa__EndpointReferenceType


#define soap_read__wsa__From soap_read_wsa__EndpointReferenceType


#define soap_GET__wsa__From soap_GET_wsa__EndpointReferenceType


#define soap_POST_recv__wsa__From soap_POST_recv_wsa__EndpointReferenceType

#endif
/* _wsa__RelatesTo is a typedef synonym of wsa__Relationship */

#ifndef SOAP_TYPE__wsa__RelatesTo_DEFINED
#define SOAP_TYPE__wsa__RelatesTo_DEFINED

#define soap_default__wsa__RelatesTo soap_default_wsa__Relationship

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsa__Relationship(struct soap*, const struct wsa__Relationship *);

#define soap_serialize__wsa__RelatesTo soap_serialize_wsa__Relationship


#define soap__wsa__RelatesTo2s soap_wsa__Relationship2s


#define soap_out__wsa__RelatesTo soap_out_wsa__Relationship


#define soap_s2_wsa__RelatesTo soap_s2wsa__Relationship


#define soap_in__wsa__RelatesTo soap_in_wsa__Relationship


#define soap_instantiate__wsa__RelatesTo soap_instantiate_wsa__Relationship


#define soap_new__wsa__RelatesTo soap_new_wsa__Relationship


#define soap_new_req__wsa__RelatesTo soap_new_req_wsa__Relationship


#define soap_new_set__wsa__RelatesTo soap_new_set_wsa__Relationship

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsa__RelatesTo(struct soap*, const struct wsa__Relationship *, const char*, const char*);

inline int soap_write__wsa__RelatesTo(struct soap *soap, struct wsa__Relationship const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsa__RelatesTo(soap, p), 0) || ::soap_put__wsa__RelatesTo(soap, p, "wsa:RelatesTo", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsa__RelatesTo(struct soap *soap, const char *URL, struct wsa__Relationship const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__RelatesTo(soap, p), 0) || ::soap_put__wsa__RelatesTo(soap, p, "wsa:RelatesTo", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsa__RelatesTo(struct soap *soap, const char *URL, struct wsa__Relationship const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__RelatesTo(soap, p), 0) || ::soap_put__wsa__RelatesTo(soap, p, "wsa:RelatesTo", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsa__RelatesTo(struct soap *soap, const char *URL, struct wsa__Relationship const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__RelatesTo(soap, p), 0) || ::soap_put__wsa__RelatesTo(soap, p, "wsa:RelatesTo", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsa__RelatesTo soap_get_wsa__Relationship


#define soap_read__wsa__RelatesTo soap_read_wsa__Relationship


#define soap_GET__wsa__RelatesTo soap_GET_wsa__Relationship


#define soap_POST_recv__wsa__RelatesTo soap_POST_recv_wsa__Relationship

#endif
/* _wsa__EndpointReference is a typedef synonym of wsa__EndpointReferenceType */

#ifndef SOAP_TYPE__wsa__EndpointReference_DEFINED
#define SOAP_TYPE__wsa__EndpointReference_DEFINED

#define soap_default__wsa__EndpointReference soap_default_wsa__EndpointReferenceType

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsa__EndpointReferenceType(struct soap*, const struct wsa__EndpointReferenceType *);

#define soap_serialize__wsa__EndpointReference soap_serialize_wsa__EndpointReferenceType


#define soap__wsa__EndpointReference2s soap_wsa__EndpointReferenceType2s


#define soap_out__wsa__EndpointReference soap_out_wsa__EndpointReferenceType


#define soap_s2_wsa__EndpointReference soap_s2wsa__EndpointReferenceType


#define soap_in__wsa__EndpointReference soap_in_wsa__EndpointReferenceType


#define soap_instantiate__wsa__EndpointReference soap_instantiate_wsa__EndpointReferenceType


#define soap_new__wsa__EndpointReference soap_new_wsa__EndpointReferenceType


#define soap_new_req__wsa__EndpointReference soap_new_req_wsa__EndpointReferenceType


#define soap_new_set__wsa__EndpointReference soap_new_set_wsa__EndpointReferenceType

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsa__EndpointReference(struct soap*, const struct wsa__EndpointReferenceType *, const char*, const char*);

inline int soap_write__wsa__EndpointReference(struct soap *soap, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize__wsa__EndpointReference(soap, p), 0) || ::soap_put__wsa__EndpointReference(soap, p, "wsa:EndpointReference", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__wsa__EndpointReference(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__EndpointReference(soap, p), 0) || ::soap_put__wsa__EndpointReference(soap, p, "wsa:EndpointReference", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsa__EndpointReference(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__EndpointReference(soap, p), 0) || ::soap_put__wsa__EndpointReference(soap, p, "wsa:EndpointReference", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsa__EndpointReference(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize__wsa__EndpointReference(soap, p), 0) || ::soap_put__wsa__EndpointReference(soap, p, "wsa:EndpointReference", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsa__EndpointReference soap_get_wsa__EndpointReferenceType


#define soap_read__wsa__EndpointReference soap_read_wsa__EndpointReferenceType


#define soap_GET__wsa__EndpointReference soap_GET_wsa__EndpointReferenceType


#define soap_POST_recv__wsa__EndpointReference soap_POST_recv_wsa__EndpointReferenceType

#endif

#ifndef SOAP_TYPE_wsa__Relationship_DEFINED
#define SOAP_TYPE_wsa__Relationship_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsa__Relationship(struct soap*, struct wsa__Relationship *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsa__Relationship(struct soap*, const struct wsa__Relationship *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsa__Relationship(struct soap*, const char*, int, const struct wsa__Relationship *, const char*);
SOAP_FMAC3 struct wsa__Relationship * SOAP_FMAC4 soap_in_wsa__Relationship(struct soap*, const char*, struct wsa__Relationship *, const char*);
SOAP_FMAC1 struct wsa__Relationship * SOAP_FMAC2 soap_instantiate_wsa__Relationship(struct soap*, int, const char*, const char*, size_t*);

inline struct wsa__Relationship * soap_new_wsa__Relationship(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsa__Relationship(soap, n, NULL, NULL, NULL);
}

inline struct wsa__Relationship * soap_new_req_wsa__Relationship(
	struct soap *soap)
{
	struct wsa__Relationship *_p = ::soap_new_wsa__Relationship(soap);
	if (_p)
	{	::soap_default_wsa__Relationship(soap, _p);
	}
	return _p;
}

inline struct wsa__Relationship * soap_new_set_wsa__Relationship(
	struct soap *soap,
	char *__item,
	char *RelationshipType,
	char *__anyAttribute)
{
	struct wsa__Relationship *_p = ::soap_new_wsa__Relationship(soap);
	if (_p)
	{	::soap_default_wsa__Relationship(soap, _p);
		_p->__item = __item;
		_p->RelationshipType = RelationshipType;
		_p->__anyAttribute = __anyAttribute;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsa__Relationship(struct soap*, const struct wsa__Relationship *, const char*, const char*);

inline int soap_write_wsa__Relationship(struct soap *soap, struct wsa__Relationship const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsa__Relationship(soap, p), 0) || ::soap_put_wsa__Relationship(soap, p, "wsa:Relationship", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsa__Relationship(struct soap *soap, const char *URL, struct wsa__Relationship const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__Relationship(soap, p), 0) || ::soap_put_wsa__Relationship(soap, p, "wsa:Relationship", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsa__Relationship(struct soap *soap, const char *URL, struct wsa__Relationship const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__Relationship(soap, p), 0) || ::soap_put_wsa__Relationship(soap, p, "wsa:Relationship", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsa__Relationship(struct soap *soap, const char *URL, struct wsa__Relationship const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__Relationship(soap, p), 0) || ::soap_put_wsa__Relationship(soap, p, "wsa:Relationship", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsa__Relationship * SOAP_FMAC4 soap_get_wsa__Relationship(struct soap*, struct wsa__Relationship *, const char*, const char*);

inline int soap_read_wsa__Relationship(struct soap *soap, struct wsa__Relationship *p)
{
	if (p)
	{	::soap_default_wsa__Relationship(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsa__Relationship(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsa__Relationship(struct soap *soap, const char *URL, struct wsa__Relationship *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsa__Relationship(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsa__Relationship(struct soap *soap, struct wsa__Relationship *p)
{
	if (::soap_read_wsa__Relationship(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsa__ServiceNameType_DEFINED
#define SOAP_TYPE_wsa__ServiceNameType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsa__ServiceNameType(struct soap*, struct wsa__ServiceNameType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsa__ServiceNameType(struct soap*, const struct wsa__ServiceNameType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsa__ServiceNameType(struct soap*, const char*, int, const struct wsa__ServiceNameType *, const char*);
SOAP_FMAC3 struct wsa__ServiceNameType * SOAP_FMAC4 soap_in_wsa__ServiceNameType(struct soap*, const char*, struct wsa__ServiceNameType *, const char*);
SOAP_FMAC1 struct wsa__ServiceNameType * SOAP_FMAC2 soap_instantiate_wsa__ServiceNameType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsa__ServiceNameType * soap_new_wsa__ServiceNameType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsa__ServiceNameType(soap, n, NULL, NULL, NULL);
}

inline struct wsa__ServiceNameType * soap_new_req_wsa__ServiceNameType(
	struct soap *soap)
{
	struct wsa__ServiceNameType *_p = ::soap_new_wsa__ServiceNameType(soap);
	if (_p)
	{	::soap_default_wsa__ServiceNameType(soap, _p);
	}
	return _p;
}

inline struct wsa__ServiceNameType * soap_new_set_wsa__ServiceNameType(
	struct soap *soap,
	char *__item,
	char *PortName,
	char *__anyAttribute)
{
	struct wsa__ServiceNameType *_p = ::soap_new_wsa__ServiceNameType(soap);
	if (_p)
	{	::soap_default_wsa__ServiceNameType(soap, _p);
		_p->__item = __item;
		_p->PortName = PortName;
		_p->__anyAttribute = __anyAttribute;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsa__ServiceNameType(struct soap*, const struct wsa__ServiceNameType *, const char*, const char*);

inline int soap_write_wsa__ServiceNameType(struct soap *soap, struct wsa__ServiceNameType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsa__ServiceNameType(soap, p), 0) || ::soap_put_wsa__ServiceNameType(soap, p, "wsa:ServiceNameType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsa__ServiceNameType(struct soap *soap, const char *URL, struct wsa__ServiceNameType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__ServiceNameType(soap, p), 0) || ::soap_put_wsa__ServiceNameType(soap, p, "wsa:ServiceNameType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsa__ServiceNameType(struct soap *soap, const char *URL, struct wsa__ServiceNameType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__ServiceNameType(soap, p), 0) || ::soap_put_wsa__ServiceNameType(soap, p, "wsa:ServiceNameType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsa__ServiceNameType(struct soap *soap, const char *URL, struct wsa__ServiceNameType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__ServiceNameType(soap, p), 0) || ::soap_put_wsa__ServiceNameType(soap, p, "wsa:ServiceNameType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsa__ServiceNameType * SOAP_FMAC4 soap_get_wsa__ServiceNameType(struct soap*, struct wsa__ServiceNameType *, const char*, const char*);

inline int soap_read_wsa__ServiceNameType(struct soap *soap, struct wsa__ServiceNameType *p)
{
	if (p)
	{	::soap_default_wsa__ServiceNameType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsa__ServiceNameType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsa__ServiceNameType(struct soap *soap, const char *URL, struct wsa__ServiceNameType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsa__ServiceNameType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsa__ServiceNameType(struct soap *soap, struct wsa__ServiceNameType *p)
{
	if (::soap_read_wsa__ServiceNameType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsa__ReferenceParametersType_DEFINED
#define SOAP_TYPE_wsa__ReferenceParametersType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsa__ReferenceParametersType(struct soap*, struct wsa__ReferenceParametersType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsa__ReferenceParametersType(struct soap*, const struct wsa__ReferenceParametersType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsa__ReferenceParametersType(struct soap*, const char*, int, const struct wsa__ReferenceParametersType *, const char*);
SOAP_FMAC3 struct wsa__ReferenceParametersType * SOAP_FMAC4 soap_in_wsa__ReferenceParametersType(struct soap*, const char*, struct wsa__ReferenceParametersType *, const char*);
SOAP_FMAC1 struct wsa__ReferenceParametersType * SOAP_FMAC2 soap_instantiate_wsa__ReferenceParametersType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsa__ReferenceParametersType * soap_new_wsa__ReferenceParametersType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsa__ReferenceParametersType(soap, n, NULL, NULL, NULL);
}

inline struct wsa__ReferenceParametersType * soap_new_req_wsa__ReferenceParametersType(
	struct soap *soap,
	int __size,
	char **__any)
{
	struct wsa__ReferenceParametersType *_p = ::soap_new_wsa__ReferenceParametersType(soap);
	if (_p)
	{	::soap_default_wsa__ReferenceParametersType(soap, _p);
		_p->__size = __size;
		_p->__any = __any;
	}
	return _p;
}

inline struct wsa__ReferenceParametersType * soap_new_set_wsa__ReferenceParametersType(
	struct soap *soap,
	int __size,
	char **__any)
{
	struct wsa__ReferenceParametersType *_p = ::soap_new_wsa__ReferenceParametersType(soap);
	if (_p)
	{	::soap_default_wsa__ReferenceParametersType(soap, _p);
		_p->__size = __size;
		_p->__any = __any;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsa__ReferenceParametersType(struct soap*, const struct wsa__ReferenceParametersType *, const char*, const char*);

inline int soap_write_wsa__ReferenceParametersType(struct soap *soap, struct wsa__ReferenceParametersType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsa__ReferenceParametersType(soap, p), 0) || ::soap_put_wsa__ReferenceParametersType(soap, p, "wsa:ReferenceParametersType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsa__ReferenceParametersType(struct soap *soap, const char *URL, struct wsa__ReferenceParametersType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__ReferenceParametersType(soap, p), 0) || ::soap_put_wsa__ReferenceParametersType(soap, p, "wsa:ReferenceParametersType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsa__ReferenceParametersType(struct soap *soap, const char *URL, struct wsa__ReferenceParametersType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__ReferenceParametersType(soap, p), 0) || ::soap_put_wsa__ReferenceParametersType(soap, p, "wsa:ReferenceParametersType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsa__ReferenceParametersType(struct soap *soap, const char *URL, struct wsa__ReferenceParametersType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__ReferenceParametersType(soap, p), 0) || ::soap_put_wsa__ReferenceParametersType(soap, p, "wsa:ReferenceParametersType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsa__ReferenceParametersType * SOAP_FMAC4 soap_get_wsa__ReferenceParametersType(struct soap*, struct wsa__ReferenceParametersType *, const char*, const char*);

inline int soap_read_wsa__ReferenceParametersType(struct soap *soap, struct wsa__ReferenceParametersType *p)
{
	if (p)
	{	::soap_default_wsa__ReferenceParametersType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsa__ReferenceParametersType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsa__ReferenceParametersType(struct soap *soap, const char *URL, struct wsa__ReferenceParametersType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsa__ReferenceParametersType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsa__ReferenceParametersType(struct soap *soap, struct wsa__ReferenceParametersType *p)
{
	if (::soap_read_wsa__ReferenceParametersType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsa__ReferencePropertiesType_DEFINED
#define SOAP_TYPE_wsa__ReferencePropertiesType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsa__ReferencePropertiesType(struct soap*, struct wsa__ReferencePropertiesType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsa__ReferencePropertiesType(struct soap*, const struct wsa__ReferencePropertiesType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsa__ReferencePropertiesType(struct soap*, const char*, int, const struct wsa__ReferencePropertiesType *, const char*);
SOAP_FMAC3 struct wsa__ReferencePropertiesType * SOAP_FMAC4 soap_in_wsa__ReferencePropertiesType(struct soap*, const char*, struct wsa__ReferencePropertiesType *, const char*);
SOAP_FMAC1 struct wsa__ReferencePropertiesType * SOAP_FMAC2 soap_instantiate_wsa__ReferencePropertiesType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsa__ReferencePropertiesType * soap_new_wsa__ReferencePropertiesType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsa__ReferencePropertiesType(soap, n, NULL, NULL, NULL);
}

inline struct wsa__ReferencePropertiesType * soap_new_req_wsa__ReferencePropertiesType(
	struct soap *soap,
	int __size,
	char **__any)
{
	struct wsa__ReferencePropertiesType *_p = ::soap_new_wsa__ReferencePropertiesType(soap);
	if (_p)
	{	::soap_default_wsa__ReferencePropertiesType(soap, _p);
		_p->__size = __size;
		_p->__any = __any;
	}
	return _p;
}

inline struct wsa__ReferencePropertiesType * soap_new_set_wsa__ReferencePropertiesType(
	struct soap *soap,
	int __size,
	char **__any)
{
	struct wsa__ReferencePropertiesType *_p = ::soap_new_wsa__ReferencePropertiesType(soap);
	if (_p)
	{	::soap_default_wsa__ReferencePropertiesType(soap, _p);
		_p->__size = __size;
		_p->__any = __any;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsa__ReferencePropertiesType(struct soap*, const struct wsa__ReferencePropertiesType *, const char*, const char*);

inline int soap_write_wsa__ReferencePropertiesType(struct soap *soap, struct wsa__ReferencePropertiesType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsa__ReferencePropertiesType(soap, p), 0) || ::soap_put_wsa__ReferencePropertiesType(soap, p, "wsa:ReferencePropertiesType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsa__ReferencePropertiesType(struct soap *soap, const char *URL, struct wsa__ReferencePropertiesType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__ReferencePropertiesType(soap, p), 0) || ::soap_put_wsa__ReferencePropertiesType(soap, p, "wsa:ReferencePropertiesType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsa__ReferencePropertiesType(struct soap *soap, const char *URL, struct wsa__ReferencePropertiesType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__ReferencePropertiesType(soap, p), 0) || ::soap_put_wsa__ReferencePropertiesType(soap, p, "wsa:ReferencePropertiesType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsa__ReferencePropertiesType(struct soap *soap, const char *URL, struct wsa__ReferencePropertiesType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__ReferencePropertiesType(soap, p), 0) || ::soap_put_wsa__ReferencePropertiesType(soap, p, "wsa:ReferencePropertiesType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsa__ReferencePropertiesType * SOAP_FMAC4 soap_get_wsa__ReferencePropertiesType(struct soap*, struct wsa__ReferencePropertiesType *, const char*, const char*);

inline int soap_read_wsa__ReferencePropertiesType(struct soap *soap, struct wsa__ReferencePropertiesType *p)
{
	if (p)
	{	::soap_default_wsa__ReferencePropertiesType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsa__ReferencePropertiesType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsa__ReferencePropertiesType(struct soap *soap, const char *URL, struct wsa__ReferencePropertiesType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsa__ReferencePropertiesType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsa__ReferencePropertiesType(struct soap *soap, struct wsa__ReferencePropertiesType *p)
{
	if (::soap_read_wsa__ReferencePropertiesType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsa__EndpointReferenceType_DEFINED
#define SOAP_TYPE_wsa__EndpointReferenceType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_wsa__EndpointReferenceType(struct soap*, struct wsa__EndpointReferenceType *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsa__EndpointReferenceType(struct soap*, const struct wsa__EndpointReferenceType *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsa__EndpointReferenceType(struct soap*, const char*, int, const struct wsa__EndpointReferenceType *, const char*);
SOAP_FMAC3 struct wsa__EndpointReferenceType * SOAP_FMAC4 soap_in_wsa__EndpointReferenceType(struct soap*, const char*, struct wsa__EndpointReferenceType *, const char*);
SOAP_FMAC1 struct wsa__EndpointReferenceType * SOAP_FMAC2 soap_instantiate_wsa__EndpointReferenceType(struct soap*, int, const char*, const char*, size_t*);

inline struct wsa__EndpointReferenceType * soap_new_wsa__EndpointReferenceType(struct soap *soap, int n = -1)
{
	return soap_instantiate_wsa__EndpointReferenceType(soap, n, NULL, NULL, NULL);
}

inline struct wsa__EndpointReferenceType * soap_new_req_wsa__EndpointReferenceType(
	struct soap *soap,
	char *Address,
	int __size,
	char **__any)
{
	struct wsa__EndpointReferenceType *_p = ::soap_new_wsa__EndpointReferenceType(soap);
	if (_p)
	{	::soap_default_wsa__EndpointReferenceType(soap, _p);
		_p->Address = Address;
		_p->__size = __size;
		_p->__any = __any;
	}
	return _p;
}

inline struct wsa__EndpointReferenceType * soap_new_set_wsa__EndpointReferenceType(
	struct soap *soap,
	char *Address,
	struct wsa__ReferencePropertiesType *ReferenceProperties,
	struct wsa__ReferenceParametersType *ReferenceParameters,
	char **PortType,
	struct wsa__ServiceNameType *ServiceName,
	int __size,
	char **__any,
	char *__anyAttribute)
{
	struct wsa__EndpointReferenceType *_p = ::soap_new_wsa__EndpointReferenceType(soap);
	if (_p)
	{	::soap_default_wsa__EndpointReferenceType(soap, _p);
		_p->Address = Address;
		_p->ReferenceProperties = ReferenceProperties;
		_p->ReferenceParameters = ReferenceParameters;
		_p->PortType = PortType;
		_p->ServiceName = ServiceName;
		_p->__size = __size;
		_p->__any = __any;
		_p->__anyAttribute = __anyAttribute;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsa__EndpointReferenceType(struct soap*, const struct wsa__EndpointReferenceType *, const char*, const char*);

inline int soap_write_wsa__EndpointReferenceType(struct soap *soap, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize_wsa__EndpointReferenceType(soap, p), 0) || ::soap_put_wsa__EndpointReferenceType(soap, p, "wsa:EndpointReferenceType", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_wsa__EndpointReferenceType(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__EndpointReferenceType(soap, p), 0) || ::soap_put_wsa__EndpointReferenceType(soap, p, "wsa:EndpointReferenceType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsa__EndpointReferenceType(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__EndpointReferenceType(soap, p), 0) || ::soap_put_wsa__EndpointReferenceType(soap, p, "wsa:EndpointReferenceType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsa__EndpointReferenceType(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize_wsa__EndpointReferenceType(soap, p), 0) || ::soap_put_wsa__EndpointReferenceType(soap, p, "wsa:EndpointReferenceType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct wsa__EndpointReferenceType * SOAP_FMAC4 soap_get_wsa__EndpointReferenceType(struct soap*, struct wsa__EndpointReferenceType *, const char*, const char*);

inline int soap_read_wsa__EndpointReferenceType(struct soap *soap, struct wsa__EndpointReferenceType *p)
{
	if (p)
	{	::soap_default_wsa__EndpointReferenceType(soap, p);
		if (soap_begin_recv(soap) || ::soap_get_wsa__EndpointReferenceType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsa__EndpointReferenceType(struct soap *soap, const char *URL, struct wsa__EndpointReferenceType *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsa__EndpointReferenceType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsa__EndpointReferenceType(struct soap *soap, struct wsa__EndpointReferenceType *p)
{
	if (::soap_read_wsa__EndpointReferenceType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_PointerTowsdd__ResolveMatchesType_DEFINED
#define SOAP_TYPE_PointerTowsdd__ResolveMatchesType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowsdd__ResolveMatchesType(struct soap*, struct wsdd__ResolveMatchesType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowsdd__ResolveMatchesType(struct soap*, const char *, int, struct wsdd__ResolveMatchesType *const*, const char *);
SOAP_FMAC3 struct wsdd__ResolveMatchesType ** SOAP_FMAC4 soap_in_PointerTowsdd__ResolveMatchesType(struct soap*, const char*, struct wsdd__ResolveMatchesType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowsdd__ResolveMatchesType(struct soap*, struct wsdd__ResolveMatchesType *const*, const char*, const char*);
SOAP_FMAC3 struct wsdd__ResolveMatchesType ** SOAP_FMAC4 soap_get_PointerTowsdd__ResolveMatchesType(struct soap*, struct wsdd__ResolveMatchesType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTowsdd__ResolveType_DEFINED
#define SOAP_TYPE_PointerTowsdd__ResolveType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowsdd__ResolveType(struct soap*, struct wsdd__ResolveType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowsdd__ResolveType(struct soap*, const char *, int, struct wsdd__ResolveType *const*, const char *);
SOAP_FMAC3 struct wsdd__ResolveType ** SOAP_FMAC4 soap_in_PointerTowsdd__ResolveType(struct soap*, const char*, struct wsdd__ResolveType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowsdd__ResolveType(struct soap*, struct wsdd__ResolveType *const*, const char*, const char*);
SOAP_FMAC3 struct wsdd__ResolveType ** SOAP_FMAC4 soap_get_PointerTowsdd__ResolveType(struct soap*, struct wsdd__ResolveType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTowsdd__ProbeMatchesType_DEFINED
#define SOAP_TYPE_PointerTowsdd__ProbeMatchesType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowsdd__ProbeMatchesType(struct soap*, struct wsdd__ProbeMatchesType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowsdd__ProbeMatchesType(struct soap*, const char *, int, struct wsdd__ProbeMatchesType *const*, const char *);
SOAP_FMAC3 struct wsdd__ProbeMatchesType ** SOAP_FMAC4 soap_in_PointerTowsdd__ProbeMatchesType(struct soap*, const char*, struct wsdd__ProbeMatchesType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowsdd__ProbeMatchesType(struct soap*, struct wsdd__ProbeMatchesType *const*, const char*, const char*);
SOAP_FMAC3 struct wsdd__ProbeMatchesType ** SOAP_FMAC4 soap_get_PointerTowsdd__ProbeMatchesType(struct soap*, struct wsdd__ProbeMatchesType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTowsdd__ProbeType_DEFINED
#define SOAP_TYPE_PointerTowsdd__ProbeType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowsdd__ProbeType(struct soap*, struct wsdd__ProbeType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowsdd__ProbeType(struct soap*, const char *, int, struct wsdd__ProbeType *const*, const char *);
SOAP_FMAC3 struct wsdd__ProbeType ** SOAP_FMAC4 soap_in_PointerTowsdd__ProbeType(struct soap*, const char*, struct wsdd__ProbeType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowsdd__ProbeType(struct soap*, struct wsdd__ProbeType *const*, const char*, const char*);
SOAP_FMAC3 struct wsdd__ProbeType ** SOAP_FMAC4 soap_get_PointerTowsdd__ProbeType(struct soap*, struct wsdd__ProbeType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTowsdd__ByeType_DEFINED
#define SOAP_TYPE_PointerTowsdd__ByeType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowsdd__ByeType(struct soap*, struct wsdd__ByeType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowsdd__ByeType(struct soap*, const char *, int, struct wsdd__ByeType *const*, const char *);
SOAP_FMAC3 struct wsdd__ByeType ** SOAP_FMAC4 soap_in_PointerTowsdd__ByeType(struct soap*, const char*, struct wsdd__ByeType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowsdd__ByeType(struct soap*, struct wsdd__ByeType *const*, const char*, const char*);
SOAP_FMAC3 struct wsdd__ByeType ** SOAP_FMAC4 soap_get_PointerTowsdd__ByeType(struct soap*, struct wsdd__ByeType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTowsdd__HelloType_DEFINED
#define SOAP_TYPE_PointerTowsdd__HelloType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowsdd__HelloType(struct soap*, struct wsdd__HelloType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowsdd__HelloType(struct soap*, const char *, int, struct wsdd__HelloType *const*, const char *);
SOAP_FMAC3 struct wsdd__HelloType ** SOAP_FMAC4 soap_in_PointerTowsdd__HelloType(struct soap*, const char*, struct wsdd__HelloType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowsdd__HelloType(struct soap*, struct wsdd__HelloType *const*, const char*, const char*);
SOAP_FMAC3 struct wsdd__HelloType ** SOAP_FMAC4 soap_get_PointerTowsdd__HelloType(struct soap*, struct wsdd__HelloType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTowsdd__AppSequenceType_DEFINED
#define SOAP_TYPE_PointerTowsdd__AppSequenceType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowsdd__AppSequenceType(struct soap*, struct wsdd__AppSequenceType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowsdd__AppSequenceType(struct soap*, const char *, int, struct wsdd__AppSequenceType *const*, const char *);
SOAP_FMAC3 struct wsdd__AppSequenceType ** SOAP_FMAC4 soap_in_PointerTowsdd__AppSequenceType(struct soap*, const char*, struct wsdd__AppSequenceType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowsdd__AppSequenceType(struct soap*, struct wsdd__AppSequenceType *const*, const char*, const char*);
SOAP_FMAC3 struct wsdd__AppSequenceType ** SOAP_FMAC4 soap_get_PointerTowsdd__AppSequenceType(struct soap*, struct wsdd__AppSequenceType **, const char*, const char*);
#endif
/* _wsdd__Id is a typedef synonym of string */

#ifndef SOAP_TYPE__wsdd__Id_DEFINED
#define SOAP_TYPE__wsdd__Id_DEFINED

#define soap_default__wsdd__Id soap_default_string


#define soap_serialize__wsdd__Id soap_serialize_string


#define soap__wsdd__Id2s(soap, a) (a)

#define soap_out__wsdd__Id soap_out_string


#define soap_s2_wsdd__Id(soap, s, a) soap_s2char((soap), (s), (char**)(a), 1, 0, -1, NULL)

#define soap_in__wsdd__Id soap_in_string


#define soap_instantiate__wsdd__Id soap_instantiate_string


#define soap_new__wsdd__Id soap_new_string

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsdd__Id(struct soap*, char *const*, const char*, const char*);

inline int soap_write__wsdd__Id(struct soap *soap, char *const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put__wsdd__Id(soap, p, "wsdd:Id", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT__wsdd__Id(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsdd__Id(soap, p, "wsdd:Id", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsdd__Id(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsdd__Id(soap, p, "wsdd:Id", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsdd__Id(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsdd__Id(soap, p, "wsdd:Id", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsdd__Id soap_get_string


#define soap_read__wsdd__Id soap_read_string


#define soap_GET__wsdd__Id soap_GET_string


#define soap_POST_recv__wsdd__Id soap_POST_recv_string

#endif
/* _wsdd__SupportedMatchingRules is a typedef synonym of wsdd__UriListType */

#ifndef SOAP_TYPE__wsdd__SupportedMatchingRules_DEFINED
#define SOAP_TYPE__wsdd__SupportedMatchingRules_DEFINED

#define soap_default__wsdd__SupportedMatchingRules soap_default_wsdd__UriListType


#define soap_serialize__wsdd__SupportedMatchingRules soap_serialize_wsdd__UriListType


#define soap__wsdd__SupportedMatchingRules2s(soap, a) (a)

#define soap_out__wsdd__SupportedMatchingRules soap_out_wsdd__UriListType


#define soap_s2_wsdd__SupportedMatchingRules(soap, s, a) soap_s2char((soap), (s), (char**)(a), 1, 0, -1, NULL)

#define soap_in__wsdd__SupportedMatchingRules soap_in_wsdd__UriListType


#define soap_instantiate__wsdd__SupportedMatchingRules soap_instantiate_wsdd__UriListType


#define soap_new__wsdd__SupportedMatchingRules soap_new_wsdd__UriListType


#define soap_put__wsdd__SupportedMatchingRules soap_put_wsdd__UriListType


#define soap_write__wsdd__SupportedMatchingRules soap_write_wsdd__UriListType


#define soap_PUT__wsdd__SupportedMatchingRules soap_PUT_wsdd__UriListType


#define soap_PATCH__wsdd__SupportedMatchingRules soap_PATCH_wsdd__UriListType


#define soap_POST_send__wsdd__SupportedMatchingRules soap_POST_send_wsdd__UriListType


#define soap_get__wsdd__SupportedMatchingRules soap_get_wsdd__UriListType


#define soap_read__wsdd__SupportedMatchingRules soap_read_wsdd__UriListType


#define soap_GET__wsdd__SupportedMatchingRules soap_GET_wsdd__UriListType


#define soap_POST_recv__wsdd__SupportedMatchingRules soap_POST_recv_wsdd__UriListType

#endif
/* _wsdd__XAddrs is a typedef synonym of wsdd__UriListType */

#ifndef SOAP_TYPE__wsdd__XAddrs_DEFINED
#define SOAP_TYPE__wsdd__XAddrs_DEFINED

#define soap_default__wsdd__XAddrs soap_default_wsdd__UriListType


#define soap_serialize__wsdd__XAddrs soap_serialize_wsdd__UriListType


#define soap__wsdd__XAddrs2s(soap, a) (a)

#define soap_out__wsdd__XAddrs soap_out_wsdd__UriListType


#define soap_s2_wsdd__XAddrs(soap, s, a) soap_s2char((soap), (s), (char**)(a), 1, 0, -1, NULL)

#define soap_in__wsdd__XAddrs soap_in_wsdd__UriListType


#define soap_instantiate__wsdd__XAddrs soap_instantiate_wsdd__UriListType


#define soap_new__wsdd__XAddrs soap_new_wsdd__UriListType


#define soap_put__wsdd__XAddrs soap_put_wsdd__UriListType


#define soap_write__wsdd__XAddrs soap_write_wsdd__UriListType


#define soap_PUT__wsdd__XAddrs soap_PUT_wsdd__UriListType


#define soap_PATCH__wsdd__XAddrs soap_PATCH_wsdd__UriListType


#define soap_POST_send__wsdd__XAddrs soap_POST_send_wsdd__UriListType


#define soap_get__wsdd__XAddrs soap_get_wsdd__UriListType


#define soap_read__wsdd__XAddrs soap_read_wsdd__UriListType


#define soap_GET__wsdd__XAddrs soap_GET_wsdd__UriListType


#define soap_POST_recv__wsdd__XAddrs soap_POST_recv_wsdd__UriListType

#endif
/* _wsdd__Types is a typedef synonym of wsdd__QNameListType */

#ifndef SOAP_TYPE__wsdd__Types_DEFINED
#define SOAP_TYPE__wsdd__Types_DEFINED

#define soap_default__wsdd__Types soap_default_wsdd__QNameListType


#define soap_serialize__wsdd__Types soap_serialize_wsdd__QNameListType


#define soap__wsdd__Types2s(soap, a) soap_QName2s(soap, (a))

#define soap_out__wsdd__Types soap_out_wsdd__QNameListType


#define soap_s2_wsdd__Types(soap, s, a) soap_s2QName((soap), (s), (char**)(a), 0, -1, NULL)

#define soap_in__wsdd__Types soap_in_wsdd__QNameListType


#define soap_instantiate__wsdd__Types soap_instantiate_wsdd__QNameListType


#define soap_new__wsdd__Types soap_new_wsdd__QNameListType


#define soap_put__wsdd__Types soap_put_wsdd__QNameListType


#define soap_write__wsdd__Types soap_write_wsdd__QNameListType


#define soap_PUT__wsdd__Types soap_PUT_wsdd__QNameListType


#define soap_PATCH__wsdd__Types soap_PATCH_wsdd__QNameListType


#define soap_POST_send__wsdd__Types soap_POST_send_wsdd__QNameListType


#define soap_get__wsdd__Types soap_get_wsdd__QNameListType


#define soap_read__wsdd__Types soap_read_wsdd__QNameListType


#define soap_GET__wsdd__Types soap_GET_wsdd__QNameListType


#define soap_POST_recv__wsdd__Types soap_POST_recv_wsdd__QNameListType

#endif

#ifndef SOAP_TYPE_PointerTowsdd__SigType_DEFINED
#define SOAP_TYPE_PointerTowsdd__SigType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowsdd__SigType(struct soap*, struct wsdd__SigType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowsdd__SigType(struct soap*, const char *, int, struct wsdd__SigType *const*, const char *);
SOAP_FMAC3 struct wsdd__SigType ** SOAP_FMAC4 soap_in_PointerTowsdd__SigType(struct soap*, const char*, struct wsdd__SigType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowsdd__SigType(struct soap*, struct wsdd__SigType *const*, const char*, const char*);
SOAP_FMAC3 struct wsdd__SigType ** SOAP_FMAC4 soap_get_PointerTowsdd__SigType(struct soap*, struct wsdd__SigType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTowsdd__ResolveMatchType_DEFINED
#define SOAP_TYPE_PointerTowsdd__ResolveMatchType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowsdd__ResolveMatchType(struct soap*, struct wsdd__ResolveMatchType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowsdd__ResolveMatchType(struct soap*, const char *, int, struct wsdd__ResolveMatchType *const*, const char *);
SOAP_FMAC3 struct wsdd__ResolveMatchType ** SOAP_FMAC4 soap_in_PointerTowsdd__ResolveMatchType(struct soap*, const char*, struct wsdd__ResolveMatchType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowsdd__ResolveMatchType(struct soap*, struct wsdd__ResolveMatchType *const*, const char*, const char*);
SOAP_FMAC3 struct wsdd__ResolveMatchType ** SOAP_FMAC4 soap_get_PointerTowsdd__ResolveMatchType(struct soap*, struct wsdd__ResolveMatchType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTowsdd__ProbeMatchType_DEFINED
#define SOAP_TYPE_PointerTowsdd__ProbeMatchType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowsdd__ProbeMatchType(struct soap*, struct wsdd__ProbeMatchType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowsdd__ProbeMatchType(struct soap*, const char *, int, struct wsdd__ProbeMatchType *const*, const char *);
SOAP_FMAC3 struct wsdd__ProbeMatchType ** SOAP_FMAC4 soap_in_PointerTowsdd__ProbeMatchType(struct soap*, const char*, struct wsdd__ProbeMatchType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowsdd__ProbeMatchType(struct soap*, struct wsdd__ProbeMatchType *const*, const char*, const char*);
SOAP_FMAC3 struct wsdd__ProbeMatchType ** SOAP_FMAC4 soap_get_PointerTowsdd__ProbeMatchType(struct soap*, struct wsdd__ProbeMatchType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTounsignedInt_DEFINED
#define SOAP_TYPE_PointerTounsignedInt_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTounsignedInt(struct soap*, unsigned int *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTounsignedInt(struct soap*, const char *, int, unsigned int *const*, const char *);
SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_in_PointerTounsignedInt(struct soap*, const char*, unsigned int **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTounsignedInt(struct soap*, unsigned int *const*, const char*, const char*);
SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_get_PointerTounsignedInt(struct soap*, unsigned int **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTowsdd__ScopesType_DEFINED
#define SOAP_TYPE_PointerTowsdd__ScopesType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowsdd__ScopesType(struct soap*, struct wsdd__ScopesType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowsdd__ScopesType(struct soap*, const char *, int, struct wsdd__ScopesType *const*, const char *);
SOAP_FMAC3 struct wsdd__ScopesType ** SOAP_FMAC4 soap_in_PointerTowsdd__ScopesType(struct soap*, const char*, struct wsdd__ScopesType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowsdd__ScopesType(struct soap*, struct wsdd__ScopesType *const*, const char*, const char*);
SOAP_FMAC3 struct wsdd__ScopesType ** SOAP_FMAC4 soap_get_PointerTowsdd__ScopesType(struct soap*, struct wsdd__ScopesType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_wsdd__FaultCodeOpenType_DEFINED
#define SOAP_TYPE_wsdd__FaultCodeOpenType_DEFINED

inline void soap_default_wsdd__FaultCodeOpenType(struct soap *soap, char **a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_wsdd__FaultCodeOpenType
	*a = SOAP_DEFAULT_wsdd__FaultCodeOpenType;
#else
	*a = (char *)0;
#endif
}
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__FaultCodeOpenType(struct soap*, char *const*);

#define soap_wsdd__FaultCodeOpenType2s(soap, a) (a)
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__FaultCodeOpenType(struct soap*, const char*, int, char*const*, const char*);

#define soap_s2wsdd__FaultCodeOpenType(soap, s, a) soap_s2char((soap), (s), (char**)(a), 1, 0, -1, NULL)
SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_wsdd__FaultCodeOpenType(struct soap*, const char*, char **, const char*);

#define soap_instantiate_wsdd__FaultCodeOpenType soap_instantiate_string


#define soap_new_wsdd__FaultCodeOpenType soap_new_string

SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__FaultCodeOpenType(struct soap*, char *const*, const char*, const char*);

inline int soap_write_wsdd__FaultCodeOpenType(struct soap *soap, char *const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put_wsdd__FaultCodeOpenType(soap, p, "wsdd:FaultCodeOpenType", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT_wsdd__FaultCodeOpenType(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsdd__FaultCodeOpenType(soap, p, "wsdd:FaultCodeOpenType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__FaultCodeOpenType(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsdd__FaultCodeOpenType(soap, p, "wsdd:FaultCodeOpenType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__FaultCodeOpenType(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsdd__FaultCodeOpenType(soap, p, "wsdd:FaultCodeOpenType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_wsdd__FaultCodeOpenType(struct soap*, char **, const char*, const char*);

inline int soap_read_wsdd__FaultCodeOpenType(struct soap *soap, char **p)
{
	if (p)
	{	if (soap_begin_recv(soap) || ::soap_get_wsdd__FaultCodeOpenType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__FaultCodeOpenType(struct soap *soap, const char *URL, char **p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__FaultCodeOpenType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__FaultCodeOpenType(struct soap *soap, char **p)
{
	if (::soap_read_wsdd__FaultCodeOpenType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE_wsdd__UriListType_DEFINED
#define SOAP_TYPE_wsdd__UriListType_DEFINED

inline void soap_default_wsdd__UriListType(struct soap *soap, char **a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_wsdd__UriListType
	*a = SOAP_DEFAULT_wsdd__UriListType;
#else
	*a = (char *)0;
#endif
}
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wsdd__UriListType(struct soap*, char *const*);

#define soap_wsdd__UriListType2s(soap, a) (a)
SOAP_FMAC3 int SOAP_FMAC4 soap_out_wsdd__UriListType(struct soap*, const char*, int, char*const*, const char*);

#define soap_s2wsdd__UriListType(soap, s, a) soap_s2char((soap), (s), (char**)(a), 1, 0, -1, NULL)
SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_wsdd__UriListType(struct soap*, const char*, char **, const char*);

#define soap_instantiate_wsdd__UriListType soap_instantiate_string


#define soap_new_wsdd__UriListType soap_new_string

SOAP_FMAC3 int SOAP_FMAC4 soap_put_wsdd__UriListType(struct soap*, char *const*, const char*, const char*);

inline int soap_write_wsdd__UriListType(struct soap *soap, char *const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put_wsdd__UriListType(soap, p, "wsdd:UriListType", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT_wsdd__UriListType(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsdd__UriListType(soap, p, "wsdd:UriListType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_wsdd__UriListType(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsdd__UriListType(soap, p, "wsdd:UriListType", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_wsdd__UriListType(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_wsdd__UriListType(soap, p, "wsdd:UriListType", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_wsdd__UriListType(struct soap*, char **, const char*, const char*);

inline int soap_read_wsdd__UriListType(struct soap *soap, char **p)
{
	if (p)
	{	if (soap_begin_recv(soap) || ::soap_get_wsdd__UriListType(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_wsdd__UriListType(struct soap *soap, const char *URL, char **p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_wsdd__UriListType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_wsdd__UriListType(struct soap *soap, char **p)
{
	if (::soap_read_wsdd__UriListType(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif
/* wsdd__QNameListType is a typedef synonym of _QName */

#ifndef SOAP_TYPE_wsdd__QNameListType_DEFINED
#define SOAP_TYPE_wsdd__QNameListType_DEFINED

#define soap_default_wsdd__QNameListType soap_default__QName


#define soap_serialize_wsdd__QNameListType soap_serialize__QName


#define soap_wsdd__QNameListType2s(soap, a) soap_QName2s(soap, (a))

#define soap_out_wsdd__QNameListType soap_out__QName


#define soap_s2wsdd__QNameListType(soap, s, a) soap_s2QName((soap), (s), (char**)(a), 0, -1, NULL)

#define soap_in_wsdd__QNameListType soap_in__QName


#define soap_instantiate_wsdd__QNameListType soap_instantiate__QName


#define soap_new_wsdd__QNameListType soap_new__QName


#define soap_put_wsdd__QNameListType soap_put__QName


#define soap_write_wsdd__QNameListType soap_write__QName


#define soap_PUT_wsdd__QNameListType soap_PUT__QName


#define soap_PATCH_wsdd__QNameListType soap_PATCH__QName


#define soap_POST_send_wsdd__QNameListType soap_POST_send__QName


#define soap_get_wsdd__QNameListType soap_get__QName


#define soap_read_wsdd__QNameListType soap_read__QName


#define soap_GET_wsdd__QNameListType soap_GET__QName


#define soap_POST_recv_wsdd__QNameListType soap_POST_recv__QName

#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_PointerToSOAP_ENV__Reason_DEFINED
#define SOAP_TYPE_PointerToSOAP_ENV__Reason_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Reason(struct soap*, const char *, int, struct SOAP_ENV__Reason *const*, const char *);
SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Reason(struct soap*, const char*, struct SOAP_ENV__Reason **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *const*, const char*, const char*);
SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason **, const char*, const char*);
#endif

#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_PointerToSOAP_ENV__Code_DEFINED
#define SOAP_TYPE_PointerToSOAP_ENV__Code_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Code(struct soap*, const char *, int, struct SOAP_ENV__Code *const*, const char *);
SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Code(struct soap*, const char*, struct SOAP_ENV__Code **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *const*, const char*, const char*);
SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code **, const char*, const char*);
#endif

#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_PointerToSOAP_ENV__Detail_DEFINED
#define SOAP_TYPE_PointerToSOAP_ENV__Detail_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Detail(struct soap*, const char *, int, struct SOAP_ENV__Detail *const*, const char *);
SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Detail(struct soap*, const char*, struct SOAP_ENV__Detail **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *const*, const char*, const char*);
SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail **, const char*, const char*);
#endif

#endif

#ifndef SOAP_TYPE_PointerTo_wsa__FaultTo_DEFINED
#define SOAP_TYPE_PointerTo_wsa__FaultTo_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wsa__FaultTo(struct soap*, struct wsa__EndpointReferenceType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wsa__FaultTo(struct soap*, const char *, int, struct wsa__EndpointReferenceType *const*, const char *);
SOAP_FMAC3 struct wsa__EndpointReferenceType ** SOAP_FMAC4 soap_in_PointerTo_wsa__FaultTo(struct soap*, const char*, struct wsa__EndpointReferenceType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wsa__FaultTo(struct soap*, struct wsa__EndpointReferenceType *const*, const char*, const char*);
SOAP_FMAC3 struct wsa__EndpointReferenceType ** SOAP_FMAC4 soap_get_PointerTo_wsa__FaultTo(struct soap*, struct wsa__EndpointReferenceType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_wsa__ReplyTo_DEFINED
#define SOAP_TYPE_PointerTo_wsa__ReplyTo_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wsa__ReplyTo(struct soap*, struct wsa__EndpointReferenceType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wsa__ReplyTo(struct soap*, const char *, int, struct wsa__EndpointReferenceType *const*, const char *);
SOAP_FMAC3 struct wsa__EndpointReferenceType ** SOAP_FMAC4 soap_in_PointerTo_wsa__ReplyTo(struct soap*, const char*, struct wsa__EndpointReferenceType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wsa__ReplyTo(struct soap*, struct wsa__EndpointReferenceType *const*, const char*, const char*);
SOAP_FMAC3 struct wsa__EndpointReferenceType ** SOAP_FMAC4 soap_get_PointerTo_wsa__ReplyTo(struct soap*, struct wsa__EndpointReferenceType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_wsa__From_DEFINED
#define SOAP_TYPE_PointerTo_wsa__From_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wsa__From(struct soap*, struct wsa__EndpointReferenceType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wsa__From(struct soap*, const char *, int, struct wsa__EndpointReferenceType *const*, const char *);
SOAP_FMAC3 struct wsa__EndpointReferenceType ** SOAP_FMAC4 soap_in_PointerTo_wsa__From(struct soap*, const char*, struct wsa__EndpointReferenceType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wsa__From(struct soap*, struct wsa__EndpointReferenceType *const*, const char*, const char*);
SOAP_FMAC3 struct wsa__EndpointReferenceType ** SOAP_FMAC4 soap_get_PointerTo_wsa__From(struct soap*, struct wsa__EndpointReferenceType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_wsa__RelatesTo_DEFINED
#define SOAP_TYPE_PointerTo_wsa__RelatesTo_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wsa__RelatesTo(struct soap*, struct wsa__Relationship *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wsa__RelatesTo(struct soap*, const char *, int, struct wsa__Relationship *const*, const char *);
SOAP_FMAC3 struct wsa__Relationship ** SOAP_FMAC4 soap_in_PointerTo_wsa__RelatesTo(struct soap*, const char*, struct wsa__Relationship **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wsa__RelatesTo(struct soap*, struct wsa__Relationship *const*, const char*, const char*);
SOAP_FMAC3 struct wsa__Relationship ** SOAP_FMAC4 soap_get_PointerTo_wsa__RelatesTo(struct soap*, struct wsa__Relationship **, const char*, const char*);
#endif
/* _wsa__Action is a typedef synonym of string */

#ifndef SOAP_TYPE__wsa__Action_DEFINED
#define SOAP_TYPE__wsa__Action_DEFINED

#define soap_default__wsa__Action soap_default_string


#define soap_serialize__wsa__Action soap_serialize_string


#define soap__wsa__Action2s(soap, a) (a)

#define soap_out__wsa__Action soap_out_string


#define soap_s2_wsa__Action(soap, s, a) soap_s2char((soap), (s), (char**)(a), 1, 0, -1, NULL)

#define soap_in__wsa__Action soap_in_string


#define soap_instantiate__wsa__Action soap_instantiate_string


#define soap_new__wsa__Action soap_new_string

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsa__Action(struct soap*, char *const*, const char*, const char*);

inline int soap_write__wsa__Action(struct soap *soap, char *const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put__wsa__Action(soap, p, "wsa:Action", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT__wsa__Action(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsa__Action(soap, p, "wsa:Action", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsa__Action(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsa__Action(soap, p, "wsa:Action", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsa__Action(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsa__Action(soap, p, "wsa:Action", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsa__Action soap_get_string


#define soap_read__wsa__Action soap_read_string


#define soap_GET__wsa__Action soap_GET_string


#define soap_POST_recv__wsa__Action soap_POST_recv_string

#endif
/* _wsa__To is a typedef synonym of string */

#ifndef SOAP_TYPE__wsa__To_DEFINED
#define SOAP_TYPE__wsa__To_DEFINED

#define soap_default__wsa__To soap_default_string


#define soap_serialize__wsa__To soap_serialize_string


#define soap__wsa__To2s(soap, a) (a)

#define soap_out__wsa__To soap_out_string


#define soap_s2_wsa__To(soap, s, a) soap_s2char((soap), (s), (char**)(a), 1, 0, -1, NULL)

#define soap_in__wsa__To soap_in_string


#define soap_instantiate__wsa__To soap_instantiate_string


#define soap_new__wsa__To soap_new_string

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsa__To(struct soap*, char *const*, const char*, const char*);

inline int soap_write__wsa__To(struct soap *soap, char *const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put__wsa__To(soap, p, "wsa:To", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT__wsa__To(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsa__To(soap, p, "wsa:To", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsa__To(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsa__To(soap, p, "wsa:To", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsa__To(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsa__To(soap, p, "wsa:To", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsa__To soap_get_string


#define soap_read__wsa__To soap_read_string


#define soap_GET__wsa__To soap_GET_string


#define soap_POST_recv__wsa__To soap_POST_recv_string

#endif
/* _wsa__MessageID is a typedef synonym of string */

#ifndef SOAP_TYPE__wsa__MessageID_DEFINED
#define SOAP_TYPE__wsa__MessageID_DEFINED

#define soap_default__wsa__MessageID soap_default_string


#define soap_serialize__wsa__MessageID soap_serialize_string


#define soap__wsa__MessageID2s(soap, a) (a)

#define soap_out__wsa__MessageID soap_out_string


#define soap_s2_wsa__MessageID(soap, s, a) soap_s2char((soap), (s), (char**)(a), 1, 0, -1, NULL)

#define soap_in__wsa__MessageID soap_in_string


#define soap_instantiate__wsa__MessageID soap_instantiate_string


#define soap_new__wsa__MessageID soap_new_string

SOAP_FMAC3 int SOAP_FMAC4 soap_put__wsa__MessageID(struct soap*, char *const*, const char*, const char*);

inline int soap_write__wsa__MessageID(struct soap *soap, char *const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put__wsa__MessageID(soap, p, "wsa:MessageID", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT__wsa__MessageID(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsa__MessageID(soap, p, "wsa:MessageID", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__wsa__MessageID(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsa__MessageID(soap, p, "wsa:MessageID", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__wsa__MessageID(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__wsa__MessageID(soap, p, "wsa:MessageID", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

#define soap_get__wsa__MessageID soap_get_string


#define soap_read__wsa__MessageID soap_read_string


#define soap_GET__wsa__MessageID soap_GET_string


#define soap_POST_recv__wsa__MessageID soap_POST_recv_string

#endif

#ifndef SOAP_TYPE_PointerTo_XML_DEFINED
#define SOAP_TYPE_PointerTo_XML_DEFINED
#endif

#ifndef SOAP_TYPE_PointerTowsa__ServiceNameType_DEFINED
#define SOAP_TYPE_PointerTowsa__ServiceNameType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowsa__ServiceNameType(struct soap*, struct wsa__ServiceNameType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowsa__ServiceNameType(struct soap*, const char *, int, struct wsa__ServiceNameType *const*, const char *);
SOAP_FMAC3 struct wsa__ServiceNameType ** SOAP_FMAC4 soap_in_PointerTowsa__ServiceNameType(struct soap*, const char*, struct wsa__ServiceNameType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowsa__ServiceNameType(struct soap*, struct wsa__ServiceNameType *const*, const char*, const char*);
SOAP_FMAC3 struct wsa__ServiceNameType ** SOAP_FMAC4 soap_get_PointerTowsa__ServiceNameType(struct soap*, struct wsa__ServiceNameType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_QName_DEFINED
#define SOAP_TYPE_PointerTo_QName_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_QName(struct soap*, char **const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_QName(struct soap*, const char *, int, char **const*, const char *);
SOAP_FMAC3 char *** SOAP_FMAC4 soap_in_PointerTo_QName(struct soap*, const char*, char ***, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_QName(struct soap*, char **const*, const char*, const char*);
SOAP_FMAC3 char *** SOAP_FMAC4 soap_get_PointerTo_QName(struct soap*, char ***, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTowsa__ReferenceParametersType_DEFINED
#define SOAP_TYPE_PointerTowsa__ReferenceParametersType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowsa__ReferenceParametersType(struct soap*, struct wsa__ReferenceParametersType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowsa__ReferenceParametersType(struct soap*, const char *, int, struct wsa__ReferenceParametersType *const*, const char *);
SOAP_FMAC3 struct wsa__ReferenceParametersType ** SOAP_FMAC4 soap_in_PointerTowsa__ReferenceParametersType(struct soap*, const char*, struct wsa__ReferenceParametersType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowsa__ReferenceParametersType(struct soap*, struct wsa__ReferenceParametersType *const*, const char*, const char*);
SOAP_FMAC3 struct wsa__ReferenceParametersType ** SOAP_FMAC4 soap_get_PointerTowsa__ReferenceParametersType(struct soap*, struct wsa__ReferenceParametersType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTowsa__ReferencePropertiesType_DEFINED
#define SOAP_TYPE_PointerTowsa__ReferencePropertiesType_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowsa__ReferencePropertiesType(struct soap*, struct wsa__ReferencePropertiesType *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowsa__ReferencePropertiesType(struct soap*, const char *, int, struct wsa__ReferencePropertiesType *const*, const char *);
SOAP_FMAC3 struct wsa__ReferencePropertiesType ** SOAP_FMAC4 soap_in_PointerTowsa__ReferencePropertiesType(struct soap*, const char*, struct wsa__ReferencePropertiesType **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowsa__ReferencePropertiesType(struct soap*, struct wsa__ReferencePropertiesType *const*, const char*, const char*);
SOAP_FMAC3 struct wsa__ReferencePropertiesType ** SOAP_FMAC4 soap_get_PointerTowsa__ReferencePropertiesType(struct soap*, struct wsa__ReferencePropertiesType **, const char*, const char*);
#endif

#ifndef SOAP_TYPE__QName_DEFINED
#define SOAP_TYPE__QName_DEFINED

inline void soap_default__QName(struct soap *soap, char **a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT__QName
	*a = SOAP_DEFAULT__QName;
#else
	*a = (char *)0;
#endif
}
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__QName(struct soap*, char *const*);

#define soap__QName2s(soap, a) soap_QName2s(soap, (a))
SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap*, const char*, int, char*const*, const char*);

#define soap_s2_QName(soap, s, a) soap_s2QName((soap), (s), (char**)(a), 0, -1, NULL)
SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap*, const char*, char **, const char*);

#define soap_instantiate__QName soap_instantiate_string


#define soap_new__QName soap_new_string

SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap*, char *const*, const char*, const char*);

inline int soap_write__QName(struct soap *soap, char *const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put__QName(soap, p, "QName", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT__QName(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__QName(soap, p, "QName", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__QName(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__QName(soap, p, "QName", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__QName(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put__QName(soap, p, "QName", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap*, char **, const char*, const char*);

inline int soap_read__QName(struct soap *soap, char **p)
{
	if (p)
	{	if (soap_begin_recv(soap) || ::soap_get__QName(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET__QName(struct soap *soap, const char *URL, char **p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read__QName(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv__QName(struct soap *soap, char **p)
{
	if (::soap_read__QName(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__XML_DEFINED
#define SOAP_TYPE__XML_DEFINED
#endif

#ifndef SOAP_TYPE_string_DEFINED
#define SOAP_TYPE_string_DEFINED

inline void soap_default_string(struct soap *soap, char **a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_string
	*a = SOAP_DEFAULT_string;
#else
	*a = (char *)0;
#endif
}
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap*, char *const*);

#define soap_string2s(soap, a) (a)
SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap*, const char*, int, char*const*, const char*);

#define soap_s2string(soap, s, a) soap_s2char((soap), (s), (char**)(a), 1, 0, -1, NULL)
SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap*, const char*, char **, const char*);

SOAP_FMAC3 char * * SOAP_FMAC4 soap_new_string(struct soap *soap, int n = -1);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap*, char *const*, const char*, const char*);

inline int soap_write_string(struct soap *soap, char *const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || ::soap_put_string(soap, p, "string", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT_string(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_string(soap, p, "string", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH_string(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_string(soap, p, "string", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send_string(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_string(soap, p, "string", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap*, char **, const char*, const char*);

inline int soap_read_string(struct soap *soap, char **p)
{
	if (p)
	{	if (soap_begin_recv(soap) || ::soap_get_string(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_string(struct soap *soap, const char *URL, char **p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_string(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_string(struct soap *soap, char **p)
{
	if (::soap_read_string(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#endif

/* End of soapH.h */
