<!--
  ~ 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.
  -->

<!-- This schema is used to generate the JAX-B artifacts
     used by the JAX-B Dispatch tests -->
<s:schema xmlns:s="http://www.w3.org/2001/XMLSchema"
	elementFormDefault="qualified" 
	targetNamespace="http://test">
  <s:element name="echoString">
    <s:complexType>
      <s:sequence>
        <s:element minOccurs="0" maxOccurs="1" name="input" type="s:string" />
      </s:sequence>
    </s:complexType>
  </s:element>
  <s:element name="echoStringResponse">
    <s:complexType>
      <s:sequence>
        <s:element minOccurs="0" maxOccurs="1" name="echoStringReturn" type="s:string" />
      </s:sequence>
    </s:complexType>
  </s:element>
</s:schema>