<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://incubator.apache.org/uima"
            xmlns="http://incubator.apache.org/uima" elementFormDefault="qualified">
	<!--
		* 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.
	-->
	<xs:element name="dictionary">
		<xs:complexType>
			<xs:sequence>
				<xs:element ref="typeCollection" minOccurs="1"
					maxOccurs="1" />
			</xs:sequence>
		</xs:complexType>
	</xs:element>

	<xs:element name="typeCollection">
		<xs:complexType>
			<xs:sequence>
				<xs:element ref="dictionaryMetaData" minOccurs="0" maxOccurs="1" />
				<xs:element name="languageId" type="xs:string"
					minOccurs="0" maxOccurs="1" />
				<xs:element ref="typeDescription" minOccurs="1"
					maxOccurs="1" />
				<xs:element ref="entries" minOccurs="1"
					maxOccurs="1" />
			</xs:sequence>
		</xs:complexType>
	</xs:element>

	<xs:element name="dictionaryMetaData">
		<xs:complexType>
		  <xs:attribute name="caseNormalization" type="xs:boolean" use="optional" default="true" />
		  <xs:attribute name="multiWordEntries" type="xs:boolean" use="optional" default="true" />
		  <xs:attribute name="multiWordSeparator" type="xs:string" use="optional" default=" " />
		</xs:complexType>
	</xs:element>

	<xs:element name="typeDescription">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="typeName" type="xs:string" minOccurs="1"
					maxOccurs="1" />
			</xs:sequence>
		</xs:complexType>
	</xs:element>

	<xs:element name="entries">
		<xs:complexType>
			<xs:sequence>
				<xs:element ref="entry" minOccurs="1"
					maxOccurs="unbounded" />
			</xs:sequence>
		</xs:complexType>
	</xs:element>


	<xs:element name="entry">
		<xs:complexType>
			<xs:sequence>
				<xs:element ref="key" minOccurs="1"
					maxOccurs="1" />
			</xs:sequence>
		</xs:complexType>
	</xs:element>

	<xs:element name="key" nillable="false">
		<xs:complexType>
			<xs:simpleContent>
				<xs:extension base="xs:string" />
			</xs:simpleContent>
		</xs:complexType>
	</xs:element>

</xs:schema>
