<?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.
 -->
 <schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:tns="http://www.example.org/xjc-javadoc-plugin/" targetNamespace="http://www.example.org/xjc-javadoc-plugin/">
    <complexType name="ComplexTypeWithDocumentedProperties">
    	<sequence>
    		<element name="documentedElement" type="string">
    			<annotation>
    				<documentation>
    					Some documentation of element
    				</documentation>
    			</annotation>
    		</element>
    		<element name="elementWithoutAnnotation" type="string"/>
    		<element name="elementWithoutDocumentation" type="string">
    			<annotation></annotation>
    		</element>
    	</sequence>
    </complexType>
</schema>