Advanced XML Schema Patterns for Databinding Version 1.0

1. Introduction

A databinding tool generates a mapping between XML documents which conform to an [XML Schema 1.0] schema and an internal data representation. For example, a Web services databinding tool may use [XML Schema 1.0] descriptions inside a [WSDL 2.0] document to produce and consume [SOAP 1.2] messages in terms of data structures in a programming language or data held inside a database.

State of the art databinding implementations have displayed uneven and inconsistent support of the W3C [XML Schema 1.0] Recommendation. XML Schema provides a wide variety of methods for describing the same XML structure, conversely a concept such as "null" may be represented in a wide variety of different ways.

The result of these issues is impaired interoperability and a poor user experience of databinding tools:

rejecting valid XML Schema documents,
rejecting valid XML instance documents, and
making the content of valid XML instance documents unavailable in mapped data structures.

This specification provides a advanced set of example [XML Schema 1.0] constructs and types in the form of concrete [XPath 2.0] expressions. These patterns are known to be in widespresd use and considered to be compatible with databinding implementations.

Implementers of databinding tools may find these patterns useful to represent simple and common place data structures. Ensuring tools recognise at least these simple [XML Schema 1.0] patterns and present them in terms most appropriate to the specific language, database or environment will provide an improved user experience when using databinding tools. It is inappropriate to use this specification to constrain the use of the [XML Schema 1.0] Recommendation.

1.1 Notational Conventions

All parts of this specification are normative, with the EXCEPTION of notes, examples, and sections explicitly marked as Non-Normative.

The keywords "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this specification are to be interpreted as described in [RFC 2119].

Each [XML Schema 1.0] pattern is defined using a single [XPath 2.0] expression constraining one or more [XML Schema 1.0] items.

Each [XML Schema 1.0] pattern is identified using a unique and stable URI [RFC 3986].

Assertions about documents and implementations that are not enforced by the normative patterns are marked by a dagger symbol (†) at the end of a sentence. Each assertion has been assigned a unique and stable identifier. The assertion identifiers MAY be used by implementations of this specification for any purpose, such as error reporting. The assertions and their identifiers are summarized in section C. Assertion Summary.

1.2 Namespaces

This specification uses a number of namespace prefixes throughout; they are listed in Table 1-1. Note that the choice of any namespace prefix is arbitrary and not semantically significant (see [XML Namespaces]).

Table 1-1. Prefixes and Namespaces used in this specification
Prefix	Namespace
xs	http://www.w3.org/2001/XMLSchema
xsi	http://www.w3.org/2001/XMLSchema-instance
soap11	http://schemas.xmlsoap.org/soap/envelope/
soap12	http://www.w3.org/2003/05/soap-envelope
wsdl11	http://schemas.xmlsoap.org/wsdl/
wsdl20	http://www.w3.org/2005/08/wsdl
pat	http://www.w3.org/2002/ws/databinding/patterns/6/09/
ex	http://www.w3.org/2002/ws/databinding/examples/6/09/

1.3 Document Conformance

A Document claiming conformance to this specification:

MUST use either the UTF-8 or UTF-16 [Unicode] encoding.^†
MAY include the [Unicode] Byte Order Mark (BOM).^†
MUST be a Well-formed [XML 1.0] document^†
MUST conform to the [XML Schema 1.0] Recommendation^†
MUST only contain [XML 1.0] element nodes and attribute nodes which form a part of one or more complete patterns contained in this and the [Basic Patterns] specifications.^†
MAY contain additional [XML 1.0] comment nodes and processing instruction nodes.^†

1.4 Implementation Conformance

An implementation that claims conformance to this specification:

SHOULD be able to process any valid [XML Schema 1.0] Document.^†
MUST be able to process any [XML Schema 1.0] Document conforming to this specification^†
MUST produce a data model exposing all of the [XML 1.0] element node and attribute node content described by the originating [XML Schema 1.0] Document.^†
MUST be able to consume any Well-formed [XML 1.0] Document which satisfies local-schema validity against the originating [XML Schema 1.0] Document exposing all of the [XML 1.0] element node and attribute node content in the data model.^†
MUST be able to produce Well-formed [XML 1.0] instance documents which satisfy local-schema validity against the originating [XML Schema 1.0] Document containing values exposed in the data model.^†
MAY consume Well-formed [XML 1.0] instance documents which do not satisfy local-schema validity against the originating [XML Schema 1.0] Document.^†
MAY allow the production of Well-formed [XML 1.0] instance documents containing values exposed in the data model which do not satisfy local-schema validity against the originating [XML Schema 1.0] Document.^†

Describing the form of the data model provided by a databinding implementation is beyond the scope of this specification. For example, the unconstrained built-in numeric primitive types, xs:decimal, xs:integer, xs:negativeInteger, xs:positiveInteger, xs:nonNegativeInteger and xs:nonPositiveInteger, do not map directly to native types in many programming languages and are likely to be presented as a toolkit specific construct or more generalised ways, such as a 'string'.

Note that although the patterns contained in this document are defined using [XPath 2.0], there is no requirement for a conformant implementation to support [XPath 2.0].

2. Schema Patterns

This section enumerates a series of concrete [XML Schema 1.0] patterns. Each pattern is identified by a URI [RFC 3986], defined using an [XPath 2.0] expression and accompanied by an example schema and one or more instance documents. This document offers no additional semantics for the schema patterns presented beyond those specified by the [XML Schema 1.0] Recommendation.

2.1 Properties

2.1.1 MixedContentElement

An [XML 1.0] document exhibits the MixedContentElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/MixedContentElement 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:

.//xs:element[@mixed = 'true']/ (@mixed)

2.1.2 MixedComplexContent

An [XML 1.0] document exhibits the MixedComplexContent pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/MixedComplexContent 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:

.//xs:complexContent[@mixed = 'true']/ (@mixed)

2.1.3 MixedContentType

An [XML 1.0] document exhibits the MixedContentType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/MixedContentType 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:

.//xs:complexType[@mixed = 'true']/ (@mixed)

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

<xs:element name="mixedContentType" type="ex:MixedContentType" />
<xs:complexType name="MixedContentType" mixed="true">
  <xs:sequence>
    <xs:element name="elem1" type="xs:string" />
    <xs:element name="elem2" 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 [MixedContentType01]:

  <ex:mixedContentType>
      <ex:elem1>Tagged Value</ex:elem1>

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

as is the following element when included in an instance document [MixedContentType02]:

  <ex:mixedContentType>

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

      more text
      
      
      <ex:elem2>Tagged Value</ex:elem2>
   </ex:mixedContentType>

and the following element when included in an instance document [MixedContentType03]:

  <ex:mixedContentType>
      <ex:elem1>Tagged Value</ex:elem1>

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

      mixed text value
   
   
   </ex:mixedContentType>

and the following element when included in an instance document [MixedContentType04]:

  <ex:mixedContentType>

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

      some more text in a mixed value
   
   
   </ex:mixedContentType>

2.2 Import and Include

2.2.1 ImportSchemaNamespace

An [XML 1.0] document exhibits the ImportSchemaNamespace pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ImportSchemaNamespace 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:

./xs:import[not(@schemaLocation) and @namespace =
'http://www.w3.org/2001/XMLSchema']/ (., @namespace)

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

<xs:importnamespace="http://www.w3.org/2001/XMLSchema" />
<xs:element name="importSchemaNamespace" 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 [ImportSchemaNamespace01]:

  <ex:importSchemaNamespace>hello service</ex:importSchemaNamespace>

2.3 Global Element Declarations

2.3.1 GlobalElementUnqualifiedType

An [XML 1.0] document exhibits the GlobalElementUnqualifiedType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalElementUnqualifiedType 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:

./xs:element[@name and @type and not(contains(@type, ':'))]/
(., @name, @type)

2.3.2 ElementTypeDefaultNamespace

An [XML 1.0] document exhibits the ElementTypeDefaultNamespace pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementTypeDefaultNamespace 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:

.//xs:element[@name and @type and not(contains(@type, ':'))]/
(@name, @type)

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

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

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

  <ex:stringElementDefaultNamespace/>

as is the following element when included in an instance document [ElementTypeDefaultNamespace02]:

  <ex:stringElementDefaultNamespace>This is a string!</ex:stringElementDefaultNamespace>

2.3.3 GlobalElementAbstract

An [XML 1.0] document exhibits the GlobalElementAbstract pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalElementAbstract 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:

./xs:element[@abstract='true']/ (@abstract)

2.3.4 GlobalElementAll

An [XML 1.0] document exhibits the GlobalElementAll pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalElementAll 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:

./xs:element[@name]/xs:complexType/xs:all[xs:element]/
(../../(., @name), .., ., xs:element/(., @name))

2.3.5 GlobalElementChoice

An [XML 1.0] document exhibits the GlobalElementChoice pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalElementChoice 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:

./xs:element[@name]/xs:complexType/xs:choice[xs:element]/
(../../(., @name), .., ., xs:element/(., @name))

2.3.6 GlobalElementComplexTypeSequenceExtension

An [XML 1.0] document exhibits the GlobalElementComplexTypeSequenceExtension pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalElementComplexTypeSequenceExtension 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:

./xs:element[@name]/xs:complexType/xs:complexContent[xs:extension[@base]/xs:sequence]/
(../../(., @name), .., ., xs:extension/(., @base, xs:sequence/(.,
xs:element/(., @name), xs:attribute/(., @name))))

2.4 Global Attribute Declarations

2.4.1 GlobalAttributeUnqualifiedType

An [XML 1.0] document exhibits the GlobalAttributeUnqualifiedType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GlobalAttributeUnqualifiedType 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:

./xs:attribute[@name and @type and not(contains(@type,
':'))]/ (., @name, @type)

2.5 Element Declarations

2.5.1 ElementMinOccursFinite

An [XML 1.0] document exhibits the ElementMinOccursFinite pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementMinOccursFinite 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:

.//xs:element[xs:integer(@minOccurs) gt 1]/ (@minOccurs,
@maxOccurs)

The following example [XML Schema 1.0] extract illustrates the use of the ElementMinOccursFinite 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 ElementMinOccursFinite pattern within an [XML Schema 1.0] document [ElementMinOccurs2orMore]:

<xs:element name="itemColors" type="ex:ItemColors" />
<xs:complexType name="ItemColors">
  <xs:sequence>
    <xs:element name="itemColor" type="xs:string" minOccurs="2" maxOccurs="unbounded" />
  </xs:sequence>
</xs:complexType>

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

  <ex:itemColors>
      <ex:itemColor>Red</ex:itemColor>
      <ex:itemColor>Black</ex:itemColor>
      <ex:itemColor>White</ex:itemColor>
      <ex:itemColor>Yellow</ex:itemColor>
   </ex:itemColors>

as is the following element when included in an instance document [ElementMinOccurs2orMore02]:

  <ex:itemColors>
      <ex:itemColor>Black</ex:itemColor>
      <ex:itemColor>White</ex:itemColor>
   </ex:itemColors>

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

.//xs:element[@maxOccurs and not(@maxOccurs = '0' or
@maxOccurs = '1' or @maxOccurs = 'unbounded')]/
(@maxOccurs)

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.5.3 AttributeElementNameClash

An [XML 1.0] document exhibits the AttributeElementNameClash pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AttributeElementNameClash 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:

.//xs:complexType/xs:sequence/xs:element[@name =
../../xs:attribute/@name]/ (@name)

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

<xs:element name="clientDetails" type="ex:ClientDetails" />
<xs:complexType name="ClientDetails">
  <xs:sequence>
    <xs:element name="forename" type="xs:string" />
    <xs:element name="surname" type="xs:string" />
    <xs:element name="title" type="xs:string" />
  </xs:sequence>
  <xs:attribute name="phone" type="xs:long" />
  <xs:attribute name="title" type="xs:boolean" />
</xs:complexType>

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

  <ex:clientDetails phone="0123456789" title="true">
      <ex:forename>Bobby</ex:forename>
      <ex:surname>Sox</ex:surname>
      <ex:title>Mr</ex:title>
   </ex:clientDetails>

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

.//xs:element[@nillable = 'true' and @minOccurs = '0']/
(@nillable, @minOccurs)

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.5.5 ElementTypeReferenceUnqualified

An [XML 1.0] document exhibits the ElementTypeReferenceUnqualified pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementTypeReferenceUnqualified 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:

.//xs:element[@name and @type and
namespace-uri-from-QName(resolve-QName(@type,.)) !=
'http://www.w3.org/2001/XMLSchema' and not(contains(@type, ':'))]/
(., @name, @type)

2.5.6 ElementReferenceUnqualified

An [XML 1.0] document exhibits the ElementReferenceUnqualified pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementReferenceUnqualified 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:

.//xs:element[@ref and not(contains(@ref, ':'))]/ (.,
@ref)

2.6 Attribute Declarations

2.6.1 ElementDefault

An [XML 1.0] document exhibits the ElementDefault pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ElementDefault 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:

.//xs:element[@default]/ (@default)

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

<xs:element name="globalElementDefault" type="xs:string" default="theDefaultValue" />

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

  <ex:globalElementDefault/>

as is the following element when included in an instance document [GlobalElementDefault02]:

  <ex:globalElementDefault>theDefaultValue</ex:globalElementDefault>

and the following element when included in an instance document [GlobalElementDefault03]:

  <ex:globalElementDefault>anotherValue</ex:globalElementDefault>

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

<xs:element name="localElementDefault" type="ex:LocalElementDefault" />
<xs:complexType name="LocalElementDefault">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" default="theDefaultValue" />
  </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 [LocalElementDefault01]:

  <ex:localElementDefault/>

as is the following element when included in an instance document [LocalElementDefault02]:

  <ex:localElementDefault>
      <ex:text/>
   </ex:localElementDefault>

and the following element when included in an instance document [LocalElementDefault03]:

  <ex:localElementDefault>
      <ex:text>theDefaultValue</ex:text>
   </ex:localElementDefault>

and the following element when included in an instance document [LocalElementDefault04]:

  <ex:localElementDefault>
      <ex:text>anotherValue</ex:text>
   </ex:localElementDefault>

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

.//xs:attribute[@use = 'required']/ (@use)

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.6.3 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:

.//xs:attribute[@fixed] / (@fixed)

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.6.4 AttributeDefault

An [XML 1.0] document exhibits the AttributeDefault pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AttributeDefault 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:

.//xs:attribute[@default] / (@default)

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

<xs:element name="attributeDefault" type="ex:AttributeDefault" />
<xs:complexType name="AttributeDefault">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="defaultedValue" type="xs:string" default="theDefaultValue" />
</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 [AttributeDefault01]:

  <ex:attributeDefault/>

as is the following element when included in an instance document [AttributeDefault02]:

  <ex:attributeDefault defaultedValue="theDefaultValue"/>

and the following element when included in an instance document [AttributeDefault03]:

  <ex:attributeDefault defaultedValue=""/>

and the following element when included in an instance document [AttributeDefault04]:

  <ex:attributeDefault defaultedValue="anotherValue"/>

2.6.5 AttributeReferenceUnqualified

An [XML 1.0] document exhibits the AttributeReferenceUnqualified pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AttributeReferenceUnqualified 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:

.//xs:attribute[@ref and not(contains(@ref, ':'))]/ (.,
@ref)

2.6.6 AttributeTypeReferenceUnqualified

An [XML 1.0] document exhibits the AttributeTypeReferenceUnqualified pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AttributeTypeReferenceUnqualified 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:

.//xs:attribute[@name and @type and
namespace-uri-from-QName(resolve-QName(@type,.)) !=
'http://www.w3.org/2001/XMLSchema' and not(contains(@type, ':'))]/
(., @name, @type)

2.6.7 LocalAttributeSimpleType

An [XML 1.0] document exhibits the LocalAttributeSimpleType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/LocalAttributeSimpleType 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:

.//xs:attribute[not(parent::xs:schema)]/xs:simpleType

2.7 SimpleType Declarations

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

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:NMTOKEN') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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:restrictionbase="xs:NMTOKEN">
    <xs:enumerationvalue="token1" />
    <xs:enumerationvalue="token2" />
    <xs:enumerationvalue="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.7.2 IntEnumerationType

An [XML 1.0] document exhibits the IntEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IntEnumerationType 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:int') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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

<xs:element name="intEnumerationType" type="ex:IntEnumerationType" />
<xs:simpleType name="IntEnumerationType">
  <xs:restrictionbase="xs:int">
    <xs:enumerationvalue="2" />
    <xs:enumerationvalue="3" />
    <xs:enumerationvalue="5" />
    <xs:enumerationvalue="7" />
  </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 [IntEnumerationType01]:

  <ex:intEnumerationType>2</ex:intEnumerationType>

2.7.3 ShortEnumerationType

An [XML 1.0] document exhibits the ShortEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ShortEnumerationType 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:short') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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

<xs:element name="shortEnumerationType" type="ex:ShortEnumerationType" />
<xs:simpleType name="ShortEnumerationType">
  <xs:restrictionbase="xs:short">
    <xs:enumerationvalue="7" />
    <xs:enumerationvalue="11" />
    <xs:enumerationvalue="13" />
  </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 [ShortEnumerationType01]:

  <ex:shortEnumerationType>11</ex:shortEnumerationType>

2.7.4 LongEnumerationType

An [XML 1.0] document exhibits the LongEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/LongEnumerationType 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:long') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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

<xs:element name="longEnumerationType" type="ex:LongEnumerationType" />
<xs:simpleType name="LongEnumerationType">
  <xs:restrictionbase="xs:long">
    <xs:enumerationvalue="9152052" />
    <xs:enumerationvalue="7816230" />
    <xs:enumerationvalue="7235733" />
  </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 [LongEnumerationType01]:

  <ex:longEnumerationType>9152052</ex:longEnumerationType>

2.7.5 DoubleEnumerationType

An [XML 1.0] document exhibits the DoubleEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DoubleEnumerationType 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:double') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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

<xs:element name="doubleEnumerationType" type="ex:DoubleEnumerationType" />
<xs:simpleType name="DoubleEnumerationType">
  <xs:restrictionbase="xs:double">
    <xs:enumerationvalue="1267.43233E12" />
    <xs:enumerationvalue="7234.34541E12" />
    <xs:enumerationvalue="5733.65565E12" />
  </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 [DoubleEnumerationType01]:

  <ex:doubleEnumerationType>1267.43233E12</ex:doubleEnumerationType>

2.7.6 IntegerEnumerationType

An [XML 1.0] document exhibits the IntegerEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IntegerEnumerationType 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:integer') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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

<xs:element name="integerEnumerationType" type="ex:IntegerEnumerationType" />
<xs:simpleType name="IntegerEnumerationType">
  <xs:restrictionbase="xs:integer">
    <xs:enumerationvalue="4000000" />
    <xs:enumerationvalue="5000000" />
    <xs:enumerationvalue="6000000" />
  </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 [IntegerEnumerationType01]:

  <ex:integerEnumerationType>4000000</ex:integerEnumerationType>

2.7.7 DecimalEnumerationType

An [XML 1.0] document exhibits the DecimalEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DecimalEnumerationType 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:decimal') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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

<xs:element name="decimalEnumerationType" type="ex:DecimalEnumerationType" />
<xs:simpleType name="DecimalEnumerationType">
  <xs:restrictionbase="xs:decimal">
    <xs:enumerationvalue="+1000.0001" />
    <xs:enumerationvalue="-1000.0001" />
    <xs:enumerationvalue="1000.0002" />
  </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 [DecimalEnumerationType01]:

  <ex:decimalEnumerationType>1000.0002</ex:decimalEnumerationType>

2.7.8 FloatEnumerationType

An [XML 1.0] document exhibits the FloatEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/FloatEnumerationType 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:float') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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

<xs:element name="floatEnumerationType" type="ex:FloatEnumerationType" />
<xs:simpleType name="FloatEnumerationType">
  <xs:restrictionbase="xs:float">
    <xs:enumerationvalue="1267.43233E12" />
    <xs:enumerationvalue="7234.34541E12" />
    <xs:enumerationvalue="5733.65565E12" />
  </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 [FloatEnumerationType01]:

  <ex:floatEnumerationType>1267.43233E12</ex:floatEnumerationType>

2.7.9 NonNegativeIntegerEnumerationType

An [XML 1.0] document exhibits the NonNegativeIntegerEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NonNegativeIntegerEnumerationType 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:nonNegativeInteger') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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

<xs:element name="nonNegativeIntegerEnumerationType" type="ex:NonNegativeIntegerEnumerationType" />
<xs:simpleType name="NonNegativeIntegerEnumerationType">
  <xs:restrictionbase="xs:nonNegativeInteger">
    <xs:enumerationvalue="12" />
    <xs:enumerationvalue="24" />
    <xs:enumerationvalue="33" />
  </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 [NonNegativeIntegerEnumerationType01]:

  <ex:nonNegativeIntegerEnumerationType>12</ex:nonNegativeIntegerEnumerationType>

2.7.10 PositiveIntegerEnumerationType

An [XML 1.0] document exhibits the PositiveIntegerEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/PositiveIntegerEnumerationType 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:positiveInteger') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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

<xs:element name="positiveIntegerEnumerationType" type="ex:PositiveIntegerEnumerationType" />
<xs:simpleType name="PositiveIntegerEnumerationType">
  <xs:restrictionbase="xs:positiveInteger">
    <xs:enumerationvalue="12" />
    <xs:enumerationvalue="24" />
    <xs:enumerationvalue="33" />
  </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 [PositiveIntegerEnumerationType01]:

  <ex:positiveIntegerEnumerationType>12</ex:positiveIntegerEnumerationType>

2.7.11 UnsignedIntEnumerationType

An [XML 1.0] document exhibits the UnsignedIntEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnsignedIntEnumerationType 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:unsignedInt') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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

<xs:element name="unsignedIntEnumerationType" type="ex:UnsignedIntEnumerationType" />
<xs:simpleType name="UnsignedIntEnumerationType">
  <xs:restrictionbase="xs:unsignedInt">
    <xs:enumerationvalue="1111111111" />
    <xs:enumerationvalue="2222222222" />
    <xs:enumerationvalue="3333333333" />
  </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 [UnsignedIntEnumerationType01]:

  <ex:unsignedIntEnumerationType>3333333333</ex:unsignedIntEnumerationType>

2.7.12 UnsignedLongEnumerationType

An [XML 1.0] document exhibits the UnsignedLongEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnsignedLongEnumerationType 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:unsignedLong') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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

<xs:element name="unsignedLongEnumerationType" type="ex:UnsignedLongEnumerationType" />
<xs:simpleType name="UnsignedLongEnumerationType">
  <xs:restrictionbase="xs:unsignedLong">
    <xs:enumerationvalue="11111111111111" />
    <xs:enumerationvalue="22222222222222" />
    <xs:enumerationvalue="33333333333333" />
  </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 [UnsignedLongEnumerationType01]:

  <ex:unsignedLongEnumerationType>33333333333333</ex:unsignedLongEnumerationType>

2.7.13 UnsignedShortEnumerationType

An [XML 1.0] document exhibits the UnsignedShortEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnsignedShortEnumerationType 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:unsignedShort') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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

<xs:element name="unsignedShortEnumerationType" type="ex:UnsignedShortEnumerationType" />
<xs:simpleType name="UnsignedShortEnumerationType">
  <xs:restrictionbase="xs:unsignedShort">
    <xs:enumerationvalue="1111" />
    <xs:enumerationvalue="2222" />
    <xs:enumerationvalue="3333" />
  </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 [UnsignedShortEnumerationType01]:

  <ex:unsignedShortEnumerationType>3333</ex:unsignedShortEnumerationType>

2.7.14 TokenEnumerationType

An [XML 1.0] document exhibits the TokenEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/TokenEnumerationType 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:token') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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

<xs:element name="tokenEnumerationType" type="ex:TokenEnumerationType" />
<xs:simpleType name="TokenEnumerationType">
  <xs:restrictionbase="xs:token">
    <xs:enumerationvalue="1" />
    <xs:enumerationvalue="2" />
    <xs:enumerationvalue="3" />
  </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 [TokenEnumerationType01]:

  <ex:tokenEnumerationType>1</ex:tokenEnumerationType>

as is the following element when included in an instance document [TokenEnumerationType02]:

  <ex:tokenEnumerationType>2</ex:tokenEnumerationType>

2.7.15 LanguageEnumerationType

An [XML 1.0] document exhibits the LanguageEnumerationType pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/LanguageEnumerationType 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:language') and xs:enumeration]/ (., @base,
xs:enumeration/(., @value))

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

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:decimal') and xs:totalDigits/@value]/ (., @base,
xs:totalDigits/(., @value))

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:restrictionbase="xs:decimal">
    <xs:totalDigitsvalue="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>

as is the following element when included in an instance document [DecimalSimpleTypeTotalDigits02]:

  <ex:decimalSimpleTypeTotalDigits>12345</ex:decimalSimpleTypeTotalDigits>

2.7.17 DecimalSimpleTypeFractionDigits

An [XML 1.0] document exhibits the DecimalSimpleTypeFractionDigits pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DecimalSimpleTypeFractionDigits 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:decimal') and xs:fractionDigits/@value]/ (., @base,
xs:fractionDigits/(., @value))

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

<xs:element name="decimalSimpleTypeFractionDigits" type="ex:DecimalSimpleTypeFractionDigits" />
<xs:simpleType name="DecimalSimpleTypeFractionDigits">
  <xs:restrictionbase="xs:decimal">
    <xs:fractionDigitsvalue="2" />
  </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 [DecimalSimpleTypeFractionDigits01]:

  <ex:decimalSimpleTypeFractionDigits>1234.00</ex:decimalSimpleTypeFractionDigits>

as is the following element when included in an instance document [DecimalSimpleTypeFractionDigits02]:

  <ex:decimalSimpleTypeFractionDigits>1234</ex:decimalSimpleTypeFractionDigits>

2.8 ComplexType Declarations

2.8.1 ComplexTypeAll

An [XML 1.0] document exhibits the ComplexTypeAll pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ComplexTypeAll 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:

.//xs:complexType/xs:all/ (., xs:element/(.,
@name))

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

<xs:element name="complexTypeAll" type="ex:ComplexTypeAll" />
<xs:complexType name="ComplexTypeAll">
  <xs:all>
    <xs:elementname="name" type="xs:string" />
    <xs:elementname="shade" type="xs:string" />
    <xs:elementname="length" type="xs:int" />
  </xs:all>
  <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 [ComplexTypeAll01]:

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

as is the following element when included in an instance document [ComplexTypeAll02]:

  <ex:complexTypeAll inStock="332" id="6026">
      <ex:shade>Green</ex:shade>
      <ex:length>21</ex:length>
      <ex:name>Widget</ex:name>
   </ex:complexTypeAll>

2.8.2 ComplexTypeChoice

An [XML 1.0] document exhibits the ComplexTypeChoice pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ComplexTypeChoice 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:

.//xs:complexType/xs:choice/ (., xs:element/(.,
@name))

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

<xs:element name="fruit" type="ex:Fruit" />
<xs:complexType name="Fruit">
  <xs:choice>
    <xs:elementname="apple" type="xs:int" />
    <xs:elementname="orange" type="xs:string" />
    <xs:elementname="banana" type="xs:int" />
  </xs:choice>
</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 [ComplexTypeChoice01]:

  <ex:fruit>
      <ex:apple>21</ex:apple>
   </ex:fruit>

as is the following element when included in an instance document [ComplexTypeChoice02]:

  <ex:fruit>
      <ex:orange>Two Hundred</ex:orange>
   </ex:fruit>

and the following element when included in an instance document [ComplexTypeChoice03]:

  <ex:fruit>
      <ex:banana>329</ex:banana>
   </ex:fruit>

2.8.3 ComplexTypeAnyAttribute

An [XML 1.0] document exhibits the ComplexTypeAnyAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ComplexTypeAnyAttribute 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:

.//xs:complexType/xs:anyAttribute

2.8.4 AnyAttributeStrict

An [XML 1.0] document exhibits the AnyAttributeStrict pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AnyAttributeStrict 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:

.//xs:complexType/xs:anyAttribute[(not(@processContents) or
@processContents = 'strict') and (not(@namespace) or @namespace =
'##any')]/ (., @processContents, @namespace)

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

<xs:element name="anyAttributeStrict" type="ex:AnyAttributeStrict" />
<xs:complexType name="AnyAttributeStrict">
  <xs:sequence>
    <xs:element name="firstName" type="xs:string" />
    <xs:element name="lastName" type="xs:string" />
  </xs:sequence>
  <xs:anyAttribute />
</xs:complexType>
<xs:attribute name="eyeColor" type="xs:string" />
<xs:attribute name="hairColor" 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 [AnyAttributeStrict01]:

  <ex:anyAttributeStrict ex:eyeColor="blue">
      <ex:firstName>Bobby</ex:firstName>
      <ex:lastName>Sox</ex:lastName>
   </ex:anyAttributeStrict>

as is the following element when included in an instance document [AnyAttributeStrict02]:

  <ex:anyAttributeStrict ex:eyeColor="blue">
      <ex:firstName>Bobby</ex:firstName>
      <ex:lastName>Sox</ex:lastName>
   </ex:anyAttributeStrict>

and the following element when included in an instance document [AnyAttributeStrict03]:

  <ex:anyAttributeStrict ex:eyeColor="blue" ex:hairColor="green">
      <ex:firstName>Bobby</ex:firstName>
      <ex:lastName>Sox</ex:lastName>
   </ex:anyAttributeStrict>

2.8.5 AnyAttributeLax

An [XML 1.0] document exhibits the AnyAttributeLax pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AnyAttributeLax 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:

.//xs:complexType/xs:anyAttribute[(@processContents = 'lax')
and (not(@namespace) or @namespace = '##any')]/ (.,
@processContents, @namespace)

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

<xs:element name="anyAttributeLax" type="ex:AnyAttributeLax" />
<xs:complexType name="AnyAttributeLax">
  <xs:sequence>
    <xs:element name="firstName" type="xs:string" />
    <xs:element name="lastName" type="xs:string" />
  </xs:sequence>
  <xs:anyAttributeprocessContents="lax" />
</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 [AnyAttributeLax01]:

  <ex:anyAttributeLax eyeColor="blue">
      <ex:firstName>Bobby</ex:firstName>
      <ex:lastName>Sox</ex:lastName>
   </ex:anyAttributeLax>

2.8.6 AnyAttributeSkip

An [XML 1.0] document exhibits the AnyAttributeSkip pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AnyAttributeSkip 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:

.//xs:complexType/xs:anyAttribute[(@processContents = 'skip')
and (not(@namespace) or @namespace = '##any')]/ (.,
@processContents, @namespace)

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

<xs:element name="anyAttributeSkip" type="ex:AnyAttributeSkip" />
<xs:complexType name="AnyAttributeSkip">
  <xs:sequence>
    <xs:element name="firstName" type="xs:string" />
    <xs:element name="lastName" type="xs:string" />
  </xs:sequence>
  <xs:anyAttributeprocessContents="skip" />
</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 [AnyAttributeSkip01]:

  <ex:anyAttributeSkip eyeColor="blue">
      <ex:firstName>Bobby</ex:firstName>
      <ex:lastName>Sox</ex:lastName>
   </ex:anyAttributeSkip>

2.8.7 AnyAttributeOtherStrict

An [XML 1.0] document exhibits the AnyAttributeOtherStrict pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AnyAttributeOtherStrict 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:

.//xs:complexType/xs:anyAttribute[(not(@processContents) or
@processContents = 'strict') and (@namespace = '##other')]/ (.,
@processContents, @namespace)

2.8.8 AnyAttributeOtherLax

An [XML 1.0] document exhibits the AnyAttributeOtherLax pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AnyAttributeOtherLax 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:

.//xs:complexType/xs:anyAttribute[(@processContents = 'lax')
and (@namespace = '##other')]/ (., @processContents,
@namespace)

2.8.9 AnyAttributeOtherSkip

An [XML 1.0] document exhibits the AnyAttributeOtherSkip pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AnyAttributeOtherSkip 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:

.//xs:complexType/xs:anyAttribute[(@processContents = 'skip')
and (@namespace = '##other')]/ (., @processContents,
@namespace)

2.8.10 ExtendedSimpleContent

An [XML 1.0] document exhibits the ExtendedSimpleContent pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ExtendedSimpleContent 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:

.//xs:complexType/xs:simpleContent/xs:extension[@base]/ (..,
., ./@base, xs:attribute/ (., @name))

2.9 Sequences

2.9.1 ComplexTypeSequenceChoice

An [XML 1.0] document exhibits the ComplexTypeSequenceChoice pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ComplexTypeSequenceChoice 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:

.//xs:complexType/xs:sequence/xs:choice/ (., xs:element/(.,
@name))

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

<xs:element name="mortgage" type="ex:Mortgage" />
<xs:complexType name="Mortgage">
  <xs:sequence>
    <xs:element name="amount" type="xs:int" />
    <xs:choice>
      <xs:elementname="repayment" type="ex:Repayment" />
      <xs:elementname="interestonly" type="ex:InterestOnly" />
    </xs:choice>
  </xs:sequence>
</xs:complexType>
<xs:complexType name="Repayment">
  <xs:sequence>
    <xs:element name="years" type="xs:int" />
    <xs:element name="months" type="xs:int" />
    <xs:element name="rate" type="xs:string" />
  </xs:sequence>
</xs:complexType>
<xs:complexType name="InterestOnly">
  <xs:sequence>
    <xs:element name="years" type="xs:int" />
    <xs:element name="rate" 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 [ComplexTypeSequenceChoice01]:

  <ex:mortgage>
      <ex:amount>225000</ex:amount>
      <ex:repayment>
         <ex:years>20</ex:years>
         <ex:months>6</ex:months>
         <ex:rate>5.25</ex:rate>
      </ex:repayment>
   </ex:mortgage>

as is the following element when included in an instance document [ComplexTypeSequenceChoice02]:

  <ex:mortgage>
      <ex:amount>225000</ex:amount>
      <ex:interestonly>
         <ex:years>25</ex:years>
         <ex:rate>5.50</ex:rate>
      </ex:interestonly>
   </ex:mortgage>

2.9.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:

.//xs:sequence[@minOccurs = '0' and (not(@maxOccurs) or
@maxOccurs = '1')]/ (@minOccurs, @maxOccurs)

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.9.3 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:

.//xs:sequence[@minOccurs = '0' and @maxOccurs =
'unbounded']/ (@minOccurs, @maxOccurs)

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:string" />
    <xs:element name="durationPercentage" 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 [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.9.4 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:

.//xs:sequence[(not(@minOccurs) or @minOccurs = '1') and
@maxOccurs = 'unbounded']/ (@minOccurs, @maxOccurs)

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:string" />
    <xs:element name="agePercentage" 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 [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>

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

<xs:element name="bookPublications" type="ex:BookPublications" />
<xs:complexType name="BookPublications">
  <xs:sequence maxOccurs="unbounded">
    <xs:element name="pubDate" type="xs:string" />
    <xs:element name="pubISBN" 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 [SequenceMaxOccursUnbounded01]:

  <ex:bookPublications>
      <ex:pubDate>2002-09-24</ex:pubDate>
      <ex:pubISBN>1-55960-907-6</ex:pubISBN>
      <ex:pubDate>2003-04-14</ex:pubDate>
      <ex:pubISBN>1-25466-908-6</ex:pubISBN>
      <ex:pubDate>2004-03-31</ex:pubDate>
      <ex:pubISBN>1-35460-909-6</ex:pubISBN>
      <ex:pubDate>2005-06-04</ex:pubDate>
      <ex:pubISBN>1-54560-910-6</ex:pubISBN>
      <ex:pubDate>2006-07-03</ex:pubDate>
      <ex:pubISBN>1-74869-911-6</ex:pubISBN>
   </ex:bookPublications>

as is the following element when included in an instance document [SequenceMaxOccursUnbounded02]:

  <ex:bookPublications>
      <ex:pubDate>2006-01-26</ex:pubDate>
      <ex:pubISBN>1-44795-912-6</ex:pubISBN>
   </ex:bookPublications>

2.9.5 SequenceMinOccursFinite

An [XML 1.0] document exhibits the SequenceMinOccursFinite pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/SequenceMinOccursFinite 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:

.//xs:sequence[xs:integer(@minOccurs) gt 1]/ (@minOccurs,
@maxOccurs)

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

<xs:element name="articleColors" type="ex:ArticleColors" />
<xs:complexType name="ArticleColors">
  <xs:sequence minOccurs="2" maxOccurs="unbounded">
    <xs:element name="articleColor" type="xs:string" />
    <xs:element name="articleContrast" 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 [SequenceMinOccursFinite01]:

  <ex:articleColors>
      <ex:articleColor>Red</ex:articleColor>
      <ex:articleContrast>Bright</ex:articleContrast>
      <ex:articleColor>Black</ex:articleColor>
      <ex:articleContrast>Bright</ex:articleContrast>
      <ex:articleColor>White</ex:articleColor>
      <ex:articleContrast>Low</ex:articleContrast>
      <ex:articleColor>Yellow</ex:articleColor>
      <ex:articleContrast>Normal</ex:articleContrast>
   </ex:articleColors>

as is the following element when included in an instance document [SequenceMinOccursFinite02]:

  <ex:articleColors>
      <ex:articleColor>Black</ex:articleColor>
      <ex:articleContrast>Normal</ex:articleContrast>
      <ex:articleColor>White</ex:articleColor>
      <ex:articleContrast>Bright</ex:articleContrast>
   </ex:articleColors>

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

.//xs:sequence[@maxOccurs and not(@maxOccurs = '0' or
@maxOccurs = '1' or @maxOccurs = 'unbounded')]/
(@maxOccurs)

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:winter>
      <ex:mnth>December</ex:mnth>
      <ex:weather>Snow</ex:weather>
   </ex:winter>

2.9.7 ExtendedSequenceStrict

An [XML 1.0] document exhibits the ExtendedSequenceStrict pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ExtendedSequenceStrict 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:

.//xs:sequence/xs:any[(not(@processContents) or
@processContents = 'strict') and (not (@minOccurs) or @minOccurs =
'1' or @minOccurs = '0') and (not (@maxOccurs) or @maxOccurs = '1'
or @maxOccurs='unbounded') and @namespace = '##targetNamespace']/
(., @processContents, @minOccurs, @maxOccurs,
@namespace)

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

<xs:element name="extendedSequenceStrict" type="ex:ExtendedSequenceStrict" />
<xs:complexType name="ExtendedSequenceStrict">
  <xs:sequence>
    <xs:element name="firstName" type="xs:string" />
    <xs:element name="lastName" type="xs:string" />
    <xs:element name="extension" type="ex:StrictExtension" minOccurs="0" />
  </xs:sequence>
</xs:complexType>
<xs:element name="title" type="xs:string" />
<xs:element name="middleName" type="xs:string" />
<xs:complexType name="StrictExtension">
  <xs:sequence>
    <xs:anyprocessContents="strict" minOccurs="0" maxOccurs="unbounded" namespace="##targetNamespace" />
  </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 [ExtendedSequenceStrict01]:

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

as is the following element when included in an instance document [ExtendedSequenceStrict02]:

  <ex:extendedSequenceStrict>
      <ex:firstName>Bobby</ex:firstName>
      <ex:lastName>Sox</ex:lastName>
      <ex:extension>
         <ex:middleName>William</ex:middleName>
         <ex:title>Mr</ex:title>
      </ex:extension>
   </ex:extendedSequenceStrict>

2.9.8 ExtendedSequenceLax

An [XML 1.0] document exhibits the ExtendedSequenceLax pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ExtendedSequenceLax 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:

.//xs:sequence/xs:any[@processContents = 'lax' and (not
(@minOccurs) or @minOccurs = '1' or @minOccurs = '0') and (not
(@maxOccurs) or @maxOccurs = '1' or @maxOccurs='unbounded') and
@namespace = '##targetNamespace']/ (., @processContents,
@minOccurs, @maxOccurs, @namespace)

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

<xs:element name="extendedSequenceLax" type="ex:ExtendedSequenceLax" />
<xs:complexType name="ExtendedSequenceLax">
  <xs:sequence>
    <xs:element name="firstName" type="xs:string" />
    <xs:element name="lastName" type="xs:string" />
    <xs:element name="extension" type="ex:LaxExtension" minOccurs="0" />
  </xs:sequence>
</xs:complexType>
<xs:complexType name="LaxExtension">
  <xs:sequence>
    <xs:anyprocessContents="lax" minOccurs="0" maxOccurs="unbounded" namespace="##targetNamespace" />
  </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 [ExtendedSequenceLax01]:

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

as is the following element when included in an instance document [ExtendedSequenceLax02]:

  <ex:extendedSequenceLax>
      <ex:firstName>Bobby</ex:firstName>
      <ex:lastName>Sox</ex:lastName>
      <ex:extension>
         <ex:middleName>William</ex:middleName>
         <ex:title>Mr</ex:title>
      </ex:extension>
   </ex:extendedSequenceLax>

2.9.9 ExtendedSequenceSkip

An [XML 1.0] document exhibits the ExtendedSequenceSkip pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ExtendedSequenceSkip 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:

.//xs:sequence/xs:any[@processContents = 'skip' and (not
(@minOccurs) or @minOccurs = '1' or @minOccurs = '0') and (not
(@maxOccurs) or @maxOccurs = '1' or @maxOccurs='unbounded') and
@namespace = '##targetNamespace']/ (., @processContents,
@minOccurs, @maxOccurs, @namespace)

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

<xs:element name="extendedSequenceSkip" type="ex:ExtendedSequenceSkip" />
<xs:complexType name="ExtendedSequenceSkip">
  <xs:sequence>
    <xs:element name="firstName" type="xs:string" />
    <xs:element name="lastName" type="xs:string" />
    <xs:element name="extension" type="ex:SkipExtension" minOccurs="0" />
  </xs:sequence>
</xs:complexType>
<xs:complexType name="SkipExtension">
  <xs:sequence>
    <xs:anyprocessContents="skip" minOccurs="0" maxOccurs="unbounded" namespace="##targetNamespace" />
  </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 [ExtendedSequenceSkip01]:

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

as is the following element when included in an instance document [ExtendedSequenceSkip02]:

  <ex:extendedSequenceSkip>
      <ex:firstName>Bobby</ex:firstName>
      <ex:lastName>Sox</ex:lastName>
      <ex:extension>
         <ex:middleName>William</ex:middleName>
         <ex:title>Mr</ex:title>
      </ex:extension>
   </ex:extendedSequenceSkip>

2.9.10 ExtendedSequenceStrictAny

An [XML 1.0] document exhibits the ExtendedSequenceStrictAny pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ExtendedSequenceStrictAny 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:

.//xs:sequence/xs:any[(not(@processContents) or
@processContents = 'strict') and (not (@minOccurs) or @minOccurs =
'1' or @minOccurs = '0') and (not (@maxOccurs) or @maxOccurs = '1'
or @maxOccurs='unbounded') and (not(@namespace) or @namespace =
'##any')]/ (., @processContents, @minOccurs, @maxOccurs,
@namespace)

2.9.11 ExtendedSequenceLaxAny

An [XML 1.0] document exhibits the ExtendedSequenceLaxAny pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ExtendedSequenceLaxAny 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:

.//xs:sequence/xs:any[@processContents = 'lax' and (not
(@minOccurs) or @minOccurs = '1' or @minOccurs = '0') and (not
(@maxOccurs) or @maxOccurs = '1' or @maxOccurs='unbounded') and
(not(@namespace) or @namespace = '##any')]/ (., @processContents,
@minOccurs, @maxOccurs, @namespace)

2.9.12 ExtendedSequenceSkipAny

An [XML 1.0] document exhibits the ExtendedSequenceSkipAny pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ExtendedSequenceSkipAny 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:

.//xs:sequence/xs:any[@processContents = 'skip' and (not
(@minOccurs) or @minOccurs = '1' or @minOccurs = '0') and (not
(@maxOccurs) or @maxOccurs = '1' or @maxOccurs='unbounded') and
(not(@namespace) or @namespace = '##any')]/ (., @processContents,
@minOccurs, @maxOccurs, @namespace)

2.9.13 ExtendedSequenceStrictOther

An [XML 1.0] document exhibits the ExtendedSequenceStrictOther pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ExtendedSequenceStrictOther 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:

.//xs:sequence/xs:any[(not(@processContents) or
@processContents = 'strict') and (not (@minOccurs) or @minOccurs =
'1' or @minOccurs = '0') and (not (@maxOccurs) or @maxOccurs = '1'
or @maxOccurs='unbounded') and @namespace = '##other']/ (.,
@processContents, @minOccurs, @maxOccurs, @namespace)

2.9.14 ExtendedSequenceLaxOther

An [XML 1.0] document exhibits the ExtendedSequenceLaxOther pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ExtendedSequenceLaxOther 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:

.//xs:sequence/xs:any[@processContents = 'lax' and (not
(@minOccurs) or @minOccurs = '1' or @minOccurs = '0') and (not
(@maxOccurs) or @maxOccurs = '1' or @maxOccurs='unbounded') and
@namespace = '##other']/ (., @processContents, @minOccurs,
@maxOccurs, @namespace)

2.9.15 ExtendedSequenceSkipOther

An [XML 1.0] document exhibits the ExtendedSequenceSkipOther pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ExtendedSequenceSkipOther 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:

.//xs:sequence/xs:any[@processContents = 'skip' and (not
(@minOccurs) or @minOccurs = '1' or @minOccurs = '0') and (not
(@maxOccurs) or @maxOccurs = '1' or @maxOccurs='unbounded') and
@namespace = '##other']/ (., @processContents, @minOccurs,
@maxOccurs, @namespace)

2.10 Unions

2.10.1 UnionMemberTypes

An [XML 1.0] document exhibits the UnionMemberTypes pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnionMemberTypes 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:

.//xs:simpleType/xs:union[@memberTypes and
not(xs:simpleType)]/ (., @memberTypes)

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

<xs:simpleType name="UnionMemberTypes">
  <xs:unionmemberTypes="xs:int xs:string" />
</xs:simpleType>
<xs:element name="unionMemberTypes" type="ex:UnionMemberTypes" />

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

  <ex:unionMemberTypes>22</ex:unionMemberTypes>

as is the following element when included in an instance document [UnionMemberTypes02]:

  <ex:unionMemberTypes>a string?</ex:unionMemberTypes>

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

<xs:simpleType name="UnionDateString">
  <xs:unionmemberTypes="xs:date xs:string" />
</xs:simpleType>
<xs:element name="unionDateString" type="ex:UnionDateString" />

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

  <ex:unionDateString>Tonight</ex:unionDateString>

as is the following element when included in an instance document [UnionDateString02]:

  <ex:unionDateString>2006-06-06</ex:unionDateString>

2.10.2 UnionSimpleTypes

An [XML 1.0] document exhibits the UnionSimpleTypes pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnionSimpleTypes 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:

.//xs:simpleType/xs:union[not(@memberTypes)]/xs:simpleType/
(.., .)

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

<xs:simpleType name="UnionSimpleDateString">
  <xs:union>
    <xs:simpleType>
      <xs:restriction base="xs:date" />
    </xs:simpleType>
    <xs:simpleType>
      <xs:restriction base="xs:string" />
    </xs:simpleType>
  </xs:union>
</xs:simpleType>
<xs:element name="unionSimpleDateString" type="ex:UnionSimpleDateString" />

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

  <ex:unionSimpleDateString>Monday Night</ex:unionSimpleDateString>

as is the following element when included in an instance document [UnionSimpleDateString02]:

  <ex:unionSimpleDateString>2006-06-06</ex:unionSimpleDateString>

2.10.3 UnionSimpleAndMemberTypes

An [XML 1.0] document exhibits the UnionSimpleAndMemberTypes pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnionSimpleAndMemberTypes 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:

.//xs:simpleType/xs:union[@memberTypes and xs:simpleType]/
(., @memberTypes, xs:simpleType)

2.11 Lists

2.11.1 List

An [XML 1.0] document exhibits the List pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/List 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:

.//xs:list[@itemType]/ (.,
@itemType)

2.12 Element Predefined Types

2.12.1 AnyTypeElement

An [XML 1.0] document exhibits the AnyTypeElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AnyTypeElement 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:anyType')]

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

<xs:element name="anyTypeElement" type="xs:anyType" />

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

  <ex:anyTypeElement/>

as is the following element when included in an instance document [AnyTypeElement02]:

  <ex:anyTypeElement>
      <foo>
         <bar>cheese</bar>
      </foo>
   </ex:anyTypeElement>

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

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:decimal')]

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.12.3 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:float')]

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.12.4 DurationElement

An [XML 1.0] document exhibits the DurationElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DurationElement 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:duration')]

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

<xs:element name="durationElement" type="xs:duration" />

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

  <ex:durationElement>P1Y2M3DT10H30M</ex:durationElement>

as is the following element when included in an instance document [DurationElement02]:

  <ex:durationElement>-P1347M</ex:durationElement>

and the following element when included in an instance document [DurationElement03]:

  <ex:durationElement>P1347Y</ex:durationElement>

and the following element when included in an instance document [DurationElement04]:

  <ex:durationElement>P1M</ex:durationElement>

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

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:time')]

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.12.6 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:date')]

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.12.7 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:gYearMonth')]

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.12.8 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:gYear')]

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.12.9 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:gMonthDay')]

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.12.10 GDayElement

An [XML 1.0] document exhibits the GDayElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GDayElement 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:gDay')]

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

<xs:element name="gDayElement" type="xs:gDay" />

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

  <ex:gDayElement>---05</ex:gDayElement>

2.12.11 GMonthElement

An [XML 1.0] document exhibits the GMonthElement pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GMonthElement 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:gMonth')]

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

<xs:element name="gMonthElement" type="xs:gMonth" />

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

  <ex:gMonthElement>--02--</ex:gMonthElement>

as is the following element when included in an instance document [GMonthElement02]:

  <ex:gMonthElement>--12--</ex:gMonthElement>

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

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:language')]

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.12.13 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:NMTOKEN')]

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.12.14 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:NMTOKENS')]

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.12.15 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:ID')]

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.12.16 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:IDREF')]

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.12.17 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:IDREFS')]

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.12.18 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:ENTITY')]

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.12.19 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:ENTITIES')]

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.12.20 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:integer')]

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>

and the following element when included in an instance document [IntegerElement05]:

  <ex:integerElement>123456789123456789123456789123456789</ex:integerElement>

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

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:nonPositiveInteger')]

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>

as is the following element when included in an instance document [NonPositiveIntegerElement02]:

  <ex:nonPositiveIntegerElement>-1234324234532534254325234534252345342534253425324534253244</ex:nonPositiveIntegerElement>

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

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:negativeInteger')]

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>

as is the following element when included in an instance document [NegativeIntegerElement02]:

  <ex:negativeIntegerElement>-12343242342345345346453643564536543645363456</ex:negativeIntegerElement>

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

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:nonNegativeInteger')]

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.12.24 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:unsignedLong')]

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.12.25 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:unsignedInt')]

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.12.26 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:unsignedShort')]

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.12.27 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:

.//xs:element/@type[resolve-QName(.,..) =
xs:QName('xs:unsignedByte')]

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.13 Attribute Predefined Types

2.13.1 AnyTypeAttribute

An [XML 1.0] document exhibits the AnyTypeAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/AnyTypeAttribute 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:anyType')]

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

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:decimal')]

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.13.3 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:float')]

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.13.4 DurationAttribute

An [XML 1.0] document exhibits the DurationAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DurationAttribute 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:duration')]

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

<xs:element name="durationAttribute" type="ex:DurationAttribute" />
<xs:complexType name="DurationAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="duration" type="xs:duration" />
</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 [DurationAttribute01]:

  <ex:durationAttribute duration="P1M"/>

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

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:time')]

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.13.6 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:date')]

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.13.7 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:gYearMonth')]

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.13.8 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:gYear')]

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.13.9 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:gMonthDay')]

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.13.10 GDayAttribute

An [XML 1.0] document exhibits the GDayAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GDayAttribute 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:gDay')]

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

<xs:element name="gDayAttribute" type="ex:GDayAttribute" />
<xs:complexType name="GDayAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="gDay" type="xs:gDay" />
</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 [GDayAttribute01]:

  <ex:gDayAttribute gDay="---09"/>

2.13.11 GMonthAttribute

An [XML 1.0] document exhibits the GMonthAttribute pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GMonthAttribute 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:gMonth')]

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

<xs:element name="gMonthAttribute" type="ex:GMonthAttribute" />
<xs:complexType name="GMonthAttribute">
  <xs:sequence>
    <xs:element name="text" type="xs:string" minOccurs="0" />
  </xs:sequence>
  <xs:attribute name="gMonth" type="xs:gMonth" />
</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 [GMonthAttribute01]:

  <ex:gMonthAttribute gMonth="--04--"/>

2.13.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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:base64Binary')]

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.13.13 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:language')]

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.13.14 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:NMTOKEN')]

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.13.15 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:NMTOKENS')]

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.13.16 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:ID')]

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.13.17 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:IDREF')]

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.13.18 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:IDREFS')]

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.13.19 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:ENTITY')]

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.13.20 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:ENTITIES')]

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.13.21 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:integer')]

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

as is the following element when included in an instance document [IntegerAttribute02]:

  <ex:integerAttribute integer="123456789013234235435325235325325345432543253425324534253245"/>

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

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:nonPositiveInteger')]

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

as is the following element when included in an instance document [NonPositiveIntegerAttribute02]:

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

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

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:negativeInteger')]

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.13.24 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:unsignedLong')]

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.13.25 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:unsignedInt')]

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.13.26 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:unsignedShort')]

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.13.27 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:

.//xs:attribute/@type[resolve-QName(.,..) =
xs:QName('xs:unsignedByte')]

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.14 Restricted Schema Types

2.14.1 StringSimpleTypePattern

An [XML 1.0] document exhibits the StringSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/StringSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:string')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

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

<xs:element name="stringSimpleTypePattern" type="ex:StringSimpleTypePattern" />
<xs:simpleType name="StringSimpleTypePattern">
  <xs:restrictionbase="xs:string">
    <xs:patternvalue="\d{3}" />
  </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 [StringSimpleTypePattern01]:

  <ex:stringSimpleTypePattern>123</ex:stringSimpleTypePattern>

as is the following element when included in an instance document [StringSimpleTypePattern02]:

  <ex:stringSimpleTypePattern>009</ex:stringSimpleTypePattern>

2.14.2 IntSimpleTypePattern

An [XML 1.0] document exhibits the IntSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IntSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:int')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

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

<xs:element name="intSimpleTypePattern" type="ex:IntSimpleTypePattern" />
<xs:simpleType name="IntSimpleTypePattern">
  <xs:restrictionbase="xs:int">
    <xs:patternvalue="\d{3}" />
  </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 [IntSimpleTypePattern01]:

  <ex:intSimpleTypePattern>123</ex:intSimpleTypePattern>

as is the following element when included in an instance document [IntSimpleTypePattern02]:

  <ex:intSimpleTypePattern>009</ex:intSimpleTypePattern>

2.14.3 IntegerSimpleTypePattern

An [XML 1.0] document exhibits the IntegerSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/IntegerSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:integer')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

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

<xs:element name="integerSimpleTypePattern" type="ex:IntegerSimpleTypePattern" />
<xs:simpleType name="IntegerSimpleTypePattern">
  <xs:restrictionbase="xs:integer">
    <xs:patternvalue="[+\-]?([1-9][0-9]*)|0" />
  </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 [IntegerSimpleTypePattern01]:

  <ex:integerSimpleTypePattern>123</ex:integerSimpleTypePattern>

as is the following element when included in an instance document [IntegerSimpleTypePattern02]:

  <ex:integerSimpleTypePattern>9</ex:integerSimpleTypePattern>

2.14.4 LongSimpleTypePattern

An [XML 1.0] document exhibits the LongSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/LongSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:long')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

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

<xs:element name="longSimpleTypePattern" type="ex:LongSimpleTypePattern" />
<xs:simpleType name="LongSimpleTypePattern">
  <xs:restrictionbase="xs:long">
    <xs:patternvalue="\d{3}" />
  </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 [LongSimpleTypePattern01]:

  <ex:longSimpleTypePattern>123</ex:longSimpleTypePattern>

as is the following element when included in an instance document [LongSimpleTypePattern02]:

  <ex:longSimpleTypePattern>009</ex:longSimpleTypePattern>

2.14.5 DecimalSimpleTypePattern

An [XML 1.0] document exhibits the DecimalSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DecimalSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:decimal')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

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

<xs:element name="decimalSimpleTypePattern" type="ex:DecimalSimpleTypePattern" />
<xs:simpleType name="DecimalSimpleTypePattern">
  <xs:restrictionbase="xs:decimal">
    <xs:patternvalue="\d{4}\.\d{2}" />
  </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 [DecimalSimpleTypePattern01]:

  <ex:decimalSimpleTypePattern>1234.12</ex:decimalSimpleTypePattern>

as is the following element when included in an instance document [DecimalSimpleTypePattern02]:

  <ex:decimalSimpleTypePattern>9898.00</ex:decimalSimpleTypePattern>

2.14.6 FloatSimpleTypePattern

An [XML 1.0] document exhibits the FloatSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/FloatSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:float')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

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

<xs:element name="floatSimpleTypePattern" type="ex:FloatSimpleTypePattern" />
<xs:simpleType name="FloatSimpleTypePattern">
  <xs:restrictionbase="xs:float">
    <xs:patternvalue="\d{3}" />
  </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 [FloatSimpleTypePattern01]:

  <ex:floatSimpleTypePattern>123</ex:floatSimpleTypePattern>

as is the following element when included in an instance document [FloatSimpleTypePattern02]:

  <ex:floatSimpleTypePattern>009</ex:floatSimpleTypePattern>

2.14.7 DoubleSimpleTypePattern

An [XML 1.0] document exhibits the DoubleSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DoubleSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:double')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

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

<xs:element name="doubleSimpleTypePattern" type="ex:DoubleSimpleTypePattern" />
<xs:simpleType name="DoubleSimpleTypePattern">
  <xs:restrictionbase="xs:double">
    <xs:patternvalue="\d{3}" />
  </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 [DoubleSimpleTypePattern01]:

  <ex:doubleSimpleTypePattern>123</ex:doubleSimpleTypePattern>

as is the following element when included in an instance document [DoubleSimpleTypePattern02]:

  <ex:doubleSimpleTypePattern>009</ex:doubleSimpleTypePattern>

2.14.8 ShortSimpleTypePattern

An [XML 1.0] document exhibits the ShortSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/ShortSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:short')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

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

<xs:element name="shortSimpleTypePattern" type="ex:ShortSimpleTypePattern" />
<xs:simpleType name="ShortSimpleTypePattern">
  <xs:restrictionbase="xs:short">
    <xs:patternvalue="\d{3}" />
  </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 [ShortSimpleTypePattern01]:

  <ex:shortSimpleTypePattern>123</ex:shortSimpleTypePattern>

as is the following element when included in an instance document [ShortSimpleTypePattern02]:

  <ex:shortSimpleTypePattern>009</ex:shortSimpleTypePattern>

2.14.9 NonNegativeIntegerSimpleTypePattern

An [XML 1.0] document exhibits the NonNegativeIntegerSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/NonNegativeIntegerSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:nonNegativeInteger')]/xs:pattern[@value]/ (..,
../@base, ., @value)

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

<xs:element name="nonNegativeIntegerSimpleTypePattern" type="ex:NonNegativeIntegerSimpleTypePattern" />
<xs:simpleType name="NonNegativeIntegerSimpleTypePattern">
  <xs:restrictionbase="xs:nonNegativeInteger">
    <xs:patternvalue="\d{3}" />
  </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 [NonNegativeIntegerSimpleTypePattern01]:

  <ex:nonNegativeIntegerSimpleTypePattern>123</ex:nonNegativeIntegerSimpleTypePattern>

as is the following element when included in an instance document [NonNegativeIntegerSimpleTypePattern02]:

  <ex:nonNegativeIntegerSimpleTypePattern>009</ex:nonNegativeIntegerSimpleTypePattern>

2.14.10 PositiveIntegerSimpleTypePattern

An [XML 1.0] document exhibits the PositiveIntegerSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/PositiveIntegerSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:positiveInteger')]/xs:pattern[@value]/ (.., ../@base,
., @value)

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

<xs:element name="positiveIntegerSimpleTypePattern" type="ex:PositiveIntegerSimpleTypePattern" />
<xs:simpleType name="PositiveIntegerSimpleTypePattern">
  <xs:restrictionbase="xs:positiveInteger">
    <xs:patternvalue="\d{3}" />
  </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 [PositiveIntegerSimpleTypePattern01]:

  <ex:positiveIntegerSimpleTypePattern>123</ex:positiveIntegerSimpleTypePattern>

as is the following element when included in an instance document [PositiveIntegerSimpleTypePattern02]:

  <ex:positiveIntegerSimpleTypePattern>009</ex:positiveIntegerSimpleTypePattern>

2.14.11 UnsignedLongSimpleTypePattern

An [XML 1.0] document exhibits the UnsignedLongSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnsignedLongSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:unsignedLong')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

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

<xs:element name="unsignedLongSimpleTypePattern" type="ex:UnsignedLongSimpleTypePattern" />
<xs:simpleType name="UnsignedLongSimpleTypePattern">
  <xs:restrictionbase="xs:unsignedLong">
    <xs:patternvalue="\d{3}" />
  </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 [UnsignedLongSimpleTypePattern01]:

  <ex:unsignedLongSimpleTypePattern>123</ex:unsignedLongSimpleTypePattern>

as is the following element when included in an instance document [UnsignedLongSimpleTypePattern02]:

  <ex:unsignedLongSimpleTypePattern>009</ex:unsignedLongSimpleTypePattern>

2.14.12 UnsignedIntSimpleTypePattern

An [XML 1.0] document exhibits the UnsignedIntSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnsignedIntSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:unsignedInt')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

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

<xs:element name="unsignedIntSimpleTypePattern" type="ex:UnsignedIntSimpleTypePattern" />
<xs:simpleType name="UnsignedIntSimpleTypePattern">
  <xs:restrictionbase="xs:unsignedInt">
    <xs:patternvalue="\d{3}" />
  </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 [UnsignedIntSimpleTypePattern01]:

  <ex:unsignedIntSimpleTypePattern>123</ex:unsignedIntSimpleTypePattern>

as is the following element when included in an instance document [UnsignedIntSimpleTypePattern02]:

  <ex:unsignedIntSimpleTypePattern>009</ex:unsignedIntSimpleTypePattern>

2.14.13 UnsignedShortSimpleTypePattern

An [XML 1.0] document exhibits the UnsignedShortSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/UnsignedShortSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:unsignedShort')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

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

<xs:element name="unsignedShortSimpleTypePattern" type="ex:UnsignedShortSimpleTypePattern" />
<xs:simpleType name="UnsignedShortSimpleTypePattern">
  <xs:restrictionbase="xs:unsignedShort">
    <xs:patternvalue="\d{3}" />
  </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 [UnsignedShortSimpleTypePattern01]:

  <ex:unsignedShortSimpleTypePattern>123</ex:unsignedShortSimpleTypePattern>

as is the following element when included in an instance document [UnsignedShortSimpleTypePattern02]:

  <ex:unsignedShortSimpleTypePattern>009</ex:unsignedShortSimpleTypePattern>

2.14.14 DateSimpleTypePattern

An [XML 1.0] document exhibits the DateSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/DateSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:date')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

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

<xs:element name="dateSimpleTypePattern" type="ex:DateSimpleTypePattern" />
<xs:simpleType name="DateSimpleTypePattern">
  <xs:restrictionbase="xs:date">
    <xs:patternvalue="[^\-]{4}\-[^\-]{2}\-[^\-]{2}" />
  </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 [DateSimpleTypePattern01]:

  <ex:dateSimpleTypePattern>2006-12-18</ex:dateSimpleTypePattern>

as is the following element when included in an instance document [DateSimpleTypePattern02]:

  <ex:dateSimpleTypePattern>2007-01-01</ex:dateSimpleTypePattern>

2.14.15 GYearSimpleTypePattern

An [XML 1.0] document exhibits the GYearSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GYearSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:gYear')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

2.14.16 GMonthSimpleTypePattern

An [XML 1.0] document exhibits the GMonthSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GMonthSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:gMonth')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

2.14.17 GDaySimpleTypePattern

An [XML 1.0] document exhibits the GDaySimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GDaySimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:gDay')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

2.14.18 GYearMonthSimpleTypePattern

An [XML 1.0] document exhibits the GYearMonthSimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GYearMonthSimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:gYearMonth')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

2.14.19 GMonthDaySimpleTypePattern

An [XML 1.0] document exhibits the GMonthDaySimpleTypePattern pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/GMonthDaySimpleTypePattern 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:

.//xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:gMonthDay')]/xs:pattern[@value]/ (.., ../@base, .,
@value)

2.14.20 RestrictedStringMinLength

An [XML 1.0] document exhibits the RestrictedStringMinLength pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/RestrictedStringMinLength 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:string')]/xs:minLength[@value]/ (.., ../@base, .,
@value)

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

<xs:element name="restrictedStringMinLength" type="ex:RestrictedStringMinLength" />
<xs:simpleType name="RestrictedStringMinLength">
  <xs:restrictionbase="xs:string">
    <xs:minLengthvalue="1" />
  </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 [RestrictedStringMinLength01]:

  <ex:restrictedStringMinLength>String Value</ex:restrictedStringMinLength>

2.14.21 RestrictedStringMaxLength

An [XML 1.0] document exhibits the RestrictedStringMaxLength pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/RestrictedStringMaxLength 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:string')]/xs:maxLength[@value]/ (.., ../@base, .,
@value)

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

<xs:element name="restrictedStringMaxLength" type="ex:RestrictedStringMaxLength" />
<xs:simpleType name="RestrictedStringMaxLength">
  <xs:restrictionbase="xs:string">
    <xs:maxLengthvalue="12" />
  </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 [RestrictedStringMaxLength01]:

  <ex:restrictedStringMaxLength>String Value</ex:restrictedStringMaxLength>

2.14.22 RestrictedStringMinMaxLength

An [XML 1.0] document exhibits the RestrictedStringMinMaxLength pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/RestrictedStringMinMaxLength 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:

.//xs:simpleType/xs:restriction[@base/resolve-QName(.,..) =
xs:QName('xs:string') and xs:minLength/@value and
xs:maxLength/@value]/ (., @base, xs:minLength/(., @value),
xs:maxLength/(., @value))

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

<xs:element name="restrictedStringMinMaxLength" type="ex:RestrictedStringMinMaxLength" />
<xs:simpleType name="RestrictedStringMinMaxLength">
  <xs:restrictionbase="xs:string">
    <xs:minLengthvalue="12" />
    <xs:maxLengthvalue="15" />
  </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 [RestrictedStringMinMaxLength01]:

  <ex:restrictedStringMinMaxLength>String Value 2</ex:restrictedStringMinMaxLength>

2.14.23 RestrictedMinInclusive

An [XML 1.0] document exhibits the RestrictedMinInclusive pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/RestrictedMinInclusive 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:

.//xs:simpleType/xs:restriction/xs:minInclusive[@value]/(..,
../@base, ., @value)

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

<xs:element name="restrictedMinInclusive" type="ex:RestrictedMinInclusive" />
<xs:simpleType name="RestrictedMinInclusive">
  <xs:restrictionbase="xs:integer">
    <xs:minInclusivevalue="1" />
  </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 [RestrictedMinInclusive01]:

  <ex:restrictedMinInclusive>1</ex:restrictedMinInclusive>

as is the following element when included in an instance document [RestrictedMinInclusive02]:

  <ex:restrictedMinInclusive>2</ex:restrictedMinInclusive>

2.14.24 RestrictedMaxInclusive

An [XML 1.0] document exhibits the RestrictedMaxInclusive pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/RestrictedMaxInclusive 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:

.//xs:simpleType/xs:restriction/xs:maxInclusive[@value]/(..,
../@base, ., @value)

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

<xs:element name="restrictedMaxInclusive" type="ex:RestrictedMaxInclusive" />
<xs:simpleType name="RestrictedMaxInclusive">
  <xs:restrictionbase="xs:integer">
    <xs:maxInclusivevalue="3" />
  </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 [RestrictedMaxInclusive01]:

  <ex:restrictedMaxInclusive>1</ex:restrictedMaxInclusive>

as is the following element when included in an instance document [RestrictedMaxInclusive02]:

  <ex:restrictedMaxInclusive>3</ex:restrictedMaxInclusive>

2.14.25 RestrictedMinExclusive

An [XML 1.0] document exhibits the RestrictedMinExclusive pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/RestrictedMinExclusive 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:

.//xs:simpleType/xs:restriction/xs:minExclusive[@value]/(..,
../@base, ., @value)

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

<xs:element name="restrictedMinExclusive" type="ex:RestrictedMinExclusive" />
<xs:simpleType name="RestrictedMinExclusive">
  <xs:restrictionbase="xs:integer">
    <xs:minExclusivevalue="1" />
  </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 [RestrictedMinExclusive01]:

  <ex:restrictedMinExclusive>2</ex:restrictedMinExclusive>

as is the following element when included in an instance document [RestrictedMinExclusive02]:

  <ex:restrictedMinExclusive>3</ex:restrictedMinExclusive>

2.14.26 RestrictedMaxExclusive

An [XML 1.0] document exhibits the RestrictedMaxExclusive pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/RestrictedMaxExclusive 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:

.//xs:simpleType/xs:restriction/xs:maxExclusive[@value]/(..,
../@base, ., @value)

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

<xs:element name="restrictedMaxExclusive" type="ex:RestrictedMaxExclusive" />
<xs:simpleType name="RestrictedMaxExclusive">
  <xs:restrictionbase="xs:integer">
    <xs:maxExclusivevalue="3" />
  </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 [RestrictedMaxExclusive01]:

  <ex:restrictedMaxExclusive>1</ex:restrictedMaxExclusive>

as is the following element when included in an instance document [RestrictedMaxExclusive02]:

  <ex:restrictedMaxExclusive>2</ex:restrictedMaxExclusive>

2.14.27 RestrictedLength

An [XML 1.0] document exhibits the RestrictedLength pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/RestrictedLength 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:

.//xs:simpleType/xs:restriction/xs:length[@value]/(..,
../@base, ., @value)

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

<xs:element name="restrictedLength" type="ex:RestrictedLength" />
<xs:simpleType name="RestrictedLength">
  <xs:restrictionbase="xs:language">
    <xs:lengthvalue="2" />
  </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 [RestrictedLength01]:

  <ex:restrictedLength>en</ex:restrictedLength>

as is the following element when included in an instance document [RestrictedLength02]:

  <ex:restrictedLength>FR</ex:restrictedLength>

2.14.28 RestrictedMaxLength

An [XML 1.0] document exhibits the RestrictedMaxLength pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/RestrictedMaxLength 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:

.//xs:simpleType/xs:restriction/xs:maxLength[@value]/(..,
../@base, ., @value)

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

<xs:element name="restrictedMaxLength" type="ex:RestrictedMaxLength" />
<xs:simpleType name="RestrictedMaxLength">
  <xs:restrictionbase="xs:string">
    <xs:maxLengthvalue="12" />
  </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 [RestrictedMaxLength01]:

  <ex:restrictedMaxLength>AUSTRALIA</ex:restrictedMaxLength>

as is the following element when included in an instance document [RestrictedMaxLength02]:

  <ex:restrictedMaxLength>N AMERICA</ex:restrictedMaxLength>

2.14.29 RestrictedMinLength

An [XML 1.0] document exhibits the RestrictedMinLength pattern identified using the URI [RFC 3986] http://www.w3.org/2002/ws/databinding/patterns/6/09/RestrictedMinLength 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:

.//xs:simpleType/xs:restriction/xs:minLength[@value]/(..,
../@base, ., @value)

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

<xs:element name="restrictedMinLength" type="ex:RestrictedMinLength" />
<xs:simpleType name="RestrictedMinLength">
  <xs:restrictionbase="xs:string">
    <xs:minLengthvalue="2" />
  </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 [RestrictedMinLength01]:

  <ex:restrictedMinLength>AUS</ex:restrictedMinLength>

as is the following element when included in an instance document [RestrictedMinLength02]:

  <ex:restrictedMinLength>GB</ex:restrictedMinLength>

3. Data Types & Structures

This section offers one or more patterns which may be used to represent an abstract data structure. Each data structure presented is intended to be independent of any particular programming language, database or modeling environment. No semantics are implied by the order in which patterns are listed for a given abstract data structure.

3.1 Default Value

Definition: A preselected value used by when no alternative is explicitly specified.
Patterns

3.2 Map

Editorial note: pdowney	2006-10-25
ISSUE-25: need to incorporate examples for Hash tables and maps

3.3 Extensible Enumeration

Editorial note: pdowney	2006-10-25
ISSUE-5: need to incorporate extensible enum examples

4. References

4.1 Normative References

[Basic Patterns]: XML Schema Patterns for Databinding 1.0, Jonathan Calladine, George Cowe, Paul Downey, Yves Lafon, Editors. World Wide Web Consortium, October, 2007. The latest version of Basic Patterns is available at http://www.w3.org/TR/xmlschema-patterns/. (See http://www.w3.org/TR/2007/WD-xmlschema-patterns-20071031/.)
[XML Schema 1.0]: Henry S. Thompson, David Beech, Murray Maloney, and Noah Mendelsohn, Editors. World Wide Web Consortium. XML Schema, Parts 0, 1, and 2 (Second Edition). W3C Recommendation, 28 October 2004. See http://www.w3.org/TR/xmlschema-0/, http://www.w3.org/TR/xmlschema-1/, and http://www.w3.org/TR/xmlschema-2/.
[XPath 2.0]: XML Path Language (XPath) 2.0, Don Chamberlin , Anders Berglund, Scott Boag, et. al., Editors. World Wide Web Consortium, 3 Nov 2005. The latest version is available at http://www.w3.org/TR/xpath20/. (See http://www.w3.org/TR/2006/CR-xpath20-20060608/.)
[XML Namespaces]: Namespaces in XML, T. Bray, D. Hollander, and A. Layman, Editors. World Wide Web Consortium, 14 January 1999. The latest version is available at http://www.w3.org/TR/REC-xml-names. (See http://www.w3.org/TR/1999/REC-xml-names-19990114.)
[XML 1.0]: World Wide Web Consortium. Extensible Markup Language (XML) 1.0. (Fourth Edition) W3C Recommendation, 16 August 2006. See http://www.w3.org/TR/REC-xml
[RFC 2119]: Key words for use in RFCs to Indicate Requirement Levels, S. Bradner, Editor. IETF, March 1997. (See http://www.ietf.org/rfc/rfc2119.txt.)
[RFC 3986]: Uniform Resource Identifiers (URI): Generic Syntax, T. Berners-Lee, R. Fielding, L. Masinter, Authors. Internet Engineering Task Force, January 2005. Available at http://www.ietf.org/rfc/rfc3986.txt. (See http://www.ietf.org/rfc/rfc3986.txt.)
[Unicode]: The Unicode Consortium. The Unicode Standard, Version 4.0. Reading, Mass.: Addison-Wesley, 2003, as updated from time to time by the publication of new versions. (See http://www.unicode.org/unicode/standard/versions for the latest version and additional information on versions of the standard and of the Unicode Character Database)

4.2 Informative References

[WSDL 2.0]: Web Services Description Language (WSDL) Version 2.0 Part 1: Core Language, R. Chinnici, J. J. Moreau, A. Ryman, S. Weerawarana, Editors. World Wide Web Consortium, 6 January 2006. The latest version is available at http://www.w3.org/TR/wsdl20. (See http://www.w3.org/TR/2006/CR-wsdl20-20060106/.)
[WSDL 1.1]: E. Christensen, et al, Web Services Description Language (WSDL) 1.1, March 2001. (See http://www.w3.org/TR/2001/NOTE-wsdl-20010315.)
[SOAP 1.2]: SOAP Version 1.2 Part 1: Messaging Framework, M. Gudgin, M. Hadley, N. Mendelsohn, J-J. Moreau, H. Frystyk Nielsen, Editors. World Wide Web Consortium, 24 June 2003. The latest version is available at http://www.w3.org/TR/soap12-part1/. (See http://www.w3.org/TR/2003/REC-soap12-part1-20030624/.)
[SOAP 1.1]: Simple Object Access Protocol (SOAP) 1.1, D. Box, D. Ehnebuske, G. Kakivaya, A. Layman, N. Mendelsohn, H Frystyk Nielsen, S. Thatte, D. Winer, Editors. W3C Member Submission, 8 May 2000. (See http://www.w3.org/TR/2000/NOTE-SOAP-20000508/.)
[XSLT 2.0]: XSL Transformations (XSLT) Version 2.0, M. Kay, Editor. World Wide Web Consortium, 8 June 2006. The latest version is available at http://www.w3.org/TR/xslt20. (See http://www.w3.org/TR/2006/CR-xslt20-20060608/.)
[WS-I Basic Profile 1.1]: WS-I Basic Profile 1.1, Web Services Interoperability Organization, April 2004 The latest version and errata is available from http://www.ws-i.org/Profiles/BasicProfile-1.1.html. (See http://www.ws-i.org/Profiles/BasicProfile-1.1-2004-08-24.html.)
[X.694]: Information technology - ASN.1 encoding rules: Mapping W3C XML schema definitions into ASN.1, International Telecommunications Union Recommendation. X.694 January 2004. (See http://www.itu.int/ITU-T/studygroups/com17/languages/X694.pdf.)
[Schematron]: ISO/IEC 19757-3:2006, Information technology - Document Schema Definition Languages (DSDL) - Part 3: Rule-based validation - International Standards Organization (JTC1/SC34) - Schematron. (See http://standards.iso.org/ittf/PubliclyAvailableStandards/c040833_ISO_IEC_19757-3_2006%28E%29.zip.)

Element	Patterns
xs:all	GlobalElementAll, ComplexTypeAll
xs:annotation	N/A
xs:any	ComplexTypeAnyAttribute, AnyAttributeStrict, AnyAttributeLax, AnyAttributeSkip, AnyAttributeOtherStrict, AnyAttributeOtherLax, AnyAttributeOtherSkip, ExtendedSequenceStrict, ExtendedSequenceLax, ExtendedSequenceSkip, ExtendedSequenceStrictAny, ExtendedSequenceLaxAny, ExtendedSequenceSkipAny, ExtendedSequenceStrictOther, ExtendedSequenceLaxOther, ExtendedSequenceSkipOther, AnyTypeElement, AnyTypeAttribute
xs:anyAttribute	ComplexTypeAnyAttribute, AnyAttributeStrict, AnyAttributeLax, AnyAttributeSkip, AnyAttributeOtherStrict, AnyAttributeOtherLax, AnyAttributeOtherSkip
xs:appinfo	N/A
xs:attribute	GlobalElementComplexTypeSequenceExtension, GlobalAttributeUnqualifiedType, AttributeElementNameClash, AttributeRequired, AttributeFixed, AttributeDefault, AttributeReferenceUnqualified, AttributeTypeReferenceUnqualified, LocalAttributeSimpleType, ExtendedSimpleContent, AnyTypeAttribute, DecimalAttribute, FloatAttribute, DurationAttribute, TimeAttribute, DateAttribute, GYearMonthAttribute, GYearAttribute, GMonthDayAttribute, GDayAttribute, GMonthAttribute, Base64BinaryAttribute, LanguageAttribute, NMTOKENAttribute, NMTOKENSAttribute, IDAttribute, IDREFAttribute, IDREFSAttribute, ENTITYAttribute, ENTITIESAttribute, IntegerAttribute, NonPositiveIntegerAttribute, NegativeIntegerAttribute, UnsignedLongAttribute, UnsignedIntAttribute, UnsignedShortAttribute, UnsignedByteAttribute
xs:attributeGroup	N/A
xs:choice	GlobalElementChoice, ComplexTypeChoice, ComplexTypeSequenceChoice
xs:complexContent	MixedComplexContent, GlobalElementComplexTypeSequenceExtension
xs:complexType	MixedContentType, GlobalElementAll, GlobalElementChoice, GlobalElementComplexTypeSequenceExtension, AttributeElementNameClash, ComplexTypeAll, ComplexTypeChoice, ComplexTypeAnyAttribute, AnyAttributeStrict, AnyAttributeLax, AnyAttributeSkip, AnyAttributeOtherStrict, AnyAttributeOtherLax, AnyAttributeOtherSkip, ExtendedSimpleContent, ComplexTypeSequenceChoice
xs:documentation	N/A
xs:element	MixedContentElement, GlobalElementUnqualifiedType, ElementTypeDefaultNamespace, GlobalElementAbstract, GlobalElementAll, GlobalElementChoice, GlobalElementComplexTypeSequenceExtension, ElementMinOccursFinite, ElementMaxOccursFinite, AttributeElementNameClash, NillableOptionalElement, ElementTypeReferenceUnqualified, ElementReferenceUnqualified, ElementDefault, ComplexTypeAll, ComplexTypeChoice, ComplexTypeSequenceChoice, AnyTypeElement, DecimalElement, FloatElement, DurationElement, TimeElement, DateElement, GYearMonthElement, GYearElement, GMonthDayElement, GDayElement, GMonthElement, LanguageElement, NMTOKENElement, NMTOKENSElement, IDElement, IDREFElement, IDREFSElement, ENTITYElement, ENTITIESElement, IntegerElement, NonPositiveIntegerElement, NegativeIntegerElement, NonNegativeIntegerElement, UnsignedLongElement, UnsignedIntElement, UnsignedShortElement, UnsignedByteElement
xs:enumeration	NMTOKENEnumerationType, IntEnumerationType, ShortEnumerationType, LongEnumerationType, DoubleEnumerationType, IntegerEnumerationType, DecimalEnumerationType, FloatEnumerationType, NonNegativeIntegerEnumerationType, PositiveIntegerEnumerationType, UnsignedIntEnumerationType, UnsignedLongEnumerationType, UnsignedShortEnumerationType, TokenEnumerationType, LanguageEnumerationType
xs:field	N/A
xs:fractionDigits	DecimalSimpleTypeFractionDigits
xs:group	N/A
xs:import	ImportSchemaNamespace
xs:include	N/A
xs:key	N/A
xs:keyref	N/A
xs:length	RestrictedLength
xs:list	List
xs:maxExclusive	RestrictedMaxExclusive
xs:maxInclusive	RestrictedMaxInclusive
xs:maxLength	RestrictedStringMaxLength, RestrictedStringMinMaxLength, RestrictedMaxLength
xs:minExclusive	RestrictedMinExclusive
xs:minInclusive	RestrictedMinInclusive
xs:minLength	RestrictedStringMinLength, RestrictedStringMinMaxLength, RestrictedMinLength
xs:notation	N/A
xs:pattern	StringSimpleTypePattern, IntSimpleTypePattern, IntegerSimpleTypePattern, LongSimpleTypePattern, DecimalSimpleTypePattern, FloatSimpleTypePattern, DoubleSimpleTypePattern, ShortSimpleTypePattern, NonNegativeIntegerSimpleTypePattern, PositiveIntegerSimpleTypePattern, UnsignedLongSimpleTypePattern, UnsignedIntSimpleTypePattern, UnsignedShortSimpleTypePattern, DateSimpleTypePattern, GYearSimpleTypePattern, GMonthSimpleTypePattern, GDaySimpleTypePattern, GYearMonthSimpleTypePattern, GMonthDaySimpleTypePattern
xs:redefine	N/A
xs:restriction	NMTOKENEnumerationType, IntEnumerationType, ShortEnumerationType, LongEnumerationType, DoubleEnumerationType, IntegerEnumerationType, DecimalEnumerationType, FloatEnumerationType, NonNegativeIntegerEnumerationType, PositiveIntegerEnumerationType, UnsignedIntEnumerationType, UnsignedLongEnumerationType, UnsignedShortEnumerationType, TokenEnumerationType, LanguageEnumerationType, DecimalSimpleTypeTotalDigits, DecimalSimpleTypeFractionDigits, StringSimpleTypePattern, IntSimpleTypePattern, IntegerSimpleTypePattern, LongSimpleTypePattern, DecimalSimpleTypePattern, FloatSimpleTypePattern, DoubleSimpleTypePattern, ShortSimpleTypePattern, NonNegativeIntegerSimpleTypePattern, PositiveIntegerSimpleTypePattern, UnsignedLongSimpleTypePattern, UnsignedIntSimpleTypePattern, UnsignedShortSimpleTypePattern, DateSimpleTypePattern, GYearSimpleTypePattern, GMonthSimpleTypePattern, GDaySimpleTypePattern, GYearMonthSimpleTypePattern, GMonthDaySimpleTypePattern, RestrictedStringMinLength, RestrictedStringMaxLength, RestrictedStringMinMaxLength, RestrictedMinInclusive, RestrictedMaxInclusive, RestrictedMinExclusive, RestrictedMaxExclusive, RestrictedLength, RestrictedMaxLength, RestrictedMinLength
xs:schema	LocalAttributeSimpleType
xs:selector	N/A
xs:sequence	GlobalElementComplexTypeSequenceExtension, AttributeElementNameClash, ComplexTypeSequenceChoice, SequenceMinOccurs0, SequenceMinOccurs0MaxOccursUnbounded, SequenceMinOccurs1MaxOccursUnbounded, SequenceMinOccursFinite, SequenceMaxOccursFinite, ExtendedSequenceStrict, ExtendedSequenceLax, ExtendedSequenceSkip, ExtendedSequenceStrictAny, ExtendedSequenceLaxAny, ExtendedSequenceSkipAny, ExtendedSequenceStrictOther, ExtendedSequenceLaxOther, ExtendedSequenceSkipOther
xs:simpleContent	ExtendedSimpleContent
xs:simpleType	LocalAttributeSimpleType, NMTOKENEnumerationType, IntEnumerationType, ShortEnumerationType, LongEnumerationType, DoubleEnumerationType, IntegerEnumerationType, DecimalEnumerationType, FloatEnumerationType, NonNegativeIntegerEnumerationType, PositiveIntegerEnumerationType, UnsignedIntEnumerationType, UnsignedLongEnumerationType, UnsignedShortEnumerationType, TokenEnumerationType, LanguageEnumerationType, DecimalSimpleTypeTotalDigits, DecimalSimpleTypeFractionDigits, UnionMemberTypes, UnionSimpleTypes, UnionSimpleAndMemberTypes, RestrictedStringMinLength, RestrictedStringMaxLength, RestrictedStringMinMaxLength, RestrictedMinInclusive, RestrictedMaxInclusive, RestrictedMinExclusive, RestrictedMaxExclusive, RestrictedLength, RestrictedMaxLength, RestrictedMinLength
xs:totalDigits	DecimalSimpleTypeTotalDigits
xs:union	UnionMemberTypes, UnionSimpleTypes, UnionSimpleAndMemberTypes
xs:unique	N/A
xs:whiteSpace	N/A

Attribute	Patterns
@abstract	GlobalElementAbstract
@attributeFormDefault	N/A
@base	GlobalElementComplexTypeSequenceExtension, NMTOKENEnumerationType, IntEnumerationType, ShortEnumerationType, LongEnumerationType, DoubleEnumerationType, IntegerEnumerationType, DecimalEnumerationType, FloatEnumerationType, NonNegativeIntegerEnumerationType, PositiveIntegerEnumerationType, UnsignedIntEnumerationType, UnsignedLongEnumerationType, UnsignedShortEnumerationType, TokenEnumerationType, LanguageEnumerationType, DecimalSimpleTypeTotalDigits, DecimalSimpleTypeFractionDigits, ExtendedSimpleContent, StringSimpleTypePattern, IntSimpleTypePattern, IntegerSimpleTypePattern, LongSimpleTypePattern, DecimalSimpleTypePattern, FloatSimpleTypePattern, DoubleSimpleTypePattern, ShortSimpleTypePattern, NonNegativeIntegerSimpleTypePattern, PositiveIntegerSimpleTypePattern, UnsignedLongSimpleTypePattern, UnsignedIntSimpleTypePattern, UnsignedShortSimpleTypePattern, DateSimpleTypePattern, GYearSimpleTypePattern, GMonthSimpleTypePattern, GDaySimpleTypePattern, GYearMonthSimpleTypePattern, GMonthDaySimpleTypePattern, RestrictedStringMinLength, RestrictedStringMaxLength, RestrictedStringMinMaxLength, RestrictedMinInclusive, RestrictedMaxInclusive, RestrictedMinExclusive, RestrictedMaxExclusive, RestrictedLength, RestrictedMaxLength, RestrictedMinLength
@block	N/A
@blockDefault	N/A
@default	ElementDefault, AttributeDefault
@elementFormDefault	N/A
@final	N/A
@finalDefault	N/A
@fixed	AttributeFixed
@form	N/A
@id	N/A
@itemType	List
@maxOccurs	ElementMinOccursFinite, ElementMaxOccursFinite, SequenceMinOccurs0, SequenceMinOccurs0MaxOccursUnbounded, SequenceMinOccurs1MaxOccursUnbounded, SequenceMinOccursFinite, SequenceMaxOccursFinite, ExtendedSequenceStrict, ExtendedSequenceLax, ExtendedSequenceSkip, ExtendedSequenceStrictAny, ExtendedSequenceLaxAny, ExtendedSequenceSkipAny, ExtendedSequenceStrictOther, ExtendedSequenceLaxOther, ExtendedSequenceSkipOther
@memberTypes	UnionMemberTypes, UnionSimpleTypes, UnionSimpleAndMemberTypes
@minOccurs	ElementMinOccursFinite, NillableOptionalElement, SequenceMinOccurs0, SequenceMinOccurs0MaxOccursUnbounded, SequenceMinOccurs1MaxOccursUnbounded, SequenceMinOccursFinite, ExtendedSequenceStrict, ExtendedSequenceLax, ExtendedSequenceSkip, ExtendedSequenceStrictAny, ExtendedSequenceLaxAny, ExtendedSequenceSkipAny, ExtendedSequenceStrictOther, ExtendedSequenceLaxOther, ExtendedSequenceSkipOther
@mixed	MixedContentElement, MixedComplexContent, MixedContentType
@name	ImportSchemaNamespace, GlobalElementUnqualifiedType, ElementTypeDefaultNamespace, GlobalElementAll, GlobalElementChoice, GlobalElementComplexTypeSequenceExtension, GlobalAttributeUnqualifiedType, AttributeElementNameClash, ElementTypeReferenceUnqualified, AttributeTypeReferenceUnqualified, ComplexTypeAll, ComplexTypeChoice, AnyAttributeStrict, AnyAttributeLax, AnyAttributeSkip, AnyAttributeOtherStrict, AnyAttributeOtherLax, AnyAttributeOtherSkip, ExtendedSimpleContent, ComplexTypeSequenceChoice, ExtendedSequenceStrict, ExtendedSequenceLax, ExtendedSequenceSkip, ExtendedSequenceStrictAny, ExtendedSequenceLaxAny, ExtendedSequenceSkipAny, ExtendedSequenceStrictOther, ExtendedSequenceLaxOther, ExtendedSequenceSkipOther
@namespace	ImportSchemaNamespace, AnyAttributeStrict, AnyAttributeLax, AnyAttributeSkip, AnyAttributeOtherStrict, AnyAttributeOtherLax, AnyAttributeOtherSkip, ExtendedSequenceStrict, ExtendedSequenceLax, ExtendedSequenceSkip, ExtendedSequenceStrictAny, ExtendedSequenceLaxAny, ExtendedSequenceSkipAny, ExtendedSequenceStrictOther, ExtendedSequenceLaxOther, ExtendedSequenceSkipOther
@nillable	NillableOptionalElement
@processContents	AnyAttributeStrict, AnyAttributeLax, AnyAttributeSkip, AnyAttributeOtherStrict, AnyAttributeOtherLax, AnyAttributeOtherSkip, ExtendedSequenceStrict, ExtendedSequenceLax, ExtendedSequenceSkip, ExtendedSequenceStrictAny, ExtendedSequenceLaxAny, ExtendedSequenceSkipAny, ExtendedSequenceStrictOther, ExtendedSequenceLaxOther, ExtendedSequenceSkipOther
@public	N/A
@ref	ElementReferenceUnqualified, AttributeReferenceUnqualified
@refer	N/A
@schemaLocation	ImportSchemaNamespace
@source	N/A
@substitutionGroup	N/A
@system	N/A
@targetNamespace	N/A
@type	GlobalElementUnqualifiedType, ElementTypeDefaultNamespace, GlobalAttributeUnqualifiedType, ElementTypeReferenceUnqualified, AttributeTypeReferenceUnqualified, AnyTypeElement, DecimalElement, FloatElement, DurationElement, TimeElement, DateElement, GYearMonthElement, GYearElement, GMonthDayElement, GDayElement, GMonthElement, LanguageElement, NMTOKENElement, NMTOKENSElement, IDElement, IDREFElement, IDREFSElement, ENTITYElement, ENTITIESElement, IntegerElement, NonPositiveIntegerElement, NegativeIntegerElement, NonNegativeIntegerElement, UnsignedLongElement, UnsignedIntElement, UnsignedShortElement, UnsignedByteElement, AnyTypeAttribute, DecimalAttribute, FloatAttribute, DurationAttribute, TimeAttribute, DateAttribute, GYearMonthAttribute, GYearAttribute, GMonthDayAttribute, GDayAttribute, GMonthAttribute, Base64BinaryAttribute, LanguageAttribute, NMTOKENAttribute, NMTOKENSAttribute, IDAttribute, IDREFAttribute, IDREFSAttribute, ENTITYAttribute, ENTITIESAttribute, IntegerAttribute, NonPositiveIntegerAttribute, NegativeIntegerAttribute, UnsignedLongAttribute, UnsignedIntAttribute, UnsignedShortAttribute, UnsignedByteAttribute
@use	AttributeRequired
@value	NMTOKENEnumerationType, IntEnumerationType, ShortEnumerationType, LongEnumerationType, DoubleEnumerationType, IntegerEnumerationType, DecimalEnumerationType, FloatEnumerationType, NonNegativeIntegerEnumerationType, PositiveIntegerEnumerationType, UnsignedIntEnumerationType, UnsignedLongEnumerationType, UnsignedShortEnumerationType, TokenEnumerationType, LanguageEnumerationType, DecimalSimpleTypeTotalDigits, DecimalSimpleTypeFractionDigits, StringSimpleTypePattern, IntSimpleTypePattern, IntegerSimpleTypePattern, LongSimpleTypePattern, DecimalSimpleTypePattern, FloatSimpleTypePattern, DoubleSimpleTypePattern, ShortSimpleTypePattern, NonNegativeIntegerSimpleTypePattern, PositiveIntegerSimpleTypePattern, UnsignedLongSimpleTypePattern, UnsignedIntSimpleTypePattern, UnsignedShortSimpleTypePattern, DateSimpleTypePattern, GYearSimpleTypePattern, GMonthSimpleTypePattern, GDaySimpleTypePattern, GYearMonthSimpleTypePattern, GMonthDaySimpleTypePattern, RestrictedStringMinLength, RestrictedStringMaxLength, RestrictedStringMinMaxLength, RestrictedMinInclusive, RestrictedMaxInclusive, RestrictedMinExclusive, RestrictedMaxExclusive, RestrictedLength, RestrictedMaxLength, RestrictedMinLength
@version	N/A
@xpath	N/A

Simple Type	Patterns
xs:ENTITIES	ENTITIESElement, ENTITIESAttribute
xs:ENTITY	ENTITYElement, ENTITYAttribute
xs:ID	IDElement, IDAttribute
xs:IDREF	IDREFElement, IDREFAttribute
xs:IDREFS	IDREFSElement, IDREFSAttribute
xs:NCName	N/A
xs:NMTOKEN	NMTOKENEnumerationType, NMTOKENElement, NMTOKENAttribute
xs:NMTOKENS	NMTOKENSElement, NMTOKENSAttribute
xs:NOTATION	N/A
xs:Name	N/A
xs:QName	N/A
xs:anyURI	N/A
xs:base64Binary	Base64BinaryAttribute
xs:boolean	N/A
xs:byte	N/A
xs:date	DateElement, DateAttribute, DateSimpleTypePattern
xs:dateTime	N/A
xs:decimal	DecimalEnumerationType, DecimalSimpleTypeTotalDigits, DecimalSimpleTypeFractionDigits, DecimalElement, DecimalAttribute, DecimalSimpleTypePattern
xs:double	DoubleEnumerationType, DoubleSimpleTypePattern
xs:duration	DurationElement, DurationAttribute
xs:float	FloatEnumerationType, FloatElement, FloatAttribute, FloatSimpleTypePattern
xs:gDay	GDayElement, GDayAttribute, GDaySimpleTypePattern
xs:gMonth	GMonthElement, GMonthAttribute, GMonthSimpleTypePattern
xs:gMonthDay	GMonthDayElement, GMonthDayAttribute, GMonthDaySimpleTypePattern
xs:gYear	GYearElement, GYearAttribute, GYearSimpleTypePattern
xs:gYearMonth	GYearMonthElement, GYearMonthAttribute, GYearMonthSimpleTypePattern
xs:hexBinary	N/A
xs:int	IntEnumerationType, IntSimpleTypePattern
xs:integer	IntegerEnumerationType, IntegerElement, IntegerAttribute, IntegerSimpleTypePattern
xs:language	LanguageEnumerationType, LanguageElement, LanguageAttribute
xs:long	LongEnumerationType, LongSimpleTypePattern
xs:negativeInteger	NegativeIntegerElement, NegativeIntegerAttribute
xs:nonNegativeInteger	NonNegativeIntegerEnumerationType, NonNegativeIntegerElement, NonNegativeIntegerSimpleTypePattern
xs:nonPositiveInteger	NonPositiveIntegerElement, NonPositiveIntegerAttribute
xs:normalizedString	N/A
xs:positiveInteger	PositiveIntegerEnumerationType, PositiveIntegerSimpleTypePattern
xs:short	ShortEnumerationType, ShortSimpleTypePattern
xs:string	StringSimpleTypePattern, RestrictedStringMinLength, RestrictedStringMaxLength, RestrictedStringMinMaxLength
xs:time	TimeElement, TimeAttribute
xs:token	TokenEnumerationType
xs:unsignedByte	UnsignedByteElement, UnsignedByteAttribute
xs:unsignedInt	UnsignedIntEnumerationType, UnsignedIntElement, UnsignedIntAttribute, UnsignedIntSimpleTypePattern
xs:unsignedLong	UnsignedLongEnumerationType, UnsignedLongElement, UnsignedLongAttribute, UnsignedLongSimpleTypePattern
xs:unsignedShort	UnsignedShortEnumerationType, UnsignedShortElement, UnsignedShortAttribute, UnsignedShortSimpleTypePattern

Id	Assertion
assert-BOM	MAY include the [Unicode] Byte Order Mark (BOM).
assert-BasicPatterns	MUST only contain [XML 1.0] element nodes and attribute nodes which form a part of one or more complete patterns contained in this and the [Basic Patterns] specifications.
assert-CommentsAndPIs	MAY contain additional [XML 1.0] comment nodes and processing instruction nodes.
assert-Unicode	MUST use either the UTF-8 or UTF-16 [Unicode] encoding.
assert-XML10	MUST be a Well-formed [XML 1.0] document
assert-XMLSchema10	MUST conform to the [XML Schema 1.0] Recommendation

Id	Assertion
assert-AnySchema	SHOULD be able to process any valid [XML Schema 1.0] Document.
assert-ConsumeInvalidAllowed	MAY consume Well-formed [XML 1.0] instance documents which do not satisfy local-schema validity against the originating [XML Schema 1.0] Document.
assert-ConsumeXML	MUST be able to consume any Well-formed [XML 1.0] Document which satisfies local-schema validity against the originating [XML Schema 1.0] Document exposing all of the [XML 1.0] element node and attribute node content in the data model.
assert-DataModel	MUST produce a data model exposing all of the [XML 1.0] element node and attribute node content described by the originating [XML Schema 1.0] Document.
assert-ProduceInvalidAllowed	MAY allow the production of Well-formed [XML 1.0] instance documents containing values exposed in the data model which do not satisfy local-schema validity against the originating [XML Schema 1.0] Document.
assert-ProduceXML	MUST be able to produce Well-formed [XML 1.0] instance documents which satisfy local-schema validity against the originating [XML Schema 1.0] Document containing values exposed in the data model.
assert-SchemaValid	MUST be able to process any [XML Schema 1.0] Document conforming to this specification