<?xml version="1.0"?>
<!-- 
    Copyright (C) 2006 W3C (R) (MIT ERCIM Keio), All Rights Reserved.
    W3C liability, trademark and document use rules apply.

    http://www.w3.org/Consortium/Legal/ipr-notice
    http://www.w3.org/Consortium/Legal/copyright-documents

    $Header: /w3ccvs/WWW/2002/ws/databinding/examples/6/05/examples.xml,v 1.17 2006/09/05 15:06:46 pdowney Exp $
-->

<ex:examples xmlns:e="http://www.w3.org/2002/ws/databinding/examples/6/05/" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ex="http://www.w3.org/2002/ws/databinding/examples/6/05/" wsdlNamespace="http://www.w3.org/2002/ws/databinding/examples/6/05/wsdl" targetNamespace="http://www.w3.org/2002/ws/databinding/examples/6/05/">
   <ex:example xml:id="TargetNamespace" element="ex:targetNamespace">
      <ex:types>
         <xs:schema targetNamespace="http://www.w3.org/2002/ws/databinding/examples/6/05/">
            <xs:element name="targetNamespace" type="xs:string"/>
         </xs:schema>
      </ex:types>
      <ex:instance xml:id="TargetNamespace01">
         <ex:targetNamespace>foo</ex:targetNamespace>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="NoTargetNamespace" element="noTargetNamespace">
      <ex:types>
         <xs:schema>
            <xs:element name="noTargetNamespace" type="xs:string"/>
         </xs:schema>
      </ex:types>
      <ex:instance xml:id="NoTargetNamespace01">
         <noTargetNamespace>foo</noTargetNamespace>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="AnySimpleTypeElement" element="ex:anySimpleTypeElement">
      <ex:typedef>
         <xs:element name="anySimpleTypeElement" type="xs:anySimpleType"/>
      </ex:typedef>
      <ex:instance xml:id="AnySimpleTypeElement00">
         <ex:anySimpleTypeElement/>
      </ex:instance>
      <ex:instance xml:id="AnySimpleTypeElement01">
         <ex:anySimpleTypeElement>anySimpleTypeValue</ex:anySimpleTypeElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="AnyTypeElement" element="ex:anyTypeElement">
      <ex:typedef>
         <xs:element name="anyTypeElement" type="xs:anyType"/>
      </ex:typedef>
      <ex:instance xml:id="AnyTypeElement00">
         <ex:anyTypeElement/>
      </ex:instance>
      <ex:instance xml:id="AnyTypeElement01">
         <ex:anyTypeElement>
            <foo>
               <bar>cheese</bar>
            </foo>
         </ex:anyTypeElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ImportSchema" element="ex:importSchema">
      <ex:typedef>
         <xs:import namespace="http://www.w3.org/2001/XMLSchema"/>
         <xs:element name="importSchema" type="xs:string"/>
      </ex:typedef>
      <ex:instance xml:id="importSchema00">
         <ex:importSchema>hello service</ex:importSchema>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="DocumentationElement" element="ex:documentationElement">
      <ex:typedef>
         <xs:annotation>
            <xs:documentation xml:lang="en">Schema Level Documentation</xs:documentation>
         </xs:annotation>
         <xs:element name="documentationElement" type="xs:string">
            <xs:annotation>
               <xs:documentation xml:lang="en">This is a string Element</xs:documentation>
            </xs:annotation>
         </xs:element>
      </ex:typedef>
      <ex:instance xml:id="DocumentationElement00">
         <ex:documentationElement>hello world</ex:documentationElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="StringElement" element="ex:stringElement">
      <ex:typedef>
         <xs:element name="stringElement" type="xs:string"/>
      </ex:typedef>
      <ex:instance xml:id="StringElement00">
         <ex:stringElement/>
      </ex:instance>
      <ex:instance xml:id="StringElement01">
         <ex:stringElement>concentrate, concentrate, concentrate. I've got to concentrate, concentrate, concentrate. Hello, hello, hello. Echo, echo, echo</ex:stringElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="StringAttribute" element="ex:stringAttribute">
      <ex:typedef>
         <xs:attribute name="stringAttribute" type="xs:string"/>
      </ex:typedef>
      <ex:instance xml:id="StringAttribute00">
ex:stringAttribute="Echo, echo, echo..."
      </ex:instance>
      <ex:instance xml:id="StringAttribute01">
ex:stringAttribute=""
      </ex:instance>
   </ex:example>
   <ex:example xml:id="BooleanElement" element="ex:booleanElement">
      <ex:typedef>
         <xs:element name="booleanElement" type="xs:boolean"/>
      </ex:typedef>
      <ex:instance xml:id="BooleanElement01">
         <ex:booleanElement>false</ex:booleanElement>
      </ex:instance>
      <ex:instance xml:id="BooleanElement02">
         <ex:booleanElement>true</ex:booleanElement>
      </ex:instance>
      <ex:instance xml:id="BooleanElement03">
         <ex:booleanElement>0</ex:booleanElement>
      </ex:instance>
      <ex:instance xml:id="BooleanElement04">
         <ex:booleanElement>1</ex:booleanElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="BooleanAttribute" element="ex:booleanAttribute">
      <ex:typedef>
         <xs:attribute name="booleanAttribute" type="xs:boolean"/>
      </ex:typedef>
      <ex:instance xml:id="BooleanAttribute01">
ex:booleanAttribute="false"
      </ex:instance>
      <ex:instance xml:id="BooleanAttribute02">
ex:booleanAttribute="1"
      </ex:instance>
   </ex:example>
   <ex:example xml:id="DecimalElement" element="ex:decimalElement">
      <ex:typedef>
         <xs:element name="decimalElement" type="xs:decimal"/>
      </ex:typedef>
      <ex:instance xml:id="DecimalElement01">
         <ex:decimalElement>0</ex:decimalElement>
      </ex:instance>
      <ex:instance xml:id="DecimalElement02">
         <ex:decimalElement>-1.23</ex:decimalElement>
      </ex:instance>
      <ex:instance xml:id="DecimalElement03">
         <ex:decimalElement>12678967.543233</ex:decimalElement>
      </ex:instance>
      <ex:instance xml:id="DecimalElement04">
         <ex:decimalElement>+1000000.00</ex:decimalElement>
      </ex:instance>
      <ex:instance xml:id="DecimalElement05">
         <ex:decimalElement>+100000000000000000000000000000000000000000000.00</ex:decimalElement>
      </ex:instance>
      <ex:instance xml:id="DecimalElement06">
         <ex:decimalElement>210</ex:decimalElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="FloatElement" element="ex:floatElement">
      <ex:typedef>
         <xs:element name="floatElement" type="xs:float"/>
      </ex:typedef>
      <ex:instance xml:id="FloatElement01">
         <ex:floatElement>-1E4</ex:floatElement>
      </ex:instance>
      <ex:instance xml:id="FloatElement02">
         <ex:floatElement>1267.43233E12</ex:floatElement>
      </ex:instance>
      <ex:instance xml:id="FloatElement03">
         <ex:floatElement>12.78e-2</ex:floatElement>
      </ex:instance>
      <ex:instance xml:id="FloatElement04">
         <ex:floatElement>12</ex:floatElement>
      </ex:instance>
      <ex:instance xml:id="FloatElement05">
         <ex:floatElement>INF</ex:floatElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="DoubleElement" element="ex:doubleElement">
      <ex:typedef>
         <xs:element name="doubleElement" type="xs:double"/>
      </ex:typedef>
      <ex:instance xml:id="DoubleElement01">
         <ex:doubleElement>-1E4</ex:doubleElement>
      </ex:instance>
      <ex:instance xml:id="DoubleElement02">
         <ex:doubleElement>1267.432233E12</ex:doubleElement>
      </ex:instance>
      <ex:instance xml:id="DoubleElement03">
         <ex:doubleElement>12.78e-2</ex:doubleElement>
      </ex:instance>
      <ex:instance xml:id="DoubleElement04">
         <ex:doubleElement>12</ex:doubleElement>
      </ex:instance>
      <ex:instance xml:id="DoubleElement05">
         <ex:doubleElement>INF</ex:doubleElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="DurationElement" element="ex:durationElement">
      <ex:typedef>
         <xs:element name="durationElement" type="xs:duration"/>
      </ex:typedef>
      <ex:instance xml:id="DurationElement01">
         <ex:durationElement>P1Y2M3DT10H30M</ex:durationElement>
      </ex:instance>
      <ex:instance xml:id="DurationElement02">
         <ex:durationElement>-P1347M</ex:durationElement>
      </ex:instance>
      <ex:instance xml:id="DurationElement03">
         <ex:durationElement>P1347Y</ex:durationElement>
      </ex:instance>
      <ex:instance xml:id="DurationElement04">
         <ex:durationElement>P1M</ex:durationElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="DateTimeElement" element="ex:dateTimeElement">
      <ex:typedef>
         <xs:element name="dateTimeElement" type="xs:dateTime"/>
      </ex:typedef>
      <ex:instance xml:id="DateTimeElement01">
         <ex:dateTimeElement>1999-05-31T13:20:00-05:00</ex:dateTimeElement>
      </ex:instance>
      <ex:instance xml:id="DateTimeElement02">
         <ex:dateTimeElement>2000-03-04T23:00:00+03:00</ex:dateTimeElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="TimeElement" element="ex:timeElement">
      <ex:typedef>
         <xs:element name="timeElement" type="xs:time"/>
      </ex:typedef>
      <ex:instance xml:id="TimeElement01">
         <ex:timeElement>00:00:00</ex:timeElement>
      </ex:instance>
      <ex:instance xml:id="TimeElement02">
         <ex:timeElement>12:00:01</ex:timeElement>
      </ex:instance>
      <ex:instance xml:id="TimeElement03">
         <ex:timeElement>23:59:34</ex:timeElement>
      </ex:instance>
      <ex:instance xml:id="TimeElement04">
         <ex:timeElement>13:21:03Z</ex:timeElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="DateElement" element="ex:dateElement">
      <ex:typedef>
         <xs:element name="dateElement" type="xs:date"/>
      </ex:typedef>
      <ex:instance xml:id="DateElement01">
         <ex:dateElement>1999-05-31</ex:dateElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="GYearMonthElement" element="ex:gYearMonthElement">
      <ex:typedef>
         <xs:element name="gYearMonthElement" type="xs:gYearMonth"/>
      </ex:typedef>
      <ex:instance xml:id="GYearMonthElement01">
         <ex:gYearMonthElement>1999-05</ex:gYearMonthElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="GYearElement" element="ex:gYearElement">
      <ex:typedef>
         <xs:element name="gYearElement" type="xs:gYear"/>
      </ex:typedef>
      <ex:instance xml:id="GYearElement01">
         <ex:gYearElement>1999</ex:gYearElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="GMonthDayElement" element="ex:gMonthDayElement">
      <ex:typedef>
         <xs:element name="gMonthDayElement" type="xs:gMonthDay"/>
      </ex:typedef>
      <ex:instance xml:id="GMonthDayElement01">
         <ex:gMonthDayElement>--12-31</ex:gMonthDayElement>
      </ex:instance>
      <ex:instance xml:id="GMonthDayElement02">
         <ex:gMonthDayElement>--12-31Z</ex:gMonthDayElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="GDayElement" element="ex:gDayElement">
      <ex:typedef>
         <xs:element name="gDayElement" type="xs:gDay"/>
      </ex:typedef>
      <ex:instance xml:id="GDayElement01">
         <ex:gDayElement>---05</ex:gDayElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="GMonthElement" element="ex:gMonthElement">
      <ex:typedef>
         <xs:element name="gMonthElement" type="xs:gMonth"/>
      </ex:typedef>
      <ex:instance xml:id="GMonthElement01">
         <ex:gMonthElement>--02--</ex:gMonthElement>
      </ex:instance>
      <ex:instance xml:id="GMonthElement02">
         <ex:gMonthElement>--12--</ex:gMonthElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="HexBinaryElement" element="ex:hexBinaryElement">
      <ex:typedef>
         <xs:element name="hexBinaryElement" type="xs:hexBinary"/>
      </ex:typedef>
      <ex:instance xml:id="HexBinaryElement01">
         <ex:hexBinaryElement>76</ex:hexBinaryElement>
      </ex:instance>
      <ex:instance xml:id="HexBinaryElement02">
         <ex:hexBinaryElement>77696f646d6f6e7974637174716a7169696e6b65616f76786f746e66716b707875757261736e686469796b65706c656d7465626661637661646e6b65636662647669726d6f6e757361</ex:hexBinaryElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="Base64BinaryElement" element="ex:base64BinaryElement">
      <ex:typedef>
         <xs:element name="base64BinaryElement" type="xs:base64Binary"/>
      </ex:typedef>
      <ex:instance xml:id="Base64BinaryElement01">
         <ex:base64BinaryElement>bQ==</ex:base64BinaryElement>
      </ex:instance>
      <ex:instance xml:id="Base64BinaryElement02">
         <ex:base64BinaryElement>eHdmb3Rh</ex:base64BinaryElement>
      </ex:instance>
      <ex:instance xml:id="Base64BinaryElement03">
         <ex:base64BinaryElement>cnRjbGNyZW9scg==</ex:base64BinaryElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="AnyURIElement" element="ex:anyURIElement">
      <ex:typedef>
         <xs:element name="anyURIElement" type="xs:anyURI"/>
      </ex:typedef>
      <ex:instance xml:id="AnyURIElement01">
         <ex:anyURIElement>http://www.w3.org/2002/ws/databinding/</ex:anyURIElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="QNameElement" element="ex:QNameElement">
      <ex:typedef>
         <xs:element name="QNameElement" type="xs:QName"/>
      </ex:typedef>
      <ex:instance xml:id="QNameElement01">
         <ex:QNameElement>ex:QNameElement</ex:QNameElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="NormalizedStringElement" element="ex:normalizedStringElement">
      <ex:typedef>
         <xs:element name="normalizedStringElement" type="xs:normalizedString"/>
      </ex:typedef>
      <ex:instance xml:id="NormalizedStringElement00">
         <ex:normalizedStringElement/>
      </ex:instance>
      <ex:instance xml:id="NormalizedStringElement01">
         <ex:normalizedStringElement>How now brown cow.</ex:normalizedStringElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="TokenElement" element="ex:tokenElement">
      <ex:typedef>
         <xs:element name="tokenElement" type="xs:token"/>
      </ex:typedef>
      <ex:instance xml:id="TokenElement01">
         <ex:tokenElement>tokenElement</ex:tokenElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="LanguageElement" element="ex:languageElement">
      <ex:typedef>
         <xs:element name="languageElement" type="xs:language"/>
      </ex:typedef>
      <ex:instance xml:id="LanguageElement01">
         <ex:languageElement>en</ex:languageElement>
      </ex:instance>
      <ex:instance xml:id="LanguageElement02">
         <ex:languageElement>fr</ex:languageElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="NMTOKENElement" element="ex:NMTOKENElement">
      <ex:typedef>
         <xs:element name="NMTOKENElement" type="xs:NMTOKEN"/>
      </ex:typedef>
      <ex:instance xml:id="NMTOKENElement01">
         <ex:NMTOKENElement>id</ex:NMTOKENElement>
      </ex:instance>
      <ex:instance xml:id="NMTOKENElement02">
         <ex:NMTOKENElement>vocabularies:that.as:clean:assuring-s_to:The_we:contain</ex:NMTOKENElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="NMTOKENSElement" element="ex:NMTOKENSElement">
      <ex:typedef>
         <xs:element name="NMTOKENSElement" type="xs:NMTOKENS"/>
      </ex:typedef>
      <ex:instance xml:id="NMTOKENSElement01">
         <ex:NMTOKENSElement>a b c d e.b:s-w_x:q</ex:NMTOKENSElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="NameElement" element="ex:NameElement">
      <ex:typedef>
         <xs:element name="NameElement" type="xs:Name"/>
      </ex:typedef>
      <ex:instance xml:id="NameElement01">
         <ex:NameElement>foo</ex:NameElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="NCNameElement" element="ex:NCNameElement">
      <ex:typedef>
         <xs:element name="NCNameElement" type="xs:NCName"/>
      </ex:typedef>
      <ex:instance xml:id="NCNameElement01">
         <ex:NCNameElement>foo</ex:NCNameElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="IDElement" element="ex:IDElement">
      <ex:typedef>
         <xs:element name="IDElement" type="xs:ID"/>
      </ex:typedef>
      <ex:instance xml:id="IDElement01">
         <ex:IDElement>foo</ex:IDElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="IDREFElement" element="ex:IDREFElement">
      <ex:typedef>
         <xs:element name="IDREFElement" type="xs:IDREF"/>
      </ex:typedef>
      <ex:instance xml:id="IDREFElement01">
         <ex:IDREFElement>foo</ex:IDREFElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="IDREFSElement" element="ex:IDREFSElement">
      <ex:typedef>
         <xs:element name="IDREFSElement" type="xs:IDREFS"/>
      </ex:typedef>
      <ex:instance xml:id="IDREFSElement01">
         <ex:IDREFSElement>foo</ex:IDREFSElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ENTITYElement" element="ex:ENTITYElement">
      <ex:typedef>
         <xs:element name="ENTITYElement" type="xs:ENTITY"/>
      </ex:typedef>
      <ex:instance xml:id="ENTITYElement01">
         <ex:ENTITYElement>lt</ex:ENTITYElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ENTITIESElement" element="ex:ENTITIESElement">
      <ex:typedef>
         <xs:element name="ENTITIESElement" type="xs:ENTITIES"/>
      </ex:typedef>
      <ex:instance xml:id="ENTITIESElement01">
         <ex:ENTITIESElement>lt gt apos quot</ex:ENTITIESElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="IntegerElement" element="ex:integerElement">
      <ex:typedef>
         <xs:element name="integerElement" type="xs:integer"/>
      </ex:typedef>
      <ex:instance xml:id="IntegerElement00">
         <ex:integerElement>0</ex:integerElement>
      </ex:instance>
      <ex:instance xml:id="IntegerElement01">
         <ex:integerElement>1</ex:integerElement>
      </ex:instance>
      <ex:instance xml:id="IntegerElement02">
         <ex:integerElement>12678967543233</ex:integerElement>
      </ex:instance>
      <ex:instance xml:id="IntegerElement03">
         <ex:integerElement>+10000</ex:integerElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="NonPositiveIntegerElement" element="ex:nonPositiveIntegerElement">
      <ex:typedef>
         <xs:element name="nonPositiveIntegerElement" type="xs:nonPositiveInteger"/>
      </ex:typedef>
      <ex:instance xml:id="NonPositiveIntegerElement01">
         <ex:nonPositiveIntegerElement>-1</ex:nonPositiveIntegerElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="NegativeIntegerElement" element="ex:negativeIntegerElement">
      <ex:typedef>
         <xs:element name="negativeIntegerElement" type="xs:negativeInteger"/>
      </ex:typedef>
      <ex:instance xml:id="NegativeIntegerElement01">
         <ex:negativeIntegerElement>-1</ex:negativeIntegerElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="LongElement" element="ex:longElement">
      <ex:typedef>
         <xs:element name="longElement" type="xs:long"/>
      </ex:typedef>
      <ex:instance xml:id="LongElement01">
         <ex:longElement>1</ex:longElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="IntElement" element="ex:intElement">
      <ex:typedef>
         <xs:element name="intElement" type="xs:int"/>
      </ex:typedef>
      <ex:instance xml:id="IntElement01">
         <ex:intElement>1</ex:intElement>
      </ex:instance>
      <ex:instance xml:id="IntElement02">
         <ex:intElement>10042</ex:intElement>
      </ex:instance>
      <ex:instance xml:id="IntElement03">
         <ex:intElement>-42</ex:intElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="IntAttribute" element="ex:intAttribute">
      <ex:typedef>
         <xs:attribute name="intAttribute" type="xs:int"/>
      </ex:typedef>
      <ex:instance xml:id="IntAttribute01">
ex:intAttribute="42"
      </ex:instance>
      <ex:instance xml:id="IntAttribute02">
ex:intAttribute="-10042"
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ShortElement" element="ex:shortElement">
      <ex:typedef>
         <xs:element name="shortElement" type="xs:short"/>
      </ex:typedef>
      <ex:instance xml:id="ShortElement01">
         <ex:shortElement>1</ex:shortElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ByteElement" element="ex:byteElement">
      <ex:typedef>
         <xs:element name="byteElement" type="xs:byte"/>
      </ex:typedef>
      <ex:instance xml:id="ByteElement01">
         <ex:byteElement>1</ex:byteElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="NonNegativeIntegerElement" element="ex:nonNegativeIntegerElement">
      <ex:typedef>
         <xs:element name="nonNegativeIntegerElement" type="xs:nonNegativeInteger"/>
      </ex:typedef>
      <ex:instance xml:id="NonNegativeIntegerElement01">
         <ex:nonNegativeIntegerElement>1</ex:nonNegativeIntegerElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="UnsignedLongElement" element="ex:unsignedLongElement">
      <ex:typedef>
         <xs:element name="unsignedLongElement" type="xs:unsignedLong"/>
      </ex:typedef>
      <ex:instance xml:id="UnsignedLongElement01">
         <ex:unsignedLongElement>1</ex:unsignedLongElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="UnsignedIntElement" element="ex:unsignedIntElement">
      <ex:typedef>
         <xs:element name="unsignedIntElement" type="xs:unsignedInt"/>
      </ex:typedef>
      <ex:instance xml:id="UnsignedIntElement01">
         <ex:unsignedIntElement>1</ex:unsignedIntElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="UnsignedShortElement" element="ex:unsignedShortElement">
      <ex:typedef>
         <xs:element name="unsignedShortElement" type="xs:unsignedShort"/>
      </ex:typedef>
      <ex:instance xml:id="UnsignedShortElement01">
         <ex:unsignedShortElement>1</ex:unsignedShortElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="UnsignedByteElement" element="ex:unsignedByteElement">
      <ex:typedef>
         <xs:element name="unsignedByteElement" type="xs:unsignedByte"/>
      </ex:typedef>
      <ex:instance xml:id="UnsignedByteElement01">
         <ex:unsignedByteElement>1</ex:unsignedByteElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="PositiveIntegerElement" element="ex:positiveIntegerElement">
      <ex:typedef>
         <xs:element name="positiveIntegerElement" type="xs:positiveInteger"/>
      </ex:typedef>
      <ex:instance xml:id="PositiveIntegerElement01">
         <ex:positiveIntegerElement>1</ex:positiveIntegerElement>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="StringEnumeration" element="ex:beatle">
      <ex:typedef>
         <xs:element name="beatle" type="ex:Beatle"/>
         <xs:simpleType name="Beatle">
            <xs:restriction base="xs:string">
               <xs:enumeration value="John"/>
               <xs:enumeration value="Paul"/>
               <xs:enumeration value="George"/>
               <xs:enumeration value="Stuart"/>
               <xs:enumeration value="Pete"/>
               <xs:enumeration value="Ringo"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="B01">
         <ex:beatle>John</ex:beatle>
      </ex:instance>
      <ex:instance xml:id="B02">
         <ex:beatle>Paul</ex:beatle>
      </ex:instance>
      <ex:instance xml:id="B03">
         <ex:beatle>Ringo</ex:beatle>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="IntEnumeration" element="ex:intEnumeration">
      <ex:typedef>
         <xs:element name="intEnumeration" type="ex:IntEnumeration"/>
         <xs:simpleType name="IntEnumeration">
            <xs:restriction base="xs:int">
               <xs:enumeration value="2"/>
               <xs:enumeration value="3"/>
               <xs:enumeration value="5"/>
               <xs:enumeration value="7"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="IntEnumeration01">
         <ex:intEnumeration>2</ex:intEnumeration>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ShortEnumeration" element="ex:shortEnumeration">
      <ex:typedef>
         <xs:element name="shortEnumeration" type="ex:ShortEnumeration"/>
         <xs:simpleType name="ShortEnumeration">
            <xs:restriction base="xs:short">
               <xs:enumeration value="7"/>
               <xs:enumeration value="11"/>
               <xs:enumeration value="13"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="ShortEnumeration01">
         <ex:shortEnumeration>11</ex:shortEnumeration>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="LongEnumeration" element="ex:longEnumeration">
      <ex:typedef>
         <xs:element name="longEnumeration" type="ex:LongEnumeration"/>
         <xs:simpleType name="LongEnumeration">
            <xs:restriction base="xs:long">
               <xs:enumeration value="9152052"/>
               <xs:enumeration value="7816230"/>
               <xs:enumeration value="7235733"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="LongiEnumeration01">
         <ex:longEnumeration>9152052</ex:longEnumeration>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="DoubleEnumeration" element="ex:doubleEnumeration">
      <ex:typedef>
         <xs:element name="doubleEnumeration" type="ex:DoubleEnumeration"/>
         <xs:simpleType name="DoubleEnumeration">
            <xs:restriction base="xs:double">
               <xs:enumeration value="1267.43233E12"/>
               <xs:enumeration value="7234.34541E12"/>
               <xs:enumeration value="5733.65565E12"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="DoubleEnumeration01">
         <ex:doubleEnumeration>1267.43233E12</ex:doubleEnumeration>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="IntegerEnumeration" element="ex:integerEnumeration">
      <ex:typedef>
         <xs:element name="integerEnumeration" type="ex:IntegerEnumeration"/>
         <xs:simpleType name="IntegerEnumeration">
            <xs:restriction base="xs:integer">
               <xs:enumeration value="4000000"/>
               <xs:enumeration value="5000000"/>
               <xs:enumeration value="6000000"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="IntegerEnumeration01">
         <ex:integerEnumeration>4000000</ex:integerEnumeration>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="DecimalEnumeration" element="ex:decimalEnumeration">
      <ex:typedef>
         <xs:element name="decimalEnumeration" type="ex:DecimalEnumeration"/>
         <xs:simpleType name="DecimalEnumeration">
            <xs:restriction base="xs:decimal">
               <xs:enumeration value="+1000.0001"/>
               <xs:enumeration value="-1000.0001"/>
               <xs:enumeration value="1000.0002"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="DecimalEnumeration01">
         <ex:decimalEnumeration>1000.0002</ex:decimalEnumeration>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="FloatEnumeration" element="ex:floatEnumeration">
      <ex:typedef>
         <xs:element name="floatEnumeration" type="ex:FloatEnumeration"/>
         <xs:simpleType name="FloatEnumeration">
            <xs:restriction base="xs:float">
               <xs:enumeration value="1267.43233E12"/>
               <xs:enumeration value="7234.34541E12"/>
               <xs:enumeration value="5733.65565E12"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="FloatEnumeration01">
         <ex:floatEnumeration>1267.43233E12</ex:floatEnumeration>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="NonNegativeIntegerEnumeration" element="ex:nonNegativeIntegerEnumeration">
      <ex:typedef>
         <xs:element name="nonNegativeIntegerEnumeration" type="ex:NonNegativeIntegerEnumeration"/>
         <xs:simpleType name="NonNegativeIntegerEnumeration">
            <xs:restriction base="xs:nonNegativeInteger">
               <xs:enumeration value="12"/>
               <xs:enumeration value="24"/>
               <xs:enumeration value="33"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="NonNegativeIntegerEnumeration01">
         <ex:nonNegativeIntegerEnumeration>12</ex:nonNegativeIntegerEnumeration>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="PositiveIntegerEnumeration" element="ex:positiveIntegerEnumeration">
      <ex:typedef>
         <xs:element name="positiveIntegerEnumeration" type="ex:PositiveIntegerEnumeration"/>
         <xs:simpleType name="PositiveIntegerEnumeration">
            <xs:restriction base="xs:positiveInteger">
               <xs:enumeration value="12"/>
               <xs:enumeration value="24"/>
               <xs:enumeration value="33"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="PositiveIntegerEnumeration01">
         <ex:positiveIntegerEnumeration>12</ex:positiveIntegerEnumeration>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="UnsignedLongEnumeration" element="ex:unsignedLongEnumeration">
      <ex:typedef>
         <xs:element name="unsignedLongEnumeration" type="ex:UnsignedLongEnumeration"/>
         <xs:simpleType name="UnsignedLongEnumeration">
            <xs:restriction base="xs:unsignedLong">
               <xs:enumeration value="11111111111111"/>
               <xs:enumeration value="22222222222222"/>
               <xs:enumeration value="33333333333333"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="UnsignedLongEnumeration01">
         <ex:unsignedLongEnumeration>33333333333333</ex:unsignedLongEnumeration>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="UnsignedIntEnumeration" element="ex:unsignedIntEnumeration">
      <ex:typedef>
         <xs:element name="unsignedIntEnumeration" type="ex:UnsignedIntEnumeration"/>
         <xs:simpleType name="UnsignedIntEnumeration">
            <xs:restriction base="xs:unsignedInt">
               <xs:enumeration value="1111111111"/>
               <xs:enumeration value="2222222222"/>
               <xs:enumeration value="3333333333"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="UnsignedIntEnumeration01">
         <ex:unsignedIntEnumeration>3333333333</ex:unsignedIntEnumeration>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="UnsignedShortEnumeration" element="ex:unsignedShortEnumeration">
      <ex:typedef>
         <xs:element name="unsignedShortEnumeration" type="ex:UnsignedShortEnumeration"/>
         <xs:simpleType name="UnsignedShortEnumeration">
            <xs:restriction base="xs:unsignedShort">
               <xs:enumeration value="1111"/>
               <xs:enumeration value="2222"/>
               <xs:enumeration value="3333"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="UnsignedShortEnumeration01">
         <ex:unsignedShortEnumeration>3333</ex:unsignedShortEnumeration>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="Collection" element="ex:collection">
      <ex:typedef>
         <xs:element name="collection" type="ex:Collection"/>
         <xs:complexType name="Collection">
            <xs:sequence>
               <xs:element name="name" type="xs:string"/>
               <xs:element name="shade" type="xs:string"/>
               <xs:element name="length" type="xs:int"/>
            </xs:sequence>
            <xs:attribute name="id" type="xs:string"/>
            <xs:attribute name="inStock" type="xs:int"/>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="Collection01">
         <ex:collection id="6026" inStock="232">
            <ex:name>Widget</ex:name>
            <ex:shade>Light Blue</ex:shade>
            <ex:length>33</ex:length>
         </ex:collection>
      </ex:instance>
      <ex:instance xml:id="Collection02">
         <ex:collection inStock="52" id="6026">
            <ex:name>Widget</ex:name>
            <ex:shade>Green</ex:shade>
            <ex:length>1233</ex:length>
         </ex:collection>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="MinOccurs1" element="ex:minOccurs1">
      <ex:typedef>
         <xs:element name="minOccurs1" type="ex:MinOccurs1"/>
         <xs:complexType name="MinOccurs1">
            <xs:sequence>
               <xs:element name="minOccurs1item" type="xs:string" minOccurs="1"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="MinOccurs01">
         <ex:minOccurs1>
            <ex:minOccurs1item>item1</ex:minOccurs1item>
         </ex:minOccurs1>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="MinOccurs2MaxOccurs2" element="ex:itemColors2">
      <ex:typedef>
         <xs:element name="itemColors2" type="ex:ItemColors2"/>
         <xs:complexType name="ItemColors2">
            <xs:sequence>
               <xs:element name="itemColor" type="xs:string" minOccurs="2" maxOccurs="2"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="MinOccurs2MaxOccurs201">
         <ex:itemColors>
            <ex:itemColor>Red</ex:itemColor>
            <ex:itemColor>Yellow</ex:itemColor>
         </ex:itemColors>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="MinOccurs2orMore" element="ex:itemColors">
      <ex:typedef>
         <xs:element name="itemColors" type="ex:ItemColors"/>
         <xs:complexType name="ItemColors">
            <xs:sequence>
               <xs:element name="itemColor" type="xs:string" minOccurs="2" maxOccurs="unbounded"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="MinOccurs2orMore01">
         <ex:itemColors>
            <ex:itemColor>Red</ex:itemColor>
            <ex:itemColor>Black</ex:itemColor>
            <ex:itemColor>White</ex:itemColor>
            <ex:itemColor>Yellow</ex:itemColor>
         </ex:itemColors>
      </ex:instance>
      <ex:instance xml:id="MinOccurs2orMore02">
         <ex:itemColors>
            <ex:itemColor>Black</ex:itemColor>
            <ex:itemColor>White</ex:itemColor>
         </ex:itemColors>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="MaxOccurs1" element="ex:ageDetails">
      <ex:typedef>
         <xs:element name="ageDetails" type="ex:AgeDetails"/>
         <xs:complexType name="AgeDetails">
            <xs:sequence>
               <xs:element name="age" type="xs:short" maxOccurs="1" minOccurs="1"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="MaxOccurs101">
         <ex:ageDetails>
            <ex:age>44</ex:age>
         </ex:ageDetails>
      </ex:instance>
      <ex:instance xml:id="MaxOccurs102">
         <ex:ageDetails>
            <ex:age>4</ex:age>
         </ex:ageDetails>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="MaxOccursUnbounded" element="ex:publications">
      <ex:typedef>
         <xs:element name="publications" type="ex:Publications"/>
         <xs:complexType name="Publications">
            <xs:sequence>
               <xs:element name="pubDate" type="xs:date" maxOccurs="unbounded"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="MaxOccursUnbounded01">
         <ex:publications>
            <ex:pubDate>2002-09-24</ex:pubDate>
            <ex:pubDate>2003-04-14</ex:pubDate>
            <ex:pubDate>2004-03-31</ex:pubDate>
            <ex:pubDate>2005-06-04</ex:pubDate>
            <ex:pubDate>2006-07-03</ex:pubDate>
         </ex:publications>
      </ex:instance>
      <ex:instance xml:id="MaxOccursUnbounded03">
         <ex:publications>
            <ex:pubDate>2006-01-26</ex:pubDate>
         </ex:publications>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="MaxOccursFinite" element="ex:summer">
      <ex:typedef>
         <xs:element name="summer" type="ex:Summer"/>
         <xs:complexType name="Summer">
            <xs:sequence>
               <xs:element name="mnth" type="xs:string" maxOccurs="4"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="MaxOccursFinite02">
         <ex:summer>
            <ex:mnth>May</ex:mnth>
            <ex:mnth>June</ex:mnth>
            <ex:mnth>July</ex:mnth>
            <ex:mnth>August</ex:mnth>
         </ex:summer>
      </ex:instance>
      <ex:instance xml:id="MaxOccursFinite03">
         <ex:summer>
            <ex:mnth>August</ex:mnth>
            <ex:mnth>September</ex:mnth>
         </ex:summer>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="AttributeOptional" element="ex:premium">
      <ex:typedef>
         <xs:element name="premium" type="ex:Premium"/>
         <xs:complexType name="Premium">
            <xs:sequence>
               <xs:element name="amount" type="xs:decimal"/>
            </xs:sequence>
            <xs:attribute name="id" type="xs:string"/>
            <xs:attribute name="currency" type="xs:string" use="optional"/>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="AttributeOptional01">
         <ex:premium id="1711" currency="EUR">
            <ex:amount>12.50</ex:amount>
         </ex:premium>
      </ex:instance>
      <ex:instance xml:id="AttributeOptional02">
         <ex:premium id="1712">
            <ex:amount>12.50</ex:amount>
         </ex:premium>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="AttributeRequired" element="ex:discount">
      <ex:typedef>
         <xs:element name="discount" type="ex:Discount"/>
         <xs:complexType name="Discount">
            <xs:sequence>
               <xs:element name="percentage" type="xs:int"/>
            </xs:sequence>
            <xs:attribute name="id" type="xs:string"/>
            <xs:attribute name="seasonal" type="xs:boolean" use="required"/>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="AttributeRequired01">
         <ex:discount id="1611" seasonal="true">
            <ex:percentage>5</ex:percentage>
         </ex:discount>
      </ex:instance>
      <ex:instance xml:id="AttributeRequired02">
         <ex:discount id="1612" seasonal="false">
            <ex:percentage>2</ex:percentage>
         </ex:discount>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="AttributeFixed" element="ex:survey">
      <ex:typedef>
         <xs:element name="survey" type="ex:Survey"/>
         <xs:complexType name="Survey">
            <xs:sequence>
               <xs:element name="fee" type="xs:decimal"/>
            </xs:sequence>
            <xs:attribute name="id" type="xs:string"/>
            <xs:attribute name="currency" type="xs:string" fixed="GBP"/>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="AttributeFixed01">
         <ex:survey id="1511" currency="GBP">
            <ex:fee>500.00</ex:fee>
         </ex:survey>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="UnorderedCollection" element="ex:unorderedCollection">
      <ex:typedef>
         <xs:element name="unorderedCollection" type="ex:UnorderedCollection"/>
         <xs:complexType name="UnorderedCollection">
            <xs:all>
               <xs:element name="name" type="xs:string"/>
               <xs:element name="shade" type="xs:string"/>
               <xs:element name="length" type="xs:int"/>
            </xs:all>
            <xs:attribute name="id" type="xs:string"/>
            <xs:attribute name="inStock" type="xs:int"/>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="UnorderedCollection01">
         <ex:unorderedCollection id="6026" inStock="232">
            <ex:name>Widget</ex:name>
            <ex:length>33</ex:length>
            <ex:shade>Light Blue</ex:shade>
         </ex:unorderedCollection>
      </ex:instance>
      <ex:instance xml:id="UnorderedCollection02">
         <ex:unorderedCollection inStock="332" id="6026">
            <ex:shade>Green</ex:shade>
            <ex:length>21</ex:length>
            <ex:name>Widget</ex:name>
         </ex:unorderedCollection>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="OptionalElement" element="ex:optionalMiddleName">
      <ex:typedef>
         <xs:element name="optionalMiddleName" type="ex:OptionalMiddleName"/>
         <xs:complexType name="OptionalMiddleName">
            <xs:sequence>
               <xs:element name="firstName" type="xs:string"/>
               <xs:element name="middleName" type="xs:string" minOccurs="0"/>
               <xs:element name="lastName" type="xs:string"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="Oe01">
         <ex:optionalMiddleName>
            <ex:firstName>Paul</ex:firstName>
            <ex:lastName>Downey</ex:lastName>
         </ex:optionalMiddleName>
      </ex:instance>
      <ex:instance xml:id="Oe02">
         <ex:optionalMiddleName>
            <ex:firstName>Paul</ex:firstName>
            <ex:middleName>Sumner</ex:middleName>
            <ex:lastName>Downey</ex:lastName>
         </ex:optionalMiddleName>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="NillableElement" element="ex:nillableMiddleName">
      <ex:typedef>
         <xs:element name="nillableMiddleName" type="ex:NillableMiddleName"/>
         <xs:complexType name="NillableMiddleName">
            <xs:sequence>
               <xs:element name="firstName" type="xs:string"/>
               <xs:element name="middleName" type="xs:string" nillable="true"/>
               <xs:element name="lastName" type="xs:string"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="Nmn01">
         <ex:nillableMiddleName>
            <ex:firstName>Paul</ex:firstName>
            <ex:middleName xsi:nil="true"/>
            <ex:lastName>Downey</ex:lastName>
         </ex:nillableMiddleName>
      </ex:instance>
      <ex:instance xml:id="Nmn02">
         <ex:nillableMiddleName>
            <ex:firstName>Paul</ex:firstName>
            <ex:middleName>Sumner</ex:middleName>
            <ex:lastName>Downey</ex:lastName>
         </ex:nillableMiddleName>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="NillableOptionalElement" element="ex:nillableOptionalMiddleName">
      <ex:typedef>
         <xs:element name="nillableOptionalMiddleName" type="ex:NillableOptionalMiddleName"/>
         <xs:complexType name="NillableOptionalMiddleName">
            <xs:sequence>
               <xs:element name="firstName" type="xs:string"/>
               <xs:element name="middleName" type="xs:string" minOccurs="0" nillable="true"/>
               <xs:element name="lastName" type="xs:string"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="Nomn01">
         <ex:nillableOptionalMiddleName>
            <ex:firstName>Paul</ex:firstName>
            <ex:lastName>Downey</ex:lastName>
         </ex:nillableOptionalMiddleName>
      </ex:instance>
      <ex:instance xml:id="Nomn02">
         <ex:nillableOptionalMiddleName>
            <ex:firstName>Paul</ex:firstName>
            <ex:middleName>Sumner</ex:middleName>
            <ex:lastName>Downey</ex:lastName>
         </ex:nillableOptionalMiddleName>
      </ex:instance>
      <ex:instance xml:id="Nomn03">
         <ex:nillableOptionalMiddleName>
            <ex:firstName>Paul</ex:firstName>
            <ex:middleName xsi:nil="true"/>
            <ex:lastName>Downey</ex:lastName>
         </ex:nillableOptionalMiddleName>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="Choice" element="ex:fruit">
      <ex:typedef>
         <xs:element name="fruit" type="ex:Fruit"/>
         <xs:complexType name="Fruit">
            <xs:choice>
               <xs:element name="apple" type="xs:int"/>
               <xs:element name="orange" type="xs:string"/>
               <xs:element name="banana" type="xs:int"/>
            </xs:choice>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="Fruit01">
         <ex:fruit>
            <ex:apple>21</ex:apple>
         </ex:fruit>
      </ex:instance>
      <ex:instance xml:id="Fruit02">
         <ex:fruit>
            <ex:orange>Two Hundred</ex:orange>
         </ex:fruit>
      </ex:instance>
      <ex:instance xml:id="Fruit03">
         <ex:fruit>
            <ex:banana>329</ex:banana>
         </ex:fruit>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="Union" element="ex:jeansSize">
      <ex:typedef>
         <xs:element name="jeansSize">
            <xs:simpleType>
               <xs:union memberTypes="sizebyno sizebystring"/>
            </xs:simpleType>
         </xs:element>
         <xs:simpleType name="sizebyno">
            <xs:restriction base="xs:positiveInteger">
               <xs:maxInclusive value="46"/>
            </xs:restriction>
         </xs:simpleType>
         <xs:simpleType name="sizebystring">
            <xs:restriction base="xs:string">
               <xs:enumeration value="small"/>
               <xs:enumeration value="medium"/>
               <xs:enumeration value="large"/>
               <xs:enumeration value="x-large"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="js01">
         <ex:jeansSize>40</ex:jeansSize>
      </ex:instance>
      <ex:instance xml:id="js02">
         <ex:jeansSize>x-large</ex:jeansSize>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="UnionDateString" element="ex:unionDateString">
      <ex:typedef>
         <xs:simpleType name="UnionDateString">
            <xs:union memberTypes="xs:date xs:string"/>
         </xs:simpleType>
         <xs:element name="unionDateString" type="ex:UnionDateString"/>
      </ex:typedef>
      <ex:instance xml:id="Sd01">
         <ex:unionDateString>Tonight</ex:unionDateString>
      </ex:instance>
      <ex:instance xml:id="Sd02">
         <ex:unionDateString>2006-06-06</ex:unionDateString>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="UnionSimpleDateString" element="ex:unionSimpleDateString">
      <ex:typedef>
         <xs:simpleType name="UnionSimpleDateString">
            <xs:union>
               <xs:simpleType>
                  <xs:restriction base="xs:date"/>
               </xs:simpleType>
               <xs:simpleType>
                  <xs:restriction base="xs:string"/>
               </xs:simpleType>
            </xs:union>
         </xs:simpleType>
         <xs:element name="unionSimpleDateString" type="ex:UnionSimpleDateString"/>
      </ex:typedef>
      <ex:instance xml:id="Sds01">
         <ex:unionSimpleDateString>Monday Night</ex:unionSimpleDateString>
      </ex:instance>
      <ex:instance xml:id="Sds02">
         <ex:unionSimpleDateString>2006-06-06</ex:unionSimpleDateString>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="NullEnumeration" element="ex:nullEnumeration">
      <ex:typedef>
         <xs:element name="nullEnumeration" type="ex:NullEnumeration"/>
         <xs:simpleType name="NullEnumeration">
            <xs:restriction base="xs:string">
               <xs:enumeration value=""/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="NullEnumeration01">
         <ex:nullEnumeration/>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="EmptyComplexType" element="ex:emptyComplexType">
      <ex:typedef>
         <xs:element name="emptyComplexType">
            <xs:complexType/>
         </xs:element>
      </ex:typedef>
      <ex:instance xml:id="EmptyComplexType01">
         <ex:emptyComplexType/>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="EmptySequence" element="ex:emptySequence">
      <ex:typedef>
         <xs:element name="emptySequence">
            <xs:complexType>
               <xs:sequence/>
            </xs:complexType>
         </xs:element>
      </ex:typedef>
      <ex:instance xml:id="EmptySequence01">
         <ex:emptySequence/>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ItemList" element="ex:itemList">
      <ex:typedef>
         <xs:element name="itemList" type="ex:ItemList"/>
         <xs:complexType name="ItemList">
            <xs:sequence>
               <xs:element name="item" minOccurs="0" maxOccurs="unbounded" type="xs:string"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="ItemList01">
         <ex:itemList>
            <ex:item>item one</ex:item>
            <ex:item>item two</ex:item>
            <ex:item>item three</ex:item>
            <ex:item>item four</ex:item>
         </ex:itemList>
      </ex:instance>
      <ex:instance xml:id="ItemList02">
         <ex:itemList>
            <ex:item>item one</ex:item>
         </ex:itemList>
      </ex:instance>
      <ex:instance xml:id="ItemList03">
         <ex:itemList/>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="NestedItemList" element="ex:nestedItemList" pattern="ItemList">
      <ex:typedef>
         <xs:element name="nestedItemList" type="ex:NestedItemList"/>
         <xs:complexType name="NestedItem">
            <xs:sequence>
               <xs:element name="item" minOccurs="0" maxOccurs="unbounded" type="xs:string"/>
            </xs:sequence>
         </xs:complexType>
         <xs:complexType name="NestedItemList">
            <xs:sequence>
               <xs:element name="nestedItem" minOccurs="0" maxOccurs="unbounded" type="ex:NestedItem"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="NestedItemList01">
         <ex:nestedItemList>
            <ex:nestedItem>
               <ex:item>item onexone</ex:item>
               <ex:item>item onextwo</ex:item>
               <ex:item>item onexthree</ex:item>
               <ex:item>item onexfour</ex:item>
            </ex:nestedItem>
            <ex:nestedItem>
               <ex:item>item twoxone</ex:item>
               <ex:item>item twoxtwo</ex:item>
               <ex:item>item twoxthree</ex:item>
               <ex:item>item twoxfour</ex:item>
            </ex:nestedItem>
         </ex:nestedItemList>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="MixedContent" element="ex:mixedContent">
      <ex:typedef>
         <xs:element name="mixedContent" type="ex:MixedContent"/>
         <xs:complexType name="MixedContent" mixed="true">
            <xs:sequence>
               <xs:element name="elem1" type="xs:string"/>
               <xs:element name="elem2" type="xs:string"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="MixedContent01">
         <ex:mixedContent>
            <ex:elem1>Tagged Value</ex:elem1>

            mixed value
            
            
            <ex:elem2>Tagged Value</ex:elem2>
         </ex:mixedContent>
      </ex:instance>
      <ex:instance xml:id="MixedContent02">
         <ex:mixedContent>

            some text
            
            
            <ex:elem1>Tagged Value</ex:elem1>

            more text
            
            
            <ex:elem2>Tagged Value</ex:elem2>
         </ex:mixedContent>
      </ex:instance>
      <ex:instance xml:id="MixedContent03">
         <ex:mixedContent>
            <ex:elem1>Tagged Value</ex:elem1>

            mixed text value
            
            
            <ex:elem2>Tagged Value</ex:elem2>

            mixed text value
         
         
         </ex:mixedContent>
      </ex:instance>
      <ex:instance xml:id="MixedContent04">
         <ex:mixedContent>

            text mixed value
            
            
            <ex:elem1>Tagged Value</ex:elem1>
            <ex:elem2>Tagged Value</ex:elem2>

            some more text in a mixed value
         
         
         </ex:mixedContent>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ConstrainedIntType" element="ex:constrainedIntType">
      <ex:typedef>
         <xs:element name="constrainedIntType" type="ex:ConstrainedIntType"/>
         <xs:simpleType name="ConstrainedIntType">
            <xs:restriction base="xs:int">
               <xs:pattern value="\d{3}"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="ConstrainedIntType01">
         <ex:constrainedIntType>123</ex:constrainedIntType>
      </ex:instance>
      <ex:instance xml:id="ConstrainedIntType02">
         <ex:constrainedIntType>009</ex:constrainedIntType>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ConstrainedIntegerType" element="ex:constrainedIntegerType">
      <ex:typedef>
         <xs:element name="constrainedIntegerType" type="ex:ConstrainedIntegerType"/>
         <xs:simpleType name="ConstrainedIntegerType">
            <xs:restriction base="xs:integer">
               <xs:pattern value="[+\-]?([1-9][0-9]*)|0"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="ConstrainedIntegerType01">
         <ex:constrainedIntegerType>123</ex:constrainedIntegerType>
      </ex:instance>
      <ex:instance xml:id="ConstrainedIntegerType02">
         <ex:constrainedIntegerType>9</ex:constrainedIntegerType>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ConstrainedLongType" element="ex:constrainedLongType">
      <ex:typedef>
         <xs:element name="constrainedLongType" type="ex:ConstrainedLongType"/>
         <xs:simpleType name="ConstrainedLongType">
            <xs:restriction base="xs:long">
               <xs:pattern value="\d{3}"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="ConstrainedLongType01">
         <ex:constrainedLongType>123</ex:constrainedLongType>
      </ex:instance>
      <ex:instance xml:id="ConstrainedLongType02">
         <ex:constrainedLongType>009</ex:constrainedLongType>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ConstrainedDecimalType" element="ex:constrainedDecimalType">
      <ex:typedef>
         <xs:element name="constrainedDecimalType" type="ex:ConstrainedDecimalType"/>
         <xs:simpleType name="ConstrainedDecimalType">
            <xs:restriction base="xs:decimal">
               <xs:pattern value="\d{4}\.\d{2}"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="ConstrainedDecimalType01">
         <ex:constrainedDecimalType>1234.12</ex:constrainedDecimalType>
      </ex:instance>
      <ex:instance xml:id="ConstrainedDecimalType02">
         <ex:constrainedDecimalType>9898.00</ex:constrainedDecimalType>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ConstrainedFloatType" element="ex:constrainedFloatType">
      <ex:typedef>
         <xs:element name="constrainedFloatType" type="ex:ConstrainedFloatType"/>
         <xs:simpleType name="ConstrainedFloatType">
            <xs:restriction base="xs:float">
               <xs:pattern value="\d{3}"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="ConstrainedFloatType01">
         <ex:constrainedFloatType>123</ex:constrainedFloatType>
      </ex:instance>
      <ex:instance xml:id="ConstrainedFloatType02">
         <ex:constrainedFloatType>009</ex:constrainedFloatType>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ConstrainedDoubleType" element="ex:constrainedDoubleType">
      <ex:typedef>
         <xs:element name="constrainedDoubleType" type="ex:ConstrainedDoubleType"/>
         <xs:simpleType name="ConstrainedDoubleType">
            <xs:restriction base="xs:double">
               <xs:pattern value="\d{3}"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="ConstrainedDoubleType01">
         <ex:constrainedDoubleType>123</ex:constrainedDoubleType>
      </ex:instance>
      <ex:instance xml:id="ConstrainedDoubleType02">
         <ex:constrainedDoubleType>009</ex:constrainedDoubleType>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ConstrainedShortType" element="ex:constrainedShortType">
      <ex:typedef>
         <xs:element name="constrainedShortType" type="ex:ConstrainedShortType"/>
         <xs:simpleType name="ConstrainedShortType">
            <xs:restriction base="xs:short">
               <xs:pattern value="\d{3}"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="ConstrainedShortType01">
         <ex:constrainedShortType>123</ex:constrainedShortType>
      </ex:instance>
      <ex:instance xml:id="ConstrainedShortType02">
         <ex:constrainedShortType>009</ex:constrainedShortType>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ConstrainedNonNegativeIntegerType" element="ex:constrainedNonNegativeIntegerType">
      <ex:typedef>
         <xs:element name="constrainedNonNegativeIntegerType" type="ex:ConstrainedNonNegativeIntegerType"/>
         <xs:simpleType name="ConstrainedNonNegativeIntegerType">
            <xs:restriction base="xs:nonNegativeInteger">
               <xs:pattern value="\d{3}"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="ConstrainedNonNegativeIntegerType01">
         <ex:constrainedNonNegativeIntegerType>123</ex:constrainedNonNegativeIntegerType>
      </ex:instance>
      <ex:instance xml:id="ConstrainedNonNegativeIntegerType02">
         <ex:constrainedNonNegativeIntegerType>009</ex:constrainedNonNegativeIntegerType>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ConstrainedPositiveIntegerType" element="ex:constrainedPositiveIntegerType">
      <ex:typedef>
         <xs:element name="constrainedPositiveIntegerType" type="ex:ConstrainedPositiveIntegerType"/>
         <xs:simpleType name="ConstrainedPositiveIntegerType">
            <xs:restriction base="xs:positiveInteger">
               <xs:pattern value="\d{3}"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="ConstrainedPositiveIntegerType01">
         <ex:constrainedPositiveIntegerType>123</ex:constrainedPositiveIntegerType>
      </ex:instance>
      <ex:instance xml:id="ConstrainedPositiveIntegerType02">
         <ex:constrainedPositiveIntegerType>009</ex:constrainedPositiveIntegerType>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ConstrainedUnsignedLongType" element="ex:constrainedUnsignedLongType">
      <ex:typedef>
         <xs:element name="constrainedUnsignedLongType" type="ex:ConstrainedUnsignedLongType"/>
         <xs:simpleType name="ConstrainedUnsignedLongType">
            <xs:restriction base="xs:unsignedLong">
               <xs:pattern value="\d{3}"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="ConstrainedUnsignedLongType01">
         <ex:constrainedUnsignedLongType>123</ex:constrainedUnsignedLongType>
      </ex:instance>
      <ex:instance xml:id="ConstrainedUnsignedLongType02">
         <ex:constrainedUnsignedLongType>009</ex:constrainedUnsignedLongType>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ConstrainedUnsignedIntType" element="ex:constrainedUnsignedIntType">
      <ex:typedef>
         <xs:element name="constrainedUnsignedIntType" type="ex:ConstrainedUnsignedIntType"/>
         <xs:simpleType name="ConstrainedUnsignedIntType">
            <xs:restriction base="xs:unsignedInt">
               <xs:pattern value="\d{3}"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="ConstrainedUnsignedIntType01">
         <ex:constrainedUnsignedIntType>123</ex:constrainedUnsignedIntType>
      </ex:instance>
      <ex:instance xml:id="ConstrainedUnsignedIntType02">
         <ex:constrainedUnsignedIntType>009</ex:constrainedUnsignedIntType>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ConstrainedUnsignedShortType" element="ex:constrainedUnsignedShortType">
      <ex:typedef>
         <xs:element name="constrainedUnsignedShortType" type="ex:ConstrainedUnsignedShortType"/>
         <xs:simpleType name="ConstrainedUnsignedShortType">
            <xs:restriction base="xs:unsignedShort">
               <xs:pattern value="\d{3}"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="ConstrainedUnsignedShortType01">
         <ex:constrainedUnsignedShortType>123</ex:constrainedUnsignedShortType>
      </ex:instance>
      <ex:instance xml:id="ConstrainedUnsignedShortType02">
         <ex:constrainedUnsignedShortType>009</ex:constrainedUnsignedShortType>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="AnyAttribute" element="ex:anyAttribute">
      <ex:typedef>
         <xs:element name="anyAttribute" type="ex:AnyAttribute"/>
         <xs:complexType name="AnyAttribute">
            <xs:sequence>
               <xs:element name="firstName" type="xs:string"/>
               <xs:element name="lastName" type="xs:string"/>
            </xs:sequence>
            <xs:anyAttribute processContents="lax"/>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="AnyAttribute01">
         <ex:anyAttribute eyeColor="blue">
            <ex:firstName>Bobby</ex:firstName>
            <ex:lastName>Sox</ex:lastName>
         </ex:anyAttribute>
      </ex:instance>
      <ex:instance xml:id="AnyAttribute02">
         <ex:anyAttribute eyeColor="blue">
            <ex:firstName>Bobby</ex:firstName>
            <ex:lastName>Sox</ex:lastName>
         </ex:anyAttribute>
      </ex:instance>
      <ex:instance xml:id="AnyAttribute03">
         <ex:anyAttribute eyeColor="blue" hairColor="green">
            <ex:firstName>Bobby</ex:firstName>
            <ex:lastName>Sox</ex:lastName>
         </ex:anyAttribute>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ElementReference" element="ex:customerName">
      <ex:typedef>
         <xs:element name="customerName" type="ex:CustomerName"/>
         <xs:element name="firstName" type="xs:string"/>
         <xs:element name="lastName" type="xs:string"/>
         <xs:complexType name="CustomerName">
            <xs:sequence>
               <xs:element ref="ex:firstName"/>
               <xs:element ref="ex:lastName"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="ElementReference01">
         <ex:customerName>
            <ex:firstName>Bobby</ex:firstName>
            <ex:lastName>Sox</ex:lastName>
         </ex:customerName>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="AttributeReference" element="ex:clientName">
      <ex:typedef>
         <xs:element name="clientName" type="ex:ClientName"/>
         <xs:attribute name="phoneNumber" type="xs:string"/>
         <xs:complexType name="ClientName">
            <xs:sequence>
               <xs:element name="firstName" type="xs:string"/>
               <xs:element name="lastName" type="xs:string"/>
            </xs:sequence>
            <xs:attribute ref="ex:phoneNumber"/>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="AttributeReference01">
         <ex:clientName phoneNumber="01211345678">
            <ex:firstName>Bobby</ex:firstName>
            <ex:lastName>Sox</ex:lastName>
         </ex:clientName>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="AttributeElementNameClash" element="ex:clientDetails">
      <ex:typedef>
         <xs:element name="clientDetails" type="ex:ClientDetails"/>
         <xs:complexType name="ClientDetails">
            <xs:sequence>
               <xs:element name="forename" type="xs:string"/>
               <xs:element name="surname" type="xs:string"/>
               <xs:element name="title" type="xs:string"/>
            </xs:sequence>
            <xs:attribute name="phone" type="xs:long"/>
            <xs:attribute name="title" type="xs:boolean"/>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="AttributeElementNameClash01">
         <ex:clientDetails phone="01211345678" title="true">
            <ex:forename>Bobby</ex:forename>
            <ex:surname>Sox</ex:surname>
            <ex:title>Mr</ex:title>
         </ex:clientDetails>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ExtendedCollectionStrict" element="ex:extendedCollectionStrict">
      <ex:typedef>
         <xs:element name="extendedCollectionStrict" type="ex:ExtendedCollectionStrict"/>
         <xs:complexType name="ExtendedCollectionStrict">
            <xs:sequence>
               <xs:element name="firstName" type="xs:string"/>
               <xs:element name="lastName" type="xs:string"/>
               <xs:element name="extension" type="ex:StrictExtension" minOccurs="0"/>
            </xs:sequence>
         </xs:complexType>
         <xs:element name="title" type="xs:string"/>
         <xs:element name="middleName" type="xs:string"/>
         <xs:complexType name="StrictExtension">
            <xs:sequence>
               <xs:any processContents="strict" minOccurs="0" maxOccurs="unbounded" namespace="##targetNamespace"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="ExtendedCollectionStrict01">
         <ex:extendedCollectionStrict>
            <ex:firstName>Bobby</ex:firstName>
            <ex:lastName>Sox</ex:lastName>
         </ex:extendedCollectionStrict>
      </ex:instance>
      <ex:instance xml:id="ExtendedCollectionStrict02">
         <ex:extendedCollectionStrict>
            <ex:firstName>Bobby</ex:firstName>
            <ex:lastName>Sox</ex:lastName>
            <ex:extension>
               <ex:middleName>William</ex:middleName>
               <ex:title>Mr</ex:title>
            </ex:extension>
         </ex:extendedCollectionStrict>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ExtendedCollectionLax" element="ex:extendedCollectionLax">
      <ex:typedef>
         <xs:element name="extendedCollectionLax" type="ex:ExtendedCollectionLax"/>
         <xs:complexType name="ExtendedCollectionLax">
            <xs:sequence>
               <xs:element name="firstName" type="xs:string"/>
               <xs:element name="lastName" type="xs:string"/>
               <xs:element name="extension" type="ex:LaxExtension" minOccurs="0"/>
            </xs:sequence>
         </xs:complexType>
         <xs:complexType name="LaxExtension">
            <xs:sequence>
               <xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded" namespace="##targetNamespace"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="ExtendedCollectionLax01">
         <ex:extendedCollectionLax>
            <ex:firstName>Bobby</ex:firstName>
            <ex:lastName>Sox</ex:lastName>
         </ex:extendedCollectionLax>
      </ex:instance>
      <ex:instance xml:id="ExtendedCollectionLax02">
         <ex:extendedCollectionLax>
            <ex:firstName>Bobby</ex:firstName>
            <ex:lastName>Sox</ex:lastName>
            <ex:extension>
               <ex:middleName>William</ex:middleName>
               <ex:title>Mr</ex:title>
            </ex:extension>
         </ex:extendedCollectionLax>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ExtendedCollectionSkip" element="ex:extendedCollectionSkip">
      <ex:typedef>
         <xs:element name="extendedCollectionSkip" type="ex:ExtendedCollectionSkip"/>
         <xs:complexType name="ExtendedCollectionSkip">
            <xs:sequence>
               <xs:element name="firstName" type="xs:string"/>
               <xs:element name="lastName" type="xs:string"/>
               <xs:element name="extension" type="ex:SkipExtension" minOccurs="0"/>
            </xs:sequence>
         </xs:complexType>
         <xs:complexType name="SkipExtension">
            <xs:sequence>
               <xs:any processContents="skip" minOccurs="0" maxOccurs="unbounded" namespace="##targetNamespace"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="ExtendedCollectionSkip01">
         <ex:extendedCollectionSkip>
            <ex:firstName>Bobby</ex:firstName>
            <ex:lastName>Sox</ex:lastName>
         </ex:extendedCollectionSkip>
      </ex:instance>
      <ex:instance xml:id="ExtendedCollectionSkip02">
         <ex:extendedCollectionSkip>
            <ex:firstName>Bobby</ex:firstName>
            <ex:lastName>Sox</ex:lastName>
            <ex:extension>
               <ex:middleName>William</ex:middleName>
               <ex:title>Mr</ex:title>
            </ex:extension>
         </ex:extendedCollectionSkip>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="ElementTypeDefaultNamespace" element="ex:stringElementDefaultNamespace">
      <ex:typedef>
         <xs:element xmlns="http://www.w3.org/2001/XMLSchema" name="stringElementDefaultNamespace" type="string"/>
      </ex:typedef>
      <ex:instance xml:id="StringElementDefaultNamespace00">
         <ex:stringElementDefaultNamespace/>
      </ex:instance>
      <ex:instance xml:id="StringElementDefaultNamespace01">
         <ex:stringElementDefaultNamespace>This is a string!</ex:stringElementDefaultNamespace>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="RestrictedStringMinLength" element="ex:restrictedStringMinLength">
      <ex:typedef>
         <xs:element name="restrictedStringMinLength" type="ex:RestrictedStringMinLength"/>
         <xs:simpleType name="RestrictedStringMinLength">
            <xs:restriction base="xs:string">
               <xs:minLength value="1"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="RestrictedStringMinLength01">
         <ex:restrictedStringMinLength>String Value</ex:restrictedStringMinLength>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="RestrictedStringMaxLength" element="ex:restrictedStringMaxLength">
      <ex:typedef>
         <xs:element name="restrictedStringMaxLength" type="ex:RestrictedStringMaxLength"/>
         <xs:simpleType name="RestrictedStringMaxLength">
            <xs:restriction base="xs:string">
               <xs:maxLength value="12"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="RestrictedStringMaxLength01">
         <ex:restrictedStringMaxLength>String Value</ex:restrictedStringMaxLength>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="RestrictedStringMinMaxLength" element="ex:restrictedStringMinMaxLength">
      <ex:typedef>
         <xs:element name="restrictedStringMinMaxLength" type="ex:RestrictedStringMinMaxLength"/>
         <xs:simpleType name="RestrictedStringMinMaxLength">
            <xs:restriction base="xs:string">
               <xs:minLength value="12"/>
               <xs:maxLength value="15"/>
            </xs:restriction>
         </xs:simpleType>
      </ex:typedef>
      <ex:instance xml:id="RestrictedStringMinMaxLength01">
         <ex:restrictedStringMinMaxLength>String Value 2</ex:restrictedStringMinMaxLength>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="BareVector" element="ex:bareVector">
      <ex:typedef>
         <xs:element name="bareVector" type="ex:BareVector"/>
         <xs:complexType name="BareVector">
            <xs:sequence>
               <xs:element name="item1" minOccurs="0" maxOccurs="unbounded" type="xs:string"/>
               <xs:element name="item2" minOccurs="0" maxOccurs="unbounded" type="xs:string"/>
               <xs:element name="item3" minOccurs="0" maxOccurs="unbounded" type="xs:string"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="BareVector01">
         <ex:bareVector>
            <ex:item1>item one</ex:item1>
            <ex:item1>item two</ex:item1>
            <ex:item2>item three</ex:item2>
            <ex:item2>item four</ex:item2>
            <ex:item3>item five</ex:item3>
            <ex:item3>item six</ex:item3>
         </ex:bareVector>
      </ex:instance>
      <ex:instance xml:id="BareVector02">
         <ex:bareVector>
            <ex:item1>item one</ex:item1>
            <ex:item1>item two</ex:item1>
            <ex:item3>item three</ex:item3>
            <ex:item3>item four</ex:item3>
         </ex:bareVector>
      </ex:instance>
      <ex:instance xml:id="BareVector03">
         <ex:bareVector>
            <ex:item2>item one</ex:item2>
            <ex:item2>item two</ex:item2>
            <ex:item2>item three</ex:item2>
            <ex:item2>item four</ex:item2>
            <ex:item3>item five</ex:item3>
            <ex:item3>item six</ex:item3>
         </ex:bareVector>
      </ex:instance>
      <ex:instance xml:id="BareVector04">
         <ex:bareVector>
            <ex:item1>item one</ex:item1>
            <ex:item1>item two</ex:item1>
            <ex:item2>item three</ex:item2>
            <ex:item2>item four</ex:item2>
         </ex:bareVector>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="Inherited" element="ex:inherited">
      <ex:typedef>
         <xs:element name="inherited" type="ex:Inherited"/>
         <xs:complexType name="InheritedBase">
            <xs:sequence>
               <xs:element name="name" type="xs:string"/>
            </xs:sequence>
         </xs:complexType>
         <xs:complexType name="Inherited">
            <xs:complexContent>
               <xs:extension base="ex:InheritedBase">
                  <xs:sequence>
                     <xs:element name="description" type="xs:string"/>
                  </xs:sequence>
               </xs:extension>
            </xs:complexContent>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="Inherited01">
         <ex:inherited>
            <ex:name>Mary</ex:name>
            <ex:description>tall</ex:description>
         </ex:inherited>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="TypeSubstitutionUsingXsiType" element="ex:assembly">
      <ex:typedef>
         <xs:element name="assembly" type="ex:Assembly"/>
         <xs:complexType name="Assembly">
            <xs:sequence>
               <xs:element name="part" minOccurs="0" maxOccurs="unbounded" type="ex:Part"/>
            </xs:sequence>
         </xs:complexType>
         <xs:element name="part" type="ex:Part"/>
         <xs:complexType name="Part">
            <xs:sequence>
               <xs:element name="number" type="xs:string"/>
            </xs:sequence>
         </xs:complexType>
         <xs:complexType name="Part2">
            <xs:complexContent>
               <xs:extension base="ex:Part">
                  <xs:sequence>
                     <xs:element name="description" type="xs:string"/>
                  </xs:sequence>
               </xs:extension>
            </xs:complexContent>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="TypeSubstitutionUsingXsiType01">
         <ex:assembly>
            <ex:part>
               <ex:number>p1</ex:number>
            </ex:part>
            <ex:part xsi:Type="ex:Part2">
               <ex:number>p2</ex:number>
               <ex:description>extended part</ex:description>
            </ex:part>
         </ex:assembly>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="IncludeRelative" element="ex:includeRelative">
      <ex:typedef>
         <xs:include schemaLocation="../ItemList/ItemList.xsd"/>
         <xs:element name="shoppingBasket" type="ex:ShoppingBasket"/>
         <xs:complexType name="ShoppingBasket">
            <xs:sequence>
               <xs:element name="shopping" type="ex:ItemList"/>
               <xs:element name="cost" type="xs:decimal"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="IncludeRelative01">
         <ex:shoppingBasket>
            <ex:shopping>
               <ex:item>cornflakes</ex:item>
               <ex:item>teabags</ex:item>
               <ex:item>milk</ex:item>
               <ex:item>bacon</ex:item>
               <ex:item>eggs</ex:item>
            </ex:shopping>
            <ex:cost>8.50</ex:cost>
         </ex:shoppingBasket>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="IncludeFullPath" element="ex:includeFullPath">
      <ex:typedef>
         <xs:include schemaLocation="http://www.w3.org/2002/ws/databinding/examples/6/05/ItemList/ItemList.xsd"/>
         <xs:element name="shoppingBasket" type="ex:ShoppingBasket"/>
         <xs:complexType name="ShoppingBasket">
            <xs:sequence>
               <xs:element name="shopping" type="ex:ItemList"/>
               <xs:element name="cost" type="xs:decimal"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="IncludeFullPath01">
         <ex:shoppingBasket>
            <ex:shopping>
               <ex:item>flour</ex:item>
               <ex:item>margarine</ex:item>
               <ex:item>cherries</ex:item>
               <ex:item>marzipan</ex:item>
               <ex:item>sugar</ex:item>
            </ex:shopping>
            <ex:cost>6.25</ex:cost>
         </ex:shoppingBasket>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="IncludeDiffNS" element="ex:includeDiffNS">
      <ex:typedef>
         <xs:include schemaLocation="http://www.w3.org/2002/ws/databinding/examples/6/05/ItemList/ItemList.xsd"/>
         <xs:element name="shoppingBasket" type="ex:ShoppingBasket"/>
         <xs:complexType name="ShoppingBasket">
            <xs:sequence>
               <xs:element name="shopping" type="ex:ItemList"/>
               <xs:element name="cost" type="xs:decimal"/>
            </xs:sequence>
         </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="IncludeDiffNS01">
         <ex:shoppingBasket>
            <ex:shopping>
               <ex:item>cider</ex:item>
               <ex:item>lemonade</ex:item>
               <ex:item>whisky</ex:item>
               <ex:item>gin</ex:item>
               <ex:item>vodka</ex:item>
               <ex:item>alka-seltzer</ex:item>
            </ex:shopping>
            <ex:cost>22.75</ex:cost>
         </ex:shoppingBasket>
      </ex:instance>
   </ex:example>
   <ex:example xml:id="SimpleTypeAttributes" element="ex:simpleTypeAttributes">
      <ex:typedef>
	  <xs:complexType name="simpleTypeAttributes">
	    <xs:simpleContent>
	      <xs:extension base="xs:string">
		<xs:attribute name="a1" type="xs:string" />
		<xs:attribute name="a2" type="xs:string" />
	      </xs:extension>
	    </xs:simpleContent>
	  </xs:complexType>
      </ex:typedef>
      <ex:instance xml:id="SimpleTypeAttributes01">
         <ex:simpleTypeAttributes a1="foo" a2="bar">hello</ex:simpleTypeAttributes>
      </ex:instance>
   </ex:example>
</ex:examples>
