Basic XML Schema Patterns for Databinding Version 1.0

2.1.1 TargetNamespace

An [XML 1.0] document exhibits the TargetNamespace pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/TargetNamespace when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

An [XML Schema 1.0] document conforming to this specification MUST define a targetNamespace whose value is an absolute URI. ^†

The following example [XML Schema 1.0] document TargetNamespace illustrates the use of the TargetNamespace pattern:

<xs:schema targetNamespace="http://www.w3.org/2002/ws/databinding/examples/6/09/" elementFormDefault="qualified">
  <xs:element name="targetNamespace" type="xs:string" />
</xs:schema>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document TargetNamespace01:

  <ex:targetNamespace>foo</ex:targetNamespace>

2.1.2 QualifiedLocalElements

An [XML 1.0] document exhibits the QualifiedLocalElements pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/QualifiedLocalElements when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

An [XML Schema 1.0] document conforming to this specification MUST namespace qualify all locally declared elements using a schema element elementFormDefault attribute value of qualified. ^†

The following example [XML Schema 1.0] document QualifiedLocalElements illustrates the use of the QualifiedLocalElements pattern:

<xs:schema targetNamespace="http://www.w3.org/2002/ws/databinding/examples/6/09/" elementFormDefault="qualified">
  <xs:element name="qualifiedLocalElements" type="xs:string" />
</xs:schema>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document QualifiedLocalElements01:

  <qualifiedLocalElements>bar</qualifiedLocalElements>

2.1.3 UnqualifiedLocalAttributes

An [XML 1.0] document exhibits the UnqualifiedLocalAttributes pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnqualifiedLocalAttributes when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] document UnqualifiedLocalAttributes illustrates the use of the UnqualifiedLocalAttributes pattern:

<xs:schema targetNamespace="http://www.w3.org/2002/ws/databinding/examples/6/09/" attributeFormDefault="unqualified" elementFormDefault="qualified">
  <xs:element name="unqualifiedLocalAttributes" type="xs:string" />
</xs:schema>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document UnqualifiedLocalAttributes01:

  <ex:unqualifiedLocalAttributes>foo</ex:unqualifiedLocalAttributes>

2.1.4 SchemaVersion

An [XML 1.0] document exhibits the SchemaVersion pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/SchemaVersion when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] document SchemaVersion illustrates the use of the SchemaVersion pattern:

<xs:schema targetNamespace="http://www.w3.org/2002/ws/databinding/examples/6/09/" elementFormDefault="qualified" version="this is version 42">
  <xs:element name="schemaVersion" type="xs:string" />
</xs:schema>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document SchemaVersion01:

  <ex:schemaVersion>foo</ex:schemaVersion>

2.1.5 FinalDefault

An [XML 1.0] document exhibits the FinalDefault pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/FinalDefault when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] document FinalDefault illustrates the use of the FinalDefault pattern:

<xs:schema targetNamespace="http://www.w3.org/2002/ws/databinding/examples/6/09/" elementFormDefault="qualified" finalDefault="#all">
  <xs:element name="finalDefault" type="xs:string" />
</xs:schema>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document FinalDefault01:

  <ex:finalDefault>foo</ex:finalDefault>

2.1.6 BlockDefault

An [XML 1.0] document exhibits the BlockDefault pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/BlockDefault when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] document BlockDefault illustrates the use of the BlockDefault pattern:

<xs:schema targetNamespace="http://www.w3.org/2002/ws/databinding/examples/6/09/" elementFormDefault="qualified" blockDefault="#all">
  <xs:element name="blockDefault" type="xs:string" />
</xs:schema>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document BlockDefault01:

  <ex:blockDefault>foo</ex:blockDefault>

2.2.1 DocumentationElement

An [XML 1.0] document exhibits the DocumentationElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DocumentationElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the DocumentationElement pattern within an [XML Schema 1.0] document DocumentationElement:

<xs:annotation>
  <xs:documentation xml:lang="en" />
</xs:annotation>
<xs:element name="documentationElement" type="xs:string">
  <xs:annotation>
    <xs:documentation xml:lang="en" />
  </xs:annotation>
</xs:element>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document DocumentationElement01:

  <ex:documentationElement>hello world</ex:documentationElement>

2.3.1 IdentifierName

An [XML 1.0] document exhibits the IdentifierName pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IdentifierName when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

Note, this pattern represents a subset of the native identifier formats supported by many, but not all, implementations and is therefore most likely to be supported by a databinding tools which directly maps an [XML 1.0] NCName to an native identifier.

The NCName used to declare an [XML 1.0] attribute MUST NOT be used as the declared NCName of a child element. ^†

The following example [XML Schema 1.0] extract illustrates the use of the IdentifierName pattern within an [XML Schema 1.0] document IdentifierName:

<xs:element name="identifierName" type="xs:string" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document IdentifierName02:

  <ex:identifierName>Hello</ex:identifierName>

2.3.2 NonIdentifierName

An [XML 1.0] document exhibits the NonIdentifierName pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NonIdentifierName when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NonIdentifierName pattern within an [XML Schema 1.0] document NonIdentifierName:

<xs:element name="non-Identifier-Name" type="xs:string" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NonIdentifierName02:

  <ex:non-Identifier-Name>Hello</ex:non-Identifier-Name>

2.3.3 NotMixed

An [XML 1.0] document exhibits the NotMixed pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NotMixed when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.3.4 MinOccurs1

An [XML 1.0] document exhibits the MinOccurs1 pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/MinOccurs1 when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.3.5 MaxOccurs1

An [XML 1.0] document exhibits the MaxOccurs1 pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/MaxOccurs1 when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.3.6 Id

An [XML 1.0] document exhibits the Id pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/Id when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the Id pattern within an [XML Schema 1.0] document IdExample:

<xs:element name="idExample" type="ex:IdExample" id="node1" />
<xs:complexType name="IdExample" id="node2">
  <xs:sequence id="node3">
    <xs:element name="text" type="xs:string" minOccurs="0" id="node4" />
  </xs:sequence>
  <xs:attribute name="string" type="xs:string" id="node5" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document IdExample01:

  <ex:idExample string="hello"/>

2.3.7 ComplexTypeConcrete

An [XML 1.0] document exhibits the ComplexTypeConcrete pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ComplexTypeConcrete when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.3.8 GlobalElementConcrete

An [XML 1.0] document exhibits the GlobalElementConcrete pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalElementConcrete when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.3.9 ElementFinal

An [XML 1.0] document exhibits the ElementFinal pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementFinal when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.4.1 ImportTypesNamespace

An [XML 1.0] document exhibits the ImportTypesNamespace pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ImportTypesNamespace when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

This pattern is designed to capture a reference to a namespace defined within a WSDL document types section.

2.4.2 ImportNamespace

An [XML 1.0] document exhibits the ImportNamespace pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ImportNamespace when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.4.3 ImportSchema

An [XML 1.0] document exhibits the ImportSchema pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ImportSchema when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.4.4 Include

An [XML 1.0] document exhibits the Include pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/Include when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the Include pattern within an [XML Schema 1.0] document Include:

<xs:include schemaLocation="http://www.w3.org/2002/ws/databinding/examples/6/09/Include/Include.xsd" />
<xs:element name="include" type="ex:SequenceElementList" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document Include01:

  <ex:include>
      <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:include>

2.5.1 GlobalElement

An [XML 1.0] document exhibits the GlobalElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.5.2 GlobalElementBlock

An [XML 1.0] document exhibits the GlobalElementBlock pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalElementBlock when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.5.3 GlobalElementFinal

An [XML 1.0] document exhibits the GlobalElementFinal pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalElementFinal when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.5.4 GlobalElementSequence

An [XML 1.0] document exhibits the GlobalElementSequence pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalElementSequence when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the GlobalElementSequence pattern within an [XML Schema 1.0] document GlobalElementSequence:

<xs:element name="globalElementSequence">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="foo" type="xs:string" />
      <xs:element name="bar" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
</xs:element>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document GlobalElementSequence01:

  <ex:globalElementSequence>
      <ex:foo>one</ex:foo>
      <ex:bar>two</ex:bar>
   </ex:globalElementSequence>

2.6.1 GlobalAttribute

An [XML 1.0] document exhibits the GlobalAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.7.1 ElementMinOccurs0

An [XML 1.0] document exhibits the ElementMinOccurs0 pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementMinOccurs0 when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ElementMinOccurs0 pattern within an [XML Schema 1.0] document ElementMinOccurs0:

<xs:element name="elementMinOccurs0" type="ex:ElementMinOccurs0" />
<xs:complexType name="ElementMinOccurs0">
  <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>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ElementMinOccurs001:

  <ex:elementMinOccurs0>
      <ex:firstName>Paul</ex:firstName>
      <ex:lastName>Downey</ex:lastName>
   </ex:elementMinOccurs0>

as is the following element when included in an instance document ElementMinOccurs002:

  <ex:elementMinOccurs0>
      <ex:firstName>Paul</ex:firstName>
      <ex:middleName>Sumner</ex:middleName>
      <ex:lastName>Downey</ex:lastName>
   </ex:elementMinOccurs0>

2.7.2 ElementMinOccurs1

An [XML 1.0] document exhibits the ElementMinOccurs1 pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementMinOccurs1 when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ElementMinOccurs1 pattern within an [XML Schema 1.0] document ElementMinOccurs1:

<xs:element name="elementMinOccurs1" type="ex:ElementMinOccurs1" />
<xs:complexType name="ElementMinOccurs1">
  <xs:sequence>
    <xs:element name="elementMinOccurs1item" type="xs:string" minOccurs="1" />
  </xs:sequence>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ElementMinOccurs101:

  <ex:elementMinOccurs1>
      <ex:elementMinOccurs1item>item1</ex:elementMinOccurs1item>
   </ex:elementMinOccurs1>

2.7.3 ElementMaxOccurs1

An [XML 1.0] document exhibits the ElementMaxOccurs1 pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementMaxOccurs1 when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ElementMaxOccurs1 pattern within an [XML Schema 1.0] document ElementMaxOccurs1:

<xs:element name="ageDetails" type="ex:AgeDetails" />
<xs:complexType name="AgeDetails">
  <xs:sequence>
    <xs:element name="age" type="xs:short" minOccurs="1" maxOccurs="1" />
  </xs:sequence>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ElementMaxOccurs101:

  <ex:ageDetails>
      <ex:age>44</ex:age>
   </ex:ageDetails>

as is the following element when included in an instance document ElementMaxOccurs102:

  <ex:ageDetails>
      <ex:age>4</ex:age>
   </ex:ageDetails>

2.7.4 ElementMinOccurs0MaxOccursUnbounded

An [XML 1.0] document exhibits the ElementMinOccurs0MaxOccursUnbounded pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementMinOccurs0MaxOccursUnbounded when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ElementMinOccurs0MaxOccursUnbounded pattern within an [XML Schema 1.0] document ElementMinOccurs0MaxOccursUnbounded:

<xs:element name="durationList" type="ex:DurationList" />
<xs:complexType name="DurationList">
  <xs:sequence>
    <xs:element name="durationValue" type="xs:short" minOccurs="0" maxOccurs="unbounded" />
  </xs:sequence>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ElementMinOccurs0MaxOccursUnbounded101:

  <ex:durationList/>

as is the following element when included in an instance document ElementMinOccurs0MaxOccursUnbounded102:

  <ex:durationList>
      <ex:durationValue>24</ex:durationValue>
      <ex:durationValue>34</ex:durationValue>
      <ex:durationValue>44</ex:durationValue>
   </ex:durationList>

2.7.5 ElementMinOccurs1MaxOccursUnbounded

An [XML 1.0] document exhibits the ElementMinOccurs1MaxOccursUnbounded pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementMinOccurs1MaxOccursUnbounded when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ElementMinOccurs1MaxOccursUnbounded pattern within an [XML Schema 1.0] document ElementMinOccurs1MaxOccursUnbounded:

<xs:element name="ageList" type="ex:AgeList" />
<xs:complexType name="AgeList">
  <xs:sequence>
    <xs:element name="ageValue" type="xs:short" minOccurs="1" maxOccurs="unbounded" />
  </xs:sequence>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ElementMinOccurs1MaxOccursUnbounded101:

  <ex:ageList>
      <ex:ageValue>44</ex:ageValue>
   </ex:ageList>

as is the following element when included in an instance document ElementMinOccurs1MaxOccursUnbounded102:

  <ex:ageList>
      <ex:ageValue>24</ex:ageValue>
      <ex:ageValue>34</ex:ageValue>
      <ex:ageValue>44</ex:ageValue>
   </ex:ageList>

2.7.6 ElementMaxOccursFinite

An [XML 1.0] document exhibits the ElementMaxOccursFinite pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementMaxOccursFinite when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ElementMaxOccursFinite pattern within an [XML Schema 1.0] document ElementMinOccurs2MaxOccurs2:

<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>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ElementMinOccurs2MaxOccurs201:

  <ex:itemColors2>
      <ex:itemColor>Red</ex:itemColor>
      <ex:itemColor>Yellow</ex:itemColor>
   </ex:itemColors2>

The following example [XML Schema 1.0] extract illustrates the use of the ElementMaxOccursFinite pattern within an [XML Schema 1.0] document ElementMaxOccursFinite:

<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>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ElementMaxOccursFinite01:

  <ex:summer>
      <ex:mnth>May</ex:mnth>
      <ex:mnth>June</ex:mnth>
      <ex:mnth>July</ex:mnth>
      <ex:mnth>August</ex:mnth>
   </ex:summer>

as is the following element when included in an instance document ElementMaxOccursFinite02:

  <ex:summer>
      <ex:mnth>August</ex:mnth>
      <ex:mnth>September</ex:mnth>
   </ex:summer>

2.7.7 ElementFormQualified

An [XML 1.0] document exhibits the ElementFormQualified pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementFormQualified when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.7.8 SequenceSingleRepeatedElement

An [XML 1.0] document exhibits the SequenceSingleRepeatedElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/SequenceSingleRepeatedElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the SequenceSingleRepeatedElement pattern within an [XML Schema 1.0] document SequenceElementList:

<xs:element name="sequenceElementList" type="ex:SequenceElementList" />
<xs:complexType name="SequenceElementList">
  <xs:sequence>
    <xs:element name="item" minOccurs="0" maxOccurs="unbounded" type="xs:string" />
  </xs:sequence>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document SequenceElementList01:

  <ex:sequenceElementList>
      <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:sequenceElementList>

as is the following element when included in an instance document SequenceElementList02:

  <ex:sequenceElementList>
      <ex:item>item one</ex:item>
   </ex:sequenceElementList>

and the following element when included in an instance document SequenceElementList03:

  <ex:sequenceElementList/>

2.7.9 ElementEmptySequence

An [XML 1.0] document exhibits the ElementEmptySequence pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementEmptySequence when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ElementEmptySequence pattern within an [XML Schema 1.0] document ElementEmptySequence:

<xs:element name="elementEmptySequence">
  <xs:complexType>
    <xs:sequence />
  </xs:complexType>
</xs:element>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ElementEmptySequence01:

  <ex:elementEmptySequence/>

2.7.10 ElementEmptyComplexType

An [XML 1.0] document exhibits the ElementEmptyComplexType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementEmptyComplexType when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ElementEmptyComplexType pattern within an [XML Schema 1.0] document ElementEmptyComplexType:

<xs:element name="elementEmptyComplexType">
  <xs:complexType />
</xs:element>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ElementEmptyComplexType01:

  <ex:elementEmptyComplexType/>

2.7.11 NillableElement

An [XML 1.0] document exhibits the NillableElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NillableElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NillableElement pattern within an [XML Schema 1.0] document NillableElement:

<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>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NillableElement01:

  <ex:nillableMiddleName>
      <ex:firstName>Paul</ex:firstName>
      <ex:middleName xsi:nil="true"/>
      <ex:lastName>Downey</ex:lastName>
   </ex:nillableMiddleName>

as is the following element when included in an instance document NillableElement02:

  <ex:nillableMiddleName>
      <ex:firstName>Paul</ex:firstName>
      <ex:middleName>Sumner</ex:middleName>
      <ex:lastName>Downey</ex:lastName>
   </ex:nillableMiddleName>

2.7.12 NillableOptionalElement

An [XML 1.0] document exhibits the NillableOptionalElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NillableOptionalElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

Note, this specification places no particular semantics on the difference between annotating an element with xsi:nil and the absence of an element.

The following example [XML Schema 1.0] extract illustrates the use of the NillableOptionalElement pattern within an [XML Schema 1.0] document NillableOptionalElement:

<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>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NillableOptionalElement01:

  <ex:nillableOptionalMiddleName>
      <ex:firstName>Paul</ex:firstName>
      <ex:lastName>Downey</ex:lastName>
   </ex:nillableOptionalMiddleName>

as is the following element when included in an instance document NillableOptionalElement02:

  <ex:nillableOptionalMiddleName>
      <ex:firstName>Paul</ex:firstName>
      <ex:middleName>Sumner</ex:middleName>
      <ex:lastName>Downey</ex:lastName>
   </ex:nillableOptionalMiddleName>

and the following element when included in an instance document NillableOptionalElement03:

  <ex:nillableOptionalMiddleName>
      <ex:firstName>Paul</ex:firstName>
      <ex:middleName xsi:nil="true"/>
      <ex:lastName>Downey</ex:lastName>
   </ex:nillableOptionalMiddleName>

2.7.13 NotNillableElement

An [XML 1.0] document exhibits the NotNillableElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NotNillableElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.7.14 ElementTypeReference

An [XML 1.0] document exhibits the ElementTypeReference pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementTypeReference when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ElementTypeReference pattern within an [XML Schema 1.0] document ElementTypeReference:

<xs:element name="elementTypeReference" type="ex:ElementTypeReference" />
<xs:complexType name="ElementTypeReferenced">
  <xs:sequence>
    <xs:element name="referenced" type="xs:string" />
  </xs:sequence>
</xs:complexType>
<xs:complexType name="ElementTypeReference">
  <xs:sequence>
    <xs:element name="text" type="ex:ElementTypeReferenced" />
  </xs:sequence>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ElementTypeReference01:

  <ex:elementTypeReference>
      <ex:referenced>foo</ex:referenced>
   </ex:elementTypeReference>

2.7.15 ElementReference

An [XML 1.0] document exhibits the ElementReference pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementReference when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ElementReference pattern within an [XML Schema 1.0] document ElementReference:

<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>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ElementReference01:

  <ex:customerName>
      <ex:firstName>Bobby</ex:firstName>
      <ex:lastName>Sox</ex:lastName>
   </ex:customerName>

2.7.16 LocalElementComplexType

An [XML 1.0] document exhibits the LocalElementComplexType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/LocalElementComplexType when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the LocalElementComplexType pattern within an [XML Schema 1.0] document LocalElementComplexType:

<xs:element name="localElementComplexType" type="ex:LocalElementComplexType" />
<xs:complexType name="LocalElementComplexType">
  <xs:sequence>
    <xs:element name="name">
      <xs:complexType>
        <xs:sequence>
          <xs:element name="firstName" type="xs:string" />
          <xs:element name="lastName" type="xs:string" />
        </xs:sequence>
      </xs:complexType>
    </xs:element>
  </xs:sequence>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document LocalElementComplexType01:

  <ex:localElementComplexType>
      <ex:name>
         <ex:firstName>Paul</ex:firstName>
         <ex:lastName>Paul</ex:lastName>
      </ex:name>
   </ex:localElementComplexType>

2.8.1 AttributeFormUnqualified

An [XML 1.0] document exhibits the AttributeFormUnqualified pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AttributeFormUnqualified when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.8.2 AttributeOptional

An [XML 1.0] document exhibits the AttributeOptional pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AttributeOptional when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the AttributeOptional pattern within an [XML Schema 1.0] document AttributeOptional:

<xs:element name="premium" type="ex:Premium" />
<xs:complexType name="Premium">
  <xs:sequence>
    <xs:element name="amount" type="xs:int" />
  </xs:sequence>
  <xs:attribute name="id" type="xs:string" />
  <xs:attribute name="currency" type="xs:string" use="optional" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document AttributeOptional01:

  <ex:premium id="1711" currency="EUR">
      <ex:amount>1250</ex:amount>
   </ex:premium>

as is the following element when included in an instance document AttributeOptional02:

  <ex:premium id="1712">
      <ex:amount>1250</ex:amount>
   </ex:premium>

2.8.3 AttributeRequired

An [XML 1.0] document exhibits the AttributeRequired pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AttributeRequired when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the AttributeRequired pattern within an [XML Schema 1.0] document AttributeRequired:

<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>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document AttributeRequired01:

  <ex:discount id="1611" seasonal="true">
      <ex:percentage>5</ex:percentage>
   </ex:discount>

as is the following element when included in an instance document AttributeRequired02:

  <ex:discount id="1612" seasonal="false">
      <ex:percentage>2</ex:percentage>
   </ex:discount>

2.8.4 AttributeFixed

An [XML 1.0] document exhibits the AttributeFixed pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AttributeFixed when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the AttributeFixed pattern within an [XML Schema 1.0] document AttributeFixed:

<xs:element name="survey" type="ex:Survey" />
<xs:complexType name="Survey">
  <xs:sequence>
    <xs:element name="fee" type="xs:int" />
  </xs:sequence>
  <xs:attribute name="id" type="xs:string" />
  <xs:attribute name="currency" type="xs:string" fixed="GBP" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document AttributeFixed01:

  <ex:survey id="1511" currency="GBP">
      <ex:fee>500</ex:fee>
   </ex:survey>

2.8.5 AttributeReference

An [XML 1.0] document exhibits the AttributeReference pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AttributeReference when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the AttributeReference pattern within an [XML Schema 1.0] document AttributeReference:

<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>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document AttributeReference01:

  <ex:clientName ex:phoneNumber="01211345678">
      <ex:firstName>Bobby</ex:firstName>
      <ex:lastName>Sox</ex:lastName>
   </ex:clientName>

2.8.6 AttributeTypeReference

An [XML 1.0] document exhibits the AttributeTypeReference pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AttributeTypeReference when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the AttributeTypeReference pattern within an [XML Schema 1.0] document AttributeTypeReference:

<xs:element name="attributeTypeReference" type="ex:AttributeTypeReference" />
<xs:simpleType name="ThreeDigits">
  <xs:restriction base="xs:decimal">
    <xs:totalDigits value="3" />
  </xs:restriction>
</xs:simpleType>
<xs:complexType name="AttributeTypeReference">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="number" type="ex:ThreeDigits" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document AttributeTypeReference01:

  <ex:attributeTypeReference number="123"/>

2.9.1 GlobalSimpleType

An [XML 1.0] document exhibits the GlobalSimpleType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalSimpleType when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the GlobalSimpleType pattern within an [XML Schema 1.0] document GlobalSimpleType:

<xs:element name="globalSimpleType" type="ex:GlobalSimpleType" />
<xs:simpleType name="GlobalSimpleType">
  <xs:restriction base="xs:string">
    <xs:enumeration value="foo" />
  </xs:restriction>
</xs:simpleType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document GlobalSimpleType01:

  <ex:beatle>foo</ex:beatle>

2.10.1 GlobalComplexType

An [XML 1.0] document exhibits the GlobalComplexType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalComplexType when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.10.2 GlobalComplexTypeAbstract

An [XML 1.0] document exhibits the GlobalComplexTypeAbstract pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalComplexTypeAbstract when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.10.3 GlobalComplexTypeBlock

An [XML 1.0] document exhibits the GlobalComplexTypeBlock pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalComplexTypeBlock when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.11.1 StringEnumerationType

An [XML 1.0] document exhibits the StringEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/StringEnumerationType when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

Note, this pattern may be further constrained by the regular expression used by the 2.3.1 IdentifierName pattern to support databinding tools which directly map an xs:enumeration value to an native identifier.

The following example [XML Schema 1.0] extract illustrates the use of the StringEnumerationType pattern within an [XML Schema 1.0] document StringEnumerationType:

<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>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document StringEnumerationType01:

  <ex:beatle>John</ex:beatle>

as is the following element when included in an instance document StringEnumerationType02:

  <ex:beatle>Paul</ex:beatle>

and the following element when included in an instance document StringEnumerationType03:

  <ex:beatle>Ringo</ex:beatle>

2.11.2 NMTOKENEnumerationType

An [XML 1.0] document exhibits the NMTOKENEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NMTOKENEnumerationType when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NMTOKENEnumerationType pattern within an [XML Schema 1.0] document NMTOKENEnumerationType:

<xs:element name="nMTOKENEnumerationType" type="ex:NMTOKENEnumerationType" />
<xs:simpleType name="NMTOKENEnumerationType">
  <xs:restriction base="xs:NMTOKEN">
    <xs:enumeration value="token1" />
    <xs:enumeration value="token2" />
    <xs:enumeration value="token3" />
  </xs:restriction>
</xs:simpleType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NMTOKENEnumerationType01:

  <ex:nMTOKENEnumerationType>token1</ex:nMTOKENEnumerationType>

2.11.3 NullEnumerationType

An [XML 1.0] document exhibits the NullEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NullEnumerationType when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NullEnumerationType pattern within an [XML Schema 1.0] document NullEnumerationType:

<xs:element name="nullEnumerationType" type="ex:NullEnumerationType" />
<xs:simpleType name="NullEnumerationType">
  <xs:restriction base="xs:string">
    <xs:enumeration value="" />
  </xs:restriction>
</xs:simpleType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NullEnumerationType01:

  <ex:nullEnumerationType/>

2.11.4 DecimalSimpleTypeTotalDigits

An [XML 1.0] document exhibits the DecimalSimpleTypeTotalDigits pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DecimalSimpleTypeTotalDigits when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the DecimalSimpleTypeTotalDigits pattern within an [XML Schema 1.0] document DecimalSimpleTypeTotalDigits:

<xs:element name="decimalSimpleTypeTotalDigits" type="ex:DecimalSimpleTypeTotalDigits" />
<xs:simpleType name="DecimalSimpleTypeTotalDigits">
  <xs:restriction base="xs:decimal">
    <xs:totalDigits value="5" />
  </xs:restriction>
</xs:simpleType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document DecimalSimpleTypeTotalDigits01:

  <ex:decimalSimpleTypeTotalDigits>1234</ex:decimalSimpleTypeTotalDigits>

2.12.1 ComplexTypeAttribute

An [XML 1.0] document exhibits the ComplexTypeAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ComplexTypeAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.12.2 ComplexTypeSequence

An [XML 1.0] document exhibits the ComplexTypeSequence pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ComplexTypeSequence when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ComplexTypeSequence pattern within an [XML Schema 1.0] document ComplexTypeSequence:

<xs:element name="complexTypeSequence" type="ex:ComplexTypeSequence" />
<xs:complexType name="ComplexTypeSequence">
  <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>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ComplexTypeSequence01:

  <ex:complexTypeSequence id="6026" inStock="232">
      <ex:name>Widget</ex:name>
      <ex:shade>Light Blue</ex:shade>
      <ex:length>33</ex:length>
   </ex:complexTypeSequence>

as is the following element when included in an instance document ComplexTypeSequence02:

  <ex:complexTypeSequence inStock="52" id="6026">
      <ex:name>Widget</ex:name>
      <ex:shade>Green</ex:shade>
      <ex:length>1233</ex:length>
   </ex:complexTypeSequence>

2.12.3 ComplexTypeAttributeExtension

An [XML 1.0] document exhibits the ComplexTypeAttributeExtension pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ComplexTypeAttributeExtension when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

2.12.4 ComplexTypeSequenceExtension

An [XML 1.0] document exhibits the ComplexTypeSequenceExtension pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ComplexTypeSequenceExtension when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ComplexTypeSequenceExtension pattern within an [XML Schema 1.0] document ComplexTypeSequenceExtension:

<xs:element name="complexTypeSequenceExtension" type="ex:ComplexTypeSequenceExtension" />
<xs:complexType name="ComplexTypeSequenceBase">
  <xs:sequence>
    <xs:element name="name" type="xs:string" />
  </xs:sequence>
</xs:complexType>
<xs:complexType name="ComplexTypeSequenceExtension">
  <xs:complexContent>
    <xs:extension base="ex:ComplexTypeSequenceBase">
      <xs:sequence>
        <xs:element name="description" type="xs:string" />
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ComplexTypeSequenceExtension01:

  <ex:complexTypeSequenceExtension>
      <ex:name>Mary</ex:name>
      <ex:description>tall</ex:description>
   </ex:complexTypeSequenceExtension>

2.13.1 SequenceSequenceElement

An [XML 1.0] document exhibits the SequenceSequenceElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/SequenceSequenceElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the SequenceSequenceElement pattern within an [XML Schema 1.0] document SequenceSequenceElement:

<xs:element name="sequenceSequenceElement" type="ex:SequenceSequenceElement" />
<xs:complexType name="SequenceSequenceElement">
  <xs:sequence>
    <xs:element name="firstName" type="xs:string" />
    <xs:sequence minOccurs="0">
      <xs:element name="middleName" type="xs:string" />
      <xs:sequence minOccurs="0">
        <xs:element name="lastName" type="xs:string" />
      </xs:sequence>
    </xs:sequence>
  </xs:sequence>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document SequenceSequenceElement01:

  <ex:sequenceSequenceElement>
      <ex:firstName>Paul</ex:firstName>
   </ex:sequenceSequenceElement>

as is the following element when included in an instance document SequenceSequenceElement02:

  <ex:sequenceSequenceElement>
      <ex:firstName>Paul</ex:firstName>
      <ex:middleName>Sumner</ex:middleName>
   </ex:sequenceSequenceElement>

and the following element when included in an instance document SequenceSequenceElement03:

  <ex:sequenceSequenceElement>
      <ex:firstName>Paul</ex:firstName>
      <ex:middleName>Sumner</ex:middleName>
      <ex:lastName>Downey</ex:lastName>
   </ex:sequenceSequenceElement>

2.13.2 SequenceMinOccurs0

An [XML 1.0] document exhibits the SequenceMinOccurs0 pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/SequenceMinOccurs0 when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the SequenceMinOccurs0 pattern within an [XML Schema 1.0] document SequenceMinOccurs0:

<xs:element name="sequenceMinOccurs0" type="ex:SequenceMinOccurs0" />
<xs:complexType name="SequenceMinOccurs0">
  <xs:sequence minOccurs="0">
    <xs:element name="firstName" type="xs:string" />
    <xs:element name="middleName" type="xs:string" />
    <xs:element name="lastName" type="xs:string" />
  </xs:sequence>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document SequenceMinOccurs001:

  <ex:sequenceMinOccurs0>
      <ex:firstName>Paul</ex:firstName>
      <ex:middleName>Sumner</ex:middleName>
      <ex:lastName>Downey</ex:lastName>
   </ex:sequenceMinOccurs0>

as is the following element when included in an instance document SequenceMinOccurs002:

  <ex:sequenceMinOccurs0/>

2.13.3 SequenceMinOccurs1

An [XML 1.0] document exhibits the SequenceMinOccurs1 pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/SequenceMinOccurs1 when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the SequenceMinOccurs1 pattern within an [XML Schema 1.0] document SequenceMinOccurs1:

<xs:element name="sequenceMinOccurs1" type="ex:SequenceMinOccurs1" />
<xs:complexType name="SequenceMinOccurs1">
  <xs:sequence minOccurs="1">
    <xs:element name="sequenceMinOccurs1item" type="xs:string" />
  </xs:sequence>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document SequenceMinOccurs101:

  <ex:sequenceMinOccurs1>
      <ex:sequenceMinOccurs1item>item1</ex:sequenceMinOccurs1item>
   </ex:sequenceMinOccurs1>

2.13.4 SequenceMaxOccurs1

An [XML 1.0] document exhibits the SequenceMaxOccurs1 pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/SequenceMaxOccurs1 when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the SequenceMaxOccurs1 pattern within an [XML Schema 1.0] document SequenceMaxOccurs1:

<xs:element name="myAgeDetails" type="ex:AgeDetails" />
<xs:complexType name="AgeDetails">
  <xs:sequence maxOccurs="1">
    <xs:element name="myAge" type="xs:short" />
  </xs:sequence>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document SequenceMaxOccurs101:

  <ex:myAgeDetails>
      <ex:myAge>44</ex:myAge>
   </ex:myAgeDetails>

as is the following element when included in an instance document SequenceMaxOccurs102:

  <ex:myAgeDetails>
      <ex:myAge>4</ex:myAge>
   </ex:myAgeDetails>

2.13.5 SequenceMinOccurs0MaxOccursUnbounded

An [XML 1.0] document exhibits the SequenceMinOccurs0MaxOccursUnbounded pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/SequenceMinOccurs0MaxOccursUnbounded when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the SequenceMinOccurs0MaxOccursUnbounded pattern within an [XML Schema 1.0] document SequenceMinOccurs0MaxOccursUnbounded:

<xs:element name="durationListSequence" type="ex:DurationListSequence" />
<xs:complexType name="DurationListSequence">
  <xs:sequence minOccurs="0" maxOccurs="unbounded">
    <xs:element name="durationVal" type="xs:short" />
    <xs:element name="durationPercentage" type="xs:decimal" />
  </xs:sequence>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document SequenceMinOccurs0MaxOccursUnbounded101:

  <ex:durationListSequence>
      <ex:durationVal>44</ex:durationVal>
      <ex:durationPercentage>33</ex:durationPercentage>
      <ex:durationVal>24</ex:durationVal>
      <ex:durationPercentage>45</ex:durationPercentage>
      <ex:durationVal>64</ex:durationVal>
      <ex:durationPercentage>22</ex:durationPercentage>
   </ex:durationListSequence>

as is the following element when included in an instance document SequenceMinOccurs0MaxOccursUnbounded102:

  <ex:durationListSequence/>

2.13.6 SequenceMinOccurs1MaxOccursUnbounded

An [XML 1.0] document exhibits the SequenceMinOccurs1MaxOccursUnbounded pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/SequenceMinOccurs1MaxOccursUnbounded when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the SequenceMinOccurs1MaxOccursUnbounded pattern within an [XML Schema 1.0] document SequenceMinOccurs1MaxOccursUnbounded:

<xs:element name="ageListSequence" type="ex:AgeListSequence" />
<xs:complexType name="AgeListSequence">
  <xs:sequence minOccurs="1" maxOccurs="unbounded">
    <xs:element name="ageVal" type="xs:short" />
    <xs:element name="agePercentage" type="xs:decimal" />
  </xs:sequence>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document SequenceMinOccurs1MaxOccursUnbounded101:

  <ex:ageListSequence>
      <ex:ageVal>44</ex:ageVal>
      <ex:agePercentage>33</ex:agePercentage>
      <ex:ageVal>24</ex:ageVal>
      <ex:agePercentage>45</ex:agePercentage>
      <ex:ageVal>64</ex:ageVal>
      <ex:agePercentage>22</ex:agePercentage>
   </ex:ageListSequence>

as is the following element when included in an instance document SequenceMinOccurs1MaxOccursUnbounded102:

  <ex:ageListSequence>
      <ex:ageVal>44</ex:ageVal>
      <ex:agePercentage>33</ex:agePercentage>
   </ex:ageListSequence>

2.13.7 SequenceMaxOccursFinite

An [XML 1.0] document exhibits the SequenceMaxOccursFinite pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/SequenceMaxOccursFinite when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the SequenceMaxOccursFinite pattern within an [XML Schema 1.0] document SequenceMaxOccursFinite:

<xs:element name="winter" type="ex:Winter" />
<xs:complexType name="Winter">
  <xs:sequence maxOccurs="4">
    <xs:element name="mnth" type="xs:string" />
    <xs:element name="weather" type="xs:string" />
  </xs:sequence>
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document SequenceMaxOccursFinite01:

  <ex:winter>
      <ex:mnth>November</ex:mnth>
      <ex:weather>Rain</ex:weather>
      <ex:mnth>December</ex:mnth>
      <ex:weather>Snow</ex:weather>
      <ex:mnth>January</ex:mnth>
      <ex:weather>Snow</ex:weather>
      <ex:mnth>February</ex:mnth>
      <ex:weather>Rain</ex:weather>
   </ex:winter>

as is the following element when included in an instance document SequenceMaxOccursFinite02:

  <ex:summer>
      <ex:mnth>December</ex:mnth>
      <ex:weather>Snow</ex:weather>
   </ex:summer>

2.14.1 StringElement

An [XML 1.0] document exhibits the StringElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/StringElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the StringElement pattern within an [XML Schema 1.0] document StringElement:

<xs:element name="stringElement" type="xs:string" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document StringElement01:

  <ex:stringElement/>

as is the following element when included in an instance document StringElement02:

  <ex:stringElement>Hello cruel world.</ex:stringElement>

2.14.2 BooleanElement

An [XML 1.0] document exhibits the BooleanElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/BooleanElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the BooleanElement pattern within an [XML Schema 1.0] document BooleanElement:

<xs:element name="booleanElement" type="xs:boolean" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document BooleanElement01:

  <ex:booleanElement>false</ex:booleanElement>

as is the following element when included in an instance document BooleanElement02:

  <ex:booleanElement>true</ex:booleanElement>

and the following element when included in an instance document BooleanElement03:

  <ex:booleanElement>0</ex:booleanElement>

and the following element when included in an instance document BooleanElement04:

  <ex:booleanElement>1</ex:booleanElement>

2.14.3 DecimalElement

An [XML 1.0] document exhibits the DecimalElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DecimalElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the DecimalElement pattern within an [XML Schema 1.0] document DecimalElement:

<xs:element name="decimalElement" type="xs:decimal" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document DecimalElement01:

  <ex:decimalElement>0</ex:decimalElement>

as is the following element when included in an instance document DecimalElement02:

  <ex:decimalElement>-1.23</ex:decimalElement>

and the following element when included in an instance document DecimalElement03:

  <ex:decimalElement>12678967.543233</ex:decimalElement>

and the following element when included in an instance document DecimalElement04:

  <ex:decimalElement>+1000000.00</ex:decimalElement>

and the following element when included in an instance document DecimalElement05:

  <ex:decimalElement>+100000000000000000000000000000000000000000000.00</ex:decimalElement>

and the following element when included in an instance document DecimalElement06:

  <ex:decimalElement>210</ex:decimalElement>

and the following element when included in an instance document DecimalElement07:

  <ex:decimalElement>210.00</ex:decimalElement>

2.14.4 FloatElement

An [XML 1.0] document exhibits the FloatElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/FloatElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the FloatElement pattern within an [XML Schema 1.0] document FloatElement:

<xs:element name="floatElement" type="xs:float" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document FloatElement01:

  <ex:floatElement>-1E4</ex:floatElement>

as is the following element when included in an instance document FloatElement02:

  <ex:floatElement>1267.43233E12</ex:floatElement>

and the following element when included in an instance document FloatElement03:

  <ex:floatElement>12.78e-2</ex:floatElement>

and the following element when included in an instance document FloatElement04:

  <ex:floatElement>12</ex:floatElement>

and the following element when included in an instance document FloatElement05:

  <ex:floatElement>INF</ex:floatElement>

2.14.5 DoubleElement

An [XML 1.0] document exhibits the DoubleElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DoubleElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the DoubleElement pattern within an [XML Schema 1.0] document DoubleElement:

<xs:element name="doubleElement" type="xs:double" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document DoubleElement01:

  <ex:doubleElement>-1E4</ex:doubleElement>

as is the following element when included in an instance document DoubleElement02:

  <ex:doubleElement>1267.432233E12</ex:doubleElement>

and the following element when included in an instance document DoubleElement03:

  <ex:doubleElement>12.78e-2</ex:doubleElement>

and the following element when included in an instance document DoubleElement04:

  <ex:doubleElement>12</ex:doubleElement>

and the following element when included in an instance document DoubleElement05:

  <ex:doubleElement>INF</ex:doubleElement>

2.14.6 DateTimeElement

An [XML 1.0] document exhibits the DateTimeElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DateTimeElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the DateTimeElement pattern within an [XML Schema 1.0] document DateTimeElement:

<xs:element name="dateTimeElement" type="xs:dateTime" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document DateTimeElement01:

  <ex:dateTimeElement>1999-05-31T13:20:00-05:00</ex:dateTimeElement>

as is the following element when included in an instance document DateTimeElement02:

  <ex:dateTimeElement>2000-03-04T23:00:00+03:00</ex:dateTimeElement>

2.14.7 TimeElement

An [XML 1.0] document exhibits the TimeElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/TimeElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the TimeElement pattern within an [XML Schema 1.0] document TimeElement:

<xs:element name="timeElement" type="xs:time" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document TimeElement01:

  <ex:timeElement>00:00:00</ex:timeElement>

as is the following element when included in an instance document TimeElement02:

  <ex:timeElement>12:00:01</ex:timeElement>

and the following element when included in an instance document TimeElement03:

  <ex:timeElement>23:59:34</ex:timeElement>

and the following element when included in an instance document TimeElement04:

  <ex:timeElement>13:21:03Z</ex:timeElement>

2.14.8 DateElement

An [XML 1.0] document exhibits the DateElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DateElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the DateElement pattern within an [XML Schema 1.0] document DateElement:

<xs:element name="dateElement" type="xs:date" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document DateElement01:

  <ex:dateElement>1999-05-31</ex:dateElement>

2.14.9 GYearMonthElement

An [XML 1.0] document exhibits the GYearMonthElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GYearMonthElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the GYearMonthElement pattern within an [XML Schema 1.0] document GYearMonthElement:

<xs:element name="gYearMonthElement" type="xs:gYearMonth" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document GYearMonthElement01:

  <ex:gYearMonthElement>1999-05</ex:gYearMonthElement>

2.14.10 GYearElement

An [XML 1.0] document exhibits the GYearElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GYearElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the GYearElement pattern within an [XML Schema 1.0] document GYearElement:

<xs:element name="gYearElement" type="xs:gYear" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document GYearElement01:

  <ex:gYearElement>1999</ex:gYearElement>

2.14.11 GMonthDayElement

An [XML 1.0] document exhibits the GMonthDayElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GMonthDayElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the GMonthDayElement pattern within an [XML Schema 1.0] document GMonthDayElement:

<xs:element name="gMonthDayElement" type="xs:gMonthDay" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document GMonthDayElement01:

  <ex:gMonthDayElement>--12-31</ex:gMonthDayElement>

as is the following element when included in an instance document GMonthDayElement02:

  <ex:gMonthDayElement>--12-31Z</ex:gMonthDayElement>

2.14.12 Base64BinaryElement

An [XML 1.0] document exhibits the Base64BinaryElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/Base64BinaryElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the Base64BinaryElement pattern within an [XML Schema 1.0] document Base64BinaryElement:

<xs:element name="base64BinaryElement" type="xs:base64Binary" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document Base64BinaryElement01:

  <ex:base64BinaryElement>bQ==</ex:base64BinaryElement>

as is the following element when included in an instance document Base64BinaryElement02:

  <ex:base64BinaryElement>eHdmb3Rh</ex:base64BinaryElement>

and the following element when included in an instance document Base64BinaryElement03:

  <ex:base64BinaryElement>cnRjbGNyZW9scg==</ex:base64BinaryElement>

2.14.13 AnyURIElement

An [XML 1.0] document exhibits the AnyURIElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AnyURIElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the AnyURIElement pattern within an [XML Schema 1.0] document AnyURIElement:

<xs:element name="anyURIElement" type="xs:anyURI" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document AnyURIElement01:

  <ex:anyURIElement>http://www.w3.org/2002/ws/databinding/</ex:anyURIElement>

2.14.14 QNameElement

An [XML 1.0] document exhibits the QNameElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/QNameElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the QNameElement pattern within an [XML Schema 1.0] document QNameElement:

<xs:element name="QNameElement" type="xs:QName" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document QNameElement01:

  <ex:QNameElement>ex:QNameElement</ex:QNameElement>

2.14.15 NormalizedStringElement

An [XML 1.0] document exhibits the NormalizedStringElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NormalizedStringElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NormalizedStringElement pattern within an [XML Schema 1.0] document NormalizedStringElement:

<xs:element name="normalizedStringElement" type="xs:normalizedString" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NormalizedStringElement01:

  <ex:normalizedStringElement/>

as is the following element when included in an instance document NormalizedStringElement02:

  <ex:normalizedStringElement>How now brown cow.</ex:normalizedStringElement>

2.14.16 TokenElement

An [XML 1.0] document exhibits the TokenElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/TokenElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the TokenElement pattern within an [XML Schema 1.0] document TokenElement:

<xs:element name="tokenElement" type="xs:token" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document TokenElement01:

  <ex:tokenElement>tokenElement</ex:tokenElement>

2.14.17 LanguageElement

An [XML 1.0] document exhibits the LanguageElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/LanguageElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the LanguageElement pattern within an [XML Schema 1.0] document LanguageElement:

<xs:element name="languageElement" type="xs:language" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document LanguageElement01:

  <ex:languageElement>en</ex:languageElement>

as is the following element when included in an instance document LanguageElement02:

  <ex:languageElement>fr</ex:languageElement>

2.14.18 NMTOKENElement

An [XML 1.0] document exhibits the NMTOKENElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NMTOKENElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NMTOKENElement pattern within an [XML Schema 1.0] document NMTOKENElement:

<xs:element name="NMTOKENElement" type="xs:NMTOKEN" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NMTOKENElement01:

  <ex:NMTOKENElement>id</ex:NMTOKENElement>

as is the following element when included in an instance document NMTOKENElement02:

  <ex:NMTOKENElement>vocabularies:that.as:clean:assuring-s_to:The_we:contain</ex:NMTOKENElement>

2.14.19 NMTOKENSElement

An [XML 1.0] document exhibits the NMTOKENSElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NMTOKENSElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NMTOKENSElement pattern within an [XML Schema 1.0] document NMTOKENSElement:

<xs:element name="NMTOKENSElement" type="xs:NMTOKENS" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NMTOKENSElement01:

  <ex:NMTOKENSElement>a b c d e.b:s-w_x:q</ex:NMTOKENSElement>

2.14.20 NameElement

An [XML 1.0] document exhibits the NameElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NameElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NameElement pattern within an [XML Schema 1.0] document NameElement:

<xs:element name="NameElement" type="xs:Name" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NameElement01:

  <ex:NameElement>foo</ex:NameElement>

2.14.21 NCNameElement

An [XML 1.0] document exhibits the NCNameElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NCNameElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NCNameElement pattern within an [XML Schema 1.0] document NCNameElement:

<xs:element name="NCNameElement" type="xs:NCName" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NCNameElement01:

  <ex:NCNameElement>foo</ex:NCNameElement>

2.14.22 IDElement

An [XML 1.0] document exhibits the IDElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IDElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the IDElement pattern within an [XML Schema 1.0] document IDElement:

<xs:element name="IDElement" type="xs:ID" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document IDElement01:

  <ex:IDElement>foo</ex:IDElement>

2.14.23 IDREFElement

An [XML 1.0] document exhibits the IDREFElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IDREFElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the IDREFElement pattern within an [XML Schema 1.0] document IDREFElement:

<xs:element name="IDREFElement" type="xs:IDREF" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document IDREFElement01:

  <ex:IDREFElement>foo</ex:IDREFElement>

2.14.24 IDREFSElement

An [XML 1.0] document exhibits the IDREFSElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IDREFSElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the IDREFSElement pattern within an [XML Schema 1.0] document IDREFSElement:

<xs:element name="IDREFSElement" type="xs:IDREFS" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document IDREFSElement01:

  <ex:IDREFSElement>foo</ex:IDREFSElement>

2.14.25 ENTITYElement

An [XML 1.0] document exhibits the ENTITYElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ENTITYElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ENTITYElement pattern within an [XML Schema 1.0] document ENTITYElement:

<xs:element name="ENTITYElement" type="xs:ENTITY" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ENTITYElement01:

  <ex:ENTITYElement>lt</ex:ENTITYElement>

2.14.26 ENTITIESElement

An [XML 1.0] document exhibits the ENTITIESElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ENTITIESElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ENTITIESElement pattern within an [XML Schema 1.0] document ENTITIESElement:

<xs:element name="ENTITIESElement" type="xs:ENTITIES" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ENTITIESElement01:

  <ex:ENTITIESElement>lt gt apos quot</ex:ENTITIESElement>

2.14.27 IntegerElement

An [XML 1.0] document exhibits the IntegerElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IntegerElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the IntegerElement pattern within an [XML Schema 1.0] document IntegerElement:

<xs:element name="integerElement" type="xs:integer" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document IntegerElement01:

  <ex:integerElement>0</ex:integerElement>

as is the following element when included in an instance document IntegerElement02:

  <ex:integerElement>1</ex:integerElement>

and the following element when included in an instance document IntegerElement03:

  <ex:integerElement>12678967543233</ex:integerElement>

and the following element when included in an instance document IntegerElement04:

  <ex:integerElement>+10000</ex:integerElement>

2.14.28 NonPositiveIntegerElement

An [XML 1.0] document exhibits the NonPositiveIntegerElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NonPositiveIntegerElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NonPositiveIntegerElement pattern within an [XML Schema 1.0] document NonPositiveIntegerElement:

<xs:element name="nonPositiveIntegerElement" type="xs:nonPositiveInteger" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NonPositiveIntegerElement01:

  <ex:nonPositiveIntegerElement>-1</ex:nonPositiveIntegerElement>

2.14.29 NegativeIntegerElement

An [XML 1.0] document exhibits the NegativeIntegerElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NegativeIntegerElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NegativeIntegerElement pattern within an [XML Schema 1.0] document NegativeIntegerElement:

<xs:element name="negativeIntegerElement" type="xs:negativeInteger" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NegativeIntegerElement01:

  <ex:negativeIntegerElement>-1</ex:negativeIntegerElement>

2.14.30 LongElement

An [XML 1.0] document exhibits the LongElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/LongElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the LongElement pattern within an [XML Schema 1.0] document LongElement:

<xs:element name="longElement" type="xs:long" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document LongElement01:

  <ex:longElement>1</ex:longElement>

2.14.31 IntElement

An [XML 1.0] document exhibits the IntElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IntElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the IntElement pattern within an [XML Schema 1.0] document IntElement:

<xs:element name="intElement" type="xs:int" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document IntElement01:

  <ex:intElement>1</ex:intElement>

as is the following element when included in an instance document IntElement02:

  <ex:intElement>10042</ex:intElement>

and the following element when included in an instance document IntElement03:

  <ex:intElement>-42</ex:intElement>

2.14.32 ShortElement

An [XML 1.0] document exhibits the ShortElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ShortElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ShortElement pattern within an [XML Schema 1.0] document ShortElement:

<xs:element name="shortElement" type="xs:short" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ShortElement01:

  <ex:shortElement>1</ex:shortElement>

2.14.33 ByteElement

An [XML 1.0] document exhibits the ByteElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ByteElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ByteElement pattern within an [XML Schema 1.0] document ByteElement:

<xs:element name="byteElement" type="xs:byte" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ByteElement01:

  <ex:byteElement>1</ex:byteElement>

2.14.34 NonNegativeIntegerElement

An [XML 1.0] document exhibits the NonNegativeIntegerElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NonNegativeIntegerElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NonNegativeIntegerElement pattern within an [XML Schema 1.0] document NonNegativeIntegerElement:

<xs:element name="nonNegativeIntegerElement" type="xs:nonNegativeInteger" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NonNegativeIntegerElement01:

  <ex:nonNegativeIntegerElement>1</ex:nonNegativeIntegerElement>

2.14.35 UnsignedLongElement

An [XML 1.0] document exhibits the UnsignedLongElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnsignedLongElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the UnsignedLongElement pattern within an [XML Schema 1.0] document UnsignedLongElement:

<xs:element name="unsignedLongElement" type="xs:unsignedLong" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document UnsignedLongElement01:

  <ex:unsignedLongElement>1</ex:unsignedLongElement>

2.14.36 UnsignedIntElement

An [XML 1.0] document exhibits the UnsignedIntElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnsignedIntElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the UnsignedIntElement pattern within an [XML Schema 1.0] document UnsignedIntElement:

<xs:element name="unsignedIntElement" type="xs:unsignedInt" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document UnsignedIntElement01:

  <ex:unsignedIntElement>1</ex:unsignedIntElement>

2.14.37 UnsignedShortElement

An [XML 1.0] document exhibits the UnsignedShortElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnsignedShortElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the UnsignedShortElement pattern within an [XML Schema 1.0] document UnsignedShortElement:

<xs:element name="unsignedShortElement" type="xs:unsignedShort" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document UnsignedShortElement01:

  <ex:unsignedShortElement>1</ex:unsignedShortElement>

2.14.38 UnsignedByteElement

An [XML 1.0] document exhibits the UnsignedByteElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnsignedByteElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the UnsignedByteElement pattern within an [XML Schema 1.0] document UnsignedByteElement:

<xs:element name="unsignedByteElement" type="xs:unsignedByte" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document UnsignedByteElement01:

  <ex:unsignedByteElement>1</ex:unsignedByteElement>

2.14.39 PositiveIntegerElement

An [XML 1.0] document exhibits the PositiveIntegerElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/PositiveIntegerElement when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the PositiveIntegerElement pattern within an [XML Schema 1.0] document PositiveIntegerElement:

<xs:element name="positiveIntegerElement" type="xs:positiveInteger" />
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document PositiveIntegerElement01:

  <ex:positiveIntegerElement>1</ex:positiveIntegerElement>

2.15.1 StringAttribute

An [XML 1.0] document exhibits the StringAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/StringAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the StringAttribute pattern within an [XML Schema 1.0] document StringAttribute:

<xs:element name="stringAttribute" type="ex:StringAttribute" />
<xs:complexType name="StringAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="string" type="xs:string" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document StringAttribute01:

  <ex:stringAttribute string="hello"/>

2.15.2 BooleanAttribute

An [XML 1.0] document exhibits the BooleanAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/BooleanAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the BooleanAttribute pattern within an [XML Schema 1.0] document BooleanAttribute:

<xs:element name="booleanAttribute" type="ex:BooleanAttribute" />
<xs:complexType name="BooleanAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="boolean" type="xs:boolean" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document BooleanAttribute01:

  <ex:booleanAttribute boolean="true"/>

as is the following element when included in an instance document BooleanAttribute02:

  <ex:booleanAttribute boolean="0"/>

2.15.3 DecimalAttribute

An [XML 1.0] document exhibits the DecimalAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DecimalAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the DecimalAttribute pattern within an [XML Schema 1.0] document DecimalAttribute:

<xs:element name="decimalAttribute" type="ex:DecimalAttribute" />
<xs:complexType name="DecimalAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="decimal" type="xs:decimal" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document DecimalAttribute01:

  <ex:decimalAttribute decimal="+10000000999829292922093443563.32423442"/>

2.15.4 FloatAttribute

An [XML 1.0] document exhibits the FloatAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/FloatAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the FloatAttribute pattern within an [XML Schema 1.0] document FloatAttribute:

<xs:element name="floatAttribute" type="ex:FloatAttribute" />
<xs:complexType name="FloatAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="float" type="xs:float" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document FloatAttribute01:

  <ex:floatAttribute float="-7446.445E5"/>

2.15.5 DoubleAttribute

An [XML 1.0] document exhibits the DoubleAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DoubleAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the DoubleAttribute pattern within an [XML Schema 1.0] document DoubleAttribute:

<xs:element name="doubleAttribute" type="ex:DoubleAttribute" />
<xs:complexType name="DoubleAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="double" type="xs:double" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document DoubleAttribute01:

  <ex:doubleAttribute double="12.334"/>

2.15.6 DateTimeAttribute

An [XML 1.0] document exhibits the DateTimeAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DateTimeAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the DateTimeAttribute pattern within an [XML Schema 1.0] document DateTimeAttribute:

<xs:element name="dateTimeAttribute" type="ex:DateTimeAttribute" />
<xs:complexType name="DateTimeAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="dateTime" type="xs:dateTime" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document DateTimeAttribute01:

  <ex:dateTimeAttribute dateTime="2006-10-26T04:51:00+03:00"/>

2.15.7 TimeAttribute

An [XML 1.0] document exhibits the TimeAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/TimeAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the TimeAttribute pattern within an [XML Schema 1.0] document TimeAttribute:

<xs:element name="timeAttribute" type="ex:TimeAttribute" />
<xs:complexType name="TimeAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="time" type="xs:time" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document TimeAttribute01:

  <ex:timeAttribute time="00:01:58Z"/>

2.15.8 DateAttribute

An [XML 1.0] document exhibits the DateAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DateAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the DateAttribute pattern within an [XML Schema 1.0] document DateAttribute:

<xs:element name="dateAttribute" type="ex:DateAttribute" />
<xs:complexType name="DateAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="date" type="xs:date" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document DateAttribute01:

  <ex:dateAttribute date="2006-05-30"/>

2.15.9 GYearMonthAttribute

An [XML 1.0] document exhibits the GYearMonthAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GYearMonthAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the GYearMonthAttribute pattern within an [XML Schema 1.0] document GYearMonthAttribute:

<xs:element name="gYearMonthAttribute" type="ex:GYearMonthAttribute" />
<xs:complexType name="GYearMonthAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="gYearMonth" type="xs:gYearMonth" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document GYearMonthAttribute01:

  <ex:gYearMonthAttribute gYearMonth="2006-09"/>

2.15.10 GYearAttribute

An [XML 1.0] document exhibits the GYearAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GYearAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the GYearAttribute pattern within an [XML Schema 1.0] document GYearAttribute:

<xs:element name="gYearAttribute" type="ex:GYearAttribute" />
<xs:complexType name="GYearAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="gYear" type="xs:gYear" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document GYearAttribute01:

  <ex:gYearAttribute gYear="2038"/>

2.15.11 GMonthDayAttribute

An [XML 1.0] document exhibits the GMonthDayAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GMonthDayAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the GMonthDayAttribute pattern within an [XML Schema 1.0] document GMonthDayAttribute:

<xs:element name="gMonthDayAttribute" type="ex:GMonthDayAttribute" />
<xs:complexType name="GMonthDayAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="gMonthDay" type="xs:gMonthDay" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document GMonthDayAttribute01:

  <ex:gMonthDayAttribute gMonthDay="--09-28Z"/>

2.15.12 Base64BinaryAttribute

An [XML 1.0] document exhibits the Base64BinaryAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/Base64BinaryAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the Base64BinaryAttribute pattern within an [XML Schema 1.0] document Base64BinaryAttribute:

<xs:element name="base64BinaryAttribute" type="ex:Base64BinaryAttribute" />
<xs:complexType name="Base64BinaryAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="base64Binary" type="xs:base64Binary" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document Base64BinaryAttribute01:

  <ex:base64BinaryAttribute base64Binary="cnRjbGNyZW9scg=="/>

2.15.13 AnyURIAttribute

An [XML 1.0] document exhibits the AnyURIAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AnyURIAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the AnyURIAttribute pattern within an [XML Schema 1.0] document AnyURIAttribute:

<xs:element name="anyURIAttribute" type="ex:AnyURIAttribute" />
<xs:complexType name="AnyURIAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="anyURI" type="xs:anyURI" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document AnyURIAttribute01:

  <ex:anyURIAttribute anyURI="http://www.w3.org/2002/ws/"/>

2.15.14 QNameAttribute

An [XML 1.0] document exhibits the QNameAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/QNameAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the QNameAttribute pattern within an [XML Schema 1.0] document QNameAttribute:

<xs:element name="QNameAttribute" type="ex:QNameAttribute" />
<xs:complexType name="QNameAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="QName" type="xs:QName" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document QNameAttribute01:

  <ex:QNameAttribute QName="ex:QNameAttribute"/>

2.15.15 NormalizedStringAttribute

An [XML 1.0] document exhibits the NormalizedStringAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NormalizedStringAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NormalizedStringAttribute pattern within an [XML Schema 1.0] document NormalizedStringAttribute:

<xs:element name="normalizedStringAttribute" type="ex:NormalizedStringAttribute" />
<xs:complexType name="NormalizedStringAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="normalizedString" type="xs:normalizedString" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NormalizedStringAttribute01:

  <ex:normalizedStringAttribute normalizedString="Hello Paris"/>

2.15.16 TokenAttribute

An [XML 1.0] document exhibits the TokenAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/TokenAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the TokenAttribute pattern within an [XML Schema 1.0] document TokenAttribute:

<xs:element name="tokenAttribute" type="ex:TokenAttribute" />
<xs:complexType name="TokenAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="token" type="xs:token" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document TokenAttribute01:

  <ex:tokenAttribute token="hello"/>

2.15.17 LanguageAttribute

An [XML 1.0] document exhibits the LanguageAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/LanguageAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the LanguageAttribute pattern within an [XML Schema 1.0] document LanguageAttribute:

<xs:element name="languageAttribute" type="ex:LanguageAttribute" />
<xs:complexType name="LanguageAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="language" type="xs:language" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document LanguageAttribute01:

  <ex:languageAttribute language="en"/>

2.15.18 NMTOKENAttribute

An [XML 1.0] document exhibits the NMTOKENAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NMTOKENAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NMTOKENAttribute pattern within an [XML Schema 1.0] document NMTOKENAttribute:

<xs:element name="NMTOKENAttribute" type="ex:NMTOKENAttribute" />
<xs:complexType name="NMTOKENAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="NMTOKEN" type="xs:NMTOKEN" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NMTOKENAttribute01:

  <ex:NMTOKENAttribute NMTOKEN="id"/>

2.15.19 NMTOKENSAttribute

An [XML 1.0] document exhibits the NMTOKENSAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NMTOKENSAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NMTOKENSAttribute pattern within an [XML Schema 1.0] document NMTOKENSAttribute:

<xs:element name="NMTOKENSAttribute" type="ex:NMTOKENSAttribute" />
<xs:complexType name="NMTOKENSAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="NMTOKENS" type="xs:NMTOKENS" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NMTOKENSAttribute01:

  <ex:NMTOKENSAttribute NMTOKENS="id"/>

2.15.20 NameAttribute

An [XML 1.0] document exhibits the NameAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NameAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NameAttribute pattern within an [XML Schema 1.0] document NameAttribute:

<xs:element name="nameAttribute" type="ex:NameAttribute" />
<xs:complexType name="NameAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="name" type="xs:Name" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NameAttribute01:

  <ex:nameAttribute name="foo"/>

2.15.21 NCNameAttribute

An [XML 1.0] document exhibits the NCNameAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NCNameAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NCNameAttribute pattern within an [XML Schema 1.0] document NCNameAttribute:

<xs:element name="NCNameAttribute" type="ex:NCNameAttribute" />
<xs:complexType name="NCNameAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="NCName" type="xs:NCName" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NCNameAttribute01:

  <ex:NCNameAttribute NCName="bar"/>

2.15.22 IDAttribute

An [XML 1.0] document exhibits the IDAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IDAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the IDAttribute pattern within an [XML Schema 1.0] document IDAttribute:

<xs:element name="IDAttribute" type="ex:IDAttribute" />
<xs:complexType name="IDAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="ID" type="xs:ID" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document IDAttribute01:

  <ex:IDAttribute ID="bar"/>

2.15.23 IDREFAttribute

An [XML 1.0] document exhibits the IDREFAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IDREFAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the IDREFAttribute pattern within an [XML Schema 1.0] document IDREFAttribute:

<xs:element name="IDREFAttribute" type="ex:IDREFAttribute" />
<xs:complexType name="IDREFAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="IDREF" type="xs:IDREF" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document IDREFAttribute01:

  <ex:IDREFAttribute IDREF="bar"/>

2.15.24 IDREFSAttribute

An [XML 1.0] document exhibits the IDREFSAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IDREFSAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the IDREFSAttribute pattern within an [XML Schema 1.0] document IDREFSAttribute:

<xs:element name="IDREFSAttribute" type="ex:IDREFSAttribute" />
<xs:complexType name="IDREFSAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="IDREFS" type="xs:IDREFS" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document IDREFSAttribute01:

  <ex:IDREFSAttribute IDREFS="hello"/>

2.15.25 ENTITYAttribute

An [XML 1.0] document exhibits the ENTITYAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ENTITYAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ENTITYAttribute pattern within an [XML Schema 1.0] document ENTITYAttribute:

<xs:element name="ENTITYAttribute" type="ex:ENTITYAttribute" />
<xs:complexType name="ENTITYAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="ENTITY" type="xs:ENTITY" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ENTITYAttribute01:

  <ex:ENTITYAttribute ENTITY="lt"/>

2.15.26 ENTITIESAttribute

An [XML 1.0] document exhibits the ENTITIESAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ENTITIESAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ENTITIESAttribute pattern within an [XML Schema 1.0] document ENTITIESAttribute:

<xs:element name="ENTITIESAttribute" type="ex:ENTITIESAttribute" />
<xs:complexType name="ENTITIESAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="ENTITIES" type="xs:ENTITIES" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ENTITIESAttribute01:

  <ex:ENTITIESAttribute ENTITIES="lt gt"/>

2.15.27 IntegerAttribute

An [XML 1.0] document exhibits the IntegerAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IntegerAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the IntegerAttribute pattern within an [XML Schema 1.0] document IntegerAttribute:

<xs:element name="integerAttribute" type="ex:IntegerAttribute" />
<xs:complexType name="IntegerAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="integer" type="xs:integer" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document IntegerAttribute01:

  <ex:integerAttribute integer="10002"/>

2.15.28 NonPositiveIntegerAttribute

An [XML 1.0] document exhibits the NonPositiveIntegerAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NonPositiveIntegerAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NonPositiveIntegerAttribute pattern within an [XML Schema 1.0] document NonPositiveIntegerAttribute:

<xs:element name="nonPositiveIntegerAttribute" type="ex:NonPositiveIntegerAttribute" />
<xs:complexType name="NonPositiveIntegerAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="nonPositiveInteger" type="xs:nonPositiveInteger" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NonPositiveIntegerAttribute01:

  <ex:nonPositiveIntegerAttribute nonPositiveInteger="-20"/>

2.15.29 NegativeIntegerAttribute

An [XML 1.0] document exhibits the NegativeIntegerAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NegativeIntegerAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NegativeIntegerAttribute pattern within an [XML Schema 1.0] document NegativeIntegerAttribute:

<xs:element name="negativeIntegerAttribute" type="ex:NegativeIntegerAttribute" />
<xs:complexType name="NegativeIntegerAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="negativeInteger" type="xs:negativeInteger" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NegativeIntegerAttribute01:

  <ex:negativeIntegerAttribute negativeInteger="-100"/>

2.15.30 LongAttribute

An [XML 1.0] document exhibits the LongAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/LongAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the LongAttribute pattern within an [XML Schema 1.0] document LongAttribute:

<xs:element name="longAttribute" type="ex:LongAttribute" />
<xs:complexType name="LongAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="long" type="xs:long" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document LongAttribute01:

  <ex:longAttribute long="1738"/>

2.15.31 IntAttribute

An [XML 1.0] document exhibits the IntAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IntAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the IntAttribute pattern within an [XML Schema 1.0] document IntAttribute:

<xs:element name="intAttribute" type="ex:IntAttribute" />
<xs:complexType name="IntAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="int" type="xs:int" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document IntAttribute01:

  <ex:intAttribute int="42"/>

2.15.32 ShortAttribute

An [XML 1.0] document exhibits the ShortAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ShortAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ShortAttribute pattern within an [XML Schema 1.0] document ShortAttribute:

<xs:element name="shortAttribute" type="ex:ShortAttribute" />
<xs:complexType name="ShortAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="short" type="xs:short" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ShortAttribute01:

  <ex:shortAttribute short="22"/>

2.15.33 ByteAttribute

An [XML 1.0] document exhibits the ByteAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ByteAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the ByteAttribute pattern within an [XML Schema 1.0] document ByteAttribute:

<xs:element name="byteAttribute" type="ex:ByteAttribute" />
<xs:complexType name="ByteAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="byte" type="xs:byte" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document ByteAttribute01:

  <ex:byteAttribute byte="64"/>

2.15.34 NonNegativeIntegerAttribute

An [XML 1.0] document exhibits the NonNegativeIntegerAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NonNegativeIntegerAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the NonNegativeIntegerAttribute pattern within an [XML Schema 1.0] document NonNegativeIntegerAttribute:

<xs:element name="nonNegativeIntegerAttribute" type="ex:NonNegativeIntegerAttribute" />
<xs:complexType name="NonNegativeIntegerAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="nonNegativeInteger" type="xs:nonNegativeInteger" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document NonNegativeIntegerAttribute01:

  <ex:nonNegativeIntegerAttribute nonNegativeInteger="20"/>

2.15.35 UnsignedLongAttribute

An [XML 1.0] document exhibits the UnsignedLongAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnsignedLongAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the UnsignedLongAttribute pattern within an [XML Schema 1.0] document UnsignedLongAttribute:

<xs:element name="unsignedLongAttribute" type="ex:UnsignedLongAttribute" />
<xs:complexType name="UnsignedLongAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="unsignedLong" type="xs:unsignedLong" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document UnsignedLongAttribute01:

  <ex:unsignedLongAttribute unsignedLong="2034"/>

2.15.36 UnsignedIntAttribute

An [XML 1.0] document exhibits the UnsignedIntAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnsignedIntAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the UnsignedIntAttribute pattern within an [XML Schema 1.0] document UnsignedIntAttribute:

<xs:element name="unsignedIntAttribute" type="ex:UnsignedIntAttribute" />
<xs:complexType name="UnsignedIntAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="unsignedInt" type="xs:unsignedInt" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document UnsignedIntAttribute01:

  <ex:unsignedIntAttribute unsignedInt="32334"/>

2.15.37 UnsignedShortAttribute

An [XML 1.0] document exhibits the UnsignedShortAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnsignedShortAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the UnsignedShortAttribute pattern within an [XML Schema 1.0] document UnsignedShortAttribute:

<xs:element name="unsignedShortAttribute" type="ex:UnsignedShortAttribute" />
<xs:complexType name="UnsignedShortAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="unsignedShort" type="xs:unsignedShort" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document UnsignedShortAttribute01:

  <ex:unsignedShortAttribute unsignedShort="22"/>

2.15.38 UnsignedByteAttribute

An [XML 1.0] document exhibits the UnsignedByteAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnsignedByteAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the UnsignedByteAttribute pattern within an [XML Schema 1.0] document UnsignedByteAttribute:

<xs:element name="unsignedByteAttribute" type="ex:UnsignedByteAttribute" />
<xs:complexType name="UnsignedByteAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="unsignedByte" type="xs:unsignedByte" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document UnsignedByteAttribute01:

  <ex:unsignedByteAttribute unsignedByte="64"/>

2.15.39 PositiveIntegerAttribute

An [XML 1.0] document exhibits the PositiveIntegerAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/PositiveIntegerAttribute when the following [XPath 2.0] expression applied to a document or element node located by //xs:schema results in an [XPath 2.0] node-set containing at least one node:

The following example [XML Schema 1.0] extract illustrates the use of the PositiveIntegerAttribute pattern within an [XML Schema 1.0] document PositiveIntegerAttribute:

<xs:element name="positiveIntegerAttribute" type="ex:PositiveIntegerAttribute" />
<xs:complexType name="PositiveIntegerAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="positiveInteger" type="xs:positiveInteger" />
</xs:complexType>
    

The following example [XML 1.0] element is valid against the above example [XML Schema 1.0] when included inside an instance document PositiveIntegerAttribute01:

  <ex:positiveIntegerAttribute positiveInteger="257"/>