XML Schema Documentation

Table of Contents

top

Schema Document Properties

Target Namespace http://www.w3.org/2001/XMLSchema
Version 1.0
Language EN
Element and Attribute Namespaces
  • Global element and attribute declarations belong to this schema's target namespace.
  • By default, local element declarations belong to this schema's target namespace.
  • By default, local attribute declarations have no namespace.
Schema Composition
  • This schema imports schema(s) from the following namespace(s):
    • http://www.w3.org/XML/1998/namespace (at http://www.w3.org/2001/xml.xsd)
Documentation Part 1 version: Id: XMLSchema.xsd,v 1.50 2002/05/22 09:24:24 ht Exp Part 2 version: Id: datatypes.xsd,v 1.54 2002/05/27 22:22:50 ht Exp

The schema corresponding to this document is normative, with respect to the syntactic constraints it expresses in the XML Schema language. The documentation (within <documentation> elements) below, is not normative, but rather highlights important aspects of the W3C Recommendation of which this is a part
More information at: http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/structures.html.

The simpleType element and all of its members are defined towards the end of this schema document

simple type for the value of the 'namespace' attr of 'any' and 'anyAttribute'

Value is ##any - - any non-conflicting WFXML/attribute at all ##other - - any non-conflicting WFXML/attribute from namespace other than targetNS ##local - - any unqualified non-conflicting WFXML/attribute one or - - any non-conflicting WFXML/attribute from more URI the listed namespaces references (space separated) ##targetNamespace or ##local may appear in the above list, to refer to the targetNamespace of the enclosing schema or an absent targetNamespace respectively

notations for use within XML Schema schemas

First the built-in primitive datatypes. These definitions are for information only, the real built-in definitions are magic. Note in particular that there is no type named 'anySimpleType'. The primitives should really be derived from no type at all, and anySimpleType should be derived as a union of all the primitives.

For each built-in datatype in this schema (both primitive and derived) can be uniquely addressed via a URI constructed as follows: 1) the base URI is the URI of the XML Schema namespace 2) the fragment identifier is the name of the datatype For example, to address the int datatype, the URI is: http://www.w3.org/2001/XMLSchema#int Additionally, each facet definition element can be uniquely addressed via a URI constructed as follows: 1) the base URI is the URI of the XML Schema namespace 2) the fragment identifier is the name of the facet For example, to address the maxInclusive facet, the URI is: http://www.w3.org/2001/XMLSchema#maxInclusive Additionally, each facet usage in a built-in datatype definition can be uniquely addressed via a URI constructed as follows: 1) the base URI is the URI of the XML Schema namespace 2) the fragment identifier is the name of the datatype, followed by a period (".") followed by the name of the facet For example, to address the usage of the maxInclusive facet in the definition of int, the URI is: http://www.w3.org/2001/XMLSchema#int.maxInclusive

Now the derived primitive types

Declared Namespaces

Prefix Namespace
xml http://www.w3.org/XML/1998/namespace
hfp http://www.w3.org/2001/XMLSchema-hasFacetAndProperty
xs http://www.w3.org/2001/XMLSchema
Schema Component Representation
<xs:schema xml:lang="EN" targetNamespace="http://www.w3.org/2001/XMLSchema" blockDefault="#all" elementFormDefault="qualified" version="1.0">
<xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="http://www.w3.org/2001/xml.xsd"/>
...
</xs:schema>
top

Global Declarations

Element: all

Name all
Type xs:all
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-all.
XML Instance Representation
<xs:all
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).

minOccurs="xs:nonNegativeInteger (value comes from list: {'0'|'1'}) [0..1]"
maxOccurs="xs:allNNI (value comes from list: {'1'}) [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..*] ?
<xs:element
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [0..1]"
ref="xs:QName [0..1]"
type="xs:QName [0..1]"
default="xs:string [0..1]"
fixed="xs:string [0..1]"
nillable="xs:boolean [0..1]"
block="xs:blockSet [0..1]"
form="xs:formChoice [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).

minOccurs="xs:nonNegativeInteger (value comes from list: {'0'|'1'}) [0..1]"
maxOccurs="xs:allNNI (value comes from list: {'0'|'1'}) [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
> [1]
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [1]
<xs:complexType> xs:localComplexType </xs:complexType> [1]
End Choice
Start Group: xs:identityConstraint [0..*]
Start Choice [1]
<xs:unique> ... </xs:unique> [1]
<xs:key> ... </xs:key> [1]
<xs:keyref> ... </xs:keyref> [1]
End Choice
End Group: xs:identityConstraint
</xs:element>
End Choice
</xs:all>
Schema Component Representation
<xs:element name="all" type="xs:all" id="all"/>
top

Element: annotation

Name annotation
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-annotation.
XML Instance Representation
<xs:annotation
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]">
Start Choice [0..*]
<xs:appinfo> ... </xs:appinfo> [1]
<xs:documentation> ... </xs:documentation> [1]
End Choice
</xs:annotation>
Schema Component Representation
<xs:element name="annotation" id="annotation">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:openAttrs">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="xs:appinfo"/>
<xs:element ref="xs:documentation"/>
</xs:choice>
<xs:attribute name="id" type="xs:ID"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: any

Name any
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-any.
XML Instance Representation
<xs:any
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
namespace="xs:namespaceList [0..1]"
processContents="xs:NMTOKEN (value comes from list: {'skip'|'lax'|'strict'}) [0..1]"
minOccurs="xs:nonNegativeInteger [0..1]"
maxOccurs="xs:allNNI [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
</xs:any>
Schema Component Representation
<xs:element name="any" id="any">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:wildcard">
<xs:attributeGroup ref="xs:occurs"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: anyAttribute

Name anyAttribute
Type xs:wildcard
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-anyAttribute.
XML Instance Representation
<xs:anyAttribute
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
namespace="xs:namespaceList [0..1]"
processContents="xs:NMTOKEN (value comes from list: {'skip'|'lax'|'strict'}) [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
</xs:anyAttribute>
Schema Component Representation
<xs:element name="anyAttribute" type="xs:wildcard" id="anyAttribute"/>
top

Element: appinfo

Name appinfo
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-appinfo.
XML Instance Representation
<xs:appinfo
source="xs:anyURI [0..1]">
<!-- Mixed content -->
Start Sequence [0..*]
Allow any elements from any namespace (lax validation). [1]
End Sequence
</xs:appinfo>
Schema Component Representation
<xs:element name="appinfo" id="appinfo">
<xs:complexType mixed="true">
<xs:sequence minOccurs="0" maxOccurs="unbounded">
<xs:any processContents="lax"/>
</xs:sequence>
<xs:attribute name="source" type="xs:anyURI"/>
</xs:complexType>
</xs:element>
top

Element: attribute

Name attribute
Type xs:topLevelAttribute
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-attribute.
XML Instance Representation
<xs:attribute
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
type="xs:QName [0..1]"
default="xs:string [0..1]"
fixed="xs:string [0..1]"
name="xs:NCName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [0..1]
</xs:attribute>
Schema Component Representation
<xs:element name="attribute" type="xs:topLevelAttribute" id="attribute"/>
top

Element: attributeGroup

Name attributeGroup
Type xs:namedAttributeGroup
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-attributeGroup.
XML Instance Representation
<xs:attributeGroup
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..*]
<xs:attribute> xs:attribute </xs:attribute> [1]
<xs:attributeGroup> xs:attributeGroupRef </xs:attributeGroup> [1]
End Choice
<xs:anyAttribute> ... </xs:anyAttribute> [0..1]
</xs:attributeGroup>
Schema Component Representation
<xs:element name="attributeGroup" type="xs:namedAttributeGroup" id="attributeGroup"/>
top

Element: choice

Name choice
Type xs:explicitGroup
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-choice.
XML Instance Representation
<xs:choice
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
minOccurs="xs:nonNegativeInteger [0..1]"
maxOccurs="xs:allNNI [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Group: xs:nestedParticle [0..*]
Start Choice [1]
<xs:element> xs:localElement </xs:element> [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
<xs:any> ... </xs:any> [1]
End Choice
End Group: xs:nestedParticle
</xs:choice>
Schema Component Representation
<xs:element name="choice" type="xs:explicitGroup" id="choice"/>
top

Element: complexContent

Name complexContent
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-complexContent.
XML Instance Representation
<xs:complexContent
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
mixed="xs:boolean [0..1] ?">
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [1]
<xs:restriction> xs:complexRestrictionType </xs:restriction> [1]
<xs:extension> xs:extensionType </xs:extension> [1]
End Choice
</xs:complexContent>
Schema Component Representation
<xs:element name="complexContent" id="complexContent">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:choice>
<xs:element name="restriction" type="xs:complexRestrictionType"/>
<xs:element name="extension" type="xs:extensionType"/>
</xs:choice>
<xs:attribute name="mixed" type="xs:boolean"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: complexType

Name complexType
Type xs:topLevelComplexType
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-complexType.
XML Instance Representation
<xs:complexType
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
mixed="xs:boolean [0..1] ?"
abstract="xs:boolean [0..1]"
final="xs:derivationSet [0..1]"
block="xs:derivationSet [0..1]"
name="xs:NCName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [1]
<xs:simpleContent> ... </xs:simpleContent> [1]
<xs:complexContent> ... </xs:complexContent> [1]
Start Group: xs:typeDefParticle [0..1]
Start Choice [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:all> ... </xs:all> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
End Choice
End Group: xs:typeDefParticle
Start Choice [0..*]
<xs:attribute> xs:attribute </xs:attribute> [1]
<xs:attributeGroup> xs:attributeGroupRef </xs:attributeGroup> [1]
End Choice
<xs:anyAttribute> ... </xs:anyAttribute> [0..1]
End Choice
</xs:complexType>
Schema Component Representation
<xs:element name="complexType" type="xs:topLevelComplexType" id="complexType"/>
top

Element: documentation

Name documentation
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-documentation.
XML Instance Representation
<xs:documentation
source="xs:anyURI [0..1]"
xml:lang="[0..1]">
<!-- Mixed content -->
Start Sequence [0..*]
Allow any elements from any namespace (lax validation). [1]
End Sequence
</xs:documentation>
Schema Component Representation
<xs:element name="documentation" id="documentation">
<xs:complexType mixed="true">
<xs:sequence minOccurs="0" maxOccurs="unbounded">
<xs:any processContents="lax"/>
</xs:sequence>
<xs:attribute name="source" type="xs:anyURI"/>
<xs:attribute ref="xml:lang"/>
</xs:complexType>
</xs:element>
top

Element: element

Name element
Type xs:topLevelElement
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-element.
XML Instance Representation
<xs:element
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
type="xs:QName [0..1]"
substitutionGroup="xs:QName [0..1]"
default="xs:string [0..1]"
fixed="xs:string [0..1]"
nillable="xs:boolean [0..1]"
abstract="xs:boolean [0..1]"
final="xs:derivationSet [0..1]"
block="xs:blockSet [0..1]"
name="xs:NCName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [1]
<xs:complexType> xs:localComplexType </xs:complexType> [1]
End Choice
Start Group: xs:identityConstraint [0..*]
Start Choice [1]
<xs:unique> ... </xs:unique> [1]
<xs:key> ... </xs:key> [1]
<xs:keyref> ... </xs:keyref> [1]
End Choice
End Group: xs:identityConstraint
</xs:element>
Schema Component Representation
<xs:element name="element" type="xs:topLevelElement" id="element"/>
top

Element: enumeration

Name enumeration
Type xs:noFixedFacet
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#element-enumeration.
XML Instance Representation
<xs:enumeration
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
value="anySimpleType [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
</xs:enumeration>
Schema Component Representation
<xs:element name="enumeration" type="xs:noFixedFacet" id="enumeration"/>
top

Element: field

Name field
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-field.
XML Instance Representation
<xs:field
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
xpath="xs:token (pattern = (\.//)?((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)/)*((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)|((attribute::|@)((\i\c*:)?(\i\c*|\*))))(\|(\.//)?((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)/)*((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)|((attribute::|@)((\i\c*:)?(\i\c*|\*)))))*) [1]">
<xs:annotation> ... </xs:annotation> [0..1]
</xs:field>
Schema Component Representation
<xs:element name="field" id="field">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:attribute name="xpath" use="required">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:pattern value="(\.//)?((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)/)*((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)|((attribute::|@)((\i\c*:)?(\i\c*|\*))))(\|(\.//)?((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)/)*((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)|((attribute::|@)((\i\c*:)?(\i\c*|\*)))))*"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: fractionDigits

Name fractionDigits
Type xs:numFacet
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#element-fractionDigits.
XML Instance Representation
<xs:fractionDigits
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
fixed="xs:boolean [0..1]"
value="xs:nonNegativeInteger [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
</xs:fractionDigits>
Schema Component Representation
<xs:element name="fractionDigits" type="xs:numFacet" id="fractionDigits"/>
top

Element: group

Name group
Type xs:namedGroup
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-group.
XML Instance Representation
<xs:group
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).

name="xs:NCName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [1]
<xs:all
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).
> [1]
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..*] ?
<xs:element
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [0..1]"
ref="xs:QName [0..1]"
type="xs:QName [0..1]"
default="xs:string [0..1]"
fixed="xs:string [0..1]"
nillable="xs:boolean [0..1]"
block="xs:blockSet [0..1]"
form="xs:formChoice [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).

minOccurs="xs:nonNegativeInteger (value comes from list: {'0'|'1'}) [0..1]"
maxOccurs="xs:allNNI (value comes from list: {'0'|'1'}) [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
> [1]
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [1]
<xs:complexType> xs:localComplexType </xs:complexType> [1]
End Choice
Start Group: xs:identityConstraint [0..*]
Start Choice [1]
<xs:unique> ... </xs:unique> [1]
<xs:key> ... </xs:key> [1]
<xs:keyref> ... </xs:keyref> [1]
End Choice
End Group: xs:identityConstraint
</xs:element>
End Choice
</xs:all>
<xs:choice> xs:simpleExplicitGroup </xs:choice> [1]
<xs:sequence> xs:simpleExplicitGroup </xs:sequence> [1]
End Choice
</xs:group>
Schema Component Representation
<xs:element name="group" type="xs:namedGroup" id="group"/>
top

Element: import

Name import
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-import.
XML Instance Representation
<xs:import
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
namespace="xs:anyURI [0..1]"
schemaLocation="xs:anyURI [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
</xs:import>
Schema Component Representation
<xs:element name="import" id="import">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:attribute name="namespace" type="xs:anyURI"/>
<xs:attribute name="schemaLocation" type="xs:anyURI"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: include

Name include
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-include.
XML Instance Representation
<xs:include
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
schemaLocation="xs:anyURI [1]">
<xs:annotation> ... </xs:annotation> [0..1]
</xs:include>
Schema Component Representation
<xs:element name="include" id="include">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:attribute name="schemaLocation" type="xs:anyURI" use="required"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: key

Name key
Type xs:keybase
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-key.
XML Instance Representation
<xs:key
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [1]">
<xs:annotation> ... </xs:annotation> [0..1]
<xs:selector> ... </xs:selector> [1]
<xs:field> ... </xs:field> [1..*]
</xs:key>
Schema Component Representation
<xs:element name="key" type="xs:keybase" id="key"/>
top

Element: keyref

Name keyref
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-keyref.
XML Instance Representation
<xs:keyref
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [1]"
refer="xs:QName [1]">
<xs:annotation> ... </xs:annotation> [0..1]
<xs:selector> ... </xs:selector> [1]
<xs:field> ... </xs:field> [1..*]
</xs:keyref>
Schema Component Representation
<xs:element name="keyref" id="keyref">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:keybase">
<xs:attribute name="refer" type="xs:QName" use="required"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: length

Name length
Type xs:numFacet
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#element-length.
XML Instance Representation
<xs:length
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
fixed="xs:boolean [0..1]"
value="xs:nonNegativeInteger [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
</xs:length>
Schema Component Representation
<xs:element name="length" type="xs:numFacet" id="length"/>
top

Element: list

Name list
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
XML Instance Representation
<xs:list
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
itemType="xs:QName [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [0..1]
</xs:list>
Schema Component Representation
<xs:element name="list" id="list">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:sequence>
<xs:element name="simpleType" type="xs:localSimpleType" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="itemType" type="xs:QName" use="optional"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: maxExclusive

Name maxExclusive
Type xs:facet
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#element-maxExclusive.
XML Instance Representation
<xs:maxExclusive
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
value="anySimpleType [1]"
fixed="xs:boolean [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
</xs:maxExclusive>
Schema Component Representation
<xs:element name="maxExclusive" type="xs:facet" id="maxExclusive"/>
top

Element: maxInclusive

Name maxInclusive
Type xs:facet
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#element-maxInclusive.
XML Instance Representation
<xs:maxInclusive
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
value="anySimpleType [1]"
fixed="xs:boolean [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
</xs:maxInclusive>
Schema Component Representation
<xs:element name="maxInclusive" type="xs:facet" id="maxInclusive"/>
top

Element: maxLength

Name maxLength
Type xs:numFacet
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#element-maxLength.
XML Instance Representation
<xs:maxLength
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
fixed="xs:boolean [0..1]"
value="xs:nonNegativeInteger [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
</xs:maxLength>
Schema Component Representation
<xs:element name="maxLength" type="xs:numFacet" id="maxLength"/>
top

Element: minExclusive

Name minExclusive
Type xs:facet
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#element-minExclusive.
XML Instance Representation
<xs:minExclusive
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
value="anySimpleType [1]"
fixed="xs:boolean [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
</xs:minExclusive>
Schema Component Representation
<xs:element name="minExclusive" type="xs:facet" id="minExclusive"/>
top

Element: minInclusive

Name minInclusive
Type xs:facet
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#element-minInclusive.
XML Instance Representation
<xs:minInclusive
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
value="anySimpleType [1]"
fixed="xs:boolean [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
</xs:minInclusive>
Schema Component Representation
<xs:element name="minInclusive" type="xs:facet" id="minInclusive"/>
top

Element: minLength

Name minLength
Type xs:numFacet
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#element-minLength.
XML Instance Representation
<xs:minLength
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
fixed="xs:boolean [0..1]"
value="xs:nonNegativeInteger [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
</xs:minLength>
Schema Component Representation
<xs:element name="minLength" type="xs:numFacet" id="minLength"/>
top

Element: notation

Name notation
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-notation.
XML Instance Representation
<xs:notation
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [1]"
public="xs:public [1]"
system="xs:anyURI [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
</xs:notation>
Schema Component Representation
<xs:element name="notation" id="notation">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:attribute name="name" type="xs:NCName" use="required"/>
<xs:attribute name="public" type="xs:public" use="required"/>
<xs:attribute name="system" type="xs:anyURI"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: pattern

Name pattern
Type xs:noFixedFacet
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#element-pattern.
XML Instance Representation
<xs:pattern
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
value="anySimpleType [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
</xs:pattern>
Schema Component Representation
<xs:element name="pattern" type="xs:noFixedFacet" id="pattern"/>
top

Element: redefine

Name redefine
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-redefine.
XML Instance Representation
<xs:redefine
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

schemaLocation="xs:anyURI [1]"
id="xs:ID [0..1]">
Start Choice [0..*]
<xs:annotation> ... </xs:annotation> [1]
Start Choice [1]
<xs:simpleType> ... </xs:simpleType> [1]
<xs:complexType> ... </xs:complexType> [1]
<xs:group> ... </xs:group> [1]
<xs:attributeGroup> ... </xs:attributeGroup> [1]
End Choice
End Choice
</xs:redefine>
Schema Component Representation
<xs:element name="redefine" id="redefine">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:openAttrs">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="xs:annotation"/>
<xs:group ref="xs:redefinable"/>
</xs:choice>
<xs:attribute name="schemaLocation" type="xs:anyURI" use="required"/>
<xs:attribute name="id" type="xs:ID"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: restriction

Name restriction
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
XML Instance Representation
<xs:restriction
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
base="xs:QName [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [0..1]
Start Group: xs:facets [0..*]
Start Choice [1]
<xs:minExclusive> ... </xs:minExclusive> [1]
<xs:minInclusive> ... </xs:minInclusive> [1]
<xs:maxExclusive> ... </xs:maxExclusive> [1]
<xs:maxInclusive> ... </xs:maxInclusive> [1]
<xs:totalDigits> ... </xs:totalDigits> [1]
<xs:fractionDigits> ... </xs:fractionDigits> [1]
<xs:length> ... </xs:length> [1]
<xs:minLength> ... </xs:minLength> [1]
<xs:maxLength> ... </xs:maxLength> [1]
<xs:enumeration> ... </xs:enumeration> [1]
<xs:whiteSpace> ... </xs:whiteSpace> [1]
<xs:pattern> ... </xs:pattern> [1]
End Choice
End Group: xs:facets
</xs:restriction>
Schema Component Representation
<xs:element name="restriction" id="restriction">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:group ref="xs:simpleRestrictionModel"/>
<xs:attribute name="base" type="xs:QName" use="optional"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: schema

Name schema
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-schema.
XML Instance Representation
<xs:schema
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

targetNamespace="xs:anyURI [0..1]"
version="xs:normalizedString [0..1]"
finalDefault="xs:derivationSet [0..1]"
blockDefault="xs:blockSet [0..1]"
attributeFormDefault="xs:formChoice [0..1]"
elementFormDefault="xs:formChoice [0..1]"
id="xs:ID [0..1]"
xml:lang="[0..1]">
<!--
Key Constraint - element
Selector - xs:element
Field(s) - @name
-->
<!--
Key Constraint - attribute
Selector - xs:attribute
Field(s) - @name
-->
<!--
Key Constraint - type
Selector - xs:complexType|xs:simpleType
Field(s) - @name
-->
<!--
Key Constraint - group
Selector - xs:group
Field(s) - @name
-->
<!--
Key Constraint - attributeGroup
Selector - xs:attributeGroup
Field(s) - @name
-->
<!--
Key Constraint - notation
Selector - xs:notation
Field(s) - @name
-->
<!--
Key Constraint - identityConstraint
Selector - .//xs:key|.//xs:unique|.//xs:keyref
Field(s) - @name
-->

Start Choice [0..*]
<xs:include> ... </xs:include> [1]
<xs:import> ... </xs:import> [1]
<xs:redefine> ... </xs:redefine> [1]
<xs:annotation> ... </xs:annotation> [1]
End Choice
Start Sequence [0..*]
Start Choice [1]
Start Choice [1]
<xs:simpleType> ... </xs:simpleType> [1]
<xs:complexType> ... </xs:complexType> [1]
<xs:group> ... </xs:group> [1]
<xs:attributeGroup> ... </xs:attributeGroup> [1]
End Choice
<xs:element> ... </xs:element> [1]
<xs:attribute> ... </xs:attribute> [1]
<xs:notation> ... </xs:notation> [1]
End Choice
<xs:annotation> ... </xs:annotation> [0..*]
End Sequence
</xs:schema>
Schema Component Representation
<xs:element name="schema" id="schema">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:openAttrs">
<xs:sequence>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="xs:include"/>
<xs:element ref="xs:import"/>
<xs:element ref="xs:redefine"/>
<xs:element ref="xs:annotation"/>
</xs:choice>
<xs:sequence minOccurs="0" maxOccurs="unbounded">
<xs:group ref="xs:schemaTop"/>
<xs:element ref="xs:annotation" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:sequence>
<xs:attribute name="targetNamespace" type="xs:anyURI"/>
<xs:attribute name="version" type="xs:normalizedString"/>
<xs:attribute name="finalDefault" type="xs:derivationSet" use="optional" default=""/>
<xs:attribute name="blockDefault" type="xs:blockSet" use="optional" default=""/>
<xs:attribute name="attributeFormDefault" type="xs:formChoice" use="optional" default="unqualified"/>
<xs:attribute name="elementFormDefault" type="xs:formChoice" use="optional" default="unqualified"/>
<xs:attribute name="id" type="xs:ID"/>
<xs:attribute ref="xml:lang"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
<xs:key name="element">
<xs:selector xpath="xs:element"/>
<xs:field xpath="@name"/>
</xs:key>
<xs:key name="attribute">
<xs:selector xpath="xs:attribute"/>
<xs:field xpath="@name"/>
</xs:key>
<xs:key name="type">
<xs:selector xpath="xs:complexType|xs:simpleType"/>
<xs:field xpath="@name"/>
</xs:key>
<xs:key name="group">
<xs:selector xpath="xs:group"/>
<xs:field xpath="@name"/>
</xs:key>
<xs:key name="attributeGroup">
<xs:selector xpath="xs:attributeGroup"/>
<xs:field xpath="@name"/>
</xs:key>
<xs:key name="notation">
<xs:selector xpath="xs:notation"/>
<xs:field xpath="@name"/>
</xs:key>
<xs:key name="identityConstraint">
<xs:selector xpath=".//xs:key|.//xs:unique|.//xs:keyref"/>
<xs:field xpath="@name"/>
</xs:key>
</xs:element>
top

Element: selector

Name selector
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-selector.
XML Instance Representation
<xs:selector
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
xpath="xs:token (pattern = (\.//)?(((child::)?((\i\c*:)?(\i\c*|\*)))|\.)(/(((child::)?((\i\c*:)?(\i\c*|\*)))|\.))*(\|(\.//)?(((child::)?((\i\c*:)?(\i\c*|\*)))|\.)(/(((child::)?((\i\c*:)?(\i\c*|\*)))|\.))*)*) [1]">
<xs:annotation> ... </xs:annotation> [0..1]
</xs:selector>
Schema Component Representation
<xs:element name="selector" id="selector">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:attribute name="xpath" use="required">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:pattern value="(\.//)?(((child::)?((\i\c*:)?(\i\c*|\*)))|\.)(/(((child::)?((\i\c*:)?(\i\c*|\*)))|\.))*(\|(\.//)?(((child::)?((\i\c*:)?(\i\c*|\*)))|\.)(/(((child::)?((\i\c*:)?(\i\c*|\*)))|\.))*)*"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: sequence

Name sequence
Type xs:explicitGroup
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-sequence.
XML Instance Representation
<xs:sequence
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
minOccurs="xs:nonNegativeInteger [0..1]"
maxOccurs="xs:allNNI [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Group: xs:nestedParticle [0..*]
Start Choice [1]
<xs:element> xs:localElement </xs:element> [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
<xs:any> ... </xs:any> [1]
End Choice
End Group: xs:nestedParticle
</xs:sequence>
Schema Component Representation
<xs:element name="sequence" type="xs:explicitGroup" id="sequence"/>
top

Element: simpleContent

Name simpleContent
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-simpleContent.
XML Instance Representation
<xs:simpleContent
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [1]
<xs:restriction> xs:simpleRestrictionType </xs:restriction> [1]
<xs:extension> xs:simpleExtensionType </xs:extension> [1]
End Choice
</xs:simpleContent>
Schema Component Representation
<xs:element name="simpleContent" id="simpleContent">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:choice>
<xs:element name="restriction" type="xs:simpleRestrictionType"/>
<xs:element name="extension" type="xs:simpleExtensionType"/>
</xs:choice>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: simpleType

Name simpleType
Type xs:topLevelSimpleType
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#element-simpleType.
XML Instance Representation
<xs:simpleType
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
final="xs:simpleDerivationSet [0..1]"
name="xs:NCName [1] ?"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [1]
<xs:restriction> ... </xs:restriction> [1]
<xs:list> ... </xs:list> [1]
<xs:union> ... </xs:union> [1]
End Choice
</xs:simpleType>
Schema Component Representation
<xs:element name="simpleType" type="xs:topLevelSimpleType" id="simpleType"/>
top

Element: totalDigits

Name totalDigits
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#element-totalDigits.
XML Instance Representation
<xs:totalDigits
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
fixed="xs:boolean [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).

value="xs:positiveInteger [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
</xs:totalDigits>
Schema Component Representation
<xs:element name="totalDigits" id="totalDigits">
<xs:complexType>
<xs:complexContent>
<xs:restriction base="xs:numFacet">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="value" type="xs:positiveInteger" use="required"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: union

Name union
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
XML Instance Representation
<xs:union
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
memberTypes="list of: xs:QName [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [0..*]
</xs:union>
Schema Component Representation
<xs:element name="union" id="union">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:sequence>
<xs:element name="simpleType" type="xs:localSimpleType" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="memberTypes" use="optional">
<xs:simpleType>
<xs:list itemType="xs:QName"/>
</xs:simpleType>
</xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Element: unique

Name unique
Type xs:keybase
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-1/#element-unique.
XML Instance Representation
<xs:unique
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [1]">
<xs:annotation> ... </xs:annotation> [0..1]
<xs:selector> ... </xs:selector> [1]
<xs:field> ... </xs:field> [1..*]
</xs:unique>
Schema Component Representation
<xs:element name="unique" type="xs:keybase" id="unique"/>
top

Element: whiteSpace

Name whiteSpace
Type Locally-defined complex type
Nillable no
Abstract no
Disallowed Substitutions restriction, extension, substitution
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#element-whiteSpace.
XML Instance Representation
<xs:whiteSpace
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
fixed="xs:boolean [0..1]"
value="xs:NMTOKEN (value comes from list: {'preserve'|'replace'|'collapse'}) [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
</xs:whiteSpace>
Schema Component Representation
<xs:element name="whiteSpace" id="whiteSpace">
<xs:complexType>
<xs:complexContent>
<xs:restriction base="xs:facet">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="value" use="required">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="preserve"/>
<xs:enumeration value="replace"/>
<xs:enumeration value="collapse"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
</xs:element>
top

Global Definitions

Attribute Group: defRef

Name defRef
Documentation for element, group and attributeGroup, which both define and reference
XML Instance Representation
name="xs:NCName [0..1]"
ref="xs:QName [0..1]"
Schema Component Representation
<xs:attributeGroup name="defRef">
<xs:attribute name="name" type="xs:NCName"/>
<xs:attribute name="ref" type="xs:QName"/>
</xs:attributeGroup>
top

Attribute Group: occurs

Name occurs
Documentation for all particles
XML Instance Representation
minOccurs="xs:nonNegativeInteger [0..1]"
maxOccurs="xs:allNNI [0..1]"
Schema Component Representation
<xs:attributeGroup name="occurs">
<xs:attribute name="minOccurs" type="xs:nonNegativeInteger" use="optional" default="1"/>
<xs:attribute name="maxOccurs" type="xs:allNNI" use="optional" default="1"/>
</xs:attributeGroup>
top

Complex Type: all

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < group (by extension) < explicitGroup (by restriction) < all (by restriction)
Sub-types: None
Name all
Abstract no
Prohibited Substitutions restriction, extension
Documentation Only elements allowed inside
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).

minOccurs="xs:nonNegativeInteger (value comes from list: {'0'|'1'}) [0..1]"
maxOccurs="xs:allNNI (value comes from list: {'1'}) [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..*] ?
<xs:element
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [0..1]"
ref="xs:QName [0..1]"
type="xs:QName [0..1]"
default="xs:string [0..1]"
fixed="xs:string [0..1]"
nillable="xs:boolean [0..1]"
block="xs:blockSet [0..1]"
form="xs:formChoice [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).

minOccurs="xs:nonNegativeInteger (value comes from list: {'0'|'1'}) [0..1]"
maxOccurs="xs:allNNI (value comes from list: {'0'|'1'}) [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
> [1]
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [1]
<xs:complexType> xs:localComplexType </xs:complexType> [1]
End Choice
Start Group: xs:identityConstraint [0..*]
Start Choice [1]
<xs:unique> ... </xs:unique> [1]
<xs:key> ... </xs:key> [1]
<xs:keyref> ... </xs:keyref> [1]
End Choice
End Group: xs:identityConstraint
</xs:element>
End Choice
</...>
Schema Component Representation
<xs:complexType name="all">
<xs:complexContent>
<xs:restriction base="xs:explicitGroup">
<xs:group ref="xs:allModel"/>
<xs:attribute name="minOccurs" use="optional" default="1">
<xs:simpleType>
<xs:restriction base="xs:nonNegativeInteger">
<xs:enumeration value="0"/>
<xs:enumeration value="1"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="maxOccurs" use="optional" default="1">
<xs:simpleType>
<xs:restriction base="xs:allNNI">
<xs:enumeration value="1"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: annotated

Super-types: anyType < openAttrs (by restriction) < annotated (by extension)
Sub-types:
Name annotated
Abstract no
Prohibited Substitutions restriction, extension
Documentation This type is extended by all types which allow annotation other than <schema> itself
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
</...>
Schema Component Representation
<xs:complexType name="annotated">
<xs:complexContent>
<xs:extension base="xs:openAttrs">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="id" type="xs:ID"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: anyType

Super-types: None
Sub-types:
Name anyType
Abstract no
Prohibited Substitutions restriction, extension
Documentation Not the real urType, but as close an approximation as we can get in the XML representation
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
>
<!-- Mixed content -->
Allow any elements from any namespace (strict validation). [0..*]
</...>
Schema Component Representation
<xs:complexType name="anyType" mixed="true">
<xs:sequence>
<xs:any minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:anyAttribute/>
</xs:complexType>
top

Complex Type: attribute

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < attribute (by extension)
Sub-types:
Name attribute
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [0..1]"
ref="xs:QName [0..1]"
type="xs:QName [0..1]"
use="xs:NMTOKEN (value comes from list: {'prohibited'|'optional'|'required'}) [0..1]"
default="xs:string [0..1]"
fixed="xs:string [0..1]"
form="xs:formChoice [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [0..1]
</...>
Schema Component Representation
<xs:complexType name="attribute">
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:sequence>
<xs:element name="simpleType" type="xs:localSimpleType" minOccurs="0"/>
</xs:sequence>
<xs:attributeGroup ref="xs:defRef"/>
<xs:attribute name="type" type="xs:QName"/>
<xs:attribute name="use" use="optional" default="optional">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="prohibited"/>
<xs:enumeration value="optional"/>
<xs:enumeration value="required"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="default" type="xs:string"/>
<xs:attribute name="fixed" type="xs:string"/>
<xs:attribute name="form" type="xs:formChoice"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: attributeGroup

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < attributeGroup (by extension)
Sub-types:
Name attributeGroup
Abstract yes
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [0..1]"
ref="xs:QName [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..*]
<xs:attribute> xs:attribute </xs:attribute> [1]
<xs:attributeGroup> xs:attributeGroupRef </xs:attributeGroup> [1]
End Choice
<xs:anyAttribute> ... </xs:anyAttribute> [0..1]
</...>
Schema Component Representation
<xs:complexType name="attributeGroup" abstract="true">
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:group ref="xs:attrDecls"/>
<xs:attributeGroup ref="xs:defRef"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: attributeGroupRef

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < attributeGroup (by extension) < attributeGroupRef (by restriction)
Sub-types: None
Name attributeGroupRef
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
ref="xs:QName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
</...>
Schema Component Representation
<xs:complexType name="attributeGroupRef">
<xs:complexContent>
<xs:restriction base="xs:attributeGroup">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="ref" type="xs:QName" use="required"/>
<xs:attribute name="name" use="prohibited"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: complexRestrictionType

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < restrictionType (by extension) < complexRestrictionType (by restriction)
Sub-types: None
Name complexRestrictionType
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
base="xs:QName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..1] ?
Start Choice [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:all> ... </xs:all> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
End Choice
End Choice
Start Choice [0..*]
<xs:attribute> xs:attribute </xs:attribute> [1]
<xs:attributeGroup> xs:attributeGroupRef </xs:attributeGroup> [1]
End Choice
<xs:anyAttribute> ... </xs:anyAttribute> [0..1]
</...>
Schema Component Representation
<xs:complexType name="complexRestrictionType">
<xs:complexContent>
<xs:restriction base="xs:restrictionType">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:choice minOccurs="0">
<xs:group ref="xs:typeDefParticle"/>
</xs:choice>
<xs:group ref="xs:attrDecls"/>
</xs:sequence>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: complexType

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < complexType (by extension)
Sub-types:
Name complexType
Abstract yes
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [0..1] ?"
mixed="xs:boolean [0..1] ?"
abstract="xs:boolean [0..1]"
final="xs:derivationSet [0..1]"
block="xs:derivationSet [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [1]
<xs:simpleContent> ... </xs:simpleContent> [1]
<xs:complexContent> ... </xs:complexContent> [1]
Start Group: xs:typeDefParticle [0..1]
Start Choice [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:all> ... </xs:all> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
End Choice
End Group: xs:typeDefParticle
Start Choice [0..*]
<xs:attribute> xs:attribute </xs:attribute> [1]
<xs:attributeGroup> xs:attributeGroupRef </xs:attributeGroup> [1]
End Choice
<xs:anyAttribute> ... </xs:anyAttribute> [0..1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="complexType" abstract="true">
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:group ref="xs:complexTypeModel"/>
<xs:attribute name="name" type="xs:NCName"/>
<xs:attribute name="mixed" type="xs:boolean" use="optional" default="false"/>
<xs:attribute name="abstract" type="xs:boolean" use="optional" default="false"/>
<xs:attribute name="final" type="xs:derivationSet"/>
<xs:attribute name="block" type="xs:derivationSet"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: element

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < element (by extension)
Sub-types:
Name element
Abstract yes
Prohibited Substitutions restriction, extension
Documentation The element element can be used either at the top level to define an element-type binding globally, or within a content model to either reference a globally-defined element or type or declare an element-type binding locally. The ref form is not allowed at the top level.
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [0..1]"
ref="xs:QName [0..1]"
type="xs:QName [0..1]"
substitutionGroup="xs:QName [0..1]"
minOccurs="xs:nonNegativeInteger [0..1]"
maxOccurs="xs:allNNI [0..1]"
default="xs:string [0..1]"
fixed="xs:string [0..1]"
nillable="xs:boolean [0..1]"
abstract="xs:boolean [0..1]"
final="xs:derivationSet [0..1]"
block="xs:blockSet [0..1]"
form="xs:formChoice [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [1]
<xs:complexType> xs:localComplexType </xs:complexType> [1]
End Choice
Start Group: xs:identityConstraint [0..*]
Start Choice [1]
<xs:unique> ... </xs:unique> [1]
<xs:key> ... </xs:key> [1]
<xs:keyref> ... </xs:keyref> [1]
End Choice
End Group: xs:identityConstraint
</...>
Schema Component Representation
<xs:complexType name="element" abstract="true">
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:sequence>
<xs:choice minOccurs="0">
<xs:element name="simpleType" type="xs:localSimpleType"/>
<xs:element name="complexType" type="xs:localComplexType"/>
</xs:choice>
<xs:group ref="xs:identityConstraint" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attributeGroup ref="xs:defRef"/>
<xs:attribute name="type" type="xs:QName"/>
<xs:attribute name="substitutionGroup" type="xs:QName"/>
<xs:attributeGroup ref="xs:occurs"/>
<xs:attribute name="default" type="xs:string"/>
<xs:attribute name="fixed" type="xs:string"/>
<xs:attribute name="nillable" type="xs:boolean" use="optional" default="false"/>
<xs:attribute name="abstract" type="xs:boolean" use="optional" default="false"/>
<xs:attribute name="final" type="xs:derivationSet"/>
<xs:attribute name="block" type="xs:blockSet"/>
<xs:attribute name="form" type="xs:formChoice"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: explicitGroup

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < group (by extension) < explicitGroup (by restriction)
Sub-types:
Name explicitGroup
Abstract no
Prohibited Substitutions restriction, extension
Documentation group type for the three kinds of group
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
minOccurs="xs:nonNegativeInteger [0..1]"
maxOccurs="xs:allNNI [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Group: xs:nestedParticle [0..*]
Start Choice [1]
<xs:element> xs:localElement </xs:element> [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
<xs:any> ... </xs:any> [1]
End Choice
End Group: xs:nestedParticle
</...>
Schema Component Representation
<xs:complexType name="explicitGroup">
<xs:complexContent>
<xs:restriction base="xs:group">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:group ref="xs:nestedParticle" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="name" type="xs:NCName" use="prohibited"/>
<xs:attribute name="ref" type="xs:QName" use="prohibited"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: extensionType

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < extensionType (by extension)
Sub-types:
Name extensionType
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
base="xs:QName [1]">
<xs:annotation> ... </xs:annotation> [0..1]
Start Group: xs:typeDefParticle [0..1]
Start Choice [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:all> ... </xs:all> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
End Choice
End Group: xs:typeDefParticle
Start Choice [0..*]
<xs:attribute> xs:attribute </xs:attribute> [1]
<xs:attributeGroup> xs:attributeGroupRef </xs:attributeGroup> [1]
End Choice
<xs:anyAttribute> ... </xs:anyAttribute> [0..1]
</...>
Schema Component Representation
<xs:complexType name="extensionType">
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:sequence>
<xs:group ref="xs:typeDefParticle" minOccurs="0"/>
<xs:group ref="xs:attrDecls"/>
</xs:sequence>
<xs:attribute name="base" type="xs:QName" use="required"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: facet

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < facet (by extension)
Sub-types:
Name facet
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
value="anySimpleType [1]"
fixed="xs:boolean [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
</...>
Schema Component Representation
<xs:complexType name="facet">
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:attribute name="value" use="required"/>
<xs:attribute name="fixed" type="xs:boolean" use="optional" default="false"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: group

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < group (by extension)
Sub-types:
Name group
Abstract yes
Prohibited Substitutions restriction, extension
Documentation group type for explicit groups, named top-level groups and group references
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [0..1]"
ref="xs:QName [0..1]"
minOccurs="xs:nonNegativeInteger [0..1]"
maxOccurs="xs:allNNI [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
Start Group: xs:particle [0..*]
Start Choice [1]
<xs:element> xs:localElement </xs:element> [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:all> ... </xs:all> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
<xs:any> ... </xs:any> [1]
End Choice
End Group: xs:particle
</...>
Schema Component Representation
<xs:complexType name="group" abstract="true">
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:group ref="xs:particle" minOccurs="0" maxOccurs="unbounded"/>
<xs:attributeGroup ref="xs:defRef"/>
<xs:attributeGroup ref="xs:occurs"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: groupRef

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < group (by extension) < realGroup (by restriction) < groupRef (by restriction)
Sub-types: None
Name groupRef
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
minOccurs="xs:nonNegativeInteger [0..1]"
maxOccurs="xs:allNNI [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).

ref="xs:QName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
</...>
Schema Component Representation
<xs:complexType name="groupRef">
<xs:complexContent>
<xs:restriction base="xs:realGroup">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="ref" type="xs:QName" use="required"/>
<xs:attribute name="name" use="prohibited"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: keybase

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < keybase (by extension)
Sub-types: None
Name keybase
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [1]">
<xs:annotation> ... </xs:annotation> [0..1]
<xs:selector> ... </xs:selector> [1]
<xs:field> ... </xs:field> [1..*]
</...>
Schema Component Representation
<xs:complexType name="keybase">
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:sequence>
<xs:element ref="xs:selector"/>
<xs:element ref="xs:field" minOccurs="1" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="name" type="xs:NCName" use="required"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: localComplexType

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < complexType (by extension) < localComplexType (by restriction)
Sub-types: None
Name localComplexType
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
mixed="xs:boolean [0..1] ?"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [1]
<xs:simpleContent> ... </xs:simpleContent> [1]
<xs:complexContent> ... </xs:complexContent> [1]
Start Group: xs:typeDefParticle [0..1]
Start Choice [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:all> ... </xs:all> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
End Choice
End Group: xs:typeDefParticle
Start Choice [0..*]
<xs:attribute> xs:attribute </xs:attribute> [1]
<xs:attributeGroup> xs:attributeGroupRef </xs:attributeGroup> [1]
End Choice
<xs:anyAttribute> ... </xs:anyAttribute> [0..1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="localComplexType">
<xs:complexContent>
<xs:restriction base="xs:complexType">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:group ref="xs:complexTypeModel"/>
</xs:sequence>
<xs:attribute name="name" use="prohibited"/>
<xs:attribute name="abstract" use="prohibited"/>
<xs:attribute name="final" use="prohibited"/>
<xs:attribute name="block" use="prohibited"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: localElement

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < element (by extension) < localElement (by restriction)
Sub-types: None
Name localElement
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [0..1]"
ref="xs:QName [0..1]"
type="xs:QName [0..1]"
minOccurs="xs:nonNegativeInteger [0..1]"
maxOccurs="xs:allNNI [0..1]"
default="xs:string [0..1]"
fixed="xs:string [0..1]"
nillable="xs:boolean [0..1]"
block="xs:blockSet [0..1]"
form="xs:formChoice [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [1]
<xs:complexType> xs:localComplexType </xs:complexType> [1]
End Choice
Start Group: xs:identityConstraint [0..*]
Start Choice [1]
<xs:unique> ... </xs:unique> [1]
<xs:key> ... </xs:key> [1]
<xs:keyref> ... </xs:keyref> [1]
End Choice
End Group: xs:identityConstraint
</...>
Schema Component Representation
<xs:complexType name="localElement">
<xs:complexContent>
<xs:restriction base="xs:element">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:choice minOccurs="0">
<xs:element name="simpleType" type="xs:localSimpleType"/>
<xs:element name="complexType" type="xs:localComplexType"/>
</xs:choice>
<xs:group ref="xs:identityConstraint" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="substitutionGroup" use="prohibited"/>
<xs:attribute name="final" use="prohibited"/>
<xs:attribute name="abstract" use="prohibited"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: localSimpleType

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < simpleType (by extension) < localSimpleType (by restriction)
Sub-types: None
Name localSimpleType
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [1]
<xs:restriction> ... </xs:restriction> [1]
<xs:list> ... </xs:list> [1]
<xs:union> ... </xs:union> [1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="localSimpleType">
<xs:complexContent>
<xs:restriction base="xs:simpleType">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:group ref="xs:simpleDerivation"/>
</xs:sequence>
<xs:attribute name="name" use="prohibited"/>
<xs:attribute name="final" use="prohibited"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: namedAttributeGroup

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < attributeGroup (by extension) < namedAttributeGroup (by restriction)
Sub-types: None
Name namedAttributeGroup
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..*]
<xs:attribute> xs:attribute </xs:attribute> [1]
<xs:attributeGroup> xs:attributeGroupRef </xs:attributeGroup> [1]
End Choice
<xs:anyAttribute> ... </xs:anyAttribute> [0..1]
</...>
Schema Component Representation
<xs:complexType name="namedAttributeGroup">
<xs:complexContent>
<xs:restriction base="xs:attributeGroup">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:group ref="xs:attrDecls"/>
</xs:sequence>
<xs:attribute name="name" type="xs:NCName" use="required"/>
<xs:attribute name="ref" use="prohibited"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: namedGroup

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < group (by extension) < realGroup (by restriction) < namedGroup (by restriction)
Sub-types: None
Name namedGroup
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).

name="xs:NCName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [1]
<xs:all
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).
> [1]
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..*] ?
<xs:element
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [0..1]"
ref="xs:QName [0..1]"
type="xs:QName [0..1]"
default="xs:string [0..1]"
fixed="xs:string [0..1]"
nillable="xs:boolean [0..1]"
block="xs:blockSet [0..1]"
form="xs:formChoice [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).

minOccurs="xs:nonNegativeInteger (value comes from list: {'0'|'1'}) [0..1]"
maxOccurs="xs:allNNI (value comes from list: {'0'|'1'}) [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
> [1]
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [1]
<xs:complexType> xs:localComplexType </xs:complexType> [1]
End Choice
Start Group: xs:identityConstraint [0..*]
Start Choice [1]
<xs:unique> ... </xs:unique> [1]
<xs:key> ... </xs:key> [1]
<xs:keyref> ... </xs:keyref> [1]
End Choice
End Group: xs:identityConstraint
</xs:element>
End Choice
</xs:all>
<xs:choice> xs:simpleExplicitGroup </xs:choice> [1]
<xs:sequence> xs:simpleExplicitGroup </xs:sequence> [1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="namedGroup">
<xs:complexContent>
<xs:restriction base="xs:realGroup">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:choice minOccurs="1" maxOccurs="1">
<xs:element name="all">
<xs:complexType>
<xs:complexContent>
<xs:restriction base="xs:all">
<xs:group ref="xs:allModel"/>
<xs:attribute name="minOccurs" use="prohibited"/>
<xs:attribute name="maxOccurs" use="prohibited"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
</xs:element>
<xs:element name="choice" type="xs:simpleExplicitGroup"/>
<xs:element name="sequence" type="xs:simpleExplicitGroup"/>
</xs:choice>
</xs:sequence>
<xs:attribute name="name" type="xs:NCName" use="required"/>
<xs:attribute name="ref" use="prohibited"/>
<xs:attribute name="minOccurs" use="prohibited"/>
<xs:attribute name="maxOccurs" use="prohibited"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: noFixedFacet

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < facet (by extension) < noFixedFacet (by restriction)
Sub-types: None
Name noFixedFacet
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
value="anySimpleType [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
</...>
Schema Component Representation
<xs:complexType name="noFixedFacet">
<xs:complexContent>
<xs:restriction base="xs:facet">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="fixed" use="prohibited"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: numFacet

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < facet (by extension) < numFacet (by restriction)
Sub-types: None
Name numFacet
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
fixed="xs:boolean [0..1]"
value="xs:nonNegativeInteger [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
</...>
Schema Component Representation
<xs:complexType name="numFacet">
<xs:complexContent>
<xs:restriction base="xs:facet">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="value" type="xs:nonNegativeInteger" use="required"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: openAttrs

Super-types: anyType < openAttrs (by restriction)
Sub-types:
Name openAttrs
Abstract no
Prohibited Substitutions restriction, extension
Documentation This type is extended by almost all schema types to allow attributes from other namespaces to be added to user schemas.
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).
/>
Schema Component Representation
<xs:complexType name="openAttrs">
<xs:complexContent>
<xs:restriction base="xs:anyType">
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: realGroup

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < group (by extension) < realGroup (by restriction)
Sub-types:
Name realGroup
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [0..1]"
ref="xs:QName [0..1]"
minOccurs="xs:nonNegativeInteger [0..1]"
maxOccurs="xs:allNNI [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..1]
<xs:all> ... </xs:all> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="realGroup">
<xs:complexContent>
<xs:restriction base="xs:group">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:choice minOccurs="0" maxOccurs="1">
<xs:element ref="xs:all"/>
<xs:element ref="xs:choice"/>
<xs:element ref="xs:sequence"/>
</xs:choice>
</xs:sequence>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: restrictionType

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < restrictionType (by extension)
Sub-types:
Name restrictionType
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
base="xs:QName [1]">
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..1]
Start Choice [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:all> ... </xs:all> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
End Choice
<xs:simpleType> xs:localSimpleType </xs:simpleType> [0..1]
Start Group: xs:facets [0..*]
Start Choice [1]
<xs:minExclusive> ... </xs:minExclusive> [1]
<xs:minInclusive> ... </xs:minInclusive> [1]
<xs:maxExclusive> ... </xs:maxExclusive> [1]
<xs:maxInclusive> ... </xs:maxInclusive> [1]
<xs:totalDigits> ... </xs:totalDigits> [1]
<xs:fractionDigits> ... </xs:fractionDigits> [1]
<xs:length> ... </xs:length> [1]
<xs:minLength> ... </xs:minLength> [1]
<xs:maxLength> ... </xs:maxLength> [1]
<xs:enumeration> ... </xs:enumeration> [1]
<xs:whiteSpace> ... </xs:whiteSpace> [1]
<xs:pattern> ... </xs:pattern> [1]
End Choice
End Group: xs:facets
End Choice
Start Choice [0..*]
<xs:attribute> xs:attribute </xs:attribute> [1]
<xs:attributeGroup> xs:attributeGroupRef </xs:attributeGroup> [1]
End Choice
<xs:anyAttribute> ... </xs:anyAttribute> [0..1]
</...>
Schema Component Representation
<xs:complexType name="restrictionType">
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:sequence>
<xs:choice minOccurs="0">
<xs:group ref="xs:typeDefParticle"/>
<xs:group ref="xs:simpleRestrictionModel"/>
</xs:choice>
<xs:group ref="xs:attrDecls"/>
</xs:sequence>
<xs:attribute name="base" type="xs:QName" use="required"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: simpleExplicitGroup

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < group (by extension) < explicitGroup (by restriction) < simpleExplicitGroup (by restriction)
Sub-types: None
Name simpleExplicitGroup
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Group: xs:nestedParticle [0..*]
Start Choice [1]
<xs:element> xs:localElement </xs:element> [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
<xs:any> ... </xs:any> [1]
End Choice
End Group: xs:nestedParticle
</...>
Schema Component Representation
<xs:complexType name="simpleExplicitGroup">
<xs:complexContent>
<xs:restriction base="xs:explicitGroup">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:group ref="xs:nestedParticle" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="minOccurs" use="prohibited"/>
<xs:attribute name="maxOccurs" use="prohibited"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: simpleExtensionType

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < extensionType (by extension) < simpleExtensionType (by restriction)
Sub-types: None
Name simpleExtensionType
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
base="xs:QName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..*]
<xs:attribute> xs:attribute </xs:attribute> [1]
<xs:attributeGroup> xs:attributeGroupRef </xs:attributeGroup> [1]
End Choice
<xs:anyAttribute> ... </xs:anyAttribute> [0..1]
</...>
Schema Component Representation
<xs:complexType name="simpleExtensionType">
<xs:complexContent>
<xs:restriction base="xs:extensionType">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:group ref="xs:attrDecls"/>
</xs:sequence>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: simpleRestrictionType

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < restrictionType (by extension) < simpleRestrictionType (by restriction)
Sub-types: None
Name simpleRestrictionType
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
base="xs:QName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..1] ?
<xs:simpleType> xs:localSimpleType </xs:simpleType> [0..1]
Start Group: xs:facets [0..*]
Start Choice [1]
<xs:minExclusive> ... </xs:minExclusive> [1]
<xs:minInclusive> ... </xs:minInclusive> [1]
<xs:maxExclusive> ... </xs:maxExclusive> [1]
<xs:maxInclusive> ... </xs:maxInclusive> [1]
<xs:totalDigits> ... </xs:totalDigits> [1]
<xs:fractionDigits> ... </xs:fractionDigits> [1]
<xs:length> ... </xs:length> [1]
<xs:minLength> ... </xs:minLength> [1]
<xs:maxLength> ... </xs:maxLength> [1]
<xs:enumeration> ... </xs:enumeration> [1]
<xs:whiteSpace> ... </xs:whiteSpace> [1]
<xs:pattern> ... </xs:pattern> [1]
End Choice
End Group: xs:facets
End Choice
Start Choice [0..*]
<xs:attribute> xs:attribute </xs:attribute> [1]
<xs:attributeGroup> xs:attributeGroupRef </xs:attributeGroup> [1]
End Choice
<xs:anyAttribute> ... </xs:anyAttribute> [0..1]
</...>
Schema Component Representation
<xs:complexType name="simpleRestrictionType">
<xs:complexContent>
<xs:restriction base="xs:restrictionType">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:choice minOccurs="0">
<xs:group ref="xs:simpleRestrictionModel"/>
</xs:choice>
<xs:group ref="xs:attrDecls"/>
</xs:sequence>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: simpleType

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < simpleType (by extension)
Sub-types:
Name simpleType
Abstract yes
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
final="xs:simpleDerivationSet [0..1]"
name="xs:NCName [0..1] ?">
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [1]
<xs:restriction> ... </xs:restriction> [1]
<xs:list> ... </xs:list> [1]
<xs:union> ... </xs:union> [1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="simpleType" abstract="true">
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:group ref="xs:simpleDerivation"/>
<xs:attribute name="final" type="xs:simpleDerivationSet"/>
<xs:attribute name="name" type="xs:NCName"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: topLevelAttribute

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < attribute (by extension) < topLevelAttribute (by restriction)
Sub-types: None
Name topLevelAttribute
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
type="xs:QName [0..1]"
default="xs:string [0..1]"
fixed="xs:string [0..1]"
name="xs:NCName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [0..1]
</...>
Schema Component Representation
<xs:complexType name="topLevelAttribute">
<xs:complexContent>
<xs:restriction base="xs:attribute">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:element name="simpleType" type="xs:localSimpleType" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="ref" use="prohibited"/>
<xs:attribute name="form" use="prohibited"/>
<xs:attribute name="use" use="prohibited"/>
<xs:attribute name="name" type="xs:NCName" use="required"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: topLevelComplexType

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < complexType (by extension) < topLevelComplexType (by restriction)
Sub-types: None
Name topLevelComplexType
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
mixed="xs:boolean [0..1] ?"
abstract="xs:boolean [0..1]"
final="xs:derivationSet [0..1]"
block="xs:derivationSet [0..1]"
name="xs:NCName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [1]
<xs:simpleContent> ... </xs:simpleContent> [1]
<xs:complexContent> ... </xs:complexContent> [1]
Start Group: xs:typeDefParticle [0..1]
Start Choice [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:all> ... </xs:all> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
End Choice
End Group: xs:typeDefParticle
Start Choice [0..*]
<xs:attribute> xs:attribute </xs:attribute> [1]
<xs:attributeGroup> xs:attributeGroupRef </xs:attributeGroup> [1]
End Choice
<xs:anyAttribute> ... </xs:anyAttribute> [0..1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="topLevelComplexType">
<xs:complexContent>
<xs:restriction base="xs:complexType">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:group ref="xs:complexTypeModel"/>
</xs:sequence>
<xs:attribute name="name" type="xs:NCName" use="required"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: topLevelElement

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < element (by extension) < topLevelElement (by restriction)
Sub-types: None
Name topLevelElement
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
type="xs:QName [0..1]"
substitutionGroup="xs:QName [0..1]"
default="xs:string [0..1]"
fixed="xs:string [0..1]"
nillable="xs:boolean [0..1]"
abstract="xs:boolean [0..1]"
final="xs:derivationSet [0..1]"
block="xs:blockSet [0..1]"
name="xs:NCName [1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [1]
<xs:complexType> xs:localComplexType </xs:complexType> [1]
End Choice
Start Group: xs:identityConstraint [0..*]
Start Choice [1]
<xs:unique> ... </xs:unique> [1]
<xs:key> ... </xs:key> [1]
<xs:keyref> ... </xs:keyref> [1]
End Choice
End Group: xs:identityConstraint
</...>
Schema Component Representation
<xs:complexType name="topLevelElement">
<xs:complexContent>
<xs:restriction base="xs:element">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:choice minOccurs="0">
<xs:element name="simpleType" type="xs:localSimpleType"/>
<xs:element name="complexType" type="xs:localComplexType"/>
</xs:choice>
<xs:group ref="xs:identityConstraint" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="ref" use="prohibited"/>
<xs:attribute name="form" use="prohibited"/>
<xs:attribute name="minOccurs" use="prohibited"/>
<xs:attribute name="maxOccurs" use="prohibited"/>
<xs:attribute name="name" type="xs:NCName" use="required"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: topLevelSimpleType

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < simpleType (by extension) < topLevelSimpleType (by restriction)
Sub-types: None
Name topLevelSimpleType
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
final="xs:simpleDerivationSet [0..1]"
name="xs:NCName [1] ?"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
>
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [1]
<xs:restriction> ... </xs:restriction> [1]
<xs:list> ... </xs:list> [1]
<xs:union> ... </xs:union> [1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="topLevelSimpleType">
<xs:complexContent>
<xs:restriction base="xs:simpleType">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:group ref="xs:simpleDerivation"/>
</xs:sequence>
<xs:attribute name="name" type="xs:NCName" use="required"/>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
top

Complex Type: wildcard

Super-types: anyType < openAttrs (by restriction) < annotated (by extension) < wildcard (by extension)
Sub-types: None
Name wildcard
Abstract no
Prohibited Substitutions restriction, extension
XML Instance Representation
<...
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
namespace="xs:namespaceList [0..1]"
processContents="xs:NMTOKEN (value comes from list: {'skip'|'lax'|'strict'}) [0..1]">
<xs:annotation> ... </xs:annotation> [0..1]
</...>
Schema Component Representation
<xs:complexType name="wildcard">
<xs:complexContent>
<xs:extension base="xs:annotated">
<xs:attribute name="namespace" type="xs:namespaceList" use="optional" default="##any"/>
<xs:attribute name="processContents" use="optional" default="strict">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="skip"/>
<xs:enumeration value="lax"/>
<xs:enumeration value="strict"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Model Group: allModel

Name allModel
XML Instance Representation
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..*] ?
<xs:element
Allow any attributes from any namespace (strict validation).
Allow any attributes from a namespace other than this schema's namespace (lax validation).

id="xs:ID [0..1]"
name="xs:NCName [0..1]"
ref="xs:QName [0..1]"
type="xs:QName [0..1]"
default="xs:string [0..1]"
fixed="xs:string [0..1]"
nillable="xs:boolean [0..1]"
block="xs:blockSet [0..1]"
form="xs:formChoice [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).

minOccurs="xs:nonNegativeInteger (value comes from list: {'0'|'1'}) [0..1]"
maxOccurs="xs:allNNI (value comes from list: {'0'|'1'}) [0..1]"
Allow any attributes from a namespace other than this schema's namespace (lax validation).
> [1]
<xs:annotation> ... </xs:annotation> [0..1]
Start Choice [0..1]
<xs:simpleType> xs:localSimpleType </xs:simpleType> [1]
<xs:complexType> xs:localComplexType </xs:complexType> [1]
End Choice
Start Group: xs:identityConstraint [0..*]
Start Choice [1]
<xs:unique> ... </xs:unique> [1]
<xs:key> ... </xs:key> [1]
<xs:keyref> ... </xs:keyref> [1]
End Choice
End Group: xs:identityConstraint
</xs:element>
End Choice
Schema Component Representation
<xs:group name="allModel">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="element">
<xs:complexType>
<xs:complexContent>
<xs:restriction base="xs:localElement">
<xs:sequence>
<xs:element ref="xs:annotation" minOccurs="0"/>
<xs:choice minOccurs="0">
<xs:element name="simpleType" type="xs:localSimpleType"/>
<xs:element name="complexType" type="xs:localComplexType"/>
</xs:choice>
<xs:group ref="xs:identityConstraint" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="minOccurs" use="optional" default="1">
<xs:simpleType>
<xs:restriction base="xs:nonNegativeInteger">
<xs:enumeration value="0"/>
<xs:enumeration value="1"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="maxOccurs" use="optional" default="1">
<xs:simpleType>
<xs:restriction base="xs:allNNI">
<xs:enumeration value="0"/>
<xs:enumeration value="1"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:anyAttribute namespace="##other" processContents="lax"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
</xs:element>
</xs:choice>
</xs:sequence>
</xs:group>
top

Model Group: attrDecls

Name attrDecls
XML Instance Representation
Start Choice [0..*]
<xs:attribute> xs:attribute </xs:attribute> [1]
<xs:attributeGroup> xs:attributeGroupRef </xs:attributeGroup> [1]
End Choice
<xs:anyAttribute> ... </xs:anyAttribute> [0..1]
Schema Component Representation
<xs:group name="attrDecls">
<xs:sequence>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="attribute" type="xs:attribute"/>
<xs:element name="attributeGroup" type="xs:attributeGroupRef"/>
</xs:choice>
<xs:element ref="xs:anyAttribute" minOccurs="0"/>
</xs:sequence>
</xs:group>
top

Model Group: complexTypeModel

Name complexTypeModel
XML Instance Representation
Start Choice [1]
<xs:simpleContent> ... </xs:simpleContent> [1]
<xs:complexContent> ... </xs:complexContent> [1]
Start Group: xs:typeDefParticle [0..1]
Start Choice [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:all> ... </xs:all> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
End Choice
End Group: xs:typeDefParticle
Start Choice [0..*]
<xs:attribute> xs:attribute </xs:attribute> [1]
<xs:attributeGroup> xs:attributeGroupRef </xs:attributeGroup> [1]
End Choice
<xs:anyAttribute> ... </xs:anyAttribute> [0..1]
End Choice
Schema Component Representation
<xs:group name="complexTypeModel">
<xs:choice>
<xs:element ref="xs:simpleContent"/>
<xs:element ref="xs:complexContent"/>
<xs:sequence>
<xs:group ref="xs:typeDefParticle" minOccurs="0"/>
<xs:group ref="xs:attrDecls"/>
</xs:sequence>
</xs:choice>
</xs:group>
top

Model Group: facets

Name facets
Documentation We should use a substitution group for facets, but that's ruled out because it would allow users to add their own, which we're not ready for yet.
XML Instance Representation
Start Choice [1]
<xs:minExclusive> ... </xs:minExclusive> [1]
<xs:minInclusive> ... </xs:minInclusive> [1]
<xs:maxExclusive> ... </xs:maxExclusive> [1]
<xs:maxInclusive> ... </xs:maxInclusive> [1]
<xs:totalDigits> ... </xs:totalDigits> [1]
<xs:fractionDigits> ... </xs:fractionDigits> [1]
<xs:length> ... </xs:length> [1]
<xs:minLength> ... </xs:minLength> [1]
<xs:maxLength> ... </xs:maxLength> [1]
<xs:enumeration> ... </xs:enumeration> [1]
<xs:whiteSpace> ... </xs:whiteSpace> [1]
<xs:pattern> ... </xs:pattern> [1]
End Choice
Schema Component Representation
<xs:group name="facets">
<xs:choice>
<xs:element ref="xs:minExclusive"/>
<xs:element ref="xs:minInclusive"/>
<xs:element ref="xs:maxExclusive"/>
<xs:element ref="xs:maxInclusive"/>
<xs:element ref="xs:totalDigits"/>
<xs:element ref="xs:fractionDigits"/>
<xs:element ref="xs:length"/>
<xs:element ref="xs:minLength"/>
<xs:element ref="xs:maxLength"/>
<xs:element ref="xs:enumeration"/>
<xs:element ref="xs:whiteSpace"/>
<xs:element ref="xs:pattern"/>
</xs:choice>
</xs:group>
top

Model Group: identityConstraint

Name identityConstraint
Documentation The three kinds of identity constraints, all with type of or derived from 'keybase'.
XML Instance Representation
Start Choice [1]
<xs:unique> ... </xs:unique> [1]
<xs:key> ... </xs:key> [1]
<xs:keyref> ... </xs:keyref> [1]
End Choice
Schema Component Representation
<xs:group name="identityConstraint">
<xs:choice>
<xs:element ref="xs:unique"/>
<xs:element ref="xs:key"/>
<xs:element ref="xs:keyref"/>
</xs:choice>
</xs:group>
top

Model Group: nestedParticle

Name nestedParticle
XML Instance Representation
Start Choice [1]
<xs:element> xs:localElement </xs:element> [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
<xs:any> ... </xs:any> [1]
End Choice
Schema Component Representation
<xs:group name="nestedParticle">
<xs:choice>
<xs:element name="element" type="xs:localElement"/>
<xs:element name="group" type="xs:groupRef"/>
<xs:element ref="xs:choice"/>
<xs:element ref="xs:sequence"/>
<xs:element ref="xs:any"/>
</xs:choice>
</xs:group>
top

Model Group: particle

Name particle
XML Instance Representation
Start Choice [1]
<xs:element> xs:localElement </xs:element> [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:all> ... </xs:all> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
<xs:any> ... </xs:any> [1]
End Choice
Schema Component Representation
<xs:group name="particle">
<xs:choice>
<xs:element name="element" type="xs:localElement"/>
<xs:element name="group" type="xs:groupRef"/>
<xs:element ref="xs:all"/>
<xs:element ref="xs:choice"/>
<xs:element ref="xs:sequence"/>
<xs:element ref="xs:any"/>
</xs:choice>
</xs:group>
top

Model Group: redefinable

Name redefinable
Documentation This group is for the elements which can self-redefine (see <redefine> below).
XML Instance Representation
Start Choice [1]
<xs:simpleType> ... </xs:simpleType> [1]
<xs:complexType> ... </xs:complexType> [1]
<xs:group> ... </xs:group> [1]
<xs:attributeGroup> ... </xs:attributeGroup> [1]
End Choice
Schema Component Representation
<xs:group name="redefinable">
<xs:choice>
<xs:element ref="xs:simpleType"/>
<xs:element ref="xs:complexType"/>
<xs:element ref="xs:group"/>
<xs:element ref="xs:attributeGroup"/>
</xs:choice>
</xs:group>
top

Model Group: schemaTop

Name schemaTop
Documentation This group is for the elements which occur freely at the top level of schemas. All of their types are based on the "annotated" type by extension.
XML Instance Representation
Start Choice [1]
Start Choice [1]
<xs:simpleType> ... </xs:simpleType> [1]
<xs:complexType> ... </xs:complexType> [1]
<xs:group> ... </xs:group> [1]
<xs:attributeGroup> ... </xs:attributeGroup> [1]
End Choice
<xs:element> ... </xs:element> [1]
<xs:attribute> ... </xs:attribute> [1]
<xs:notation> ... </xs:notation> [1]
End Choice
Schema Component Representation
<xs:group name="schemaTop">
<xs:choice>
<xs:group ref="xs:redefinable"/>
<xs:element ref="xs:element"/>
<xs:element ref="xs:attribute"/>
<xs:element ref="xs:notation"/>
</xs:choice>
</xs:group>
top

Model Group: simpleDerivation

Name simpleDerivation
XML Instance Representation
Start Choice [1]
<xs:restriction> ... </xs:restriction> [1]
<xs:list> ... </xs:list> [1]
<xs:union> ... </xs:union> [1]
End Choice
Schema Component Representation
<xs:group name="simpleDerivation">
<xs:choice>
<xs:element ref="xs:restriction"/>
<xs:element ref="xs:list"/>
<xs:element ref="xs:union"/>
</xs:choice>
</xs:group>
top

Model Group: simpleRestrictionModel

Name simpleRestrictionModel
XML Instance Representation
<xs:simpleType> xs:localSimpleType </xs:simpleType> [0..1]
Start Group: xs:facets [0..*]
Start Choice [1]
<xs:minExclusive> ... </xs:minExclusive> [1]
<xs:minInclusive> ... </xs:minInclusive> [1]
<xs:maxExclusive> ... </xs:maxExclusive> [1]
<xs:maxInclusive> ... </xs:maxInclusive> [1]
<xs:totalDigits> ... </xs:totalDigits> [1]
<xs:fractionDigits> ... </xs:fractionDigits> [1]
<xs:length> ... </xs:length> [1]
<xs:minLength> ... </xs:minLength> [1]
<xs:maxLength> ... </xs:maxLength> [1]
<xs:enumeration> ... </xs:enumeration> [1]
<xs:whiteSpace> ... </xs:whiteSpace> [1]
<xs:pattern> ... </xs:pattern> [1]
End Choice
End Group: xs:facets
Schema Component Representation
<xs:group name="simpleRestrictionModel">
<xs:sequence>
<xs:element name="simpleType" type="xs:localSimpleType" minOccurs="0"/>
<xs:group ref="xs:facets" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
top

Model Group: typeDefParticle

Name typeDefParticle
Documentation 'complexType' uses this
XML Instance Representation
Start Choice [1]
<xs:group> xs:groupRef </xs:group> [1]
<xs:all> ... </xs:all> [1]
<xs:choice> ... </xs:choice> [1]
<xs:sequence> ... </xs:sequence> [1]
End Choice
Schema Component Representation
<xs:group name="typeDefParticle">
<xs:choice>
<xs:element name="group" type="xs:groupRef"/>
<xs:element ref="xs:all"/>
<xs:element ref="xs:choice"/>
<xs:element ref="xs:sequence"/>
</xs:choice>
</xs:group>
top

Notation: XML

Name XML
Public Identifier REC-xml-19980210
System Identifier http://www.w3.org/TR/1998/REC-xml-19980210
Schema Component Representation
<xs:notation name="XML" public="REC-xml-19980210" system="http://www.w3.org/TR/1998/REC-xml-19980210"/>
top

Notation: XMLSchemaStructures

Name XMLSchemaStructures
Public Identifier structures
System Identifier http://www.w3.org/2000/08/XMLSchema.xsd
Schema Component Representation
<xs:notation name="XMLSchemaStructures" public="structures" system="http://www.w3.org/2000/08/XMLSchema.xsd"/>
top

Simple Type: ENTITIES

Super-types: Local type definition < ENTITIES (by restriction)
Sub-types: None
Name ENTITIES
Content
  • length >= 1
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#ENTITIES.
Application Data <hfp:hasFacet name="length"/> <hfp:hasFacet name="minLength"/> <hfp:hasFacet name="maxLength"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasProperty name="ordered" value="false"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="ENTITIES" id="ENTITIES">
<xs:restriction>
<xs:simpleType>
<xs:list itemType="xs:ENTITY"/>
</xs:simpleType>
<xs:minLength value="1" id="ENTITIES.minLength"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: ENTITY

Super-types: xs:anySimpleType < string (by restriction) < normalizedString (by restriction) < token (by restriction) < Name (by restriction) < NCName (by restriction) < ENTITY (by restriction)
Sub-types: None
Name ENTITY
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#ENTITY.
Schema Component Representation
<xs:simpleType name="ENTITY" id="ENTITY">
<xs:restriction base="xs:NCName"/>
</xs:simpleType>
top

Simple Type: ID

Super-types: xs:anySimpleType < string (by restriction) < normalizedString (by restriction) < token (by restriction) < Name (by restriction) < NCName (by restriction) < ID (by restriction)
Sub-types: None
Name ID
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#ID.
Schema Component Representation
<xs:simpleType name="ID" id="ID">
<xs:restriction base="xs:NCName"/>
</xs:simpleType>
top

Simple Type: IDREF

Super-types: xs:anySimpleType < string (by restriction) < normalizedString (by restriction) < token (by restriction) < Name (by restriction) < NCName (by restriction) < IDREF (by restriction)
Sub-types: None
Name IDREF
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#IDREF.
Schema Component Representation
<xs:simpleType name="IDREF" id="IDREF">
<xs:restriction base="xs:NCName"/>
</xs:simpleType>
top

Simple Type: IDREFS

Super-types: Local type definition < IDREFS (by restriction)
Sub-types: None
Name IDREFS
Content
  • length >= 1
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#IDREFS.
Application Data <hfp:hasFacet name="length"/> <hfp:hasFacet name="minLength"/> <hfp:hasFacet name="maxLength"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasProperty name="ordered" value="false"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="IDREFS" id="IDREFS">
<xs:restriction>
<xs:simpleType>
<xs:list itemType="xs:IDREF"/>
</xs:simpleType>
<xs:minLength value="1" id="IDREFS.minLength"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: NCName

Super-types: xs:anySimpleType < string (by restriction) < normalizedString (by restriction) < token (by restriction) < Name (by restriction) < NCName (by restriction)
Sub-types:
  • ID (by restriction)
  • IDREF (by restriction)
  • ENTITY (by restriction)
Name NCName
Content
  • pattern = [\i-[:]][\c-[:]]*
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#NCName.
Schema Component Representation
<xs:simpleType name="NCName" id="NCName">
<xs:restriction base="xs:Name">
<xs:pattern value="[\i-[:]][\c-[:]]*" id="NCName.pattern"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: NMTOKEN

Super-types: xs:anySimpleType < string (by restriction) < normalizedString (by restriction) < token (by restriction) < NMTOKEN (by restriction)
Sub-types:
Name NMTOKEN
Content
  • pattern = \c+
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#NMTOKEN.
Schema Component Representation
<xs:simpleType name="NMTOKEN" id="NMTOKEN">
<xs:restriction base="xs:token">
<xs:pattern value="\c+" id="NMTOKEN.pattern"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: NMTOKENS

Super-types: Local type definition < NMTOKENS (by restriction)
Sub-types: None
Name NMTOKENS
Content
  • length >= 1
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#NMTOKENS.
Application Data <hfp:hasFacet name="length"/> <hfp:hasFacet name="minLength"/> <hfp:hasFacet name="maxLength"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasProperty name="ordered" value="false"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="NMTOKENS" id="NMTOKENS">
<xs:restriction>
<xs:simpleType>
<xs:list itemType="xs:NMTOKEN"/>
</xs:simpleType>
<xs:minLength value="1" id="NMTOKENS.minLength"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: NOTATION

Super-types: xs:anySimpleType < NOTATION (by restriction)
Sub-types: None
Name NOTATION
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#NOTATION.

NOTATION cannot be used directly in a schema; rather a type must be derived from it by specifying at least one enumeration facet whose value is the name of a NOTATION declared in the schema.
Application Data <hfp:hasFacet name="length"/> <hfp:hasFacet name="minLength"/> <hfp:hasFacet name="maxLength"/> <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasProperty name="ordered" value="false"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="NOTATION" id="NOTATION">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="NOTATION.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: Name

Super-types: xs:anySimpleType < string (by restriction) < normalizedString (by restriction) < token (by restriction) < Name (by restriction)
Sub-types:
Name Name
Content
  • pattern = \i\c*
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#Name.
Schema Component Representation
<xs:simpleType name="Name" id="Name">
<xs:restriction base="xs:token">
<xs:pattern value="\i\c*" id="Name.pattern"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: QName

Super-types: xs:anySimpleType < QName (by restriction)
Sub-types: None
Name QName
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#QName.
Application Data <hfp:hasFacet name="length"/> <hfp:hasFacet name="minLength"/> <hfp:hasFacet name="maxLength"/> <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasProperty name="ordered" value="false"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="QName" id="QName">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="QName.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: allNNI

Super-types: None
Sub-types: None
Name allNNI
Content
Documentation for maxOccurs
Schema Component Representation
<xs:simpleType name="allNNI">
<xs:union memberTypes="xs:nonNegativeInteger">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="unbounded"/>
</xs:restriction>
</xs:simpleType>
</xs:union>
</xs:simpleType>
top

Simple Type: anyURI

Super-types: xs:anySimpleType < anyURI (by restriction)
Sub-types: None
Name anyURI
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#anyURI.
Application Data <hfp:hasFacet name="length"/> <hfp:hasFacet name="minLength"/> <hfp:hasFacet name="maxLength"/> <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasProperty name="ordered" value="false"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="anyURI" id="anyURI">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="anyURI.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: base64Binary

Super-types: xs:anySimpleType < base64Binary (by restriction)
Sub-types: None
Name base64Binary
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#base64Binary.
Application Data <hfp:hasFacet name="length"/> <hfp:hasFacet name="minLength"/> <hfp:hasFacet name="maxLength"/> <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasProperty name="ordered" value="false"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="base64Binary" id="base64Binary">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="base64Binary.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: blockSet

Super-types: None
Sub-types: None
Name blockSet
Content
  • Union of following types:
    • Locally defined type:
      • value comes from list: {'#all'}
    • Locally defined type:
      • List of:
        • Locally defined type:
          • value comes from list: {'extension'|'restriction'|'substitution'}
Documentation A utility type, not for public use

#all or (possibly empty) subset of {substitution, extension, restriction}
Schema Component Representation
<xs:simpleType name="blockSet">
<xs:union>
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="#all"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType>
<xs:list>
<xs:simpleType>
<xs:restriction base="xs:derivationControl">
<xs:enumeration value="extension"/>
<xs:enumeration value="restriction"/>
<xs:enumeration value="substitution"/>
</xs:restriction>
</xs:simpleType>
</xs:list>
</xs:simpleType>
</xs:union>
</xs:simpleType>
top

Simple Type: boolean

Super-types: xs:anySimpleType < boolean (by restriction)
Sub-types: None
Name boolean
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#boolean.
Application Data <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasProperty name="ordered" value="false"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="finite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="boolean" id="boolean">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="boolean.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: byte

Super-types: xs:anySimpleType < decimal (by restriction) < integer (by restriction) < long (by restriction) < int (by restriction) < short (by restriction) < byte (by restriction)
Sub-types: None
Name byte
Content
  • -128 <= value <= 127
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#byte.
Schema Component Representation
<xs:simpleType name="byte" id="byte">
<xs:restriction base="xs:short">
<xs:minInclusive value="-128" id="byte.minInclusive"/>
<xs:maxInclusive value="127" id="byte.maxInclusive"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: date

Super-types: xs:anySimpleType < date (by restriction)
Sub-types: None
Name date
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#date.
Application Data <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="maxInclusive"/> <hfp:hasFacet name="maxExclusive"/> <hfp:hasFacet name="minInclusive"/> <hfp:hasFacet name="minExclusive"/> <hfp:hasProperty name="ordered" value="partial"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="date" id="date">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="date.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: dateTime

Super-types: xs:anySimpleType < dateTime (by restriction)
Sub-types: None
Name dateTime
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#dateTime.
Application Data <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="maxInclusive"/> <hfp:hasFacet name="maxExclusive"/> <hfp:hasFacet name="minInclusive"/> <hfp:hasFacet name="minExclusive"/> <hfp:hasProperty name="ordered" value="partial"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="dateTime" id="dateTime">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="dateTime.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: decimal

Super-types: xs:anySimpleType < decimal (by restriction)
Sub-types:
Name decimal
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#decimal.
Application Data <hfp:hasFacet name="totalDigits"/> <hfp:hasFacet name="fractionDigits"/> <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="maxInclusive"/> <hfp:hasFacet name="maxExclusive"/> <hfp:hasFacet name="minInclusive"/> <hfp:hasFacet name="minExclusive"/> <hfp:hasProperty name="ordered" value="total"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="true"/>
Schema Component Representation
<xs:simpleType name="decimal" id="decimal">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="decimal.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: derivationControl

Super-types: xs:anySimpleType < string (by restriction) < normalizedString (by restriction) < token (by restriction) < NMTOKEN (by restriction) < derivationControl (by restriction)
Sub-types:
Name derivationControl
Content
  • value comes from list: {'substitution'|'extension'|'restriction'|'list'|'union'}
Documentation A utility type, not for public use
Schema Component Representation
<xs:simpleType name="derivationControl">
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="substitution"/>
<xs:enumeration value="extension"/>
<xs:enumeration value="restriction"/>
<xs:enumeration value="list"/>
<xs:enumeration value="union"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: derivationSet

Super-types: None
Sub-types: None
Name derivationSet
Content
Documentation A utility type, not for public use

#all or (possibly empty) subset of {extension, restriction}
Schema Component Representation
<xs:simpleType name="derivationSet">
<xs:union>
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="#all"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType>
<xs:list itemType="xs:reducedDerivationControl"/>
</xs:simpleType>
</xs:union>
</xs:simpleType>
top

Simple Type: double

Super-types: xs:anySimpleType < double (by restriction)
Sub-types: None
Name double
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#double.
Application Data <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="maxInclusive"/> <hfp:hasFacet name="maxExclusive"/> <hfp:hasFacet name="minInclusive"/> <hfp:hasFacet name="minExclusive"/> <hfp:hasProperty name="ordered" value="total"/> <hfp:hasProperty name="bounded" value="true"/> <hfp:hasProperty name="cardinality" value="finite"/> <hfp:hasProperty name="numeric" value="true"/>
Schema Component Representation
<xs:simpleType name="double" id="double">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="double.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: duration

Super-types: xs:anySimpleType < duration (by restriction)
Sub-types: None
Name duration
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#duration.
Application Data <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="maxInclusive"/> <hfp:hasFacet name="maxExclusive"/> <hfp:hasFacet name="minInclusive"/> <hfp:hasFacet name="minExclusive"/> <hfp:hasProperty name="ordered" value="partial"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="duration" id="duration">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="duration.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: float

Super-types: xs:anySimpleType < float (by restriction)
Sub-types: None
Name float
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#float.
Application Data <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="maxInclusive"/> <hfp:hasFacet name="maxExclusive"/> <hfp:hasFacet name="minInclusive"/> <hfp:hasFacet name="minExclusive"/> <hfp:hasProperty name="ordered" value="total"/> <hfp:hasProperty name="bounded" value="true"/> <hfp:hasProperty name="cardinality" value="finite"/> <hfp:hasProperty name="numeric" value="true"/>
Schema Component Representation
<xs:simpleType name="float" id="float">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="float.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: formChoice

Super-types: xs:anySimpleType < string (by restriction) < normalizedString (by restriction) < token (by restriction) < NMTOKEN (by restriction) < formChoice (by restriction)
Sub-types: None
Name formChoice
Content
  • value comes from list: {'qualified'|'unqualified'}
Documentation A utility type, not for public use
Schema Component Representation
<xs:simpleType name="formChoice">
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="qualified"/>
<xs:enumeration value="unqualified"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: gDay

Super-types: xs:anySimpleType < gDay (by restriction)
Sub-types: None
Name gDay
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#gDay.
Application Data <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="maxInclusive"/> <hfp:hasFacet name="maxExclusive"/> <hfp:hasFacet name="minInclusive"/> <hfp:hasFacet name="minExclusive"/> <hfp:hasProperty name="ordered" value="partial"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="gDay" id="gDay">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="gDay.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: gMonth

Super-types: xs:anySimpleType < gMonth (by restriction)
Sub-types: None
Name gMonth
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#gMonth.
Application Data <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="maxInclusive"/> <hfp:hasFacet name="maxExclusive"/> <hfp:hasFacet name="minInclusive"/> <hfp:hasFacet name="minExclusive"/> <hfp:hasProperty name="ordered" value="partial"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="gMonth" id="gMonth">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="gMonth.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: gMonthDay

Super-types: xs:anySimpleType < gMonthDay (by restriction)
Sub-types: None
Name gMonthDay
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#gMonthDay.
Application Data <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="maxInclusive"/> <hfp:hasFacet name="maxExclusive"/> <hfp:hasFacet name="minInclusive"/> <hfp:hasFacet name="minExclusive"/> <hfp:hasProperty name="ordered" value="partial"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="gMonthDay" id="gMonthDay">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="gMonthDay.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: gYear

Super-types: xs:anySimpleType < gYear (by restriction)
Sub-types: None
Name gYear
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#gYear.
Application Data <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="maxInclusive"/> <hfp:hasFacet name="maxExclusive"/> <hfp:hasFacet name="minInclusive"/> <hfp:hasFacet name="minExclusive"/> <hfp:hasProperty name="ordered" value="partial"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="gYear" id="gYear">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="gYear.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: gYearMonth

Super-types: xs:anySimpleType < gYearMonth (by restriction)
Sub-types: None
Name gYearMonth
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#gYearMonth.
Application Data <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="maxInclusive"/> <hfp:hasFacet name="maxExclusive"/> <hfp:hasFacet name="minInclusive"/> <hfp:hasFacet name="minExclusive"/> <hfp:hasProperty name="ordered" value="partial"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="gYearMonth" id="gYearMonth">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="gYearMonth.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: hexBinary

Super-types: xs:anySimpleType < hexBinary (by restriction)
Sub-types: None
Name hexBinary
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#binary.
Application Data <hfp:hasFacet name="length"/> <hfp:hasFacet name="minLength"/> <hfp:hasFacet name="maxLength"/> <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasProperty name="ordered" value="false"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="hexBinary" id="hexBinary">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="hexBinary.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: int

Super-types: xs:anySimpleType < decimal (by restriction) < integer (by restriction) < long (by restriction) < int (by restriction)
Sub-types:
  • short (by restriction)
    • byte (by restriction)
Name int
Content
  • -2147483648 <= value <= 2147483647
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#int.
Schema Component Representation
<xs:simpleType name="int" id="int">
<xs:restriction base="xs:long">
<xs:minInclusive value="-2147483648" id="int.minInclusive"/>
<xs:maxInclusive value="2147483647" id="int.maxInclusive"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: integer

Super-types: xs:anySimpleType < decimal (by restriction) < integer (by restriction)
Sub-types:
Name integer
Content
  • no. of fraction digits = 0
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#integer.
Schema Component Representation
<xs:simpleType name="integer" id="integer">
<xs:restriction base="xs:decimal">
<xs:fractionDigits value="0" fixed="true" id="integer.fractionDigits"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: language

Super-types: xs:anySimpleType < string (by restriction) < normalizedString (by restriction) < token (by restriction) < language (by restriction)
Sub-types: None
Name language
Content
  • pattern = ([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{1,8})*
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#language.
Schema Component Representation
<xs:simpleType name="language" id="language">
<xs:restriction base="xs:token">
<xs:pattern value="([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{1,8})*" id="language.pattern"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: long

Super-types: xs:anySimpleType < decimal (by restriction) < integer (by restriction) < long (by restriction)
Sub-types:
  • int (by restriction)
Name long
Content
  • -9223372036854775808 <= value <= 9223372036854775807
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#long.
Application Data <hfp:hasProperty name="bounded" value="true"/> <hfp:hasProperty name="cardinality" value="finite"/>
Schema Component Representation
<xs:simpleType name="long" id="long">
<xs:restriction base="xs:integer">
<xs:minInclusive value="-9223372036854775808" id="long.minInclusive"/>
<xs:maxInclusive value="9223372036854775807" id="long.maxInclusive"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: namespaceList

Super-types: None
Sub-types: None
Name namespaceList
Content
  • Union of following types:
    • Locally defined type:
      • value comes from list: {'##any'|'##other'}
    • Locally defined type:
      • List of:
        • Locally defined type:
          • Union of following types:
            • xs:anyURI
            • Locally defined type:
              • value comes from list: {'##targetNamespace'|'##local'}
Documentation A utility type, not for public use
Schema Component Representation
<xs:simpleType name="namespaceList">
<xs:union>
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="##any"/>
<xs:enumeration value="##other"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType>
<xs:list>
<xs:simpleType>
<xs:union memberTypes="xs:anyURI">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="##targetNamespace"/>
<xs:enumeration value="##local"/>
</xs:restriction>
</xs:simpleType>
</xs:union>
</xs:simpleType>
</xs:list>
</xs:simpleType>
</xs:union>
</xs:simpleType>
top

Simple Type: negativeInteger

Super-types: xs:anySimpleType < decimal (by restriction) < integer (by restriction) < nonPositiveInteger (by restriction) < negativeInteger (by restriction)
Sub-types: None
Name negativeInteger
Content
  • value <= -1
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#negativeInteger.
Schema Component Representation
<xs:simpleType name="negativeInteger" id="negativeInteger">
<xs:restriction base="xs:nonPositiveInteger">
<xs:maxInclusive value="-1" id="negativeInteger.maxInclusive"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: nonNegativeInteger

Super-types: xs:anySimpleType < decimal (by restriction) < integer (by restriction) < nonNegativeInteger (by restriction)
Sub-types:
Name nonNegativeInteger
Content
  • value >= 0
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#nonNegativeInteger.
Schema Component Representation
<xs:simpleType name="nonNegativeInteger" id="nonNegativeInteger">
<xs:restriction base="xs:integer">
<xs:minInclusive value="0" id="nonNegativeInteger.minInclusive"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: nonPositiveInteger

Super-types: xs:anySimpleType < decimal (by restriction) < integer (by restriction) < nonPositiveInteger (by restriction)
Sub-types:
Name nonPositiveInteger
Content
  • value <= 0
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#nonPositiveInteger.
Schema Component Representation
<xs:simpleType name="nonPositiveInteger" id="nonPositiveInteger">
<xs:restriction base="xs:integer">
<xs:maxInclusive value="0" id="nonPositiveInteger.maxInclusive"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: normalizedString

Super-types: xs:anySimpleType < string (by restriction) < normalizedString (by restriction)
Sub-types:
Name normalizedString
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#normalizedString.
Schema Component Representation
<xs:simpleType name="normalizedString" id="normalizedString">
<xs:restriction base="xs:string">
<xs:whiteSpace value="replace" id="normalizedString.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: positiveInteger

Super-types: xs:anySimpleType < decimal (by restriction) < integer (by restriction) < nonNegativeInteger (by restriction) < positiveInteger (by restriction)
Sub-types: None
Name positiveInteger
Content
  • value >= 1
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#positiveInteger.
Schema Component Representation
<xs:simpleType name="positiveInteger" id="positiveInteger">
<xs:restriction base="xs:nonNegativeInteger">
<xs:minInclusive value="1" id="positiveInteger.minInclusive"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: public

Super-types: xs:anySimpleType < string (by restriction) < normalizedString (by restriction) < token (by restriction) < public (by restriction)
Sub-types: None
Name public
Content
Documentation A utility type, not for public use

A public identifier, per ISO 8879
Schema Component Representation
<xs:simpleType name="public">
<xs:restriction base="xs:token"/>
</xs:simpleType>
top

Simple Type: reducedDerivationControl

Super-types: xs:anySimpleType < string (by restriction) < normalizedString (by restriction) < token (by restriction) < NMTOKEN (by restriction) < derivationControl (by restriction) < reducedDerivationControl (by restriction)
Sub-types: None
Name reducedDerivationControl
Content
  • value comes from list: {'extension'|'restriction'}
Documentation A utility type, not for public use
Schema Component Representation
<xs:simpleType name="reducedDerivationControl">
<xs:restriction base="xs:derivationControl">
<xs:enumeration value="extension"/>
<xs:enumeration value="restriction"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: short

Super-types: xs:anySimpleType < decimal (by restriction) < integer (by restriction) < long (by restriction) < int (by restriction) < short (by restriction)
Sub-types:
  • byte (by restriction)
Name short
Content
  • -32768 <= value <= 32767
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#short.
Schema Component Representation
<xs:simpleType name="short" id="short">
<xs:restriction base="xs:int">
<xs:minInclusive value="-32768" id="short.minInclusive"/>
<xs:maxInclusive value="32767" id="short.maxInclusive"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: simpleDerivationSet

Super-types: None
Sub-types: None
Name simpleDerivationSet
Content
  • Union of following types:
    • Locally defined type:
      • value comes from list: {'#all'}
    • Locally defined type:
      • value comes from list: {'list'|'union'|'restriction'}
Documentation #all or (possibly empty) subset of {restriction, union, list}

A utility type, not for public use
Schema Component Representation
<xs:simpleType name="simpleDerivationSet">
<xs:union>
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="#all"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType>
<xs:restriction base="xs:derivationControl">
<xs:enumeration value="list"/>
<xs:enumeration value="union"/>
<xs:enumeration value="restriction"/>
</xs:restriction>
</xs:simpleType>
</xs:union>
</xs:simpleType>
top

Simple Type: string

Super-types: xs:anySimpleType < string (by restriction)
Sub-types:
Name string
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#string.
Application Data <hfp:hasFacet name="length"/> <hfp:hasFacet name="minLength"/> <hfp:hasFacet name="maxLength"/> <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasProperty name="ordered" value="false"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="string" id="string">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="preserve" id="string.preserve"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: time

Super-types: xs:anySimpleType < time (by restriction)
Sub-types: None
Name time
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#time.
Application Data <hfp:hasFacet name="pattern"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="maxInclusive"/> <hfp:hasFacet name="maxExclusive"/> <hfp:hasFacet name="minInclusive"/> <hfp:hasFacet name="minExclusive"/> <hfp:hasProperty name="ordered" value="partial"/> <hfp:hasProperty name="bounded" value="false"/> <hfp:hasProperty name="cardinality" value="countably infinite"/> <hfp:hasProperty name="numeric" value="false"/>
Schema Component Representation
<xs:simpleType name="time" id="time">
<xs:restriction base="xs:anySimpleType">
<xs:whiteSpace value="collapse" fixed="true" id="time.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: token

Super-types: xs:anySimpleType < string (by restriction) < normalizedString (by restriction) < token (by restriction)
Sub-types:
Name token
Content
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#token.
Schema Component Representation
<xs:simpleType name="token" id="token">
<xs:restriction base="xs:normalizedString">
<xs:whiteSpace value="collapse" id="token.whiteSpace"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: unsignedByte

Super-types: xs:anySimpleType < decimal (by restriction) < integer (by restriction) < nonNegativeInteger (by restriction) < unsignedLong (by restriction) < unsignedInt (by restriction) < unsignedShort (by restriction) < unsignedByte (by restriction)
Sub-types: None
Name unsignedByte
Content
  • value <= 255
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#unsignedByte.
Schema Component Representation
<xs:simpleType name="unsignedByte" id="unsignedByte">
<xs:restriction base="xs:unsignedShort">
<xs:maxInclusive value="255" id="unsignedByte.maxInclusive"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: unsignedInt

Super-types: xs:anySimpleType < decimal (by restriction) < integer (by restriction) < nonNegativeInteger (by restriction) < unsignedLong (by restriction) < unsignedInt (by restriction)
Sub-types:
Name unsignedInt
Content
  • value <= 4294967295
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#unsignedInt.
Schema Component Representation
<xs:simpleType name="unsignedInt" id="unsignedInt">
<xs:restriction base="xs:unsignedLong">
<xs:maxInclusive value="4294967295" id="unsignedInt.maxInclusive"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: unsignedLong

Super-types: xs:anySimpleType < decimal (by restriction) < integer (by restriction) < nonNegativeInteger (by restriction) < unsignedLong (by restriction)
Sub-types:
Name unsignedLong
Content
  • value <= 18446744073709551615
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#unsignedLong.
Application Data <hfp:hasProperty name="bounded" value="true"/> <hfp:hasProperty name="cardinality" value="finite"/>
Schema Component Representation
<xs:simpleType name="unsignedLong" id="unsignedLong">
<xs:restriction base="xs:nonNegativeInteger">
<xs:maxInclusive value="18446744073709551615" id="unsignedLong.maxInclusive"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: unsignedShort

Super-types: xs:anySimpleType < decimal (by restriction) < integer (by restriction) < nonNegativeInteger (by restriction) < unsignedLong (by restriction) < unsignedInt (by restriction) < unsignedShort (by restriction)
Sub-types:
Name unsignedShort
Content
  • value <= 65535
Documentation More information at: http://www.w3.org/TR/xmlschema-2/#unsignedShort.
Schema Component Representation
<xs:simpleType name="unsignedShort" id="unsignedShort">
<xs:restriction base="xs:unsignedInt">
<xs:maxInclusive value="65535" id="unsignedShort.maxInclusive"/>
</xs:restriction>
</xs:simpleType>
top

Legend

Complex Type:

Schema Component Type

AusAddress

Schema Component Name
Super-types: Address < AusAddress (by extension)
Sub-types:
  • QLDAddress (by restriction)
If this schema component is a type definition, its type hierarchy is shown in a gray-bordered box.
Name AusAddress
Abstract no
The table above displays the properties of this schema component.
XML Instance Representation
<... country="Australia">
<unitNo> string </unitNo> [0..1]
<houseNo> string </houseNo> [1]
<street> string </street> [1]
Start Choice[1]
<city> string </city> [1]
<town> string </town> [1]
End Choice
<state> AusStates </state> [1]
<postcode> string <<pattern = [1-9][0-9]{3}>> </postcode> [1]?
</...>

The XML Instance Representation table above shows the schema component's content as an XML instance.

Schema Component Representation
<complexTypename="AusAddress">
<complexContent>
<extensionbase="Address">
<sequence>
<elementname="state" type="AusStates"/>
<elementname="postcode">
<simpleType>
<restrictionbase="string">
<patternvalue="[1-9][0-9]{3}"/>
</restriction>
</simpleType>
</element>
</sequence>
<attributename="country" type="string" fixed="Australia"/>
</extension>
</complexContent>
</complexType>
The Schema Component Representation table above displays the underlying XML representation of the schema component. (Annotations are not shown.)
top

Glossary

Abstract (Applies to complex type definitions and element declarations). An abstract element or complex type cannot used to validate an element instance. If there is a reference to an abstract element, only element declarations that can substitute the abstract element can be used to validate the instance. For references to abstract type definitions, only derived types can be used.

All Model Group Child elements can be provided in any order in instances. See: http://www.w3.org/TR/xmlschema-1/#element-all.

Choice Model Group Only one from the list of child elements and model groups can be provided in instances. See: http://www.w3.org/TR/xmlschema-1/#element-choice.

Collapse Whitespace Policy Replace tab, line feed, and carriage return characters with space character (Unicode character 32). Then, collapse contiguous sequences of space characters into single space character, and remove leading and trailing space characters.

Disallowed Substitutions (Applies to element declarations). If substitution is specified, then substitution group members cannot be used in place of the given element declaration to validate element instances. If derivation methods, e.g. extension, restriction, are specified, then the given element declaration will not validate element instances that have types derived from the element declaration's type using the specified derivation methods. Normally, element instances can override their declaration's type by specifying an xsi:type attribute.

Key Constraint Like Uniqueness Constraint, but additionally requires that the specified value(s) must be provided. See: http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions.

Key Reference Constraint Ensures that the specified value(s) must match value(s) from a Key Constraint or Uniqueness Constraint. See: http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions.

Model Group Groups together element content, specifying the order in which the element content can occur and the number of times the group of element content may be repeated. See: http://www.w3.org/TR/xmlschema-1/#Model_Groups.

Nillable (Applies to element declarations). If an element declaration is nillable, instances can use the xsi:nil attribute. The xsi:nil attribute is the boolean attribute, nil, from the http://www.w3.org/2001/XMLSchema-instance namespace. If an element instance has an xsi:nil attribute set to true, it can be left empty, even though its element declaration may have required content.

Notation A notation is used to identify the format of a piece of data. Values of elements and attributes that are of type, NOTATION, must come from the names of declared notations. See: http://www.w3.org/TR/xmlschema-1/#cNotation_Declarations.

Preserve Whitespace Policy Preserve whitespaces exactly as they appear in instances.

Prohibited Derivations (Applies to type definitions). Derivation methods that cannot be used to create sub-types from a given type definition.

Prohibited Substitutions (Applies to complex type definitions). Prevents sub-types that have been derived using the specified derivation methods from validating element instances in place of the given type definition.

Replace Whitespace Policy Replace tab, line feed, and carriage return characters with space character (Unicode character 32).

Sequence Model Group Child elements and model groups must be provided in the specified order in instances. See: http://www.w3.org/TR/xmlschema-1/#element-sequence.

Substitution Group Elements that are members of a substitution group can be used wherever the head element of the substitution group is referenced.

Substitution Group Exclusions (Applies to element declarations). Prohibits element declarations from nominating themselves as being able to substitute a given element declaration, if they have types that are derived from the original element's type using the specified derivation methods.

Target Namespace The target namespace identifies the namespace that components in this schema belongs to. If no target namespace is provided, then the schema components do not belong to any namespace.

Uniqueness Constraint Ensures uniqueness of an element/attribute value, or a combination of values, within a specified scope. See: http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions.

top

Generated by xs3p (old link) . Last modified: