<!--
  ~ 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.
  -->

<serviceGroup>
 <service name="DemoServiceService">
  <messageReceivers>
   <messageReceiver mep="http://www.w3.org/2004/08/wsdl/in-out" class="org.apache.axis2.jaxws.server.JAXWSMessageReceiver"/>
  </messageReceivers>
  <parameter locked="false" name="ServiceClass">org.apache.axis2.jaxws.handler.header.DemoService</parameter>
  <operation name="addNumbers" mep="http://www.w3.org/2004/08/wsdl/in-out">
    <actionMapping/>
  </operation>
  <operation name="echo" mep="http://www.w3.org/2004/08/wsdl/in-only">
    <actionMapping/>
  </operation>
 </service>
</serviceGroup>
