<?xml version="1.0" encoding="UTF-8"?>

<wsdl:definitions xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
	xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
	xmlns:tns="http://nonwrap.sample.test.org"
	xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="proxy"
	targetNamespace="http://nonwrap.sample.test.org">
	
	<wsdl:types>
		<xsd:schema
			targetNamespace="http://nonwrap.sample.test.org"
			xmlns:tns="http://nonwrap.sample.test.org"
			xmlns:xsd="http://www.w3.org/2001/XMLSchema">

			<xsd:element name="MyFault" type="xsd:string" />
			
			<xsd:element name="oneWayVoid">
				<xsd:complexType>
					<xsd:sequence/>
				</xsd:complexType>
			</xsd:element>				
			
			<xsd:element name="oneWay">
				<xsd:complexType>
					<xsd:sequence>
						<xsd:element name="oneway_str" type="xsd:string" />
					</xsd:sequence>
				</xsd:complexType>
			</xsd:element>				
			
			<xsd:element name="twoWayHolder">
				<xsd:complexType>
					<xsd:sequence>
						<xsd:element name="twoWayHolder_str" type="xsd:string" />
						<xsd:element name="twoWayHolder_int" type="xsd:int" />						
					</xsd:sequence>
				</xsd:complexType>
			</xsd:element>
			
			<xsd:element name="twoWay">
				<xsd:complexType>
					<xsd:sequence>
						<xsd:element name="twoway_str" type="xsd:string" />
					</xsd:sequence>
				</xsd:complexType>
			</xsd:element>			
			
			<xsd:element name="ReturnType">
				<xsd:complexType>
					<xsd:sequence>
						<xsd:element name="return_str" type="xsd:string" />
					</xsd:sequence>
				</xsd:complexType>
			</xsd:element>				

			<!-- fin op definition -->
			
			<xsd:element name="finOp">
				<xsd:complexType>
					<xsd:sequence>
						<xsd:element name="op" type="tns:FinancialOperation" />
					</xsd:sequence>
				</xsd:complexType>
			</xsd:element>			

			<xsd:element name="finOpResponse">
				<xsd:complexType>
				<xsd:sequence>
					<xsd:element name="response" type="tns:FinancialOperation" />
				</xsd:sequence>
				</xsd:complexType>
			</xsd:element>

			<xsd:complexType name="FinancialOperation">
				<xsd:sequence>
					<xsd:element name="amount" type="xsd:float" />
				</xsd:sequence>
			</xsd:complexType>

			<xsd:complexType name="Withdraw">
			  <xsd:complexContent>
			    <xsd:extension base="tns:FinancialOperation">
			      <xsd:sequence>
			        <xsd:element name="memo" type="xsd:string" />
			      </xsd:sequence>
			    </xsd:extension>
			  </xsd:complexContent>
			</xsd:complexType>
			
			<xsd:complexType name="Deposit">
			  <xsd:complexContent>
			    <xsd:extension base="tns:FinancialOperation">
			      <xsd:sequence>
			        <xsd:element name="status" type="xsd:string" />
			      </xsd:sequence>
			     </xsd:extension>
			  </xsd:complexContent>
			</xsd:complexType>	

		</xsd:schema>
	</wsdl:types>

	<wsdl:message name="oneWayVoidRequest">
		<wsdl:part name="allByMyself" element="tns:oneWayVoid" />
	</wsdl:message>

	<wsdl:message name="oneWayRequest">
		<wsdl:part name="allByMyself" element="tns:oneWay" />
	</wsdl:message>

	<wsdl:message name="twoWayHolderRequest">
		<wsdl:part name="allByMyself" element="tns:twoWayHolder" />
	</wsdl:message>

	<wsdl:message name="twoWayHolderResponse">
		<wsdl:part name="allByMyself" element="tns:twoWayHolder" />
	</wsdl:message>
	
	<wsdl:message name="twoWayRequest">
		<wsdl:part name="allByMyself" element="tns:twoWay" />
	</wsdl:message>

	<wsdl:message name="twoWayResponse">
		<wsdl:part name="allByMyself" element="tns:ReturnType" />
	</wsdl:message>	
	
	<wsdl:portType name="DocLitNonWrapPortType">

		<wsdl:operation name="oneWayVoid">
			<wsdl:input message="tns:oneWayVoidRequest" />
		</wsdl:operation>

		<wsdl:operation name="oneWay">
			<wsdl:input message="tns:oneWayRequest" />
		</wsdl:operation>
		
		<wsdl:operation name="twoWayHolder">
			<wsdl:input message="tns:twoWayHolderRequest" />
			<wsdl:output message="tns:twoWayHolderResponse" />
		</wsdl:operation>
		
		<wsdl:operation name="twoWay">
			<wsdl:input message="tns:twoWayRequest" />
			<wsdl:output message="tns:twoWayResponse" />
		</wsdl:operation>		
			
	</wsdl:portType>
	
	<wsdl:binding name="DocLitNonWrap" type="tns:DocLitNonWrapPortType">
		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />

		<wsdl:operation name="oneWayVoid">
			<soap:operation soapAction="http://nonwrap.sample.test.org/twoWayReturn" />
			<wsdl:input>
				<soap:body use="literal"  />
			</wsdl:input>
		</wsdl:operation>

		<wsdl:operation name="oneWay">
			<soap:operation soapAction="http://nonwrap.sample.test.org/twoWayReturn" />
			<wsdl:input>
				<soap:body use="literal"  />
			</wsdl:input>
		</wsdl:operation>
		
		<wsdl:operation name="twoWayHolder">
			<soap:operation soapAction="http://nonwrap.sample.test.org/twoWayReturn" />
			<wsdl:input>
				<soap:body use="literal"  />
			</wsdl:input>
			<wsdl:output>
				<soap:body use="literal"  />
			</wsdl:output>
	
		</wsdl:operation>
		
		<wsdl:operation name="twoWay">
			<soap:operation soapAction="http://nonwrap.sample.test.org/twoWayReturn" />
			<wsdl:input>
				<soap:body use="literal"  />
			</wsdl:input>
			<wsdl:output>
				<soap:body use="literal"  />
			</wsdl:output>
	
		</wsdl:operation>		
	
	</wsdl:binding>
	
	<wsdl:service name="DocLitNonWrapService">
		<wsdl:port binding="tns:DocLitNonWrap" name="ProxyDocLitWrappedPort">
			<soap:address location="http://localhost:8080/axis2/services/DocLitNonWrapService" />
		</wsdl:port>
	</wsdl:service>
	
</wsdl:definitions>
