/* crossH.h
   Generated by gSOAP 2.8.91 for cross.h

gSOAP XML Web services tools
Copyright (C) 2000-2018, 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 crossH_H
#define crossH_H
#include "crossStub.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 cross_instantiate(struct soap*, int, const char*, const char*, size_t*);
SOAP_FMAC3 int SOAP_FMAC4 cross_fdelete(struct soap *soap, struct soap_clist*);
SOAP_FMAC3 int SOAP_FMAC4 cross_fbase(int, int);
SOAP_FMAC3 void SOAP_FMAC4 cross_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

#ifndef SOAP_TYPE_std__string_DEFINED
#define SOAP_TYPE_std__string_DEFINED

inline void soap_default_std__string(struct soap *soap, std::string *p)
{
	(void)soap; /* appease -Wall -Werror */
	p->erase();
}
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__string(struct soap*, const std::string *);

#define soap_std__string2s(soap, a) ((a).c_str())
SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__string(struct soap*, const char*, int, const std::string*, const char*);

#define soap_s2std__string(soap, s, a) soap_s2stdchar((soap), (s), (a), 1, 0, -1, NULL)
SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_std__string(struct soap*, const char*, std::string*, const char*);
SOAP_FMAC1 std::string * SOAP_FMAC2 cross_instantiate_std__string(struct soap*, int, const char*, const char*, size_t*);

inline std::string * soap_new_std__string(struct soap *soap, int n = -1)
{
	return cross_instantiate_std__string(soap, n, NULL, NULL, NULL);
}

inline std::string * soap_new_req_std__string(
	struct soap *soap)
{
	std::string *_p = ::soap_new_std__string(soap);
	if (_p)
	{	::soap_default_std__string(soap, _p);
	}
	return _p;
}

inline std::string * soap_new_set_std__string(
	struct soap *soap)
{
	std::string *_p = ::soap_new_std__string(soap);
	if (_p)
	{	::soap_default_std__string(soap, _p);
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_std__string(struct soap*, const std::string *, const char*, const char*);

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

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

inline int soap_PATCH_std__string(struct soap *soap, const char *URL, std::string const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_std__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_std__string(struct soap *soap, const char *URL, std::string const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || ::soap_put_std__string(soap, p, "string", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_std__string(struct soap*, std::string *, const char*, const char*);

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

inline int soap_GET_std__string(struct soap *soap, const char *URL, std::string *p)
{
	if (soap_GET(soap, URL, NULL) || ::soap_read_std__string(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}

inline int soap_POST_recv_std__string(struct soap *soap, std::string *p)
{
	if (::soap_read_std__string(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__escrowResendSrvResponse_DEFINED
#define SOAP_TYPE__WS1__escrowResendSrvResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__escrowResendSrvResponse(struct soap*, const char*, int, const _WS1__escrowResendSrvResponse *, const char*);
SOAP_FMAC3 _WS1__escrowResendSrvResponse * SOAP_FMAC4 soap_in__WS1__escrowResendSrvResponse(struct soap*, const char*, _WS1__escrowResendSrvResponse *, const char*);
SOAP_FMAC1 _WS1__escrowResendSrvResponse * SOAP_FMAC2 cross_instantiate__WS1__escrowResendSrvResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__escrowResendSrvResponse * soap_new__WS1__escrowResendSrvResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__escrowResendSrvResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__escrowResendSrvResponse * soap_new_req__WS1__escrowResendSrvResponse(
	struct soap *soap,
	const std::string& escrowResendSrvReturn)
{
	_WS1__escrowResendSrvResponse *_p = ::soap_new__WS1__escrowResendSrvResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__escrowResendSrvResponse::escrowResendSrvReturn = escrowResendSrvReturn;
	}
	return _p;
}

inline _WS1__escrowResendSrvResponse * soap_new_set__WS1__escrowResendSrvResponse(
	struct soap *soap,
	const std::string& escrowResendSrvReturn)
{
	_WS1__escrowResendSrvResponse *_p = ::soap_new__WS1__escrowResendSrvResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__escrowResendSrvResponse::escrowResendSrvReturn = escrowResendSrvReturn;
	}
	return _p;
}

inline int soap_write__WS1__escrowResendSrvResponse(struct soap *soap, _WS1__escrowResendSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:escrowResendSrvResponse", p->soap_type() == SOAP_TYPE__WS1__escrowResendSrvResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__escrowResendSrvResponse(struct soap *soap, const char *URL, _WS1__escrowResendSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:escrowResendSrvResponse", p->soap_type() == SOAP_TYPE__WS1__escrowResendSrvResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__escrowResendSrvResponse(struct soap *soap, const char *URL, _WS1__escrowResendSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:escrowResendSrvResponse", p->soap_type() == SOAP_TYPE__WS1__escrowResendSrvResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__escrowResendSrvResponse(struct soap *soap, const char *URL, _WS1__escrowResendSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:escrowResendSrvResponse", p->soap_type() == SOAP_TYPE__WS1__escrowResendSrvResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__escrowResendSrvResponse * SOAP_FMAC4 soap_get__WS1__escrowResendSrvResponse(struct soap*, _WS1__escrowResendSrvResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__escrowResendSrvResponse(struct soap *soap, _WS1__escrowResendSrvResponse *p)
{
	if (::soap_read__WS1__escrowResendSrvResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__escrowResendSrv_DEFINED
#define SOAP_TYPE__WS1__escrowResendSrv_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__escrowResendSrv(struct soap*, const char*, int, const _WS1__escrowResendSrv *, const char*);
SOAP_FMAC3 _WS1__escrowResendSrv * SOAP_FMAC4 soap_in__WS1__escrowResendSrv(struct soap*, const char*, _WS1__escrowResendSrv *, const char*);
SOAP_FMAC1 _WS1__escrowResendSrv * SOAP_FMAC2 cross_instantiate__WS1__escrowResendSrv(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__escrowResendSrv * soap_new__WS1__escrowResendSrv(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__escrowResendSrv(soap, n, NULL, NULL, NULL);
}

inline _WS1__escrowResendSrv * soap_new_req__WS1__escrowResendSrv(
	struct soap *soap,
	const std::string& in0,
	const std::string& in1)
{
	_WS1__escrowResendSrv *_p = ::soap_new__WS1__escrowResendSrv(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__escrowResendSrv::in0 = in0;
		_p->_WS1__escrowResendSrv::in1 = in1;
	}
	return _p;
}

inline _WS1__escrowResendSrv * soap_new_set__WS1__escrowResendSrv(
	struct soap *soap,
	const std::string& in0,
	const std::string& in1)
{
	_WS1__escrowResendSrv *_p = ::soap_new__WS1__escrowResendSrv(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__escrowResendSrv::in0 = in0;
		_p->_WS1__escrowResendSrv::in1 = in1;
	}
	return _p;
}

inline int soap_write__WS1__escrowResendSrv(struct soap *soap, _WS1__escrowResendSrv const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:escrowResendSrv", p->soap_type() == SOAP_TYPE__WS1__escrowResendSrv ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__escrowResendSrv(struct soap *soap, const char *URL, _WS1__escrowResendSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:escrowResendSrv", p->soap_type() == SOAP_TYPE__WS1__escrowResendSrv ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__escrowResendSrv(struct soap *soap, const char *URL, _WS1__escrowResendSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:escrowResendSrv", p->soap_type() == SOAP_TYPE__WS1__escrowResendSrv ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__escrowResendSrv(struct soap *soap, const char *URL, _WS1__escrowResendSrv const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:escrowResendSrv", p->soap_type() == SOAP_TYPE__WS1__escrowResendSrv ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__escrowResendSrv * SOAP_FMAC4 soap_get__WS1__escrowResendSrv(struct soap*, _WS1__escrowResendSrv *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__escrowResendSrv(struct soap *soap, _WS1__escrowResendSrv *p)
{
	if (::soap_read__WS1__escrowResendSrv(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__invokeSrvResponse_DEFINED
#define SOAP_TYPE__WS1__invokeSrvResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeSrvResponse(struct soap*, const char*, int, const _WS1__invokeSrvResponse *, const char*);
SOAP_FMAC3 _WS1__invokeSrvResponse * SOAP_FMAC4 soap_in__WS1__invokeSrvResponse(struct soap*, const char*, _WS1__invokeSrvResponse *, const char*);
SOAP_FMAC1 _WS1__invokeSrvResponse * SOAP_FMAC2 cross_instantiate__WS1__invokeSrvResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__invokeSrvResponse * soap_new__WS1__invokeSrvResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__invokeSrvResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__invokeSrvResponse * soap_new_req__WS1__invokeSrvResponse(
	struct soap *soap,
	const std::string& invokeSrvReturn)
{
	_WS1__invokeSrvResponse *_p = ::soap_new__WS1__invokeSrvResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeSrvResponse::invokeSrvReturn = invokeSrvReturn;
	}
	return _p;
}

inline _WS1__invokeSrvResponse * soap_new_set__WS1__invokeSrvResponse(
	struct soap *soap,
	const std::string& invokeSrvReturn)
{
	_WS1__invokeSrvResponse *_p = ::soap_new__WS1__invokeSrvResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeSrvResponse::invokeSrvReturn = invokeSrvReturn;
	}
	return _p;
}

inline int soap_write__WS1__invokeSrvResponse(struct soap *soap, _WS1__invokeSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeSrvResponse", p->soap_type() == SOAP_TYPE__WS1__invokeSrvResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__invokeSrvResponse(struct soap *soap, const char *URL, _WS1__invokeSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeSrvResponse", p->soap_type() == SOAP_TYPE__WS1__invokeSrvResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__invokeSrvResponse(struct soap *soap, const char *URL, _WS1__invokeSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeSrvResponse", p->soap_type() == SOAP_TYPE__WS1__invokeSrvResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__invokeSrvResponse(struct soap *soap, const char *URL, _WS1__invokeSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeSrvResponse", p->soap_type() == SOAP_TYPE__WS1__invokeSrvResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__invokeSrvResponse * SOAP_FMAC4 soap_get__WS1__invokeSrvResponse(struct soap*, _WS1__invokeSrvResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__invokeSrvResponse(struct soap *soap, _WS1__invokeSrvResponse *p)
{
	if (::soap_read__WS1__invokeSrvResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__invokeSrv_DEFINED
#define SOAP_TYPE__WS1__invokeSrv_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeSrv(struct soap*, const char*, int, const _WS1__invokeSrv *, const char*);
SOAP_FMAC3 _WS1__invokeSrv * SOAP_FMAC4 soap_in__WS1__invokeSrv(struct soap*, const char*, _WS1__invokeSrv *, const char*);
SOAP_FMAC1 _WS1__invokeSrv * SOAP_FMAC2 cross_instantiate__WS1__invokeSrv(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__invokeSrv * soap_new__WS1__invokeSrv(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__invokeSrv(soap, n, NULL, NULL, NULL);
}

inline _WS1__invokeSrv * soap_new_req__WS1__invokeSrv(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__invokeSrv *_p = ::soap_new__WS1__invokeSrv(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeSrv::in0 = in0;
	}
	return _p;
}

inline _WS1__invokeSrv * soap_new_set__WS1__invokeSrv(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__invokeSrv *_p = ::soap_new__WS1__invokeSrv(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeSrv::in0 = in0;
	}
	return _p;
}

inline int soap_write__WS1__invokeSrv(struct soap *soap, _WS1__invokeSrv const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeSrv", p->soap_type() == SOAP_TYPE__WS1__invokeSrv ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__invokeSrv(struct soap *soap, const char *URL, _WS1__invokeSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeSrv", p->soap_type() == SOAP_TYPE__WS1__invokeSrv ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__invokeSrv(struct soap *soap, const char *URL, _WS1__invokeSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeSrv", p->soap_type() == SOAP_TYPE__WS1__invokeSrv ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__invokeSrv(struct soap *soap, const char *URL, _WS1__invokeSrv const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeSrv", p->soap_type() == SOAP_TYPE__WS1__invokeSrv ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__invokeSrv * SOAP_FMAC4 soap_get__WS1__invokeSrv(struct soap*, _WS1__invokeSrv *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__invokeSrv(struct soap *soap, _WS1__invokeSrv *p)
{
	if (::soap_read__WS1__invokeSrv(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__regEAIResponse_DEFINED
#define SOAP_TYPE__WS1__regEAIResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__regEAIResponse(struct soap*, const char*, int, const _WS1__regEAIResponse *, const char*);
SOAP_FMAC3 _WS1__regEAIResponse * SOAP_FMAC4 soap_in__WS1__regEAIResponse(struct soap*, const char*, _WS1__regEAIResponse *, const char*);
SOAP_FMAC1 _WS1__regEAIResponse * SOAP_FMAC2 cross_instantiate__WS1__regEAIResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__regEAIResponse * soap_new__WS1__regEAIResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__regEAIResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__regEAIResponse * soap_new_req__WS1__regEAIResponse(
	struct soap *soap,
	const std::string& regEAIReturn)
{
	_WS1__regEAIResponse *_p = ::soap_new__WS1__regEAIResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__regEAIResponse::regEAIReturn = regEAIReturn;
	}
	return _p;
}

inline _WS1__regEAIResponse * soap_new_set__WS1__regEAIResponse(
	struct soap *soap,
	const std::string& regEAIReturn)
{
	_WS1__regEAIResponse *_p = ::soap_new__WS1__regEAIResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__regEAIResponse::regEAIReturn = regEAIReturn;
	}
	return _p;
}

inline int soap_write__WS1__regEAIResponse(struct soap *soap, _WS1__regEAIResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regEAIResponse", p->soap_type() == SOAP_TYPE__WS1__regEAIResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__regEAIResponse(struct soap *soap, const char *URL, _WS1__regEAIResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regEAIResponse", p->soap_type() == SOAP_TYPE__WS1__regEAIResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__regEAIResponse(struct soap *soap, const char *URL, _WS1__regEAIResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regEAIResponse", p->soap_type() == SOAP_TYPE__WS1__regEAIResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__regEAIResponse(struct soap *soap, const char *URL, _WS1__regEAIResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regEAIResponse", p->soap_type() == SOAP_TYPE__WS1__regEAIResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__regEAIResponse * SOAP_FMAC4 soap_get__WS1__regEAIResponse(struct soap*, _WS1__regEAIResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__regEAIResponse(struct soap *soap, _WS1__regEAIResponse *p)
{
	if (::soap_read__WS1__regEAIResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__regEAI_DEFINED
#define SOAP_TYPE__WS1__regEAI_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__regEAI(struct soap*, const char*, int, const _WS1__regEAI *, const char*);
SOAP_FMAC3 _WS1__regEAI * SOAP_FMAC4 soap_in__WS1__regEAI(struct soap*, const char*, _WS1__regEAI *, const char*);
SOAP_FMAC1 _WS1__regEAI * SOAP_FMAC2 cross_instantiate__WS1__regEAI(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__regEAI * soap_new__WS1__regEAI(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__regEAI(soap, n, NULL, NULL, NULL);
}

inline _WS1__regEAI * soap_new_req__WS1__regEAI(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__regEAI *_p = ::soap_new__WS1__regEAI(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__regEAI::in0 = in0;
	}
	return _p;
}

inline _WS1__regEAI * soap_new_set__WS1__regEAI(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__regEAI *_p = ::soap_new__WS1__regEAI(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__regEAI::in0 = in0;
	}
	return _p;
}

inline int soap_write__WS1__regEAI(struct soap *soap, _WS1__regEAI const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regEAI", p->soap_type() == SOAP_TYPE__WS1__regEAI ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__regEAI(struct soap *soap, const char *URL, _WS1__regEAI const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regEAI", p->soap_type() == SOAP_TYPE__WS1__regEAI ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__regEAI(struct soap *soap, const char *URL, _WS1__regEAI const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regEAI", p->soap_type() == SOAP_TYPE__WS1__regEAI ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__regEAI(struct soap *soap, const char *URL, _WS1__regEAI const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regEAI", p->soap_type() == SOAP_TYPE__WS1__regEAI ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__regEAI * SOAP_FMAC4 soap_get__WS1__regEAI(struct soap*, _WS1__regEAI *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__regEAI(struct soap *soap, _WS1__regEAI *p)
{
	if (::soap_read__WS1__regEAI(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__regSrvResponse_DEFINED
#define SOAP_TYPE__WS1__regSrvResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__regSrvResponse(struct soap*, const char*, int, const _WS1__regSrvResponse *, const char*);
SOAP_FMAC3 _WS1__regSrvResponse * SOAP_FMAC4 soap_in__WS1__regSrvResponse(struct soap*, const char*, _WS1__regSrvResponse *, const char*);
SOAP_FMAC1 _WS1__regSrvResponse * SOAP_FMAC2 cross_instantiate__WS1__regSrvResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__regSrvResponse * soap_new__WS1__regSrvResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__regSrvResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__regSrvResponse * soap_new_req__WS1__regSrvResponse(
	struct soap *soap,
	const std::string& regSrvReturn)
{
	_WS1__regSrvResponse *_p = ::soap_new__WS1__regSrvResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__regSrvResponse::regSrvReturn = regSrvReturn;
	}
	return _p;
}

inline _WS1__regSrvResponse * soap_new_set__WS1__regSrvResponse(
	struct soap *soap,
	const std::string& regSrvReturn)
{
	_WS1__regSrvResponse *_p = ::soap_new__WS1__regSrvResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__regSrvResponse::regSrvReturn = regSrvReturn;
	}
	return _p;
}

inline int soap_write__WS1__regSrvResponse(struct soap *soap, _WS1__regSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regSrvResponse", p->soap_type() == SOAP_TYPE__WS1__regSrvResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__regSrvResponse(struct soap *soap, const char *URL, _WS1__regSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regSrvResponse", p->soap_type() == SOAP_TYPE__WS1__regSrvResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__regSrvResponse(struct soap *soap, const char *URL, _WS1__regSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regSrvResponse", p->soap_type() == SOAP_TYPE__WS1__regSrvResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__regSrvResponse(struct soap *soap, const char *URL, _WS1__regSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regSrvResponse", p->soap_type() == SOAP_TYPE__WS1__regSrvResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__regSrvResponse * SOAP_FMAC4 soap_get__WS1__regSrvResponse(struct soap*, _WS1__regSrvResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__regSrvResponse(struct soap *soap, _WS1__regSrvResponse *p)
{
	if (::soap_read__WS1__regSrvResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__regSrv_DEFINED
#define SOAP_TYPE__WS1__regSrv_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__regSrv(struct soap*, const char*, int, const _WS1__regSrv *, const char*);
SOAP_FMAC3 _WS1__regSrv * SOAP_FMAC4 soap_in__WS1__regSrv(struct soap*, const char*, _WS1__regSrv *, const char*);
SOAP_FMAC1 _WS1__regSrv * SOAP_FMAC2 cross_instantiate__WS1__regSrv(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__regSrv * soap_new__WS1__regSrv(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__regSrv(soap, n, NULL, NULL, NULL);
}

inline _WS1__regSrv * soap_new_req__WS1__regSrv(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__regSrv *_p = ::soap_new__WS1__regSrv(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__regSrv::in0 = in0;
	}
	return _p;
}

inline _WS1__regSrv * soap_new_set__WS1__regSrv(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__regSrv *_p = ::soap_new__WS1__regSrv(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__regSrv::in0 = in0;
	}
	return _p;
}

inline int soap_write__WS1__regSrv(struct soap *soap, _WS1__regSrv const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regSrv", p->soap_type() == SOAP_TYPE__WS1__regSrv ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__regSrv(struct soap *soap, const char *URL, _WS1__regSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regSrv", p->soap_type() == SOAP_TYPE__WS1__regSrv ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__regSrv(struct soap *soap, const char *URL, _WS1__regSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regSrv", p->soap_type() == SOAP_TYPE__WS1__regSrv ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__regSrv(struct soap *soap, const char *URL, _WS1__regSrv const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regSrv", p->soap_type() == SOAP_TYPE__WS1__regSrv ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__regSrv * SOAP_FMAC4 soap_get__WS1__regSrv(struct soap*, _WS1__regSrv *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__regSrv(struct soap *soap, _WS1__regSrv *p)
{
	if (::soap_read__WS1__regSrv(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__getStandardDataNameListResponse_DEFINED
#define SOAP_TYPE__WS1__getStandardDataNameListResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getStandardDataNameListResponse(struct soap*, const char*, int, const _WS1__getStandardDataNameListResponse *, const char*);
SOAP_FMAC3 _WS1__getStandardDataNameListResponse * SOAP_FMAC4 soap_in__WS1__getStandardDataNameListResponse(struct soap*, const char*, _WS1__getStandardDataNameListResponse *, const char*);
SOAP_FMAC1 _WS1__getStandardDataNameListResponse * SOAP_FMAC2 cross_instantiate__WS1__getStandardDataNameListResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__getStandardDataNameListResponse * soap_new__WS1__getStandardDataNameListResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__getStandardDataNameListResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__getStandardDataNameListResponse * soap_new_req__WS1__getStandardDataNameListResponse(
	struct soap *soap,
	const std::string& getStandardDataNameListReturn)
{
	_WS1__getStandardDataNameListResponse *_p = ::soap_new__WS1__getStandardDataNameListResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getStandardDataNameListResponse::getStandardDataNameListReturn = getStandardDataNameListReturn;
	}
	return _p;
}

inline _WS1__getStandardDataNameListResponse * soap_new_set__WS1__getStandardDataNameListResponse(
	struct soap *soap,
	const std::string& getStandardDataNameListReturn)
{
	_WS1__getStandardDataNameListResponse *_p = ::soap_new__WS1__getStandardDataNameListResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getStandardDataNameListResponse::getStandardDataNameListReturn = getStandardDataNameListReturn;
	}
	return _p;
}

inline int soap_write__WS1__getStandardDataNameListResponse(struct soap *soap, _WS1__getStandardDataNameListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardDataNameListResponse", p->soap_type() == SOAP_TYPE__WS1__getStandardDataNameListResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__getStandardDataNameListResponse(struct soap *soap, const char *URL, _WS1__getStandardDataNameListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardDataNameListResponse", p->soap_type() == SOAP_TYPE__WS1__getStandardDataNameListResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__getStandardDataNameListResponse(struct soap *soap, const char *URL, _WS1__getStandardDataNameListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardDataNameListResponse", p->soap_type() == SOAP_TYPE__WS1__getStandardDataNameListResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__getStandardDataNameListResponse(struct soap *soap, const char *URL, _WS1__getStandardDataNameListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardDataNameListResponse", p->soap_type() == SOAP_TYPE__WS1__getStandardDataNameListResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__getStandardDataNameListResponse * SOAP_FMAC4 soap_get__WS1__getStandardDataNameListResponse(struct soap*, _WS1__getStandardDataNameListResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__getStandardDataNameListResponse(struct soap *soap, _WS1__getStandardDataNameListResponse *p)
{
	if (::soap_read__WS1__getStandardDataNameListResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__getStandardDataNameList_DEFINED
#define SOAP_TYPE__WS1__getStandardDataNameList_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getStandardDataNameList(struct soap*, const char*, int, const _WS1__getStandardDataNameList *, const char*);
SOAP_FMAC3 _WS1__getStandardDataNameList * SOAP_FMAC4 soap_in__WS1__getStandardDataNameList(struct soap*, const char*, _WS1__getStandardDataNameList *, const char*);
SOAP_FMAC1 _WS1__getStandardDataNameList * SOAP_FMAC2 cross_instantiate__WS1__getStandardDataNameList(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__getStandardDataNameList * soap_new__WS1__getStandardDataNameList(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__getStandardDataNameList(soap, n, NULL, NULL, NULL);
}

inline _WS1__getStandardDataNameList * soap_new_req__WS1__getStandardDataNameList(
	struct soap *soap)
{
	_WS1__getStandardDataNameList *_p = ::soap_new__WS1__getStandardDataNameList(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline _WS1__getStandardDataNameList * soap_new_set__WS1__getStandardDataNameList(
	struct soap *soap)
{
	_WS1__getStandardDataNameList *_p = ::soap_new__WS1__getStandardDataNameList(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline int soap_write__WS1__getStandardDataNameList(struct soap *soap, _WS1__getStandardDataNameList const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardDataNameList", p->soap_type() == SOAP_TYPE__WS1__getStandardDataNameList ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__getStandardDataNameList(struct soap *soap, const char *URL, _WS1__getStandardDataNameList const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardDataNameList", p->soap_type() == SOAP_TYPE__WS1__getStandardDataNameList ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__getStandardDataNameList(struct soap *soap, const char *URL, _WS1__getStandardDataNameList const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardDataNameList", p->soap_type() == SOAP_TYPE__WS1__getStandardDataNameList ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__getStandardDataNameList(struct soap *soap, const char *URL, _WS1__getStandardDataNameList const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardDataNameList", p->soap_type() == SOAP_TYPE__WS1__getStandardDataNameList ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__getStandardDataNameList * SOAP_FMAC4 soap_get__WS1__getStandardDataNameList(struct soap*, _WS1__getStandardDataNameList *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__getStandardDataNameList(struct soap *soap, _WS1__getStandardDataNameList *p)
{
	if (::soap_read__WS1__getStandardDataNameList(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__getStandardServiceListResponse_DEFINED
#define SOAP_TYPE__WS1__getStandardServiceListResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getStandardServiceListResponse(struct soap*, const char*, int, const _WS1__getStandardServiceListResponse *, const char*);
SOAP_FMAC3 _WS1__getStandardServiceListResponse * SOAP_FMAC4 soap_in__WS1__getStandardServiceListResponse(struct soap*, const char*, _WS1__getStandardServiceListResponse *, const char*);
SOAP_FMAC1 _WS1__getStandardServiceListResponse * SOAP_FMAC2 cross_instantiate__WS1__getStandardServiceListResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__getStandardServiceListResponse * soap_new__WS1__getStandardServiceListResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__getStandardServiceListResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__getStandardServiceListResponse * soap_new_req__WS1__getStandardServiceListResponse(
	struct soap *soap,
	const std::string& getStandardServiceListReturn)
{
	_WS1__getStandardServiceListResponse *_p = ::soap_new__WS1__getStandardServiceListResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getStandardServiceListResponse::getStandardServiceListReturn = getStandardServiceListReturn;
	}
	return _p;
}

inline _WS1__getStandardServiceListResponse * soap_new_set__WS1__getStandardServiceListResponse(
	struct soap *soap,
	const std::string& getStandardServiceListReturn)
{
	_WS1__getStandardServiceListResponse *_p = ::soap_new__WS1__getStandardServiceListResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getStandardServiceListResponse::getStandardServiceListReturn = getStandardServiceListReturn;
	}
	return _p;
}

inline int soap_write__WS1__getStandardServiceListResponse(struct soap *soap, _WS1__getStandardServiceListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardServiceListResponse", p->soap_type() == SOAP_TYPE__WS1__getStandardServiceListResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__getStandardServiceListResponse(struct soap *soap, const char *URL, _WS1__getStandardServiceListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardServiceListResponse", p->soap_type() == SOAP_TYPE__WS1__getStandardServiceListResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__getStandardServiceListResponse(struct soap *soap, const char *URL, _WS1__getStandardServiceListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardServiceListResponse", p->soap_type() == SOAP_TYPE__WS1__getStandardServiceListResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__getStandardServiceListResponse(struct soap *soap, const char *URL, _WS1__getStandardServiceListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardServiceListResponse", p->soap_type() == SOAP_TYPE__WS1__getStandardServiceListResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__getStandardServiceListResponse * SOAP_FMAC4 soap_get__WS1__getStandardServiceListResponse(struct soap*, _WS1__getStandardServiceListResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__getStandardServiceListResponse(struct soap *soap, _WS1__getStandardServiceListResponse *p)
{
	if (::soap_read__WS1__getStandardServiceListResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__getStandardServiceList_DEFINED
#define SOAP_TYPE__WS1__getStandardServiceList_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getStandardServiceList(struct soap*, const char*, int, const _WS1__getStandardServiceList *, const char*);
SOAP_FMAC3 _WS1__getStandardServiceList * SOAP_FMAC4 soap_in__WS1__getStandardServiceList(struct soap*, const char*, _WS1__getStandardServiceList *, const char*);
SOAP_FMAC1 _WS1__getStandardServiceList * SOAP_FMAC2 cross_instantiate__WS1__getStandardServiceList(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__getStandardServiceList * soap_new__WS1__getStandardServiceList(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__getStandardServiceList(soap, n, NULL, NULL, NULL);
}

inline _WS1__getStandardServiceList * soap_new_req__WS1__getStandardServiceList(
	struct soap *soap)
{
	_WS1__getStandardServiceList *_p = ::soap_new__WS1__getStandardServiceList(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline _WS1__getStandardServiceList * soap_new_set__WS1__getStandardServiceList(
	struct soap *soap)
{
	_WS1__getStandardServiceList *_p = ::soap_new__WS1__getStandardServiceList(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline int soap_write__WS1__getStandardServiceList(struct soap *soap, _WS1__getStandardServiceList const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardServiceList", p->soap_type() == SOAP_TYPE__WS1__getStandardServiceList ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__getStandardServiceList(struct soap *soap, const char *URL, _WS1__getStandardServiceList const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardServiceList", p->soap_type() == SOAP_TYPE__WS1__getStandardServiceList ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__getStandardServiceList(struct soap *soap, const char *URL, _WS1__getStandardServiceList const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardServiceList", p->soap_type() == SOAP_TYPE__WS1__getStandardServiceList ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__getStandardServiceList(struct soap *soap, const char *URL, _WS1__getStandardServiceList const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getStandardServiceList", p->soap_type() == SOAP_TYPE__WS1__getStandardServiceList ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__getStandardServiceList * SOAP_FMAC4 soap_get__WS1__getStandardServiceList(struct soap*, _WS1__getStandardServiceList *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__getStandardServiceList(struct soap *soap, _WS1__getStandardServiceList *p)
{
	if (::soap_read__WS1__getStandardServiceList(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__fpInvokeResponse_DEFINED
#define SOAP_TYPE__WS1__fpInvokeResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__fpInvokeResponse(struct soap*, const char*, int, const _WS1__fpInvokeResponse *, const char*);
SOAP_FMAC3 _WS1__fpInvokeResponse * SOAP_FMAC4 soap_in__WS1__fpInvokeResponse(struct soap*, const char*, _WS1__fpInvokeResponse *, const char*);
SOAP_FMAC1 _WS1__fpInvokeResponse * SOAP_FMAC2 cross_instantiate__WS1__fpInvokeResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__fpInvokeResponse * soap_new__WS1__fpInvokeResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__fpInvokeResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__fpInvokeResponse * soap_new_req__WS1__fpInvokeResponse(
	struct soap *soap,
	const std::string& fpInvokeReturn)
{
	_WS1__fpInvokeResponse *_p = ::soap_new__WS1__fpInvokeResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__fpInvokeResponse::fpInvokeReturn = fpInvokeReturn;
	}
	return _p;
}

inline _WS1__fpInvokeResponse * soap_new_set__WS1__fpInvokeResponse(
	struct soap *soap,
	const std::string& fpInvokeReturn)
{
	_WS1__fpInvokeResponse *_p = ::soap_new__WS1__fpInvokeResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__fpInvokeResponse::fpInvokeReturn = fpInvokeReturn;
	}
	return _p;
}

inline int soap_write__WS1__fpInvokeResponse(struct soap *soap, _WS1__fpInvokeResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:fpInvokeResponse", p->soap_type() == SOAP_TYPE__WS1__fpInvokeResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__fpInvokeResponse(struct soap *soap, const char *URL, _WS1__fpInvokeResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:fpInvokeResponse", p->soap_type() == SOAP_TYPE__WS1__fpInvokeResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__fpInvokeResponse(struct soap *soap, const char *URL, _WS1__fpInvokeResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:fpInvokeResponse", p->soap_type() == SOAP_TYPE__WS1__fpInvokeResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__fpInvokeResponse(struct soap *soap, const char *URL, _WS1__fpInvokeResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:fpInvokeResponse", p->soap_type() == SOAP_TYPE__WS1__fpInvokeResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__fpInvokeResponse * SOAP_FMAC4 soap_get__WS1__fpInvokeResponse(struct soap*, _WS1__fpInvokeResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__fpInvokeResponse(struct soap *soap, _WS1__fpInvokeResponse *p)
{
	if (::soap_read__WS1__fpInvokeResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__fpInvoke_DEFINED
#define SOAP_TYPE__WS1__fpInvoke_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__fpInvoke(struct soap*, const char*, int, const _WS1__fpInvoke *, const char*);
SOAP_FMAC3 _WS1__fpInvoke * SOAP_FMAC4 soap_in__WS1__fpInvoke(struct soap*, const char*, _WS1__fpInvoke *, const char*);
SOAP_FMAC1 _WS1__fpInvoke * SOAP_FMAC2 cross_instantiate__WS1__fpInvoke(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__fpInvoke * soap_new__WS1__fpInvoke(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__fpInvoke(soap, n, NULL, NULL, NULL);
}

inline _WS1__fpInvoke * soap_new_req__WS1__fpInvoke(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__fpInvoke *_p = ::soap_new__WS1__fpInvoke(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__fpInvoke::in0 = in0;
	}
	return _p;
}

inline _WS1__fpInvoke * soap_new_set__WS1__fpInvoke(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__fpInvoke *_p = ::soap_new__WS1__fpInvoke(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__fpInvoke::in0 = in0;
	}
	return _p;
}

inline int soap_write__WS1__fpInvoke(struct soap *soap, _WS1__fpInvoke const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:fpInvoke", p->soap_type() == SOAP_TYPE__WS1__fpInvoke ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__fpInvoke(struct soap *soap, const char *URL, _WS1__fpInvoke const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:fpInvoke", p->soap_type() == SOAP_TYPE__WS1__fpInvoke ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__fpInvoke(struct soap *soap, const char *URL, _WS1__fpInvoke const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:fpInvoke", p->soap_type() == SOAP_TYPE__WS1__fpInvoke ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__fpInvoke(struct soap *soap, const char *URL, _WS1__fpInvoke const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:fpInvoke", p->soap_type() == SOAP_TYPE__WS1__fpInvoke ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__fpInvoke * SOAP_FMAC4 soap_get__WS1__fpInvoke(struct soap*, _WS1__fpInvoke *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__fpInvoke(struct soap *soap, _WS1__fpInvoke *p)
{
	if (::soap_read__WS1__fpInvoke(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__getSrvResponse_DEFINED
#define SOAP_TYPE__WS1__getSrvResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getSrvResponse(struct soap*, const char*, int, const _WS1__getSrvResponse *, const char*);
SOAP_FMAC3 _WS1__getSrvResponse * SOAP_FMAC4 soap_in__WS1__getSrvResponse(struct soap*, const char*, _WS1__getSrvResponse *, const char*);
SOAP_FMAC1 _WS1__getSrvResponse * SOAP_FMAC2 cross_instantiate__WS1__getSrvResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__getSrvResponse * soap_new__WS1__getSrvResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__getSrvResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__getSrvResponse * soap_new_req__WS1__getSrvResponse(
	struct soap *soap,
	const std::string& getSrvReturn)
{
	_WS1__getSrvResponse *_p = ::soap_new__WS1__getSrvResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getSrvResponse::getSrvReturn = getSrvReturn;
	}
	return _p;
}

inline _WS1__getSrvResponse * soap_new_set__WS1__getSrvResponse(
	struct soap *soap,
	const std::string& getSrvReturn)
{
	_WS1__getSrvResponse *_p = ::soap_new__WS1__getSrvResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getSrvResponse::getSrvReturn = getSrvReturn;
	}
	return _p;
}

inline int soap_write__WS1__getSrvResponse(struct soap *soap, _WS1__getSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getSrvResponse", p->soap_type() == SOAP_TYPE__WS1__getSrvResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__getSrvResponse(struct soap *soap, const char *URL, _WS1__getSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getSrvResponse", p->soap_type() == SOAP_TYPE__WS1__getSrvResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__getSrvResponse(struct soap *soap, const char *URL, _WS1__getSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getSrvResponse", p->soap_type() == SOAP_TYPE__WS1__getSrvResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__getSrvResponse(struct soap *soap, const char *URL, _WS1__getSrvResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getSrvResponse", p->soap_type() == SOAP_TYPE__WS1__getSrvResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__getSrvResponse * SOAP_FMAC4 soap_get__WS1__getSrvResponse(struct soap*, _WS1__getSrvResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__getSrvResponse(struct soap *soap, _WS1__getSrvResponse *p)
{
	if (::soap_read__WS1__getSrvResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__getSrv_DEFINED
#define SOAP_TYPE__WS1__getSrv_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getSrv(struct soap*, const char*, int, const _WS1__getSrv *, const char*);
SOAP_FMAC3 _WS1__getSrv * SOAP_FMAC4 soap_in__WS1__getSrv(struct soap*, const char*, _WS1__getSrv *, const char*);
SOAP_FMAC1 _WS1__getSrv * SOAP_FMAC2 cross_instantiate__WS1__getSrv(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__getSrv * soap_new__WS1__getSrv(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__getSrv(soap, n, NULL, NULL, NULL);
}

inline _WS1__getSrv * soap_new_req__WS1__getSrv(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__getSrv *_p = ::soap_new__WS1__getSrv(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getSrv::in0 = in0;
	}
	return _p;
}

inline _WS1__getSrv * soap_new_set__WS1__getSrv(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__getSrv *_p = ::soap_new__WS1__getSrv(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getSrv::in0 = in0;
	}
	return _p;
}

inline int soap_write__WS1__getSrv(struct soap *soap, _WS1__getSrv const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getSrv", p->soap_type() == SOAP_TYPE__WS1__getSrv ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__getSrv(struct soap *soap, const char *URL, _WS1__getSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getSrv", p->soap_type() == SOAP_TYPE__WS1__getSrv ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__getSrv(struct soap *soap, const char *URL, _WS1__getSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getSrv", p->soap_type() == SOAP_TYPE__WS1__getSrv ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__getSrv(struct soap *soap, const char *URL, _WS1__getSrv const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getSrv", p->soap_type() == SOAP_TYPE__WS1__getSrv ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__getSrv * SOAP_FMAC4 soap_get__WS1__getSrv(struct soap*, _WS1__getSrv *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__getSrv(struct soap *soap, _WS1__getSrv *p)
{
	if (::soap_read__WS1__getSrv(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__getProdResponse_DEFINED
#define SOAP_TYPE__WS1__getProdResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getProdResponse(struct soap*, const char*, int, const _WS1__getProdResponse *, const char*);
SOAP_FMAC3 _WS1__getProdResponse * SOAP_FMAC4 soap_in__WS1__getProdResponse(struct soap*, const char*, _WS1__getProdResponse *, const char*);
SOAP_FMAC1 _WS1__getProdResponse * SOAP_FMAC2 cross_instantiate__WS1__getProdResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__getProdResponse * soap_new__WS1__getProdResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__getProdResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__getProdResponse * soap_new_req__WS1__getProdResponse(
	struct soap *soap,
	const std::string& getProdReturn)
{
	_WS1__getProdResponse *_p = ::soap_new__WS1__getProdResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getProdResponse::getProdReturn = getProdReturn;
	}
	return _p;
}

inline _WS1__getProdResponse * soap_new_set__WS1__getProdResponse(
	struct soap *soap,
	const std::string& getProdReturn)
{
	_WS1__getProdResponse *_p = ::soap_new__WS1__getProdResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getProdResponse::getProdReturn = getProdReturn;
	}
	return _p;
}

inline int soap_write__WS1__getProdResponse(struct soap *soap, _WS1__getProdResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProdResponse", p->soap_type() == SOAP_TYPE__WS1__getProdResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__getProdResponse(struct soap *soap, const char *URL, _WS1__getProdResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProdResponse", p->soap_type() == SOAP_TYPE__WS1__getProdResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__getProdResponse(struct soap *soap, const char *URL, _WS1__getProdResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProdResponse", p->soap_type() == SOAP_TYPE__WS1__getProdResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__getProdResponse(struct soap *soap, const char *URL, _WS1__getProdResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProdResponse", p->soap_type() == SOAP_TYPE__WS1__getProdResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__getProdResponse * SOAP_FMAC4 soap_get__WS1__getProdResponse(struct soap*, _WS1__getProdResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__getProdResponse(struct soap *soap, _WS1__getProdResponse *p)
{
	if (::soap_read__WS1__getProdResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__getProd_DEFINED
#define SOAP_TYPE__WS1__getProd_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getProd(struct soap*, const char*, int, const _WS1__getProd *, const char*);
SOAP_FMAC3 _WS1__getProd * SOAP_FMAC4 soap_in__WS1__getProd(struct soap*, const char*, _WS1__getProd *, const char*);
SOAP_FMAC1 _WS1__getProd * SOAP_FMAC2 cross_instantiate__WS1__getProd(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__getProd * soap_new__WS1__getProd(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__getProd(soap, n, NULL, NULL, NULL);
}

inline _WS1__getProd * soap_new_req__WS1__getProd(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__getProd *_p = ::soap_new__WS1__getProd(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getProd::in0 = in0;
	}
	return _p;
}

inline _WS1__getProd * soap_new_set__WS1__getProd(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__getProd *_p = ::soap_new__WS1__getProd(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getProd::in0 = in0;
	}
	return _p;
}

inline int soap_write__WS1__getProd(struct soap *soap, _WS1__getProd const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProd", p->soap_type() == SOAP_TYPE__WS1__getProd ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__getProd(struct soap *soap, const char *URL, _WS1__getProd const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProd", p->soap_type() == SOAP_TYPE__WS1__getProd ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__getProd(struct soap *soap, const char *URL, _WS1__getProd const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProd", p->soap_type() == SOAP_TYPE__WS1__getProd ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__getProd(struct soap *soap, const char *URL, _WS1__getProd const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProd", p->soap_type() == SOAP_TYPE__WS1__getProd ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__getProd * SOAP_FMAC4 soap_get__WS1__getProd(struct soap*, _WS1__getProd *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__getProd(struct soap *soap, _WS1__getProd *p)
{
	if (::soap_read__WS1__getProd(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__invokeMdmResponse_DEFINED
#define SOAP_TYPE__WS1__invokeMdmResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeMdmResponse(struct soap*, const char*, int, const _WS1__invokeMdmResponse *, const char*);
SOAP_FMAC3 _WS1__invokeMdmResponse * SOAP_FMAC4 soap_in__WS1__invokeMdmResponse(struct soap*, const char*, _WS1__invokeMdmResponse *, const char*);
SOAP_FMAC1 _WS1__invokeMdmResponse * SOAP_FMAC2 cross_instantiate__WS1__invokeMdmResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__invokeMdmResponse * soap_new__WS1__invokeMdmResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__invokeMdmResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__invokeMdmResponse * soap_new_req__WS1__invokeMdmResponse(
	struct soap *soap,
	const std::string& invokeMdmReturn)
{
	_WS1__invokeMdmResponse *_p = ::soap_new__WS1__invokeMdmResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeMdmResponse::invokeMdmReturn = invokeMdmReturn;
	}
	return _p;
}

inline _WS1__invokeMdmResponse * soap_new_set__WS1__invokeMdmResponse(
	struct soap *soap,
	const std::string& invokeMdmReturn)
{
	_WS1__invokeMdmResponse *_p = ::soap_new__WS1__invokeMdmResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeMdmResponse::invokeMdmReturn = invokeMdmReturn;
	}
	return _p;
}

inline int soap_write__WS1__invokeMdmResponse(struct soap *soap, _WS1__invokeMdmResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeMdmResponse", p->soap_type() == SOAP_TYPE__WS1__invokeMdmResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__invokeMdmResponse(struct soap *soap, const char *URL, _WS1__invokeMdmResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeMdmResponse", p->soap_type() == SOAP_TYPE__WS1__invokeMdmResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__invokeMdmResponse(struct soap *soap, const char *URL, _WS1__invokeMdmResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeMdmResponse", p->soap_type() == SOAP_TYPE__WS1__invokeMdmResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__invokeMdmResponse(struct soap *soap, const char *URL, _WS1__invokeMdmResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeMdmResponse", p->soap_type() == SOAP_TYPE__WS1__invokeMdmResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__invokeMdmResponse * SOAP_FMAC4 soap_get__WS1__invokeMdmResponse(struct soap*, _WS1__invokeMdmResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__invokeMdmResponse(struct soap *soap, _WS1__invokeMdmResponse *p)
{
	if (::soap_read__WS1__invokeMdmResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__invokeMdm_DEFINED
#define SOAP_TYPE__WS1__invokeMdm_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeMdm(struct soap*, const char*, int, const _WS1__invokeMdm *, const char*);
SOAP_FMAC3 _WS1__invokeMdm * SOAP_FMAC4 soap_in__WS1__invokeMdm(struct soap*, const char*, _WS1__invokeMdm *, const char*);
SOAP_FMAC1 _WS1__invokeMdm * SOAP_FMAC2 cross_instantiate__WS1__invokeMdm(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__invokeMdm * soap_new__WS1__invokeMdm(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__invokeMdm(soap, n, NULL, NULL, NULL);
}

inline _WS1__invokeMdm * soap_new_req__WS1__invokeMdm(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__invokeMdm *_p = ::soap_new__WS1__invokeMdm(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeMdm::in0 = in0;
	}
	return _p;
}

inline _WS1__invokeMdm * soap_new_set__WS1__invokeMdm(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__invokeMdm *_p = ::soap_new__WS1__invokeMdm(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeMdm::in0 = in0;
	}
	return _p;
}

inline int soap_write__WS1__invokeMdm(struct soap *soap, _WS1__invokeMdm const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeMdm", p->soap_type() == SOAP_TYPE__WS1__invokeMdm ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__invokeMdm(struct soap *soap, const char *URL, _WS1__invokeMdm const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeMdm", p->soap_type() == SOAP_TYPE__WS1__invokeMdm ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__invokeMdm(struct soap *soap, const char *URL, _WS1__invokeMdm const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeMdm", p->soap_type() == SOAP_TYPE__WS1__invokeMdm ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__invokeMdm(struct soap *soap, const char *URL, _WS1__invokeMdm const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeMdm", p->soap_type() == SOAP_TYPE__WS1__invokeMdm ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__invokeMdm * SOAP_FMAC4 soap_get__WS1__invokeMdm(struct soap*, _WS1__invokeMdm *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__invokeMdm(struct soap *soap, _WS1__invokeMdm *p)
{
	if (::soap_read__WS1__invokeMdm(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__invokeUnionResponse_DEFINED
#define SOAP_TYPE__WS1__invokeUnionResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeUnionResponse(struct soap*, const char*, int, const _WS1__invokeUnionResponse *, const char*);
SOAP_FMAC3 _WS1__invokeUnionResponse * SOAP_FMAC4 soap_in__WS1__invokeUnionResponse(struct soap*, const char*, _WS1__invokeUnionResponse *, const char*);
SOAP_FMAC1 _WS1__invokeUnionResponse * SOAP_FMAC2 cross_instantiate__WS1__invokeUnionResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__invokeUnionResponse * soap_new__WS1__invokeUnionResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__invokeUnionResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__invokeUnionResponse * soap_new_req__WS1__invokeUnionResponse(
	struct soap *soap,
	const std::string& invokeUnionReturn)
{
	_WS1__invokeUnionResponse *_p = ::soap_new__WS1__invokeUnionResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeUnionResponse::invokeUnionReturn = invokeUnionReturn;
	}
	return _p;
}

inline _WS1__invokeUnionResponse * soap_new_set__WS1__invokeUnionResponse(
	struct soap *soap,
	const std::string& invokeUnionReturn)
{
	_WS1__invokeUnionResponse *_p = ::soap_new__WS1__invokeUnionResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeUnionResponse::invokeUnionReturn = invokeUnionReturn;
	}
	return _p;
}

inline int soap_write__WS1__invokeUnionResponse(struct soap *soap, _WS1__invokeUnionResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeUnionResponse", p->soap_type() == SOAP_TYPE__WS1__invokeUnionResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__invokeUnionResponse(struct soap *soap, const char *URL, _WS1__invokeUnionResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeUnionResponse", p->soap_type() == SOAP_TYPE__WS1__invokeUnionResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__invokeUnionResponse(struct soap *soap, const char *URL, _WS1__invokeUnionResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeUnionResponse", p->soap_type() == SOAP_TYPE__WS1__invokeUnionResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__invokeUnionResponse(struct soap *soap, const char *URL, _WS1__invokeUnionResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeUnionResponse", p->soap_type() == SOAP_TYPE__WS1__invokeUnionResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__invokeUnionResponse * SOAP_FMAC4 soap_get__WS1__invokeUnionResponse(struct soap*, _WS1__invokeUnionResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__invokeUnionResponse(struct soap *soap, _WS1__invokeUnionResponse *p)
{
	if (::soap_read__WS1__invokeUnionResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__invokeUnion_DEFINED
#define SOAP_TYPE__WS1__invokeUnion_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeUnion(struct soap*, const char*, int, const _WS1__invokeUnion *, const char*);
SOAP_FMAC3 _WS1__invokeUnion * SOAP_FMAC4 soap_in__WS1__invokeUnion(struct soap*, const char*, _WS1__invokeUnion *, const char*);
SOAP_FMAC1 _WS1__invokeUnion * SOAP_FMAC2 cross_instantiate__WS1__invokeUnion(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__invokeUnion * soap_new__WS1__invokeUnion(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__invokeUnion(soap, n, NULL, NULL, NULL);
}

inline _WS1__invokeUnion * soap_new_req__WS1__invokeUnion(
	struct soap *soap,
	const std::string& in0,
	const std::string& in1)
{
	_WS1__invokeUnion *_p = ::soap_new__WS1__invokeUnion(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeUnion::in0 = in0;
		_p->_WS1__invokeUnion::in1 = in1;
	}
	return _p;
}

inline _WS1__invokeUnion * soap_new_set__WS1__invokeUnion(
	struct soap *soap,
	const std::string& in0,
	const std::string& in1)
{
	_WS1__invokeUnion *_p = ::soap_new__WS1__invokeUnion(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeUnion::in0 = in0;
		_p->_WS1__invokeUnion::in1 = in1;
	}
	return _p;
}

inline int soap_write__WS1__invokeUnion(struct soap *soap, _WS1__invokeUnion const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeUnion", p->soap_type() == SOAP_TYPE__WS1__invokeUnion ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__invokeUnion(struct soap *soap, const char *URL, _WS1__invokeUnion const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeUnion", p->soap_type() == SOAP_TYPE__WS1__invokeUnion ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__invokeUnion(struct soap *soap, const char *URL, _WS1__invokeUnion const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeUnion", p->soap_type() == SOAP_TYPE__WS1__invokeUnion ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__invokeUnion(struct soap *soap, const char *URL, _WS1__invokeUnion const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeUnion", p->soap_type() == SOAP_TYPE__WS1__invokeUnion ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__invokeUnion * SOAP_FMAC4 soap_get__WS1__invokeUnion(struct soap*, _WS1__invokeUnion *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__invokeUnion(struct soap *soap, _WS1__invokeUnion *p)
{
	if (::soap_read__WS1__invokeUnion(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__regProdAPResponse_DEFINED
#define SOAP_TYPE__WS1__regProdAPResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__regProdAPResponse(struct soap*, const char*, int, const _WS1__regProdAPResponse *, const char*);
SOAP_FMAC3 _WS1__regProdAPResponse * SOAP_FMAC4 soap_in__WS1__regProdAPResponse(struct soap*, const char*, _WS1__regProdAPResponse *, const char*);
SOAP_FMAC1 _WS1__regProdAPResponse * SOAP_FMAC2 cross_instantiate__WS1__regProdAPResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__regProdAPResponse * soap_new__WS1__regProdAPResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__regProdAPResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__regProdAPResponse * soap_new_req__WS1__regProdAPResponse(
	struct soap *soap,
	const std::string& regProdAPReturn)
{
	_WS1__regProdAPResponse *_p = ::soap_new__WS1__regProdAPResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__regProdAPResponse::regProdAPReturn = regProdAPReturn;
	}
	return _p;
}

inline _WS1__regProdAPResponse * soap_new_set__WS1__regProdAPResponse(
	struct soap *soap,
	const std::string& regProdAPReturn)
{
	_WS1__regProdAPResponse *_p = ::soap_new__WS1__regProdAPResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__regProdAPResponse::regProdAPReturn = regProdAPReturn;
	}
	return _p;
}

inline int soap_write__WS1__regProdAPResponse(struct soap *soap, _WS1__regProdAPResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regProdAPResponse", p->soap_type() == SOAP_TYPE__WS1__regProdAPResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__regProdAPResponse(struct soap *soap, const char *URL, _WS1__regProdAPResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regProdAPResponse", p->soap_type() == SOAP_TYPE__WS1__regProdAPResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__regProdAPResponse(struct soap *soap, const char *URL, _WS1__regProdAPResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regProdAPResponse", p->soap_type() == SOAP_TYPE__WS1__regProdAPResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__regProdAPResponse(struct soap *soap, const char *URL, _WS1__regProdAPResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regProdAPResponse", p->soap_type() == SOAP_TYPE__WS1__regProdAPResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__regProdAPResponse * SOAP_FMAC4 soap_get__WS1__regProdAPResponse(struct soap*, _WS1__regProdAPResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__regProdAPResponse(struct soap *soap, _WS1__regProdAPResponse *p)
{
	if (::soap_read__WS1__regProdAPResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__regProdAP_DEFINED
#define SOAP_TYPE__WS1__regProdAP_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__regProdAP(struct soap*, const char*, int, const _WS1__regProdAP *, const char*);
SOAP_FMAC3 _WS1__regProdAP * SOAP_FMAC4 soap_in__WS1__regProdAP(struct soap*, const char*, _WS1__regProdAP *, const char*);
SOAP_FMAC1 _WS1__regProdAP * SOAP_FMAC2 cross_instantiate__WS1__regProdAP(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__regProdAP * soap_new__WS1__regProdAP(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__regProdAP(soap, n, NULL, NULL, NULL);
}

inline _WS1__regProdAP * soap_new_req__WS1__regProdAP(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__regProdAP *_p = ::soap_new__WS1__regProdAP(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__regProdAP::in0 = in0;
	}
	return _p;
}

inline _WS1__regProdAP * soap_new_set__WS1__regProdAP(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__regProdAP *_p = ::soap_new__WS1__regProdAP(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__regProdAP::in0 = in0;
	}
	return _p;
}

inline int soap_write__WS1__regProdAP(struct soap *soap, _WS1__regProdAP const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regProdAP", p->soap_type() == SOAP_TYPE__WS1__regProdAP ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__regProdAP(struct soap *soap, const char *URL, _WS1__regProdAP const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regProdAP", p->soap_type() == SOAP_TYPE__WS1__regProdAP ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__regProdAP(struct soap *soap, const char *URL, _WS1__regProdAP const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regProdAP", p->soap_type() == SOAP_TYPE__WS1__regProdAP ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__regProdAP(struct soap *soap, const char *URL, _WS1__regProdAP const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:regProdAP", p->soap_type() == SOAP_TYPE__WS1__regProdAP ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__regProdAP * SOAP_FMAC4 soap_get__WS1__regProdAP(struct soap*, _WS1__regProdAP *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__regProdAP(struct soap *soap, _WS1__regProdAP *p)
{
	if (::soap_read__WS1__regProdAP(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__getProdListResponse_DEFINED
#define SOAP_TYPE__WS1__getProdListResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getProdListResponse(struct soap*, const char*, int, const _WS1__getProdListResponse *, const char*);
SOAP_FMAC3 _WS1__getProdListResponse * SOAP_FMAC4 soap_in__WS1__getProdListResponse(struct soap*, const char*, _WS1__getProdListResponse *, const char*);
SOAP_FMAC1 _WS1__getProdListResponse * SOAP_FMAC2 cross_instantiate__WS1__getProdListResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__getProdListResponse * soap_new__WS1__getProdListResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__getProdListResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__getProdListResponse * soap_new_req__WS1__getProdListResponse(
	struct soap *soap,
	const std::string& getProdListReturn)
{
	_WS1__getProdListResponse *_p = ::soap_new__WS1__getProdListResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getProdListResponse::getProdListReturn = getProdListReturn;
	}
	return _p;
}

inline _WS1__getProdListResponse * soap_new_set__WS1__getProdListResponse(
	struct soap *soap,
	const std::string& getProdListReturn)
{
	_WS1__getProdListResponse *_p = ::soap_new__WS1__getProdListResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getProdListResponse::getProdListReturn = getProdListReturn;
	}
	return _p;
}

inline int soap_write__WS1__getProdListResponse(struct soap *soap, _WS1__getProdListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProdListResponse", p->soap_type() == SOAP_TYPE__WS1__getProdListResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__getProdListResponse(struct soap *soap, const char *URL, _WS1__getProdListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProdListResponse", p->soap_type() == SOAP_TYPE__WS1__getProdListResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__getProdListResponse(struct soap *soap, const char *URL, _WS1__getProdListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProdListResponse", p->soap_type() == SOAP_TYPE__WS1__getProdListResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__getProdListResponse(struct soap *soap, const char *URL, _WS1__getProdListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProdListResponse", p->soap_type() == SOAP_TYPE__WS1__getProdListResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__getProdListResponse * SOAP_FMAC4 soap_get__WS1__getProdListResponse(struct soap*, _WS1__getProdListResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__getProdListResponse(struct soap *soap, _WS1__getProdListResponse *p)
{
	if (::soap_read__WS1__getProdListResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__getProdList_DEFINED
#define SOAP_TYPE__WS1__getProdList_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getProdList(struct soap*, const char*, int, const _WS1__getProdList *, const char*);
SOAP_FMAC3 _WS1__getProdList * SOAP_FMAC4 soap_in__WS1__getProdList(struct soap*, const char*, _WS1__getProdList *, const char*);
SOAP_FMAC1 _WS1__getProdList * SOAP_FMAC2 cross_instantiate__WS1__getProdList(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__getProdList * soap_new__WS1__getProdList(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__getProdList(soap, n, NULL, NULL, NULL);
}

inline _WS1__getProdList * soap_new_req__WS1__getProdList(
	struct soap *soap)
{
	_WS1__getProdList *_p = ::soap_new__WS1__getProdList(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline _WS1__getProdList * soap_new_set__WS1__getProdList(
	struct soap *soap)
{
	_WS1__getProdList *_p = ::soap_new__WS1__getProdList(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline int soap_write__WS1__getProdList(struct soap *soap, _WS1__getProdList const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProdList", p->soap_type() == SOAP_TYPE__WS1__getProdList ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__getProdList(struct soap *soap, const char *URL, _WS1__getProdList const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProdList", p->soap_type() == SOAP_TYPE__WS1__getProdList ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__getProdList(struct soap *soap, const char *URL, _WS1__getProdList const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProdList", p->soap_type() == SOAP_TYPE__WS1__getProdList ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__getProdList(struct soap *soap, const char *URL, _WS1__getProdList const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getProdList", p->soap_type() == SOAP_TYPE__WS1__getProdList ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__getProdList * SOAP_FMAC4 soap_get__WS1__getProdList(struct soap*, _WS1__getProdList *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__getProdList(struct soap *soap, _WS1__getProdList *p)
{
	if (::soap_read__WS1__getProdList(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__getParamListResponse_DEFINED
#define SOAP_TYPE__WS1__getParamListResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getParamListResponse(struct soap*, const char*, int, const _WS1__getParamListResponse *, const char*);
SOAP_FMAC3 _WS1__getParamListResponse * SOAP_FMAC4 soap_in__WS1__getParamListResponse(struct soap*, const char*, _WS1__getParamListResponse *, const char*);
SOAP_FMAC1 _WS1__getParamListResponse * SOAP_FMAC2 cross_instantiate__WS1__getParamListResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__getParamListResponse * soap_new__WS1__getParamListResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__getParamListResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__getParamListResponse * soap_new_req__WS1__getParamListResponse(
	struct soap *soap,
	const std::string& getParamListReturn)
{
	_WS1__getParamListResponse *_p = ::soap_new__WS1__getParamListResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getParamListResponse::getParamListReturn = getParamListReturn;
	}
	return _p;
}

inline _WS1__getParamListResponse * soap_new_set__WS1__getParamListResponse(
	struct soap *soap,
	const std::string& getParamListReturn)
{
	_WS1__getParamListResponse *_p = ::soap_new__WS1__getParamListResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getParamListResponse::getParamListReturn = getParamListReturn;
	}
	return _p;
}

inline int soap_write__WS1__getParamListResponse(struct soap *soap, _WS1__getParamListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getParamListResponse", p->soap_type() == SOAP_TYPE__WS1__getParamListResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__getParamListResponse(struct soap *soap, const char *URL, _WS1__getParamListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getParamListResponse", p->soap_type() == SOAP_TYPE__WS1__getParamListResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__getParamListResponse(struct soap *soap, const char *URL, _WS1__getParamListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getParamListResponse", p->soap_type() == SOAP_TYPE__WS1__getParamListResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__getParamListResponse(struct soap *soap, const char *URL, _WS1__getParamListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getParamListResponse", p->soap_type() == SOAP_TYPE__WS1__getParamListResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__getParamListResponse * SOAP_FMAC4 soap_get__WS1__getParamListResponse(struct soap*, _WS1__getParamListResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__getParamListResponse(struct soap *soap, _WS1__getParamListResponse *p)
{
	if (::soap_read__WS1__getParamListResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__getParamList_DEFINED
#define SOAP_TYPE__WS1__getParamList_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getParamList(struct soap*, const char*, int, const _WS1__getParamList *, const char*);
SOAP_FMAC3 _WS1__getParamList * SOAP_FMAC4 soap_in__WS1__getParamList(struct soap*, const char*, _WS1__getParamList *, const char*);
SOAP_FMAC1 _WS1__getParamList * SOAP_FMAC2 cross_instantiate__WS1__getParamList(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__getParamList * soap_new__WS1__getParamList(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__getParamList(soap, n, NULL, NULL, NULL);
}

inline _WS1__getParamList * soap_new_req__WS1__getParamList(
	struct soap *soap)
{
	_WS1__getParamList *_p = ::soap_new__WS1__getParamList(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline _WS1__getParamList * soap_new_set__WS1__getParamList(
	struct soap *soap)
{
	_WS1__getParamList *_p = ::soap_new__WS1__getParamList(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline int soap_write__WS1__getParamList(struct soap *soap, _WS1__getParamList const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getParamList", p->soap_type() == SOAP_TYPE__WS1__getParamList ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__getParamList(struct soap *soap, const char *URL, _WS1__getParamList const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getParamList", p->soap_type() == SOAP_TYPE__WS1__getParamList ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__getParamList(struct soap *soap, const char *URL, _WS1__getParamList const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getParamList", p->soap_type() == SOAP_TYPE__WS1__getParamList ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__getParamList(struct soap *soap, const char *URL, _WS1__getParamList const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getParamList", p->soap_type() == SOAP_TYPE__WS1__getParamList ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__getParamList * SOAP_FMAC4 soap_get__WS1__getParamList(struct soap*, _WS1__getParamList *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__getParamList(struct soap *soap, _WS1__getParamList *p)
{
	if (::soap_read__WS1__getParamList(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__getEtlJobListResponse_DEFINED
#define SOAP_TYPE__WS1__getEtlJobListResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getEtlJobListResponse(struct soap*, const char*, int, const _WS1__getEtlJobListResponse *, const char*);
SOAP_FMAC3 _WS1__getEtlJobListResponse * SOAP_FMAC4 soap_in__WS1__getEtlJobListResponse(struct soap*, const char*, _WS1__getEtlJobListResponse *, const char*);
SOAP_FMAC1 _WS1__getEtlJobListResponse * SOAP_FMAC2 cross_instantiate__WS1__getEtlJobListResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__getEtlJobListResponse * soap_new__WS1__getEtlJobListResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__getEtlJobListResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__getEtlJobListResponse * soap_new_req__WS1__getEtlJobListResponse(
	struct soap *soap,
	const std::string& getEtlJobListReturn)
{
	_WS1__getEtlJobListResponse *_p = ::soap_new__WS1__getEtlJobListResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getEtlJobListResponse::getEtlJobListReturn = getEtlJobListReturn;
	}
	return _p;
}

inline _WS1__getEtlJobListResponse * soap_new_set__WS1__getEtlJobListResponse(
	struct soap *soap,
	const std::string& getEtlJobListReturn)
{
	_WS1__getEtlJobListResponse *_p = ::soap_new__WS1__getEtlJobListResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getEtlJobListResponse::getEtlJobListReturn = getEtlJobListReturn;
	}
	return _p;
}

inline int soap_write__WS1__getEtlJobListResponse(struct soap *soap, _WS1__getEtlJobListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getEtlJobListResponse", p->soap_type() == SOAP_TYPE__WS1__getEtlJobListResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__getEtlJobListResponse(struct soap *soap, const char *URL, _WS1__getEtlJobListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getEtlJobListResponse", p->soap_type() == SOAP_TYPE__WS1__getEtlJobListResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__getEtlJobListResponse(struct soap *soap, const char *URL, _WS1__getEtlJobListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getEtlJobListResponse", p->soap_type() == SOAP_TYPE__WS1__getEtlJobListResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__getEtlJobListResponse(struct soap *soap, const char *URL, _WS1__getEtlJobListResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getEtlJobListResponse", p->soap_type() == SOAP_TYPE__WS1__getEtlJobListResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__getEtlJobListResponse * SOAP_FMAC4 soap_get__WS1__getEtlJobListResponse(struct soap*, _WS1__getEtlJobListResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__getEtlJobListResponse(struct soap *soap, _WS1__getEtlJobListResponse *p)
{
	if (::soap_read__WS1__getEtlJobListResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__getEtlJobList_DEFINED
#define SOAP_TYPE__WS1__getEtlJobList_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getEtlJobList(struct soap*, const char*, int, const _WS1__getEtlJobList *, const char*);
SOAP_FMAC3 _WS1__getEtlJobList * SOAP_FMAC4 soap_in__WS1__getEtlJobList(struct soap*, const char*, _WS1__getEtlJobList *, const char*);
SOAP_FMAC1 _WS1__getEtlJobList * SOAP_FMAC2 cross_instantiate__WS1__getEtlJobList(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__getEtlJobList * soap_new__WS1__getEtlJobList(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__getEtlJobList(soap, n, NULL, NULL, NULL);
}

inline _WS1__getEtlJobList * soap_new_req__WS1__getEtlJobList(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__getEtlJobList *_p = ::soap_new__WS1__getEtlJobList(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getEtlJobList::in0 = in0;
	}
	return _p;
}

inline _WS1__getEtlJobList * soap_new_set__WS1__getEtlJobList(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__getEtlJobList *_p = ::soap_new__WS1__getEtlJobList(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__getEtlJobList::in0 = in0;
	}
	return _p;
}

inline int soap_write__WS1__getEtlJobList(struct soap *soap, _WS1__getEtlJobList const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getEtlJobList", p->soap_type() == SOAP_TYPE__WS1__getEtlJobList ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__getEtlJobList(struct soap *soap, const char *URL, _WS1__getEtlJobList const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getEtlJobList", p->soap_type() == SOAP_TYPE__WS1__getEtlJobList ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__getEtlJobList(struct soap *soap, const char *URL, _WS1__getEtlJobList const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getEtlJobList", p->soap_type() == SOAP_TYPE__WS1__getEtlJobList ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__getEtlJobList(struct soap *soap, const char *URL, _WS1__getEtlJobList const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:getEtlJobList", p->soap_type() == SOAP_TYPE__WS1__getEtlJobList ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__getEtlJobList * SOAP_FMAC4 soap_get__WS1__getEtlJobList(struct soap*, _WS1__getEtlJobList *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__getEtlJobList(struct soap *soap, _WS1__getEtlJobList *p)
{
	if (::soap_read__WS1__getEtlJobList(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__invokeEtlResponse_DEFINED
#define SOAP_TYPE__WS1__invokeEtlResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeEtlResponse(struct soap*, const char*, int, const _WS1__invokeEtlResponse *, const char*);
SOAP_FMAC3 _WS1__invokeEtlResponse * SOAP_FMAC4 soap_in__WS1__invokeEtlResponse(struct soap*, const char*, _WS1__invokeEtlResponse *, const char*);
SOAP_FMAC1 _WS1__invokeEtlResponse * SOAP_FMAC2 cross_instantiate__WS1__invokeEtlResponse(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__invokeEtlResponse * soap_new__WS1__invokeEtlResponse(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__invokeEtlResponse(soap, n, NULL, NULL, NULL);
}

inline _WS1__invokeEtlResponse * soap_new_req__WS1__invokeEtlResponse(
	struct soap *soap,
	const std::string& invokeEtlReturn)
{
	_WS1__invokeEtlResponse *_p = ::soap_new__WS1__invokeEtlResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeEtlResponse::invokeEtlReturn = invokeEtlReturn;
	}
	return _p;
}

inline _WS1__invokeEtlResponse * soap_new_set__WS1__invokeEtlResponse(
	struct soap *soap,
	const std::string& invokeEtlReturn)
{
	_WS1__invokeEtlResponse *_p = ::soap_new__WS1__invokeEtlResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeEtlResponse::invokeEtlReturn = invokeEtlReturn;
	}
	return _p;
}

inline int soap_write__WS1__invokeEtlResponse(struct soap *soap, _WS1__invokeEtlResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeEtlResponse", p->soap_type() == SOAP_TYPE__WS1__invokeEtlResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__invokeEtlResponse(struct soap *soap, const char *URL, _WS1__invokeEtlResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeEtlResponse", p->soap_type() == SOAP_TYPE__WS1__invokeEtlResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__invokeEtlResponse(struct soap *soap, const char *URL, _WS1__invokeEtlResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeEtlResponse", p->soap_type() == SOAP_TYPE__WS1__invokeEtlResponse ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__invokeEtlResponse(struct soap *soap, const char *URL, _WS1__invokeEtlResponse const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeEtlResponse", p->soap_type() == SOAP_TYPE__WS1__invokeEtlResponse ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__invokeEtlResponse * SOAP_FMAC4 soap_get__WS1__invokeEtlResponse(struct soap*, _WS1__invokeEtlResponse *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__invokeEtlResponse(struct soap *soap, _WS1__invokeEtlResponse *p)
{
	if (::soap_read__WS1__invokeEtlResponse(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE__WS1__invokeEtl_DEFINED
#define SOAP_TYPE__WS1__invokeEtl_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeEtl(struct soap*, const char*, int, const _WS1__invokeEtl *, const char*);
SOAP_FMAC3 _WS1__invokeEtl * SOAP_FMAC4 soap_in__WS1__invokeEtl(struct soap*, const char*, _WS1__invokeEtl *, const char*);
SOAP_FMAC1 _WS1__invokeEtl * SOAP_FMAC2 cross_instantiate__WS1__invokeEtl(struct soap*, int, const char*, const char*, size_t*);

inline _WS1__invokeEtl * soap_new__WS1__invokeEtl(struct soap *soap, int n = -1)
{
	return cross_instantiate__WS1__invokeEtl(soap, n, NULL, NULL, NULL);
}

inline _WS1__invokeEtl * soap_new_req__WS1__invokeEtl(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__invokeEtl *_p = ::soap_new__WS1__invokeEtl(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeEtl::in0 = in0;
	}
	return _p;
}

inline _WS1__invokeEtl * soap_new_set__WS1__invokeEtl(
	struct soap *soap,
	const std::string& in0)
{
	_WS1__invokeEtl *_p = ::soap_new__WS1__invokeEtl(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_WS1__invokeEtl::in0 = in0;
	}
	return _p;
}

inline int soap_write__WS1__invokeEtl(struct soap *soap, _WS1__invokeEtl const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeEtl", p->soap_type() == SOAP_TYPE__WS1__invokeEtl ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__WS1__invokeEtl(struct soap *soap, const char *URL, _WS1__invokeEtl const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeEtl", p->soap_type() == SOAP_TYPE__WS1__invokeEtl ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH__WS1__invokeEtl(struct soap *soap, const char *URL, _WS1__invokeEtl const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeEtl", p->soap_type() == SOAP_TYPE__WS1__invokeEtl ? "" : NULL) || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send__WS1__invokeEtl(struct soap *soap, const char *URL, _WS1__invokeEtl const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (p->soap_serialize(soap), 0) || p->soap_put(soap, "WS1:invokeEtl", p->soap_type() == SOAP_TYPE__WS1__invokeEtl ? "" : NULL) || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 _WS1__invokeEtl * SOAP_FMAC4 soap_get__WS1__invokeEtl(struct soap*, _WS1__invokeEtl *, const char*, const char*);

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

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

inline int soap_POST_recv__WS1__invokeEtl(struct soap *soap, _WS1__invokeEtl *p)
{
	if (::soap_read__WS1__invokeEtl(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 cross_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 cross_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 cross_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 cross_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__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 cross_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 cross_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__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 cross_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 cross_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__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 cross_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 cross_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)
{
	struct SOAP_ENV__Header *_p = ::soap_new_SOAP_ENV__Header(soap);
	if (_p)
	{	::soap_default_SOAP_ENV__Header(soap, _p);
	}
	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

#ifndef SOAP_TYPE___WS1__escrowResendSrv_DEFINED
#define SOAP_TYPE___WS1__escrowResendSrv_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__escrowResendSrv(struct soap*, struct __WS1__escrowResendSrv *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__escrowResendSrv(struct soap*, const struct __WS1__escrowResendSrv *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__escrowResendSrv(struct soap*, const char*, int, const struct __WS1__escrowResendSrv *, const char*);
SOAP_FMAC3 struct __WS1__escrowResendSrv * SOAP_FMAC4 soap_in___WS1__escrowResendSrv(struct soap*, const char*, struct __WS1__escrowResendSrv *, const char*);
SOAP_FMAC1 struct __WS1__escrowResendSrv * SOAP_FMAC2 cross_instantiate___WS1__escrowResendSrv(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__escrowResendSrv * soap_new___WS1__escrowResendSrv(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__escrowResendSrv(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__escrowResendSrv * soap_new_req___WS1__escrowResendSrv(
	struct soap *soap)
{
	struct __WS1__escrowResendSrv *_p = ::soap_new___WS1__escrowResendSrv(soap);
	if (_p)
	{	::soap_default___WS1__escrowResendSrv(soap, _p);
	}
	return _p;
}

inline struct __WS1__escrowResendSrv * soap_new_set___WS1__escrowResendSrv(
	struct soap *soap,
	_WS1__escrowResendSrv *WS1__escrowResendSrv)
{
	struct __WS1__escrowResendSrv *_p = ::soap_new___WS1__escrowResendSrv(soap);
	if (_p)
	{	::soap_default___WS1__escrowResendSrv(soap, _p);
		_p->WS1__escrowResendSrv = WS1__escrowResendSrv;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__escrowResendSrv(struct soap*, const struct __WS1__escrowResendSrv *, const char*, const char*);

inline int soap_write___WS1__escrowResendSrv(struct soap *soap, struct __WS1__escrowResendSrv const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__escrowResendSrv(soap, p), 0) || ::soap_put___WS1__escrowResendSrv(soap, p, "-WS1:escrowResendSrv", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__escrowResendSrv(struct soap *soap, const char *URL, struct __WS1__escrowResendSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__escrowResendSrv(soap, p), 0) || ::soap_put___WS1__escrowResendSrv(soap, p, "-WS1:escrowResendSrv", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__escrowResendSrv(struct soap *soap, const char *URL, struct __WS1__escrowResendSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__escrowResendSrv(soap, p), 0) || ::soap_put___WS1__escrowResendSrv(soap, p, "-WS1:escrowResendSrv", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__escrowResendSrv(struct soap *soap, const char *URL, struct __WS1__escrowResendSrv const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__escrowResendSrv(soap, p), 0) || ::soap_put___WS1__escrowResendSrv(soap, p, "-WS1:escrowResendSrv", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__escrowResendSrv * SOAP_FMAC4 soap_get___WS1__escrowResendSrv(struct soap*, struct __WS1__escrowResendSrv *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__escrowResendSrv(struct soap *soap, struct __WS1__escrowResendSrv *p)
{
	if (::soap_read___WS1__escrowResendSrv(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__invokeSrv_DEFINED
#define SOAP_TYPE___WS1__invokeSrv_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__invokeSrv(struct soap*, struct __WS1__invokeSrv *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__invokeSrv(struct soap*, const struct __WS1__invokeSrv *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__invokeSrv(struct soap*, const char*, int, const struct __WS1__invokeSrv *, const char*);
SOAP_FMAC3 struct __WS1__invokeSrv * SOAP_FMAC4 soap_in___WS1__invokeSrv(struct soap*, const char*, struct __WS1__invokeSrv *, const char*);
SOAP_FMAC1 struct __WS1__invokeSrv * SOAP_FMAC2 cross_instantiate___WS1__invokeSrv(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__invokeSrv * soap_new___WS1__invokeSrv(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__invokeSrv(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__invokeSrv * soap_new_req___WS1__invokeSrv(
	struct soap *soap)
{
	struct __WS1__invokeSrv *_p = ::soap_new___WS1__invokeSrv(soap);
	if (_p)
	{	::soap_default___WS1__invokeSrv(soap, _p);
	}
	return _p;
}

inline struct __WS1__invokeSrv * soap_new_set___WS1__invokeSrv(
	struct soap *soap,
	_WS1__invokeSrv *WS1__invokeSrv)
{
	struct __WS1__invokeSrv *_p = ::soap_new___WS1__invokeSrv(soap);
	if (_p)
	{	::soap_default___WS1__invokeSrv(soap, _p);
		_p->WS1__invokeSrv = WS1__invokeSrv;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__invokeSrv(struct soap*, const struct __WS1__invokeSrv *, const char*, const char*);

inline int soap_write___WS1__invokeSrv(struct soap *soap, struct __WS1__invokeSrv const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__invokeSrv(soap, p), 0) || ::soap_put___WS1__invokeSrv(soap, p, "-WS1:invokeSrv", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__invokeSrv(struct soap *soap, const char *URL, struct __WS1__invokeSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__invokeSrv(soap, p), 0) || ::soap_put___WS1__invokeSrv(soap, p, "-WS1:invokeSrv", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__invokeSrv(struct soap *soap, const char *URL, struct __WS1__invokeSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__invokeSrv(soap, p), 0) || ::soap_put___WS1__invokeSrv(soap, p, "-WS1:invokeSrv", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__invokeSrv(struct soap *soap, const char *URL, struct __WS1__invokeSrv const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__invokeSrv(soap, p), 0) || ::soap_put___WS1__invokeSrv(soap, p, "-WS1:invokeSrv", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__invokeSrv * SOAP_FMAC4 soap_get___WS1__invokeSrv(struct soap*, struct __WS1__invokeSrv *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__invokeSrv(struct soap *soap, struct __WS1__invokeSrv *p)
{
	if (::soap_read___WS1__invokeSrv(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__regEAI_DEFINED
#define SOAP_TYPE___WS1__regEAI_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__regEAI(struct soap*, struct __WS1__regEAI *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__regEAI(struct soap*, const struct __WS1__regEAI *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__regEAI(struct soap*, const char*, int, const struct __WS1__regEAI *, const char*);
SOAP_FMAC3 struct __WS1__regEAI * SOAP_FMAC4 soap_in___WS1__regEAI(struct soap*, const char*, struct __WS1__regEAI *, const char*);
SOAP_FMAC1 struct __WS1__regEAI * SOAP_FMAC2 cross_instantiate___WS1__regEAI(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__regEAI * soap_new___WS1__regEAI(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__regEAI(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__regEAI * soap_new_req___WS1__regEAI(
	struct soap *soap)
{
	struct __WS1__regEAI *_p = ::soap_new___WS1__regEAI(soap);
	if (_p)
	{	::soap_default___WS1__regEAI(soap, _p);
	}
	return _p;
}

inline struct __WS1__regEAI * soap_new_set___WS1__regEAI(
	struct soap *soap,
	_WS1__regEAI *WS1__regEAI)
{
	struct __WS1__regEAI *_p = ::soap_new___WS1__regEAI(soap);
	if (_p)
	{	::soap_default___WS1__regEAI(soap, _p);
		_p->WS1__regEAI = WS1__regEAI;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__regEAI(struct soap*, const struct __WS1__regEAI *, const char*, const char*);

inline int soap_write___WS1__regEAI(struct soap *soap, struct __WS1__regEAI const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__regEAI(soap, p), 0) || ::soap_put___WS1__regEAI(soap, p, "-WS1:regEAI", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__regEAI(struct soap *soap, const char *URL, struct __WS1__regEAI const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__regEAI(soap, p), 0) || ::soap_put___WS1__regEAI(soap, p, "-WS1:regEAI", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__regEAI(struct soap *soap, const char *URL, struct __WS1__regEAI const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__regEAI(soap, p), 0) || ::soap_put___WS1__regEAI(soap, p, "-WS1:regEAI", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__regEAI(struct soap *soap, const char *URL, struct __WS1__regEAI const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__regEAI(soap, p), 0) || ::soap_put___WS1__regEAI(soap, p, "-WS1:regEAI", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__regEAI * SOAP_FMAC4 soap_get___WS1__regEAI(struct soap*, struct __WS1__regEAI *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__regEAI(struct soap *soap, struct __WS1__regEAI *p)
{
	if (::soap_read___WS1__regEAI(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__regSrv_DEFINED
#define SOAP_TYPE___WS1__regSrv_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__regSrv(struct soap*, struct __WS1__regSrv *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__regSrv(struct soap*, const struct __WS1__regSrv *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__regSrv(struct soap*, const char*, int, const struct __WS1__regSrv *, const char*);
SOAP_FMAC3 struct __WS1__regSrv * SOAP_FMAC4 soap_in___WS1__regSrv(struct soap*, const char*, struct __WS1__regSrv *, const char*);
SOAP_FMAC1 struct __WS1__regSrv * SOAP_FMAC2 cross_instantiate___WS1__regSrv(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__regSrv * soap_new___WS1__regSrv(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__regSrv(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__regSrv * soap_new_req___WS1__regSrv(
	struct soap *soap)
{
	struct __WS1__regSrv *_p = ::soap_new___WS1__regSrv(soap);
	if (_p)
	{	::soap_default___WS1__regSrv(soap, _p);
	}
	return _p;
}

inline struct __WS1__regSrv * soap_new_set___WS1__regSrv(
	struct soap *soap,
	_WS1__regSrv *WS1__regSrv)
{
	struct __WS1__regSrv *_p = ::soap_new___WS1__regSrv(soap);
	if (_p)
	{	::soap_default___WS1__regSrv(soap, _p);
		_p->WS1__regSrv = WS1__regSrv;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__regSrv(struct soap*, const struct __WS1__regSrv *, const char*, const char*);

inline int soap_write___WS1__regSrv(struct soap *soap, struct __WS1__regSrv const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__regSrv(soap, p), 0) || ::soap_put___WS1__regSrv(soap, p, "-WS1:regSrv", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__regSrv(struct soap *soap, const char *URL, struct __WS1__regSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__regSrv(soap, p), 0) || ::soap_put___WS1__regSrv(soap, p, "-WS1:regSrv", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__regSrv(struct soap *soap, const char *URL, struct __WS1__regSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__regSrv(soap, p), 0) || ::soap_put___WS1__regSrv(soap, p, "-WS1:regSrv", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__regSrv(struct soap *soap, const char *URL, struct __WS1__regSrv const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__regSrv(soap, p), 0) || ::soap_put___WS1__regSrv(soap, p, "-WS1:regSrv", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__regSrv * SOAP_FMAC4 soap_get___WS1__regSrv(struct soap*, struct __WS1__regSrv *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__regSrv(struct soap *soap, struct __WS1__regSrv *p)
{
	if (::soap_read___WS1__regSrv(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__getStandardDataNameList_DEFINED
#define SOAP_TYPE___WS1__getStandardDataNameList_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__getStandardDataNameList(struct soap*, struct __WS1__getStandardDataNameList *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__getStandardDataNameList(struct soap*, const struct __WS1__getStandardDataNameList *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__getStandardDataNameList(struct soap*, const char*, int, const struct __WS1__getStandardDataNameList *, const char*);
SOAP_FMAC3 struct __WS1__getStandardDataNameList * SOAP_FMAC4 soap_in___WS1__getStandardDataNameList(struct soap*, const char*, struct __WS1__getStandardDataNameList *, const char*);
SOAP_FMAC1 struct __WS1__getStandardDataNameList * SOAP_FMAC2 cross_instantiate___WS1__getStandardDataNameList(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__getStandardDataNameList * soap_new___WS1__getStandardDataNameList(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__getStandardDataNameList(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__getStandardDataNameList * soap_new_req___WS1__getStandardDataNameList(
	struct soap *soap)
{
	struct __WS1__getStandardDataNameList *_p = ::soap_new___WS1__getStandardDataNameList(soap);
	if (_p)
	{	::soap_default___WS1__getStandardDataNameList(soap, _p);
	}
	return _p;
}

inline struct __WS1__getStandardDataNameList * soap_new_set___WS1__getStandardDataNameList(
	struct soap *soap,
	_WS1__getStandardDataNameList *WS1__getStandardDataNameList)
{
	struct __WS1__getStandardDataNameList *_p = ::soap_new___WS1__getStandardDataNameList(soap);
	if (_p)
	{	::soap_default___WS1__getStandardDataNameList(soap, _p);
		_p->WS1__getStandardDataNameList = WS1__getStandardDataNameList;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__getStandardDataNameList(struct soap*, const struct __WS1__getStandardDataNameList *, const char*, const char*);

inline int soap_write___WS1__getStandardDataNameList(struct soap *soap, struct __WS1__getStandardDataNameList const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__getStandardDataNameList(soap, p), 0) || ::soap_put___WS1__getStandardDataNameList(soap, p, "-WS1:getStandardDataNameList", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__getStandardDataNameList(struct soap *soap, const char *URL, struct __WS1__getStandardDataNameList const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getStandardDataNameList(soap, p), 0) || ::soap_put___WS1__getStandardDataNameList(soap, p, "-WS1:getStandardDataNameList", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__getStandardDataNameList(struct soap *soap, const char *URL, struct __WS1__getStandardDataNameList const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getStandardDataNameList(soap, p), 0) || ::soap_put___WS1__getStandardDataNameList(soap, p, "-WS1:getStandardDataNameList", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__getStandardDataNameList(struct soap *soap, const char *URL, struct __WS1__getStandardDataNameList const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getStandardDataNameList(soap, p), 0) || ::soap_put___WS1__getStandardDataNameList(soap, p, "-WS1:getStandardDataNameList", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__getStandardDataNameList * SOAP_FMAC4 soap_get___WS1__getStandardDataNameList(struct soap*, struct __WS1__getStandardDataNameList *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__getStandardDataNameList(struct soap *soap, struct __WS1__getStandardDataNameList *p)
{
	if (::soap_read___WS1__getStandardDataNameList(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__getStandardServiceList_DEFINED
#define SOAP_TYPE___WS1__getStandardServiceList_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__getStandardServiceList(struct soap*, struct __WS1__getStandardServiceList *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__getStandardServiceList(struct soap*, const struct __WS1__getStandardServiceList *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__getStandardServiceList(struct soap*, const char*, int, const struct __WS1__getStandardServiceList *, const char*);
SOAP_FMAC3 struct __WS1__getStandardServiceList * SOAP_FMAC4 soap_in___WS1__getStandardServiceList(struct soap*, const char*, struct __WS1__getStandardServiceList *, const char*);
SOAP_FMAC1 struct __WS1__getStandardServiceList * SOAP_FMAC2 cross_instantiate___WS1__getStandardServiceList(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__getStandardServiceList * soap_new___WS1__getStandardServiceList(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__getStandardServiceList(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__getStandardServiceList * soap_new_req___WS1__getStandardServiceList(
	struct soap *soap)
{
	struct __WS1__getStandardServiceList *_p = ::soap_new___WS1__getStandardServiceList(soap);
	if (_p)
	{	::soap_default___WS1__getStandardServiceList(soap, _p);
	}
	return _p;
}

inline struct __WS1__getStandardServiceList * soap_new_set___WS1__getStandardServiceList(
	struct soap *soap,
	_WS1__getStandardServiceList *WS1__getStandardServiceList)
{
	struct __WS1__getStandardServiceList *_p = ::soap_new___WS1__getStandardServiceList(soap);
	if (_p)
	{	::soap_default___WS1__getStandardServiceList(soap, _p);
		_p->WS1__getStandardServiceList = WS1__getStandardServiceList;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__getStandardServiceList(struct soap*, const struct __WS1__getStandardServiceList *, const char*, const char*);

inline int soap_write___WS1__getStandardServiceList(struct soap *soap, struct __WS1__getStandardServiceList const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__getStandardServiceList(soap, p), 0) || ::soap_put___WS1__getStandardServiceList(soap, p, "-WS1:getStandardServiceList", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__getStandardServiceList(struct soap *soap, const char *URL, struct __WS1__getStandardServiceList const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getStandardServiceList(soap, p), 0) || ::soap_put___WS1__getStandardServiceList(soap, p, "-WS1:getStandardServiceList", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__getStandardServiceList(struct soap *soap, const char *URL, struct __WS1__getStandardServiceList const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getStandardServiceList(soap, p), 0) || ::soap_put___WS1__getStandardServiceList(soap, p, "-WS1:getStandardServiceList", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__getStandardServiceList(struct soap *soap, const char *URL, struct __WS1__getStandardServiceList const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getStandardServiceList(soap, p), 0) || ::soap_put___WS1__getStandardServiceList(soap, p, "-WS1:getStandardServiceList", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__getStandardServiceList * SOAP_FMAC4 soap_get___WS1__getStandardServiceList(struct soap*, struct __WS1__getStandardServiceList *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__getStandardServiceList(struct soap *soap, struct __WS1__getStandardServiceList *p)
{
	if (::soap_read___WS1__getStandardServiceList(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__fpInvoke_DEFINED
#define SOAP_TYPE___WS1__fpInvoke_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__fpInvoke(struct soap*, struct __WS1__fpInvoke *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__fpInvoke(struct soap*, const struct __WS1__fpInvoke *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__fpInvoke(struct soap*, const char*, int, const struct __WS1__fpInvoke *, const char*);
SOAP_FMAC3 struct __WS1__fpInvoke * SOAP_FMAC4 soap_in___WS1__fpInvoke(struct soap*, const char*, struct __WS1__fpInvoke *, const char*);
SOAP_FMAC1 struct __WS1__fpInvoke * SOAP_FMAC2 cross_instantiate___WS1__fpInvoke(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__fpInvoke * soap_new___WS1__fpInvoke(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__fpInvoke(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__fpInvoke * soap_new_req___WS1__fpInvoke(
	struct soap *soap)
{
	struct __WS1__fpInvoke *_p = ::soap_new___WS1__fpInvoke(soap);
	if (_p)
	{	::soap_default___WS1__fpInvoke(soap, _p);
	}
	return _p;
}

inline struct __WS1__fpInvoke * soap_new_set___WS1__fpInvoke(
	struct soap *soap,
	_WS1__fpInvoke *WS1__fpInvoke)
{
	struct __WS1__fpInvoke *_p = ::soap_new___WS1__fpInvoke(soap);
	if (_p)
	{	::soap_default___WS1__fpInvoke(soap, _p);
		_p->WS1__fpInvoke = WS1__fpInvoke;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__fpInvoke(struct soap*, const struct __WS1__fpInvoke *, const char*, const char*);

inline int soap_write___WS1__fpInvoke(struct soap *soap, struct __WS1__fpInvoke const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__fpInvoke(soap, p), 0) || ::soap_put___WS1__fpInvoke(soap, p, "-WS1:fpInvoke", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__fpInvoke(struct soap *soap, const char *URL, struct __WS1__fpInvoke const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__fpInvoke(soap, p), 0) || ::soap_put___WS1__fpInvoke(soap, p, "-WS1:fpInvoke", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__fpInvoke(struct soap *soap, const char *URL, struct __WS1__fpInvoke const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__fpInvoke(soap, p), 0) || ::soap_put___WS1__fpInvoke(soap, p, "-WS1:fpInvoke", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__fpInvoke(struct soap *soap, const char *URL, struct __WS1__fpInvoke const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__fpInvoke(soap, p), 0) || ::soap_put___WS1__fpInvoke(soap, p, "-WS1:fpInvoke", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__fpInvoke * SOAP_FMAC4 soap_get___WS1__fpInvoke(struct soap*, struct __WS1__fpInvoke *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__fpInvoke(struct soap *soap, struct __WS1__fpInvoke *p)
{
	if (::soap_read___WS1__fpInvoke(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__getSrv_DEFINED
#define SOAP_TYPE___WS1__getSrv_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__getSrv(struct soap*, struct __WS1__getSrv *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__getSrv(struct soap*, const struct __WS1__getSrv *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__getSrv(struct soap*, const char*, int, const struct __WS1__getSrv *, const char*);
SOAP_FMAC3 struct __WS1__getSrv * SOAP_FMAC4 soap_in___WS1__getSrv(struct soap*, const char*, struct __WS1__getSrv *, const char*);
SOAP_FMAC1 struct __WS1__getSrv * SOAP_FMAC2 cross_instantiate___WS1__getSrv(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__getSrv * soap_new___WS1__getSrv(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__getSrv(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__getSrv * soap_new_req___WS1__getSrv(
	struct soap *soap)
{
	struct __WS1__getSrv *_p = ::soap_new___WS1__getSrv(soap);
	if (_p)
	{	::soap_default___WS1__getSrv(soap, _p);
	}
	return _p;
}

inline struct __WS1__getSrv * soap_new_set___WS1__getSrv(
	struct soap *soap,
	_WS1__getSrv *WS1__getSrv)
{
	struct __WS1__getSrv *_p = ::soap_new___WS1__getSrv(soap);
	if (_p)
	{	::soap_default___WS1__getSrv(soap, _p);
		_p->WS1__getSrv = WS1__getSrv;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__getSrv(struct soap*, const struct __WS1__getSrv *, const char*, const char*);

inline int soap_write___WS1__getSrv(struct soap *soap, struct __WS1__getSrv const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__getSrv(soap, p), 0) || ::soap_put___WS1__getSrv(soap, p, "-WS1:getSrv", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__getSrv(struct soap *soap, const char *URL, struct __WS1__getSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getSrv(soap, p), 0) || ::soap_put___WS1__getSrv(soap, p, "-WS1:getSrv", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__getSrv(struct soap *soap, const char *URL, struct __WS1__getSrv const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getSrv(soap, p), 0) || ::soap_put___WS1__getSrv(soap, p, "-WS1:getSrv", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__getSrv(struct soap *soap, const char *URL, struct __WS1__getSrv const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getSrv(soap, p), 0) || ::soap_put___WS1__getSrv(soap, p, "-WS1:getSrv", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__getSrv * SOAP_FMAC4 soap_get___WS1__getSrv(struct soap*, struct __WS1__getSrv *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__getSrv(struct soap *soap, struct __WS1__getSrv *p)
{
	if (::soap_read___WS1__getSrv(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__getProd_DEFINED
#define SOAP_TYPE___WS1__getProd_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__getProd(struct soap*, struct __WS1__getProd *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__getProd(struct soap*, const struct __WS1__getProd *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__getProd(struct soap*, const char*, int, const struct __WS1__getProd *, const char*);
SOAP_FMAC3 struct __WS1__getProd * SOAP_FMAC4 soap_in___WS1__getProd(struct soap*, const char*, struct __WS1__getProd *, const char*);
SOAP_FMAC1 struct __WS1__getProd * SOAP_FMAC2 cross_instantiate___WS1__getProd(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__getProd * soap_new___WS1__getProd(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__getProd(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__getProd * soap_new_req___WS1__getProd(
	struct soap *soap)
{
	struct __WS1__getProd *_p = ::soap_new___WS1__getProd(soap);
	if (_p)
	{	::soap_default___WS1__getProd(soap, _p);
	}
	return _p;
}

inline struct __WS1__getProd * soap_new_set___WS1__getProd(
	struct soap *soap,
	_WS1__getProd *WS1__getProd)
{
	struct __WS1__getProd *_p = ::soap_new___WS1__getProd(soap);
	if (_p)
	{	::soap_default___WS1__getProd(soap, _p);
		_p->WS1__getProd = WS1__getProd;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__getProd(struct soap*, const struct __WS1__getProd *, const char*, const char*);

inline int soap_write___WS1__getProd(struct soap *soap, struct __WS1__getProd const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__getProd(soap, p), 0) || ::soap_put___WS1__getProd(soap, p, "-WS1:getProd", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__getProd(struct soap *soap, const char *URL, struct __WS1__getProd const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getProd(soap, p), 0) || ::soap_put___WS1__getProd(soap, p, "-WS1:getProd", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__getProd(struct soap *soap, const char *URL, struct __WS1__getProd const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getProd(soap, p), 0) || ::soap_put___WS1__getProd(soap, p, "-WS1:getProd", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__getProd(struct soap *soap, const char *URL, struct __WS1__getProd const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getProd(soap, p), 0) || ::soap_put___WS1__getProd(soap, p, "-WS1:getProd", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__getProd * SOAP_FMAC4 soap_get___WS1__getProd(struct soap*, struct __WS1__getProd *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__getProd(struct soap *soap, struct __WS1__getProd *p)
{
	if (::soap_read___WS1__getProd(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__invokeMdm_DEFINED
#define SOAP_TYPE___WS1__invokeMdm_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__invokeMdm(struct soap*, struct __WS1__invokeMdm *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__invokeMdm(struct soap*, const struct __WS1__invokeMdm *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__invokeMdm(struct soap*, const char*, int, const struct __WS1__invokeMdm *, const char*);
SOAP_FMAC3 struct __WS1__invokeMdm * SOAP_FMAC4 soap_in___WS1__invokeMdm(struct soap*, const char*, struct __WS1__invokeMdm *, const char*);
SOAP_FMAC1 struct __WS1__invokeMdm * SOAP_FMAC2 cross_instantiate___WS1__invokeMdm(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__invokeMdm * soap_new___WS1__invokeMdm(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__invokeMdm(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__invokeMdm * soap_new_req___WS1__invokeMdm(
	struct soap *soap)
{
	struct __WS1__invokeMdm *_p = ::soap_new___WS1__invokeMdm(soap);
	if (_p)
	{	::soap_default___WS1__invokeMdm(soap, _p);
	}
	return _p;
}

inline struct __WS1__invokeMdm * soap_new_set___WS1__invokeMdm(
	struct soap *soap,
	_WS1__invokeMdm *WS1__invokeMdm)
{
	struct __WS1__invokeMdm *_p = ::soap_new___WS1__invokeMdm(soap);
	if (_p)
	{	::soap_default___WS1__invokeMdm(soap, _p);
		_p->WS1__invokeMdm = WS1__invokeMdm;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__invokeMdm(struct soap*, const struct __WS1__invokeMdm *, const char*, const char*);

inline int soap_write___WS1__invokeMdm(struct soap *soap, struct __WS1__invokeMdm const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__invokeMdm(soap, p), 0) || ::soap_put___WS1__invokeMdm(soap, p, "-WS1:invokeMdm", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__invokeMdm(struct soap *soap, const char *URL, struct __WS1__invokeMdm const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__invokeMdm(soap, p), 0) || ::soap_put___WS1__invokeMdm(soap, p, "-WS1:invokeMdm", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__invokeMdm(struct soap *soap, const char *URL, struct __WS1__invokeMdm const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__invokeMdm(soap, p), 0) || ::soap_put___WS1__invokeMdm(soap, p, "-WS1:invokeMdm", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__invokeMdm(struct soap *soap, const char *URL, struct __WS1__invokeMdm const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__invokeMdm(soap, p), 0) || ::soap_put___WS1__invokeMdm(soap, p, "-WS1:invokeMdm", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__invokeMdm * SOAP_FMAC4 soap_get___WS1__invokeMdm(struct soap*, struct __WS1__invokeMdm *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__invokeMdm(struct soap *soap, struct __WS1__invokeMdm *p)
{
	if (::soap_read___WS1__invokeMdm(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__invokeUnion_DEFINED
#define SOAP_TYPE___WS1__invokeUnion_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__invokeUnion(struct soap*, struct __WS1__invokeUnion *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__invokeUnion(struct soap*, const struct __WS1__invokeUnion *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__invokeUnion(struct soap*, const char*, int, const struct __WS1__invokeUnion *, const char*);
SOAP_FMAC3 struct __WS1__invokeUnion * SOAP_FMAC4 soap_in___WS1__invokeUnion(struct soap*, const char*, struct __WS1__invokeUnion *, const char*);
SOAP_FMAC1 struct __WS1__invokeUnion * SOAP_FMAC2 cross_instantiate___WS1__invokeUnion(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__invokeUnion * soap_new___WS1__invokeUnion(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__invokeUnion(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__invokeUnion * soap_new_req___WS1__invokeUnion(
	struct soap *soap)
{
	struct __WS1__invokeUnion *_p = ::soap_new___WS1__invokeUnion(soap);
	if (_p)
	{	::soap_default___WS1__invokeUnion(soap, _p);
	}
	return _p;
}

inline struct __WS1__invokeUnion * soap_new_set___WS1__invokeUnion(
	struct soap *soap,
	_WS1__invokeUnion *WS1__invokeUnion)
{
	struct __WS1__invokeUnion *_p = ::soap_new___WS1__invokeUnion(soap);
	if (_p)
	{	::soap_default___WS1__invokeUnion(soap, _p);
		_p->WS1__invokeUnion = WS1__invokeUnion;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__invokeUnion(struct soap*, const struct __WS1__invokeUnion *, const char*, const char*);

inline int soap_write___WS1__invokeUnion(struct soap *soap, struct __WS1__invokeUnion const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__invokeUnion(soap, p), 0) || ::soap_put___WS1__invokeUnion(soap, p, "-WS1:invokeUnion", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__invokeUnion(struct soap *soap, const char *URL, struct __WS1__invokeUnion const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__invokeUnion(soap, p), 0) || ::soap_put___WS1__invokeUnion(soap, p, "-WS1:invokeUnion", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__invokeUnion(struct soap *soap, const char *URL, struct __WS1__invokeUnion const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__invokeUnion(soap, p), 0) || ::soap_put___WS1__invokeUnion(soap, p, "-WS1:invokeUnion", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__invokeUnion(struct soap *soap, const char *URL, struct __WS1__invokeUnion const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__invokeUnion(soap, p), 0) || ::soap_put___WS1__invokeUnion(soap, p, "-WS1:invokeUnion", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__invokeUnion * SOAP_FMAC4 soap_get___WS1__invokeUnion(struct soap*, struct __WS1__invokeUnion *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__invokeUnion(struct soap *soap, struct __WS1__invokeUnion *p)
{
	if (::soap_read___WS1__invokeUnion(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__regProdAP_DEFINED
#define SOAP_TYPE___WS1__regProdAP_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__regProdAP(struct soap*, struct __WS1__regProdAP *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__regProdAP(struct soap*, const struct __WS1__regProdAP *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__regProdAP(struct soap*, const char*, int, const struct __WS1__regProdAP *, const char*);
SOAP_FMAC3 struct __WS1__regProdAP * SOAP_FMAC4 soap_in___WS1__regProdAP(struct soap*, const char*, struct __WS1__regProdAP *, const char*);
SOAP_FMAC1 struct __WS1__regProdAP * SOAP_FMAC2 cross_instantiate___WS1__regProdAP(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__regProdAP * soap_new___WS1__regProdAP(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__regProdAP(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__regProdAP * soap_new_req___WS1__regProdAP(
	struct soap *soap)
{
	struct __WS1__regProdAP *_p = ::soap_new___WS1__regProdAP(soap);
	if (_p)
	{	::soap_default___WS1__regProdAP(soap, _p);
	}
	return _p;
}

inline struct __WS1__regProdAP * soap_new_set___WS1__regProdAP(
	struct soap *soap,
	_WS1__regProdAP *WS1__regProdAP)
{
	struct __WS1__regProdAP *_p = ::soap_new___WS1__regProdAP(soap);
	if (_p)
	{	::soap_default___WS1__regProdAP(soap, _p);
		_p->WS1__regProdAP = WS1__regProdAP;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__regProdAP(struct soap*, const struct __WS1__regProdAP *, const char*, const char*);

inline int soap_write___WS1__regProdAP(struct soap *soap, struct __WS1__regProdAP const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__regProdAP(soap, p), 0) || ::soap_put___WS1__regProdAP(soap, p, "-WS1:regProdAP", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__regProdAP(struct soap *soap, const char *URL, struct __WS1__regProdAP const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__regProdAP(soap, p), 0) || ::soap_put___WS1__regProdAP(soap, p, "-WS1:regProdAP", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__regProdAP(struct soap *soap, const char *URL, struct __WS1__regProdAP const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__regProdAP(soap, p), 0) || ::soap_put___WS1__regProdAP(soap, p, "-WS1:regProdAP", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__regProdAP(struct soap *soap, const char *URL, struct __WS1__regProdAP const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__regProdAP(soap, p), 0) || ::soap_put___WS1__regProdAP(soap, p, "-WS1:regProdAP", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__regProdAP * SOAP_FMAC4 soap_get___WS1__regProdAP(struct soap*, struct __WS1__regProdAP *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__regProdAP(struct soap *soap, struct __WS1__regProdAP *p)
{
	if (::soap_read___WS1__regProdAP(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__getProdList_DEFINED
#define SOAP_TYPE___WS1__getProdList_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__getProdList(struct soap*, struct __WS1__getProdList *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__getProdList(struct soap*, const struct __WS1__getProdList *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__getProdList(struct soap*, const char*, int, const struct __WS1__getProdList *, const char*);
SOAP_FMAC3 struct __WS1__getProdList * SOAP_FMAC4 soap_in___WS1__getProdList(struct soap*, const char*, struct __WS1__getProdList *, const char*);
SOAP_FMAC1 struct __WS1__getProdList * SOAP_FMAC2 cross_instantiate___WS1__getProdList(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__getProdList * soap_new___WS1__getProdList(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__getProdList(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__getProdList * soap_new_req___WS1__getProdList(
	struct soap *soap)
{
	struct __WS1__getProdList *_p = ::soap_new___WS1__getProdList(soap);
	if (_p)
	{	::soap_default___WS1__getProdList(soap, _p);
	}
	return _p;
}

inline struct __WS1__getProdList * soap_new_set___WS1__getProdList(
	struct soap *soap,
	_WS1__getProdList *WS1__getProdList)
{
	struct __WS1__getProdList *_p = ::soap_new___WS1__getProdList(soap);
	if (_p)
	{	::soap_default___WS1__getProdList(soap, _p);
		_p->WS1__getProdList = WS1__getProdList;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__getProdList(struct soap*, const struct __WS1__getProdList *, const char*, const char*);

inline int soap_write___WS1__getProdList(struct soap *soap, struct __WS1__getProdList const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__getProdList(soap, p), 0) || ::soap_put___WS1__getProdList(soap, p, "-WS1:getProdList", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__getProdList(struct soap *soap, const char *URL, struct __WS1__getProdList const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getProdList(soap, p), 0) || ::soap_put___WS1__getProdList(soap, p, "-WS1:getProdList", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__getProdList(struct soap *soap, const char *URL, struct __WS1__getProdList const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getProdList(soap, p), 0) || ::soap_put___WS1__getProdList(soap, p, "-WS1:getProdList", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__getProdList(struct soap *soap, const char *URL, struct __WS1__getProdList const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getProdList(soap, p), 0) || ::soap_put___WS1__getProdList(soap, p, "-WS1:getProdList", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__getProdList * SOAP_FMAC4 soap_get___WS1__getProdList(struct soap*, struct __WS1__getProdList *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__getProdList(struct soap *soap, struct __WS1__getProdList *p)
{
	if (::soap_read___WS1__getProdList(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__getParamList_DEFINED
#define SOAP_TYPE___WS1__getParamList_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__getParamList(struct soap*, struct __WS1__getParamList *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__getParamList(struct soap*, const struct __WS1__getParamList *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__getParamList(struct soap*, const char*, int, const struct __WS1__getParamList *, const char*);
SOAP_FMAC3 struct __WS1__getParamList * SOAP_FMAC4 soap_in___WS1__getParamList(struct soap*, const char*, struct __WS1__getParamList *, const char*);
SOAP_FMAC1 struct __WS1__getParamList * SOAP_FMAC2 cross_instantiate___WS1__getParamList(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__getParamList * soap_new___WS1__getParamList(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__getParamList(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__getParamList * soap_new_req___WS1__getParamList(
	struct soap *soap)
{
	struct __WS1__getParamList *_p = ::soap_new___WS1__getParamList(soap);
	if (_p)
	{	::soap_default___WS1__getParamList(soap, _p);
	}
	return _p;
}

inline struct __WS1__getParamList * soap_new_set___WS1__getParamList(
	struct soap *soap,
	_WS1__getParamList *WS1__getParamList)
{
	struct __WS1__getParamList *_p = ::soap_new___WS1__getParamList(soap);
	if (_p)
	{	::soap_default___WS1__getParamList(soap, _p);
		_p->WS1__getParamList = WS1__getParamList;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__getParamList(struct soap*, const struct __WS1__getParamList *, const char*, const char*);

inline int soap_write___WS1__getParamList(struct soap *soap, struct __WS1__getParamList const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__getParamList(soap, p), 0) || ::soap_put___WS1__getParamList(soap, p, "-WS1:getParamList", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__getParamList(struct soap *soap, const char *URL, struct __WS1__getParamList const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getParamList(soap, p), 0) || ::soap_put___WS1__getParamList(soap, p, "-WS1:getParamList", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__getParamList(struct soap *soap, const char *URL, struct __WS1__getParamList const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getParamList(soap, p), 0) || ::soap_put___WS1__getParamList(soap, p, "-WS1:getParamList", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__getParamList(struct soap *soap, const char *URL, struct __WS1__getParamList const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getParamList(soap, p), 0) || ::soap_put___WS1__getParamList(soap, p, "-WS1:getParamList", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__getParamList * SOAP_FMAC4 soap_get___WS1__getParamList(struct soap*, struct __WS1__getParamList *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__getParamList(struct soap *soap, struct __WS1__getParamList *p)
{
	if (::soap_read___WS1__getParamList(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__getEtlJobList_DEFINED
#define SOAP_TYPE___WS1__getEtlJobList_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__getEtlJobList(struct soap*, struct __WS1__getEtlJobList *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__getEtlJobList(struct soap*, const struct __WS1__getEtlJobList *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__getEtlJobList(struct soap*, const char*, int, const struct __WS1__getEtlJobList *, const char*);
SOAP_FMAC3 struct __WS1__getEtlJobList * SOAP_FMAC4 soap_in___WS1__getEtlJobList(struct soap*, const char*, struct __WS1__getEtlJobList *, const char*);
SOAP_FMAC1 struct __WS1__getEtlJobList * SOAP_FMAC2 cross_instantiate___WS1__getEtlJobList(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__getEtlJobList * soap_new___WS1__getEtlJobList(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__getEtlJobList(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__getEtlJobList * soap_new_req___WS1__getEtlJobList(
	struct soap *soap)
{
	struct __WS1__getEtlJobList *_p = ::soap_new___WS1__getEtlJobList(soap);
	if (_p)
	{	::soap_default___WS1__getEtlJobList(soap, _p);
	}
	return _p;
}

inline struct __WS1__getEtlJobList * soap_new_set___WS1__getEtlJobList(
	struct soap *soap,
	_WS1__getEtlJobList *WS1__getEtlJobList)
{
	struct __WS1__getEtlJobList *_p = ::soap_new___WS1__getEtlJobList(soap);
	if (_p)
	{	::soap_default___WS1__getEtlJobList(soap, _p);
		_p->WS1__getEtlJobList = WS1__getEtlJobList;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__getEtlJobList(struct soap*, const struct __WS1__getEtlJobList *, const char*, const char*);

inline int soap_write___WS1__getEtlJobList(struct soap *soap, struct __WS1__getEtlJobList const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__getEtlJobList(soap, p), 0) || ::soap_put___WS1__getEtlJobList(soap, p, "-WS1:getEtlJobList", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__getEtlJobList(struct soap *soap, const char *URL, struct __WS1__getEtlJobList const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getEtlJobList(soap, p), 0) || ::soap_put___WS1__getEtlJobList(soap, p, "-WS1:getEtlJobList", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__getEtlJobList(struct soap *soap, const char *URL, struct __WS1__getEtlJobList const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getEtlJobList(soap, p), 0) || ::soap_put___WS1__getEtlJobList(soap, p, "-WS1:getEtlJobList", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__getEtlJobList(struct soap *soap, const char *URL, struct __WS1__getEtlJobList const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__getEtlJobList(soap, p), 0) || ::soap_put___WS1__getEtlJobList(soap, p, "-WS1:getEtlJobList", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__getEtlJobList * SOAP_FMAC4 soap_get___WS1__getEtlJobList(struct soap*, struct __WS1__getEtlJobList *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__getEtlJobList(struct soap *soap, struct __WS1__getEtlJobList *p)
{
	if (::soap_read___WS1__getEtlJobList(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#endif

#ifndef SOAP_TYPE___WS1__invokeEtl_DEFINED
#define SOAP_TYPE___WS1__invokeEtl_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__invokeEtl(struct soap*, struct __WS1__invokeEtl *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__invokeEtl(struct soap*, const struct __WS1__invokeEtl *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__invokeEtl(struct soap*, const char*, int, const struct __WS1__invokeEtl *, const char*);
SOAP_FMAC3 struct __WS1__invokeEtl * SOAP_FMAC4 soap_in___WS1__invokeEtl(struct soap*, const char*, struct __WS1__invokeEtl *, const char*);
SOAP_FMAC1 struct __WS1__invokeEtl * SOAP_FMAC2 cross_instantiate___WS1__invokeEtl(struct soap*, int, const char*, const char*, size_t*);

inline struct __WS1__invokeEtl * soap_new___WS1__invokeEtl(struct soap *soap, int n = -1)
{
	return cross_instantiate___WS1__invokeEtl(soap, n, NULL, NULL, NULL);
}

inline struct __WS1__invokeEtl * soap_new_req___WS1__invokeEtl(
	struct soap *soap)
{
	struct __WS1__invokeEtl *_p = ::soap_new___WS1__invokeEtl(soap);
	if (_p)
	{	::soap_default___WS1__invokeEtl(soap, _p);
	}
	return _p;
}

inline struct __WS1__invokeEtl * soap_new_set___WS1__invokeEtl(
	struct soap *soap,
	_WS1__invokeEtl *WS1__invokeEtl)
{
	struct __WS1__invokeEtl *_p = ::soap_new___WS1__invokeEtl(soap);
	if (_p)
	{	::soap_default___WS1__invokeEtl(soap, _p);
		_p->WS1__invokeEtl = WS1__invokeEtl;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__invokeEtl(struct soap*, const struct __WS1__invokeEtl *, const char*, const char*);

inline int soap_write___WS1__invokeEtl(struct soap *soap, struct __WS1__invokeEtl const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (::soap_serialize___WS1__invokeEtl(soap, p), 0) || ::soap_put___WS1__invokeEtl(soap, p, "-WS1:invokeEtl", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___WS1__invokeEtl(struct soap *soap, const char *URL, struct __WS1__invokeEtl const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__invokeEtl(soap, p), 0) || ::soap_put___WS1__invokeEtl(soap, p, "-WS1:invokeEtl", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_PATCH___WS1__invokeEtl(struct soap *soap, const char *URL, struct __WS1__invokeEtl const*p)
{
	soap_free_temp(soap);
	if (soap_PATCH(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__invokeEtl(soap, p), 0) || ::soap_put___WS1__invokeEtl(soap, p, "-WS1:invokeEtl", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}

inline int soap_POST_send___WS1__invokeEtl(struct soap *soap, const char *URL, struct __WS1__invokeEtl const*p)
{
	soap_free_temp(soap);
	if (soap_POST(soap, URL, NULL, "text/xml; charset=utf-8") || (::soap_serialize___WS1__invokeEtl(soap, p), 0) || ::soap_put___WS1__invokeEtl(soap, p, "-WS1:invokeEtl", "") || soap_end_send(soap))
		return soap_closesock(soap);
	return SOAP_OK;
}
SOAP_FMAC3 struct __WS1__invokeEtl * SOAP_FMAC4 soap_get___WS1__invokeEtl(struct soap*, struct __WS1__invokeEtl *, const char*, const char*);

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

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

inline int soap_POST_recv___WS1__invokeEtl(struct soap *soap, struct __WS1__invokeEtl *p)
{
	if (::soap_read___WS1__invokeEtl(soap, p))
		return soap_closesock(soap);
	return soap_closesock(soap);
}
#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__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 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 SOAP_TYPE_PointerTo_WS1__escrowResendSrv_DEFINED
#define SOAP_TYPE_PointerTo_WS1__escrowResendSrv_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__escrowResendSrv(struct soap*, _WS1__escrowResendSrv *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__escrowResendSrv(struct soap*, const char *, int, _WS1__escrowResendSrv *const*, const char *);
SOAP_FMAC3 _WS1__escrowResendSrv ** SOAP_FMAC4 soap_in_PointerTo_WS1__escrowResendSrv(struct soap*, const char*, _WS1__escrowResendSrv **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__escrowResendSrv(struct soap*, _WS1__escrowResendSrv *const*, const char*, const char*);
SOAP_FMAC3 _WS1__escrowResendSrv ** SOAP_FMAC4 soap_get_PointerTo_WS1__escrowResendSrv(struct soap*, _WS1__escrowResendSrv **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__invokeSrv_DEFINED
#define SOAP_TYPE_PointerTo_WS1__invokeSrv_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__invokeSrv(struct soap*, _WS1__invokeSrv *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__invokeSrv(struct soap*, const char *, int, _WS1__invokeSrv *const*, const char *);
SOAP_FMAC3 _WS1__invokeSrv ** SOAP_FMAC4 soap_in_PointerTo_WS1__invokeSrv(struct soap*, const char*, _WS1__invokeSrv **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__invokeSrv(struct soap*, _WS1__invokeSrv *const*, const char*, const char*);
SOAP_FMAC3 _WS1__invokeSrv ** SOAP_FMAC4 soap_get_PointerTo_WS1__invokeSrv(struct soap*, _WS1__invokeSrv **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__regEAI_DEFINED
#define SOAP_TYPE_PointerTo_WS1__regEAI_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__regEAI(struct soap*, _WS1__regEAI *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__regEAI(struct soap*, const char *, int, _WS1__regEAI *const*, const char *);
SOAP_FMAC3 _WS1__regEAI ** SOAP_FMAC4 soap_in_PointerTo_WS1__regEAI(struct soap*, const char*, _WS1__regEAI **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__regEAI(struct soap*, _WS1__regEAI *const*, const char*, const char*);
SOAP_FMAC3 _WS1__regEAI ** SOAP_FMAC4 soap_get_PointerTo_WS1__regEAI(struct soap*, _WS1__regEAI **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__regSrv_DEFINED
#define SOAP_TYPE_PointerTo_WS1__regSrv_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__regSrv(struct soap*, _WS1__regSrv *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__regSrv(struct soap*, const char *, int, _WS1__regSrv *const*, const char *);
SOAP_FMAC3 _WS1__regSrv ** SOAP_FMAC4 soap_in_PointerTo_WS1__regSrv(struct soap*, const char*, _WS1__regSrv **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__regSrv(struct soap*, _WS1__regSrv *const*, const char*, const char*);
SOAP_FMAC3 _WS1__regSrv ** SOAP_FMAC4 soap_get_PointerTo_WS1__regSrv(struct soap*, _WS1__regSrv **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__getStandardDataNameList_DEFINED
#define SOAP_TYPE_PointerTo_WS1__getStandardDataNameList_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__getStandardDataNameList(struct soap*, _WS1__getStandardDataNameList *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__getStandardDataNameList(struct soap*, const char *, int, _WS1__getStandardDataNameList *const*, const char *);
SOAP_FMAC3 _WS1__getStandardDataNameList ** SOAP_FMAC4 soap_in_PointerTo_WS1__getStandardDataNameList(struct soap*, const char*, _WS1__getStandardDataNameList **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__getStandardDataNameList(struct soap*, _WS1__getStandardDataNameList *const*, const char*, const char*);
SOAP_FMAC3 _WS1__getStandardDataNameList ** SOAP_FMAC4 soap_get_PointerTo_WS1__getStandardDataNameList(struct soap*, _WS1__getStandardDataNameList **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__getStandardServiceList_DEFINED
#define SOAP_TYPE_PointerTo_WS1__getStandardServiceList_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__getStandardServiceList(struct soap*, _WS1__getStandardServiceList *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__getStandardServiceList(struct soap*, const char *, int, _WS1__getStandardServiceList *const*, const char *);
SOAP_FMAC3 _WS1__getStandardServiceList ** SOAP_FMAC4 soap_in_PointerTo_WS1__getStandardServiceList(struct soap*, const char*, _WS1__getStandardServiceList **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__getStandardServiceList(struct soap*, _WS1__getStandardServiceList *const*, const char*, const char*);
SOAP_FMAC3 _WS1__getStandardServiceList ** SOAP_FMAC4 soap_get_PointerTo_WS1__getStandardServiceList(struct soap*, _WS1__getStandardServiceList **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__fpInvoke_DEFINED
#define SOAP_TYPE_PointerTo_WS1__fpInvoke_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__fpInvoke(struct soap*, _WS1__fpInvoke *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__fpInvoke(struct soap*, const char *, int, _WS1__fpInvoke *const*, const char *);
SOAP_FMAC3 _WS1__fpInvoke ** SOAP_FMAC4 soap_in_PointerTo_WS1__fpInvoke(struct soap*, const char*, _WS1__fpInvoke **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__fpInvoke(struct soap*, _WS1__fpInvoke *const*, const char*, const char*);
SOAP_FMAC3 _WS1__fpInvoke ** SOAP_FMAC4 soap_get_PointerTo_WS1__fpInvoke(struct soap*, _WS1__fpInvoke **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__getSrv_DEFINED
#define SOAP_TYPE_PointerTo_WS1__getSrv_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__getSrv(struct soap*, _WS1__getSrv *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__getSrv(struct soap*, const char *, int, _WS1__getSrv *const*, const char *);
SOAP_FMAC3 _WS1__getSrv ** SOAP_FMAC4 soap_in_PointerTo_WS1__getSrv(struct soap*, const char*, _WS1__getSrv **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__getSrv(struct soap*, _WS1__getSrv *const*, const char*, const char*);
SOAP_FMAC3 _WS1__getSrv ** SOAP_FMAC4 soap_get_PointerTo_WS1__getSrv(struct soap*, _WS1__getSrv **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__getProd_DEFINED
#define SOAP_TYPE_PointerTo_WS1__getProd_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__getProd(struct soap*, _WS1__getProd *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__getProd(struct soap*, const char *, int, _WS1__getProd *const*, const char *);
SOAP_FMAC3 _WS1__getProd ** SOAP_FMAC4 soap_in_PointerTo_WS1__getProd(struct soap*, const char*, _WS1__getProd **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__getProd(struct soap*, _WS1__getProd *const*, const char*, const char*);
SOAP_FMAC3 _WS1__getProd ** SOAP_FMAC4 soap_get_PointerTo_WS1__getProd(struct soap*, _WS1__getProd **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__invokeMdm_DEFINED
#define SOAP_TYPE_PointerTo_WS1__invokeMdm_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__invokeMdm(struct soap*, _WS1__invokeMdm *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__invokeMdm(struct soap*, const char *, int, _WS1__invokeMdm *const*, const char *);
SOAP_FMAC3 _WS1__invokeMdm ** SOAP_FMAC4 soap_in_PointerTo_WS1__invokeMdm(struct soap*, const char*, _WS1__invokeMdm **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__invokeMdm(struct soap*, _WS1__invokeMdm *const*, const char*, const char*);
SOAP_FMAC3 _WS1__invokeMdm ** SOAP_FMAC4 soap_get_PointerTo_WS1__invokeMdm(struct soap*, _WS1__invokeMdm **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__invokeUnion_DEFINED
#define SOAP_TYPE_PointerTo_WS1__invokeUnion_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__invokeUnion(struct soap*, _WS1__invokeUnion *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__invokeUnion(struct soap*, const char *, int, _WS1__invokeUnion *const*, const char *);
SOAP_FMAC3 _WS1__invokeUnion ** SOAP_FMAC4 soap_in_PointerTo_WS1__invokeUnion(struct soap*, const char*, _WS1__invokeUnion **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__invokeUnion(struct soap*, _WS1__invokeUnion *const*, const char*, const char*);
SOAP_FMAC3 _WS1__invokeUnion ** SOAP_FMAC4 soap_get_PointerTo_WS1__invokeUnion(struct soap*, _WS1__invokeUnion **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__regProdAP_DEFINED
#define SOAP_TYPE_PointerTo_WS1__regProdAP_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__regProdAP(struct soap*, _WS1__regProdAP *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__regProdAP(struct soap*, const char *, int, _WS1__regProdAP *const*, const char *);
SOAP_FMAC3 _WS1__regProdAP ** SOAP_FMAC4 soap_in_PointerTo_WS1__regProdAP(struct soap*, const char*, _WS1__regProdAP **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__regProdAP(struct soap*, _WS1__regProdAP *const*, const char*, const char*);
SOAP_FMAC3 _WS1__regProdAP ** SOAP_FMAC4 soap_get_PointerTo_WS1__regProdAP(struct soap*, _WS1__regProdAP **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__getProdList_DEFINED
#define SOAP_TYPE_PointerTo_WS1__getProdList_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__getProdList(struct soap*, _WS1__getProdList *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__getProdList(struct soap*, const char *, int, _WS1__getProdList *const*, const char *);
SOAP_FMAC3 _WS1__getProdList ** SOAP_FMAC4 soap_in_PointerTo_WS1__getProdList(struct soap*, const char*, _WS1__getProdList **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__getProdList(struct soap*, _WS1__getProdList *const*, const char*, const char*);
SOAP_FMAC3 _WS1__getProdList ** SOAP_FMAC4 soap_get_PointerTo_WS1__getProdList(struct soap*, _WS1__getProdList **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__getParamList_DEFINED
#define SOAP_TYPE_PointerTo_WS1__getParamList_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__getParamList(struct soap*, _WS1__getParamList *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__getParamList(struct soap*, const char *, int, _WS1__getParamList *const*, const char *);
SOAP_FMAC3 _WS1__getParamList ** SOAP_FMAC4 soap_in_PointerTo_WS1__getParamList(struct soap*, const char*, _WS1__getParamList **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__getParamList(struct soap*, _WS1__getParamList *const*, const char*, const char*);
SOAP_FMAC3 _WS1__getParamList ** SOAP_FMAC4 soap_get_PointerTo_WS1__getParamList(struct soap*, _WS1__getParamList **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__getEtlJobList_DEFINED
#define SOAP_TYPE_PointerTo_WS1__getEtlJobList_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__getEtlJobList(struct soap*, _WS1__getEtlJobList *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__getEtlJobList(struct soap*, const char *, int, _WS1__getEtlJobList *const*, const char *);
SOAP_FMAC3 _WS1__getEtlJobList ** SOAP_FMAC4 soap_in_PointerTo_WS1__getEtlJobList(struct soap*, const char*, _WS1__getEtlJobList **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__getEtlJobList(struct soap*, _WS1__getEtlJobList *const*, const char*, const char*);
SOAP_FMAC3 _WS1__getEtlJobList ** SOAP_FMAC4 soap_get_PointerTo_WS1__getEtlJobList(struct soap*, _WS1__getEtlJobList **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_WS1__invokeEtl_DEFINED
#define SOAP_TYPE_PointerTo_WS1__invokeEtl_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__invokeEtl(struct soap*, _WS1__invokeEtl *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__invokeEtl(struct soap*, const char *, int, _WS1__invokeEtl *const*, const char *);
SOAP_FMAC3 _WS1__invokeEtl ** SOAP_FMAC4 soap_in_PointerTo_WS1__invokeEtl(struct soap*, const char*, _WS1__invokeEtl **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__invokeEtl(struct soap*, _WS1__invokeEtl *const*, const char*, const char*);
SOAP_FMAC3 _WS1__invokeEtl ** SOAP_FMAC4 soap_get_PointerTo_WS1__invokeEtl(struct soap*, _WS1__invokeEtl **, 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 cross_instantiate__QName cross_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 crossH.h */
