<?xml version="1.0" encoding="UTF-8"?>


<!--
  ~ Licensed to the Apache Software Foundation (ASF) under one
  ~ or more contributor license agreements. See the NOTICE file
  ~ distributed with this work for additional information
  ~ regarding copyright ownership. The ASF licenses this file
  ~ to you under the Apache License, Version 2.0 (the
  ~ "License"); you may not use this file except in compliance
  ~ with the License. You may obtain a copy of the License at
  ~
  ~ http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing,
  ~ software distributed under the License is distributed on an
  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  ~ KIND, either express or implied. See the License for the
  ~ specific language governing permissions and limitations
  ~ under the License.
  -->


<definitions name="AddNumbersHandler" targetNamespace="http://org/test/addnumbershandler"
	xmlns:tns="http://org/test/addnumbershandler" xmlns="http://schemas.xmlsoap.org/wsdl/"
	xmlns:xsd="http://www.w3.org/2001/XMLSchema"
	xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">


	<types>
		<xsd:schema xmlns="http://www.w3.org/2001/XMLSchema"
			elementFormDefault="qualified" targetNamespace="http://org/test/addnumbershandler">
			<element name="myHeader" type="xsd:string" />
			
			<element name="addNumbersHandlerResponse">
				<complexType>
					<sequence>
						<element name="return" type="xsd:int" />
					</sequence>
				</complexType>
			</element>

			<element name="addNumbersHandler">
				<complexType>
					<sequence>
						<element name="arg0" type="xsd:int" />
						<element name="arg1" type="xsd:int" />
					</sequence>
				</complexType>
			</element>

			<element name="AddNumbersHandlerFault">
				<complexType>
					<sequence>
						<element name="faultInfo" type="xsd:string" />
						<element name="message" type="xsd:string" />
					</sequence>
				</complexType>
			</element>

			<element name="oneWayInt">
				<complexType>
					<sequence>
						<element name="arg0" type="xsd:int" />
					</sequence>
				</complexType>
			</element>

		</xsd:schema>
	</types>

	<message name="addNumbersHandler">
		<part name="parameters" element="tns:addNumbersHandler" />
	</message>
	<message name="addNumbersHandlerResponse">
		<part name="result" element="tns:addNumbersHandlerResponse" />
	</message>
	<message name="addNumbersHandlerFault">
		<part name="AddNumbersHandlerFault" element="tns:AddNumbersHandlerFault" />
	</message>
	<message name="oneWayInt">
		<part name="parameters" element="tns:oneWayInt" />
	</message>

	<portType name="AddNumbersHandlerPortType">
		<operation name="addNumbersHandler">
			<input message="tns:addNumbersHandler" name="add" />
			<output message="tns:addNumbersHandlerResponse" name="addResponse" />
			<fault name="addNumbersHandlerFault" message="tns:addNumbersHandlerFault" />
		</operation>
		<operation name="oneWayInt">
			<input message="tns:oneWayInt" />
		</operation>
	</portType>
	<binding name="AddNumbersHandlerBinding" type="tns:AddNumbersHandlerPortType">
		<soap:binding transport="http://schemas.xmlsoap.org/soap/http"
			style="document" />
		<operation name="addNumbersHandler">
			
			<input>
				<soap:body use="literal" />
			</input>
			<output>
				<soap:body use="literal" />
			</output>
			<fault name="addNumbersHandlerFault">
				<soap:fault name="addNumbersHandlerFault" use="literal" />
			</fault>
		</operation>
		<operation name="oneWayInt">
			
			<input>
				<soap:body use="literal" />
			</input>
		</operation>
	</binding>
	<service name="AddNumbersHandlerService">
		<port name="AddNumbersHandlerPort" binding="tns:AddNumbersHandlerBinding">
			<soap:address
				location="http://localhost:9080/AddNumberHandler/AddNumbersHandlerImplService" />
		</port>
	</service>
</definitions>
