<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://userguide.axis2.apache.org/Axis2SampleDocLit" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsd1="http://userguide.axis2.apache.org/xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" targetNamespace="http://userguide.axis2.apache.org/Axis2SampleDocLit" name="Axis2SampleDocLitService">
	<types>
		<schema targetNamespace="http://userguide.axis2.apache.org/xsd" xmlns="http://www.w3.org/2001/XMLSchema" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" elementFormDefault="qualified">
			<complexType name="ArrayOfstring_literal">
				<sequence>
					<element maxOccurs="unbounded" minOccurs="1" name="string" type="xsd:string"/>
				</sequence>
			</complexType>
			<complexType name="SOAPStruct">
				<all>
					<element name="varFloat" type="xsd:float"/>
					<element name="varInt" type="xsd:int"/>
					<element name="varString" type="xsd:string"/>
				</all>
			</complexType>
			<element name="echoStringParam" type="xsd:string"/>
			<element name="echoIntParam" type="xsd:int"/>
			<element name="echoStringReturn" type="xsd:string"/>
			<element name="echoStringArrayParam" type="xsd1:ArrayOfstring_literal"/>
			<element name="echoStringArrayReturn" type="xsd1:ArrayOfstring_literal"/>
			<element name="echoStructParam" type="xsd1:SOAPStruct"/>
			<element name="echoStructReturn" type="xsd1:SOAPStruct"/>
		</schema>
	</types>
	<message name="echoString">
		<part name="a" element="xsd1:echoStringParam"/>
	</message>
	<message name="echoStringResponse">
		<part name="result" element="xsd1:echoStringReturn"/>
	</message>
	<message name="echoStringArray">
		<part name="a" element="xsd1:echoStringArrayParam"/>
	</message>
	<message name="echoStringArrayResponse">
		<part name="result" element="xsd1:echoStringArrayReturn"/>
	</message>
	<message name="echoStruct">
		<part name="a" element="xsd1:echoStructParam"/>
	</message>
	<message name="echoStructResponse">
		<part name="result" element="xsd1:echoStructReturn"/>
	</message>
	<portType name="Axis2SampleDocLitPortType">
		<operation name="echoString">
			<input name="echoString" message="tns:echoString"/>
			<output name="echoStringResponse" message="tns:echoStringResponse"/>
		</operation>
		<operation name="echoStringArray">
			<input name="echoStringArray" message="tns:echoStringArray"/>
			<output name="echoStringArrayResponse" message="tns:echoStringArrayResponse"/>
		</operation>
		<operation name="echoStruct">
			<input name="echoStruct" message="tns:echoStruct"/>
			<output name="echoStructResponse" message="tns:echoStructResponse"/>
		</operation>
	</portType>
	<binding name="Axis2SampleDocLitPortBinding" type="tns:Axis2SampleDocLitPortType">
		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
		<operation name="echoString">
			<soap:operation soapAction="echoString" style="document"/>
			<input>
				<soap:body use="literal" namespace="http://userguide.axis2.apache.org/Axis2SampleDocLit"/>
			</input>
			<output>
				<soap:body use="literal" namespace="http://userguide.axis2.apache.org/Axis2SampleDocLit"/>
			</output>
		</operation>
		<operation name="echoStringArray">
			<soap:operation soapAction="echoStringArray" style="document"/>
			<input>
				<soap:body use="literal" namespace="http://userguide.axis2.apache.org/Axis2SampleDocLit"/>
			</input>
			<output>
				<soap:body use="literal" namespace="http://userguide.axis2.apache.org/Axis2SampleDocLit"/>
			</output>
		</operation>
		<operation name="echoStruct">
			<soap:operation soapAction="echoStruct" style="document"/>
			<input>
				<soap:body use="literal" namespace="http://userguide.axis2.apache.org/Axis2SampleDocLit"/>
			</input>
			<output>
				<soap:body use="literal" namespace="http://userguide.axis2.apache.org/Axis2SampleDocLit"/>
			</output>
		</operation>
	</binding>
	<service name="Axis2SampleDocLitService">
		<port name="Axis2SampleDocLitPort" binding="tns:Axis2SampleDocLitPortBinding">
			<soap:address location="http://userguide.axis2.apache.org/stkv3/wsdl/Axis2SampleDocLit.wsdl"/>
		</port>
	</service>
</definitions>
