W3C XML Schema Definition Language (XSD) 1.1 Part 2: Datatypes

The actual value of the name [attribute], if present on the <simpleType> element, otherwise absent

The actual value of the targetNamespace [attribute] of the parent schema element information item, if present, otherwise absent.

The appropriate case among the following:

1 If the <restriction> alternative is chosen, then the type definition resolved to by the actual value of the base [attribute] of <restriction>, if present, otherwise the type definition corresponding to the <simpleType> among the [children] of <restriction>.

2 If the <list> or <union> alternative is chosen, then ·anySimpleType·.

A subset of {restriction, extension, list, union}, determined as follows. [Definition:] Let FS be the actual value of the final [attribute], if present, otherwise the actual value of the finalDefault [attribute] of the ancestor schema element, if present, otherwise the empty string. Then the property value is the appropriate case among the following:

1 If ·FS· is the empty string, then the empty set;

2 If ·FS· is '#all', then {restriction, extension, list, union};

3 otherwise Consider ·FS· as a space-separated list, and include restriction if 'restriction' is in that list, and similarly for extension, list and union.

The appropriate case among the following:

1 If the name [attribute] is present, then absent

2 otherwise the appropriate case among the following:

2.1 If the parent element information item is <attribute>, then the corresponding Attribute Declaration

2.2 If the parent element information item is <element>, then the corresponding Element Declaration

2.3 If the parent element information item is <list> or <union>, then the Simple Type Definition corresponding to the grandparent <simpleType> element information item

2.4 otherwise (the parent element information item is <restriction>), the appropriate case among the following:

2.4.1 If the grandparent element information item is <simpleType>, then the Simple Type Definition corresponding to the grandparent

2.4.2 otherwise (the grandparent element information item is <simpleContent>), the Simple Type Definition which is the {content type} of the Complex Type Definition corresponding to the great-grandparent <complexType> element information item.

{variety}

If the <list> alternative is chosen, then list, otherwise if the <union> alternative is chosen, then union, otherwise (the <restriction> alternative is chosen) the {variety} of the {base type definition}.

{facets}

The appropriate case among the following:

1 If the <restriction> alternative is chosen, then the set of Constraining Facet components obtained by overlaying the {facets} of the {base type definition} with the set of Constraining Facet components corresponding to those [children] of <restriction> which specify facets, as defined in Schema Component Constraint: Simple Type Restriction (Facets) .

2 If the <list> alternative is chosen, then a set with one member, a whiteSpace facet with {value} = collapse and {fixed} = true.

3 otherwise the empty set

{fundamental facets}

Based on {variety}, {facets}, {base type definition} and {member type definitions}, a set of Fundamental Facet components, one each as specified in The ordered Schema Component (§4.2.1.1), The bounded Schema Component (§4.2.2.1), The cardinality Schema Component (§4.2.3.1) and The numeric Schema Component (§4.2.4.1).

The annotation mapping of the set of elements containing the <simpleType>, and the <restriction>, the <list>, or the <union> [child], whichever is present, as defined in section XML Representation of Annotation Schema Components of [XSD 1.1 Part 1: Structures].

[Definition:] The ancestors of a type definition are its {base type definition} and the ·ancestors· of its {base type definition}. (The ancestors of a Simple Type Definition T in the type hierarchy are themselves type definitions; they are distinct from the XML elements which may be ancestors, in the XML document hierarchy, of the <simpleType> element which declares T.)

If the {variety} is atomic, the following additional property mapping also applies:

Atomic Simple Type Definition Schema Component

Property

Representation

From among the ·ancestors· of this Simple Type Definition, that Simple Type Definition which corresponds to a ·primitive· datatype.

Example

An electronic commerce schema might define a datatype called 'SKU' (the barcode number that appears on products) from the ·built-in· datatype string by supplying a value for the ·pattern· facet.

<simpleType name='SKU'>
    <restriction base='string'>
      <pattern value='\d{3}-[A-Z]{2}'/>
    </restriction>
</simpleType>

In this case, 'SKU' is the name of the new ·user-defined· datatype, string is its ·base type· and ·pattern· is the facet.

If the {variety} is list, the following additional property mappings also apply:

List Simple Type Definition Schema Component

Property

Representation

The appropriate case among the following:

1 If the {base type definition} is ·anySimpleType·, then the Simple Type Definition (a) resolved to by the actual value of the itemType [attribute] of <list>, or (b) corresponding to the <simpleType> among the [children] of <list>, whichever is present.

Note: In this case, a <list> element will invariably be present; it will invariably have either an itemType [attribute] or a <simpleType> [child], but not both.

2 otherwise (that is, the {base type definition} is not ·anySimpleType·), the {item type definition} of the {base type definition}.

Note: In this case, a <restriction> element will invariably be present.

Example

A system might want to store lists of floating point values.

<simpleType name='listOfFloat'>
  <list itemType='float'/>
</simpleType>

In this case, listOfFloat is the name of the new ·user-defined· datatype, float is its ·item type· and ·list· is the derivation method.

If the {variety} is union, the following additional property mappings also apply:

Union Simple Type Definition Schema Component

Property

Representation

Simple type definition of anySimpleType

The appropriate case among the following:

1 If the {base type definition} is ·anySimpleType·, then the sequence of (a) the Simple Type Definitions (a) resolved to by the items in the actual value of the memberTypes [attribute] of <union>, if any, and (b) those corresponding to the <simpleType>s among the [children] of <union>, if any, in order.

Note: In this case, a <union> element will invariably be present; it will invariably have either a memberTypes [attribute] or one or more <simpleType> [children], or both.

2 otherwise (that is, the {base type definition} is not ·anySimpleType·), the {member type definitions} of the {base type definition}.

Note: In this case, a <restriction> element will invariably be present.

Example

As an example, taken from a typical display oriented text markup language, one might want to express font sizes as an integer between 8 and 72, or with one of the tokens "small", "medium" or "large". The ·union· Simple Type Definition below would accomplish that.

<xs:attribute name="size">
  <xs:simpleType>
    <xs:union>
      <xs:simpleType>
        <xs:restriction base="xs:positiveInteger">
          <xs:minInclusive value="8"/>
          <xs:maxInclusive value="72"/>
        </xs:restriction>
      </xs:simpleType>
      <xs:simpleType>
        <xs:restriction base="xs:NMTOKEN">
          <xs:enumeration value="small"/>
          <xs:enumeration value="medium"/>
          <xs:enumeration value="large"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:union>
  </xs:simpleType>
</xs:attribute>

<p>
<font size='large'>A header</font>
</p>
<p>
<font size='12'>this is a test</font>
</p>

A datatype can be ·constructed· from a ·primitive· datatype or an ·ordinary· datatype by one of three means: by ·facet-based restriction·, by ·list· or by ·union·.

4.1.3 Constraints on XML Representation of Simple Type Definition

Schema Representation Constraint: itemType attribute or simpleType child

Either the itemType [attribute] or the <simpleType> [child] of the <list> element ↓must↓↑must↑ be present, but not both.

Schema Representation Constraint: base attribute or simpleType child

Either the base [attribute] or the simpleType [child] of the <restriction> element ↓must↓↑must↑ be present, but not both.

Schema Representation Constraint: memberTypes attribute or simpleType children

Either the memberTypes [attribute] of the <union> element ↓must↓↑must↑ be non-empty or there ↓must↓↑must↑ be at least one simpleType [child].

4.1.4 Simple Type Definition Validation Rules

Validation Rule: Facet Valid

A value in a ·value space· is facet-valid with respect to a ·constraining facet· component if and only if:

1 the value is facet-valid with respect to the particular ·constraining facet· as specified below.

Validation Rule: Datatype Valid

A ·literal· is datatype-valid with respect to a Simple Type Definition if and only if it is a member of the ·lexical space· of the corresponding datatype.

Note: Since every value in the ·value space· is denoted by some ·literal·, and every ·literal· in the ·lexical space· maps to some value, the requirement that the ·literal· be in the ·lexical space· entails the requirement that the value it maps to should fulfill all of the constraints imposed by the {facets} of the datatype. If the datatype is a ·list·, the Datatype Valid constraint also entails that each whitespace-delimited token in the list be datatype-valid against the ·item type· of the list. If the datatype is a ·union·, the Datatype Valid constraint entails that the ·literal· be datatype-valid against at least one of the ·member types·.

That is, the constraints on Simple Type Definitions and on datatype ·derivation· defined in this specification have as a consequence that a ·literal· L is datatype-valid with respect to a Simple Type Definition T if and only if either T corresponds to a ·special· datatype or all of the following are true:

1 If there is a pattern in {facets}, then L is pattern valid (§4.3.4.4) with respect to the pattern. If there are other ·lexical· facets in {facets}, then L is facet-valid with respect to them.

2 The appropriate case among the following is true:

2.1 If the {variety} of T is ·atomic·, then L is in the ·lexical space· of the {primitive type definition} of T, as defined in the appropriate documentation. Let V be the member of the ·value space· of the {primitive type definition} of T mapped to by L, as defined in the appropriate documentation.

Note: For ·built-in· ·primitives·, the "appropriate documentation" is the relevant section of this specification. For ·implementation-defined· ·primitives·, it is the normative specification of the ·primitive·, which will typically be included in, or referred to from, the implementation's documentation.

2.2 If the {variety} of T is ·list·, then each space-delimited substring of L is Datatype Valid with respect to the {item type definition} of T. Let V be the sequence consisting of the values identified by Datatype Valid for each of those substrings, in order.

2.3 If the {variety} of T is ·union·, then L is Datatype Valid with respect to at least one member of the {member type definitions} of T. Let B be the ·active basic member· of T for L. Let V be the value identified by Datatype Valid for L with respect to B.

3 V, as determined by the appropriate sub-clause of clause 2 above, is Facet Valid (§4.1.4) with respect to each member of the {facets} of T which is a ·value-based· (and not a ·pre-lexical· or ·lexical·) facet.

Note that whiteSpace facets and other ·pre-lexical· facets do not take part in checking Datatype Valid. In cases where this specification is used in conjunction with schema-validation of XML documents, such facets are used to normalize infoset values before the normalized results are checked for datatype validity. In the case of unions the ·pre-lexical· facets to use are those associated with B in clause 2.3 above. When more than one ·pre-lexical· facet applies, the whiteSpace facet is applied first; the order in which ·implementation-defined· facets are applied is ·implementation-defined·.

4.1.5 Constraints on Simple Type Definition Schema Components

Schema Component Constraint: Applicable Facets

The ·constraining facets· which are allowed to be members of {facets} depend on the {variety} and {primitive type definition} of the type, as follows:

If {variety} is absent, then no facets are applicable. (This is true for anySimpleType.)

If {variety} is list, then the applicable facets are assertions, length, minLength, maxLength, pattern, enumeration, and whiteSpace.

If {variety} is union, then the applicable facets are pattern, enumeration, and assertions.

If {variety} is atomic, and {primitive type definition} is absent then no facets are applicable. (This is true for anyAtomicType.)

In all other cases ({variety} is atomic and {primitive type definition} is not absent), then the applicable facets are shown in the table below.

{primitive type definition}	applicable {facets}
string	length, minLength, maxLength, pattern, enumeration, whiteSpace, assertions
boolean	pattern, whiteSpace, assertions
float	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive, assertions
double	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive, assertions
decimal	totalDigits, fractionDigits, pattern, whiteSpace, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive, assertions
duration	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive, assertions
dateTime	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive, assertions, explicitTimezone
time	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive, assertions, explicitTimezone
date	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive, assertions, explicitTimezone
gYearMonth	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive, assertions, explicitTimezone
gYear	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive, assertions, explicitTimezone
gMonthDay	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive, assertions, explicitTimezone
gDay	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive, assertions, explicitTimezone
gMonth	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive, assertions, explicitTimezone
hexBinary	length, minLength, maxLength, pattern, enumeration, whiteSpace, assertions
base64Binary	length, minLength, maxLength, pattern, enumeration, whiteSpace, assertions
anyURI	length, minLength, maxLength, pattern, enumeration, whiteSpace, assertions
QName	length, minLength, maxLength, pattern, enumeration, whiteSpace, assertions
NOTATION	length, minLength, maxLength, pattern, enumeration, whiteSpace, assertions

Note: For any ·implementation-defined· primitive types, it is ·implementation-defined· which constraining facets are applicable to them.

Similarly, for any ·implementation-defined· constraining facets, it is ·implementation-defined· which ·primitives· they apply to.

4.1.6 Built-in Simple Type Definitions

The Simple Type Definition of anySimpleType is present in every schema. It has the following properties:

Property

Value

'anySimpleType'

'http://www.w3.org/2001/XMLSchema'

The empty set

absent

The empty set

The empty set

absent

absent

absent

absent

Simple type definition of anyAtomicType

The empty sequence

The definition of anySimpleType is the root of the Simple Type Definition hierarchy; as such it mediates between the other simple type definitions, which all eventually trace back to it via their {base type definition} properties, and the definition of anyType, which is its {base type definition}.

The Simple Type Definition of anyAtomicType is present in every schema. It has the following properties:

Property

Value

'anyAtomicType'

'http://www.w3.org/2001/XMLSchema'

The empty set

absent

The empty set

The empty set

atomic

absent

absent

absent

Simple Type Definition corresponding to the built-in primitive datatypes

The empty sequence

Simple type definitions for all the built-in primitive datatypes, namely string, boolean, float, double, decimal, dateTime, duration, time, date, gMonth, gMonthDay, gDay, gYear, gYearMonth, hexBinary, base64Binary, anyURI are present by definition in every schema. All have a very similar structure, with only the {name}, the {primitive type definition} (which is self-referential), the {fundamental facets}, and in one case the {facets} varying from one to the next:

Property

Value

[as appropriate]

'http://www.w3.org/2001/XMLSchema'

anyAtomicType Definition

The empty set

{variety}

atomic

[this Simple Type Definition itself]

{facets}

{a whiteSpace facet with {value} = collapse and {fixed} = true in all cases except string, which has {value} = preserve and {fixed} = false}

{fundamental facets}

[as appropriate]

absent

absent

absent

Simple Type Definition corresponding to the built-in ordinary datatypes

The empty sequence

·Implementation-defined· ·primitives· must have a Simple Type Definition with the values shown above, with the following exceptions.

The {facets} property must contain a whiteSpace facet, the value of which is ·implementation-defined·. It may contain other facets, whether defined in this specification or ·implementation-defined·.
The value of {fundamental facets} is ·implementation-defined·.
The value of {annotations} may be empty, but need not be.

Note: It is a consequence of the rule just given that each ·implementation-defined· ·primitive· will have an expanded name by which it can be referred to.

Note: ·Implementation-defined· datatypes will normally have a value other than 'http://www.w3.org/2001/XMLSchema' for the {target namespace} property. That namespace is controlled by the W3C and datatypes will be added to it only by W3C or its designees.

Similarly, Simple Type Definitions for all the built-in ·ordinary· datatypes are present by definition in every schema, with properties as specified in Other Built-in Datatypes (§3.4) and as represented in XML in Illustrative XML representations for the built-in ordinary type definitions (§C.2).

Property

Value

[as appropriate]

'http://www.w3.org/2001/XMLSchema'

[as specified in the appropriate sub-section of Other Built-in Datatypes (§3.4)]

The empty set

{variety}

[atomic or list, as specified in the appropriate sub-section of Other Built-in Datatypes (§3.4)]

[if {variety} is atomic, then the {primitive type definition} of the {base type definition}, otherwise absent]

{facets}

[as specified in the appropriate sub-section of Other Built-in Datatypes (§3.4)]

{fundamental facets}

[as specified in the appropriate sub-section of Other Built-in Datatypes (§3.4)]

absent

if {variety} is atomic, then absent, otherwise as specified in the appropriate sub-section of Other Built-in Datatypes (§3.4)]

absent

As shown in the XML representations of the ordinary built-in datatypes in Illustrative XML representations for the built-in ordinary type definitions (§C.2)

4.2 Fundamental Facets

        4.2.1 ordered
            4.2.1.1 The ordered Schema Component
        4.2.2 bounded
            4.2.2.1 The bounded Schema Component
        4.2.3 cardinality
            4.2.3.1 The cardinality Schema Component
        4.2.4 numeric
            4.2.4.1 The numeric Schema Component

[Definition:] Each fundamental facet is a schema component that provides a limited piece of information about some aspect of each datatype. All ·fundamental facet· components are defined in this section. For example, cardinality is a ·fundamental facet·. Most ·fundamental facets· are given a value fixed with each primitive datatype's definition, and this value is not changed by subsequent ·derivations· (even when it would perhaps be reasonable to expect an application to give a more accurate value based on the constraining facets used to define the ·derivation·). The cardinality and bounded facets are exceptions to this rule; their values may change as a result of certain ·derivations·.

Note: Schema components are identified by kind. "Fundamental" is not a kind of component. Each kind of ·fundamental facet· ("ordered", "bounded", etc.) is a separate kind of schema component.

A ·fundamental facet· can occur only in the {fundamental facets} of a Simple Type Definition, and this is the only place where ·fundamental facet· components occur. Each kind of ·fundamental facet· component occurs (once) in each Simple Type Definition's {fundamental facets} set.

Note: The value of any ·fundamental facet· component can always be calculated from other properties of its ·owner·. Fundamental facets are not required for schema processing, but some applications use them.

4.2.1 ordered

For some datatypes, this document specifies an order relation for their value spaces (see Order (§2.2.3)); the ordered facet reflects this. It takes the values total, partial, and false, with the meanings described below. For the ·primitive· datatypes, the value of the ordered facet is specified in Fundamental Facets (§F.1). For ·ordinary· datatypes, the value is inherited without change from the ·base type·. For a ·list·, the value is always false; for a ·union·, the value is computed as described below.

A false value means no order is prescribed; a total value assures that the prescribed order is a total order; a partial value means that the prescribed order is a partial order, but not (for the primitive type in question) a total order.

Note: The value false in the ordered facet does not mean no partial or total ordering exists for the value space, only that none is specified by this document for use in checking upper and lower bounds. Mathematically, any set of values possesses at least one trivial partial ordering, in which every value pair that is not equal is incomparable.

Note: When new datatypes are derived from datatypes with partial orders, the constraints imposed can sometimes result in a value space for which the ordering is total, or trivial. The value of the ordered facet is not, however, changed to reflect this. The value partial should therefore be interpreted with appropriate caution.

[Definition:] A ·value space·, and hence a datatype, is said to be ordered if some members of the ·value space· are drawn from a ·primitive· datatype for which the table in Fundamental Facets (§F.1) specifies the value total or partial for the ordered facet.

Note: Some of the "real-world" datatypes which are the basis for those defined herein are ordered in some applications, even though no order is prescribed for schema-processing purposes. For example, boolean is sometimes ordered, and string and ·list· datatypes ·constructed· from ordered ·atomic· datatypes are sometimes given "lexical" orderings. They are not ordered for schema-processing purposes.

4.2.1.1 The ordered Schema Component

Schema Component: ordered, a kind of Fundamental Facet

{value}

One of {false, partial, total}. Required.

{value} depends on the ·owner's· {variety}, {facets}, and {member type definitions}. The appropriate case among the following must be true:

1 If the ·owner's· {variety} is atomic, then the appropriate case among the following must be true:

1.1 If the ·owner· is ·primitive·, then {value} is as specified in the table in Fundamental Facets (§F.1).

1.2 otherwise {value} is the ·owner's· {base type definition}'s ordered {value}.

2 If the ·owner's· {variety} is list, then {value} is false.

3 otherwise the ·owner's· {variety} is union; the appropriate case among the following must be true:

3.1 If every ·basic member· of the ·owner· has {variety} atomic and has the same {primitive type definition}, then {value} is the same as the ordered component's {value} in that primitive type definition's {fundamental facets}.

3.2 If each member of the ·owner's· {member type definitions} has an ordered component in its {fundamental facets} whose {value} is false, then {value} is false.

3.3 otherwise {value} is partial.

4.2.2 bounded

Some ordered datatypes have the property that there is one value greater than or equal to every other value, and another that is less than or equal to every other value. (In the case of ·ordinary· datatypes, these two values are not necessarily in the value space of the derived datatype, but they ↓must be↓↑will always be↑ in the value space of the primitive datatype from which they have been derived.) The bounded facet value is boolean and is generally true for such bounded datatypes. However, it will remain false when the mechanism for imposing such a bound is difficult to detect, as, for example, when the boundedness occurs because of derivation using a pattern component.

4.2.2.1 The bounded Schema Component

Schema Component: bounded, a kind of Fundamental Facet

{value}

An xs:boolean value. Required.

{value} depends on the ·owner's· {variety}, {facets} and {member type definitions}.

When the ·owner· is ·primitive·, {value} is as specified in the table in Fundamental Facets (§F.1). Otherwise, when the ·owner's· {variety} is atomic, if one of minInclusive or minExclusive and one of maxInclusive or maxExclusive are members of the ·owner's· {facets} set, then {value} is true; otherwise {value} is false.

When the ·owner's· {variety} is list, {value} is false.

When the ·owner's· {variety} is union, if {value} is true for every member of the ·owner's· {member type definitions} set and all of the ·owner's· ·basic members· have the same {primitive type definition}, then {value} is true; otherwise {value} is false.

4.2.3 cardinality

Every value space has a specific number of members. This number can be characterized as finite or infinite. (Currently there are no datatypes with infinite value spaces larger than countable.) The cardinality facet value is either finite or countably infinite and is generally finite for datatypes with finite value spaces. However, it will remain countably infinite when the mechanism for causing finiteness is difficult to detect, as, for example, when finiteness occurs because of a derivation using a pattern component.

4.2.3.1 The cardinality Schema Component

Schema Component: cardinality, a kind of Fundamental Facet

{value}

One of {finite, countably infinite}. Required.

{value} depends on the ·owner's· {variety}, {facets}, and {member type definitions}.

When the ·owner· is ·primitive·, {value} is as specified in the table in Fundamental Facets (§F.1). Otherwise, when the ·owner's· {variety} is atomic, {value} is countably infinite unless any of the following conditions are true, in which case {value} is finite:

the ·owner's· {base type definition}'s cardinality {value} is finite,
at least one of length, maxLength, or totalDigits is a member of the ·owner's· {facets} set,
all of the following are true:
1. one of minInclusive or minExclusive is a member of the ·owner's· {facets} set
2. one of maxInclusive or maxExclusive is a member of the ·owner's· {facets} set
3. either of the following are true:
  1. fractionDigits is a member of the ·owner's· {facets} set
  2. {primitive type definition} is one of date, gYearMonth, gYear, gMonthDay, gDay or gMonth

When the ·owner's· {variety} is list, if length or both minLength and maxLength are members of the ·owner's· {facets} set and the ·owner's· {item type definition}'s cardinality {value} is finite then {value} is finite; otherwise {value} is countably infinite.

When the ·owner's· {variety} is union, if cardinality's {value} is finite for every member of the ·owner's· {member type definitions} set then {value} is finite, otherwise {value} is countably infinite.

4.2.4 numeric

Some value spaces are made up of things that are conceptually numeric, others are not. The numeric facet value indicates which are considered numeric.

4.2.4.1 The numeric Schema Component

Schema Component: numeric, a kind of Fundamental Facet

{value}

An xs:boolean value. Required.

{value} depends on the ·owner's· {variety}, {facets}, {base type definition} and {member type definitions}.

When the ·owner· is ·primitive·, {value} is as specified in the table in Fundamental Facets (§F.1). Otherwise, when the ·owner's· {variety} is atomic, {value} is inherited from the ·owner's· {base type definition}'s numeric {value}.

When the ·owner's· {variety} is list, {value} is false.

When the ·owner's· {variety} is union, if numeric's {value} is true for every member of the ·owner's· {member type definitions} set then {value} is true, otherwise {value} is false.

4.3 Constraining Facets

[Definition:] Constraining facets are schema components whose values may be set or changed during ·derivation· (subject to facet-specific controls) to control various aspects of the derived datatype. All ·constraining facet· components defined by this specification are defined in this section. For example, whiteSpace is a ·constraining facet·. ·Constraining Facets· are given a value as part of the ·derivation· when an ·ordinary· datatype is defined by ·restricting· a ·primitive· or ·ordinary· datatype; a few ·constraining facets· have default values that are also provided for ·primitive· datatypes.

Note: Schema components are identified by kind. "Constraining" is not a kind of component. Each kind of ·constraining facet· ("whiteSpace", "length", etc.) is a separate kind of schema component.

This specification distinguishes three kinds of constraining facets:

[Definition:] A constraining facet which is used to normalize an initial ·literal· before checking to see whether the resulting character sequence is a member of a datatype's ·lexical space· is a pre-lexical facet.
This specification defines just one ·pre-lexical· facet: whiteSpace.
[Definition:] A constraining facet which directly restricts the ·lexical space· of a datatype is a lexical facet.
This specification defines just one ·lexical· facet: pattern.
Note: As specified normatively elsewhere, ·lexical· facets can have an indirect effect on the ·value space·: if every lexical representation of a value is removed from the ·lexical space·, the value itself is removed from the ·value space·.
[Definition:] A constraining facet which directly restricts the ·value space· of a datatype is a value-based facet.
Most of the constraining facets defined by this specification are ·value-based· facets.
Note: As specified normatively elsewhere, ·value-based· facets can have an indirect effect on the ·lexical space·: if a value is removed from the ·value space·, its lexical representations are removed from the ·lexical space·.

Conforming processors must support all the facets defined in this section. It is ·implementation-defined· whether a processor supports other constraining facets. [Definition:] An ·constraining facet· which is not supported by the processor in use is unknown.

Note: A reference to an ·unknown· facet might be a reference to an ·implementation-defined· facet supported by some other processor, or might be the result of a typographic error, or might have some other explanation.

The descriptions of individual facets given below include both constraints on Simple Type Definition components and rules for checking the datatype validity of a given literal against a given datatype. The validation rules typically depend upon having a full knowledge of the datatype; full knowledge of the datatype, in turn, depends on having a fully instantiated Simple Type Definition. A full instantiation of the Simple Type Definition, and the checking of the component constraints, require knowledge of the ·base type·. It follows that if a datatype's ·base type· is ·unknown·, the Simple Type Definition defining the datatype will be incompletely instantiated, and the datatype itself will be ·unknown·. Similarly, any datatype defined using an ·unknown· ·constraining facet· will be ·unknown·. It is not possible to perform datatype validation as defined here using ·unknown· datatypes.

Note: The preceding paragraph does not forbid implementations from attempting to make use of such partial information as they have about ·unknown· datatypes. But the exploitation of such partial knowledge is not datatype validity checking as defined here and is to be distinguished from it in the implementation's documentation and interface.

4.3.1 length

[Definition:] length is the number of units of length, where units of length varies depending on the type that is being ·derived· from. The value of length must be a nonNegativeInteger.

For string and datatypes ·derived· from string, length is measured in units of characters as defined in [XML]. For anyURI, length is measured in units of characters (as for string). For hexBinary and base64Binary and datatypes ·derived· from them, length is measured in octets (8 bits) of binary data. For datatypes ·constructed· by ·list·, length is measured in number of list items.

Note: For string and datatypes ·derived· from string, length will not always coincide with "string length" as perceived by some users or with the number of storage units in some digital representation. Therefore, care should be taken when specifying a value for length and in attempting to infer storage requirements from a given value for length.

·length· provides for:

Constraining a ·value space· to values with a specific number of units of length, where units of length varies depending on {base type definition}.

Example

The following is the definition of a ·user-defined· datatype to represent product codes which must be exactly 8 characters in length. By fixing the value of the length facet we ensure that types derived from productCode can change or set the values of other facets, such as pattern, but cannot change the length.

<simpleType name='productCode'>
   <restriction base='string'>
     <length value='8' fixed='true'/>
   </restriction>
</simpleType>

4.3.1.1 The length Schema Component

Schema Component: length, a kind of Constraining Facet

{annotations}

A sequence of Annotation components.

{value}

An xs:nonNegativeInteger value. Required.

{fixed}

An xs:boolean value. Required.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for length other than {value}.

Note: The {fixed} property is defined for parallelism with other facets and for ↓compatiblity↓↑compatibility↑ with version 1.0 of this specification. But it is a consequence of length valid restriction (§4.3.1.4) that the value of the length facet cannot be changed, regardless of whether {fixed} is true or false.

4.3.1.2 XML Representation of length Schema Components

The XML representation for a length schema component is a <length> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: length Element Information Item

<length
  fixed = boolean : false
  id = ID
  value = nonNegativeInteger
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</length>

length Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

The annotation mapping of the <length> element, as defined in section XML Representation of Annotation Schema Components of [XSD 1.1 Part 1: Structures].

4.3.1.3 length Validation Rules

Validation Rule: Length Valid

A value in a ·value space· is facet-valid with respect to ·length· if and only if:

1 if the {variety} is ·atomic· then

1.1 if {primitive type definition} is string or anyURI, then the length of the value, as measured in characters must be equal to {value};

1.2 if {primitive type definition} is hexBinary or base64Binary, then the length of the value, as measured in octets of the binary data, must be equal to {value};

1.3 if {primitive type definition} is QName or NOTATION, then any {value} is facet-valid.

2 if the {variety} is ·list·, then the length of the value, as measured in list items, must be equal to {value}

The use of ·length· on QName, NOTATION, and datatypes ·derived· from them is deprecated. Future versions of this specification may remove this facet for these datatypes.

4.3.1.4 Constraints on length Schema Components

Schema Component Constraint: length and minLength or maxLength

If length is a member of {facets} then

1 It is an error for minLength to be a member of {facets} unless

1.1 the {value} of minLength <= the {value} of length and

1.2 there is some type definition from which this one is derived by one or more ·restriction· steps in which minLength has the same {value} and length is not specified.

2 It is an error for maxLength to be a member of {facets} unless

2.1 the {value} of length <= the {value} of maxLength and

2.2 there is some type definition from which this one is derived by one or more restriction steps in which maxLength has the same {value} and length is not specified.

Schema Component Constraint: length valid restriction

It is an ·error· if length is among the members of {facets} of {base type definition} and {value} is not equal to the {value} of the parent length.

4.3.2 minLength

[Definition:] minLength is the minimum number of units of length, where units of length varies depending on the type that is being ·derived· from. The value of minLength must be a nonNegativeInteger.

For string and datatypes ·derived· from string, minLength is measured in units of characters as defined in [XML]. For hexBinary and base64Binary and datatypes ·derived· from them, minLength is measured in octets (8 bits) of binary data. For datatypes ·constructed· by ·list·, minLength is measured in number of list items.

Note: For string and datatypes ·derived· from string, minLength will not always coincide with "string length" as perceived by some users or with the number of storage units in some digital representation. Therefore, care should be taken when specifying a value for minLength and in attempting to infer storage requirements from a given value for minLength.

·minLength· provides for:

Constraining a ·value space· to values with at least a specific number of units of length, where units of length varies depending on {base type definition}.

Example

The following is the definition of a ·user-defined· datatype which requires strings to have at least one character (i.e., the empty string is not in the ·value space· of this datatype).

<simpleType name='non-empty-string'>
  <restriction base='string'>
    <minLength value='1'/>
  </restriction>
</simpleType>

4.3.2.1 The minLength Schema Component

Schema Component: minLength, a kind of Constraining Facet

{annotations}

A sequence of Annotation components.

{value}

An xs:nonNegativeInteger value. Required.

{fixed}

An xs:boolean value. Required.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for minLength other than {value}.

4.3.2.2 XML Representation of minLength Schema Component

The XML representation for a minLength schema component is a <minLength> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: minLength Element Information Item

<minLength
  fixed = boolean : false
  id = ID
  value = nonNegativeInteger
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</minLength>

minLength Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

The annotation mapping of the <minLength> element, as defined in section XML Representation of Annotation Schema Components of [XSD 1.1 Part 1: Structures].

4.3.2.3 minLength Validation Rules

Validation Rule: minLength Valid

A value in a ·value space· is facet-valid with respect to ·minLength·, determined as follows:

1 if the {variety} is ·atomic· then

1.1 if {primitive type definition} is string or anyURI, then the length of the value, as measured in characters must be greater than or equal to {value};

1.2 if {primitive type definition} is hexBinary or base64Binary, then the length of the value, as measured in octets of the binary data, must be greater than or equal to {value};

1.3 if {primitive type definition} is QName or NOTATION, then any {value} is facet-valid.

2 if the {variety} is ·list·, then the length of the value, as measured in list items, must be greater than or equal to {value}

The use of ·minLength· on QName, NOTATION, and datatypes ·derived· from them is deprecated. Future versions of this specification may remove this facet for these datatypes.

4.3.2.4 Constraints on minLength Schema Components

Schema Component Constraint: minLength <= maxLength

If both minLength and maxLength are members of {facets}, then the {value} of minLength must be less than or equal to the {value} of maxLength.

Schema Component Constraint: minLength valid restriction

It is an ·error· if minLength is among the members of {facets} of {base type definition} and {value} is less than the {value} of the parent minLength.

4.3.3 maxLength

[Definition:] maxLength is the maximum number of units of length, where units of length varies depending on the type that is being ·derived· from. The value of maxLength must be a nonNegativeInteger.

For string and datatypes ·derived· from string, maxLength is measured in units of characters as defined in [XML]. For hexBinary and base64Binary and datatypes ·derived· from them, maxLength is measured in octets (8 bits) of binary data. For datatypes ·constructed· by ·list·, maxLength is measured in number of list items.

Note: For string and datatypes ·derived· from string, maxLength will not always coincide with "string length" as perceived by some users or with the number of storage units in some digital representation. Therefore, care should be taken when specifying a value for maxLength and in attempting to infer storage requirements from a given value for maxLength.

·maxLength· provides for:

Constraining a ·value space· to values with at most a specific number of units of length, where units of length varies depending on {base type definition}.

Example

The following is the definition of a ·user-defined· datatype which might be used to accept form input with an upper limit to the number of characters that are acceptable.

<simpleType name='form-input'>
  <restriction base='string'>
    <maxLength value='50'/>
  </restriction>
</simpleType>

4.3.3.1 The maxLength Schema Component

Schema Component: maxLength, a kind of Constraining Facet

{annotations}

A sequence of Annotation components.

{value}

An xs:nonNegativeInteger value. Required.

{fixed}

An xs:boolean value. Required.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for maxLength other than {value}.

4.3.3.2 XML Representation of maxLength Schema Components

The XML representation for a maxLength schema component is a <maxLength> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: maxLength Element Information Item

<maxLength
  fixed = boolean : false
  id = ID
  value = nonNegativeInteger
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</maxLength>

maxLength Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

The annotation mapping of the <maxLength> element, as defined in section XML Representation of Annotation Schema Components of [XSD 1.1 Part 1: Structures].

4.3.3.3 maxLength Validation Rules

Validation Rule: maxLength Valid

A value in a ·value space· is facet-valid with respect to ·maxLength·, determined as follows:

1 if the {variety} is ·atomic· then

1.1 if {primitive type definition} is string or anyURI, then the length of the value, as measured in characters must be less than or equal to {value};

1.2 if {primitive type definition} is hexBinary or base64Binary, then the length of the value, as measured in octets of the binary data, must be less than or equal to {value};

1.3 if {primitive type definition} is QName or NOTATION, then any {value} is facet-valid.

2 if the {variety} is ·list·, then the length of the value, as measured in list items, must be less than or equal to {value}

The use of ·maxLength· on QName, NOTATION, and datatypes ·derived· from them is deprecated. Future versions of this specification may remove this facet for these datatypes.

4.3.3.4 Constraints on maxLength Schema Components

Schema Component Constraint: maxLength valid restriction

It is an ·error· if maxLength is among the members of {facets} of {base type definition} and {value} is greater than the {value} of the parent maxLength.

4.3.4 pattern

[Definition:] pattern is a constraint on the ·value space· of a datatype which is achieved by constraining the ·lexical space· to ·literals· which match each member of a set of ·regular expressions·. The value of pattern must be a set of ·regular expressions·.

Note: An XML <restriction> containing more than one <pattern> element gives rise to a single ·regular expression· in the set; this ·regular expression· is an "or" of the ·regular expressions· that are the content of the <pattern> elements.

·pattern· provides for:

Constraining a ·value space· to values that are denoted by ·literals· which match each of a set of ·regular expressions·.

Example

The following is the definition of a ·user-defined· datatype which is a better representation of postal codes in the United States, by limiting strings to those which are matched by a specific ·regular expression·.

<simpleType name='better-us-zipcode'>
  <restriction base='string'>
    <pattern value='[0-9]{5}(-[0-9]{4})?'/>
  </restriction>
</simpleType>

4.3.4.1 The pattern Schema Component

Schema Component: pattern, a kind of Constraining Facet

{annotations}

A sequence of Annotation components.

{value}

A non-empty set of ·regular expressions·.

4.3.4.2 XML Representation of pattern Schema Components

The XML representation for a pattern schema component is one or more <pattern> element information items. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: pattern Element Information Item

<pattern
  id = ID
  value = string
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</pattern>

pattern Schema Component

Property

Representation

[Definition:] Let R be a regular expression given by the appropriate case among the following:

1 If there is only one <pattern> among the [children] of a <restriction>, then the actual value of its value [attribute]

2 otherwise the concatenation of the actual values of all the <pattern> [children]'s value [attributes], in order, separated by '|', so forming a single regular expression with multiple ·branches·.

The value is then given by the appropriate case among the following:

1 If the {base type definition} of the ·owner· has a pattern facet among its {facets}, then the union of that pattern facet's {value} and {·R·}

2 otherwise just {·R·}

The annotation mapping of the set containing all of the <pattern> elements among the [children] of the <restriction> element information item, as defined in section XML Representation of Annotation Schema Components of [XSD 1.1 Part 1: Structures].

Note: The {value} property will only have more than one member when ·facet-based restriction· involves a pattern facet at more than one step in a type derivation. During validation, lexical forms will be checked against every member of the resulting {value}, effectively creating a conjunction of patterns.

In summary, ·pattern· facets specified on the same step in a type derivation are ORed together, while ·pattern· facets specified on different steps of a type derivation are ANDed together.

Thus, to impose two ·pattern· constraints simultaneously, schema authors may either write a single ·pattern· which expresses the intersection of the two ·pattern·s they wish to impose, or define each ·pattern· on a separate type derivation step.

4.3.4.3 Constraints on XML Representation of pattern

Schema Representation Constraint: Pattern value

The actual value of the value [attribute] must be a ·regular expression· as defined in Regular Expressions (§G).

4.3.4.4 pattern Validation Rules

Validation Rule: pattern valid

A ·literal· in a ·lexical space· is pattern-valid (or: facet-valid with respect to ·pattern·) if and only if for each ·regular expression· in its {value}, the ·literal· is among the set of character sequences denoted by the ·regular expression·.

Note: As noted in Datatype (§2.1), certain uses of the ·pattern· facet may eliminate from the lexical space the canonical forms of some values in the value space; this can be inconvenient for applications which write out the canonical form of a value and rely on being able to read it in again as a legal lexical form. This specification provides no recourse in such situations; applications are free to deal with it as they see fit. Caution is advised.

4.3.4.5 Constraints on pattern Schema Components

Schema Component Constraint: Valid restriction of pattern

It is an ·error· if there is any member of the {value} of the pattern facet on the {base type definition} which is not also a member of the {value}.

Note: For components constructed from XML representations in schema documents, the satisfaction of this constraint is a consequence of the XML mapping rules: any pattern imposed by a simple type definition S will always also be imposed by any type derived from S by ·facet-based restriction·. This constraint ensures that components constructed by other means (so-called "born-binary" components) similarly preserve pattern facets across ·facet-based restriction·.

4.3.5 enumeration

[Definition:] enumeration constrains the ·value space· to a specified set of values.

enumeration does not impose an order relation on the ·value space· it creates; the value of the ·ordered· property of the ·derived· datatype remains that of the datatype from which it is ·derived·.

·enumeration· provides for:

Constraining a ·value space· to a specified set of values.

Example

The following example is a Simple Type Definition for a ·user-defined· datatype which limits the values of dates to the three US holidays enumerated. This Simple Type Definition would appear in a schema authored by an "end-user" and shows how to define a datatype by enumerating the values in its ·value space·. The enumerated values must be type-valid ·literals· for the ·base type·.

<simpleType name='holidays'>
    <annotation>
        <documentation>some US holidays</documentation>
    </annotation>
    <restriction base='gMonthDay'>
      <enumeration value='--01-01'>
        <annotation>
            <documentation>New Year's day</documentation>
        </annotation>
      </enumeration>
      <enumeration value='--07-04'>
        <annotation>
            <documentation>4th of July</documentation>
        </annotation>
      </enumeration>
      <enumeration value='--12-25'>
        <annotation>
            <documentation>Christmas</documentation>
        </annotation>
      </enumeration>
    </restriction>
</simpleType>

4.3.5.1 The enumeration Schema Component

Schema Component: enumeration, a kind of Constraining Facet

{annotations}

A sequence of Annotation components.

{value}

A set of values from the ·value space· of the {base type definition}.

4.3.5.2 XML Representation of enumeration Schema Components

The XML representation for an enumeration schema component is one or more <enumeration> element information items. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: enumeration Element Information Item

<enumeration
  id = ID
  value = anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</enumeration>

enumeration Schema Component

Property

Representation

The appropriate case among the following:

1 If there is only one <enumeration> among the [children] of a <restriction>, then a set with one member, the actual value of its value [attribute], interpreted as an instance of the {base type definition}.

2 otherwise a set of the actual values of all the <enumeration> [children]'s value [attributes], interpreted as instances of the {base type definition}.

Note: The value [attribute] is declared as having type ·anySimpleType·, but the {value} property of the enumeration facet must be a member of the {base type definition}. So in mapping from the XML representation to the enumeration component, the actual value is identified by using the ·lexical mapping· of the {base type definition}.

A (possibly empty) sequence of Annotation components, one for each <annotation> among the [children] of the <enumeration>s among the [children] of a <restriction>, in order.

4.3.5.3 Constraints on XML Representation of enumeration

Schema Representation Constraint: Enumeration value

The normalized value of the value [attribute] must be Datatype Valid (§4.1.4) with respect to the {base type definition} of the Simple Type Definition corresponding to the nearest <simpleType> ancestor element.

4.3.5.4 enumeration Validation Rules

Validation Rule: enumeration valid

A value in a ·value space· is facet-valid with respect to ·enumeration· if and only if the value is equal or identical to one of the values specified in {value}.

Note: As specified normatively elsewhere, for purposes of checking enumerations, no distinction is made between an atomic value V and a list of length one containing V as its only item.

In this question, the behavior of this specification is thus the same as the behavior specified by [XQuery 1.0 and XPath 2.0 Functions and Operators] and related specifications.

4.3.5.5 Constraints on enumeration Schema Components

Schema Component Constraint: enumeration valid restriction

It is an ·error· if any member of {value} is not in the ·value space· of {base type definition}.

4.3.6 whiteSpace

[Definition:] whiteSpace constrains the ·value space· of types ·derived· from string such that the various behaviors specified in Attribute Value Normalization in [XML] are realized. The value of whiteSpace must be one of {preserve, replace, collapse}.

preserve

No normalization is done, the value is not changed (this is the behavior required by [XML] for element content)

replace

All occurrences of #x9 (tab), #xA (line feed) and #xD (carriage return) are replaced with #x20 (space)

collapse

After the processing implied by replace, contiguous sequences of #x20's are collapsed to a single #x20, and any #x20 at the start or end of the string is then removed.

Note: The notation #xA used here (and elsewhere in this specification) represents the Universal Character Set (UCS) code point hexadecimal A (line feed), which is denoted by U+000A. This notation is to be distinguished from 
, which is the XML character reference to that same UCS code point.

whiteSpace is applicable to all ·atomic· and ·list· datatypes. For all ·atomic· datatypes other than string (and types ·derived· by ·facet-based restriction· from it) the value of whiteSpace is collapse and cannot be changed by a schema author; for string the value of whiteSpace is preserve; for any type ·derived· by ·facet-based restriction· from string the value of whiteSpace can be any of the three legal values (as long as the value is at least as restrictive as the value of the ·base type·; see Constraints on whiteSpace Schema Components (§4.3.6.4)). For all datatypes ·constructed· by ·list· the value of whiteSpace is collapse and cannot be changed by a schema author. For all datatypes ·constructed· by ·union· whiteSpace does not apply directly; however, the normalization behavior of ·union· types is controlled by the value of whiteSpace on that one of the ·basic members· against which the ·union· is successfully validated.

Note: For more information on whiteSpace, see the discussion on white space normalization in Schema Component Details in [XSD 1.1 Part 1: Structures].

·whiteSpace· provides for:

Constraining a ·value space· according to the white space normalization rules.

Example

The following example is the Simple Type Definition for the ·built-in· token datatype.

<simpleType name='token'>
    <restriction base='normalizedString'>
      <whiteSpace value='collapse'/>
    </restriction>
</simpleType>

Note: The values "replace" and "collapse" may appear to provide a convenient way to "unwrap" text (i.e. undo the effects of pretty-printing and word-wrapping). In some cases, especially highly constrained data consisting of lists of artificial tokens such as part numbers or other identifiers, this appearance is correct. For natural-language data, however, the whitespace processing prescribed for these values is not only unreliable but will systematically remove the information needed to perform unwrapping correctly. For Asian scripts, for example, a correct unwrapping process will replace line boundaries not with blanks but with zero-width separators or nothing. In consequence, it is normally unwise to use these values for natural-language data, or for any data other than lists of highly constrained tokens.

4.3.6.1 The whiteSpace Schema Component

Schema Component: whiteSpace, a kind of Constraining Facet

{annotations}

A sequence of Annotation components.

{value}

One of {preserve, replace, collapse}. Required.

{fixed}

An xs:boolean value. Required.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for whiteSpace other than {value}.

4.3.6.2 XML Representation of whiteSpace Schema Components

The XML representation for a whiteSpace schema component is a <whiteSpace> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: whiteSpace Element Information Item

<whiteSpace
  fixed = boolean : false
  id = ID
  value = (collapse | preserve | replace)
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</whiteSpace>

whiteSpace Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

The annotation mapping of the <whiteSpace> element, as defined in section XML Representation of Annotation Schema Components of [XSD 1.1 Part 1: Structures].

4.3.6.3 whiteSpace Validation Rules

Note: There are no ·Validation Rule·s associated with ·whiteSpace·. For more information, see the discussion on white space normalization in Schema Component Details in [XSD 1.1 Part 1: Structures], in particular the section 3.1.4 White Space Normalization during Validation.

4.3.6.4 Constraints on whiteSpace Schema Components

Schema Component Constraint: whiteSpace valid restriction

It is an ·error· if whiteSpace is among the members of {facets} of {base type definition} and any of the following conditions is true:

1 {value} is replace or preserve and the {value} of the parent whiteSpace is collapse

2 {value} is preserve and the {value} of the parent whiteSpace is replace

Note: In order of increasing restrictiveness, the legal values for the whiteSpace facet are preserve, collapse, and replace. The more restrictive keywords are more restrictive not in the sense of accepting progressively fewer instance documents but in the sense that each corresponds to a progressively smaller, more tightly restricted value space.

4.3.7 maxInclusive

[Definition:] maxInclusive is the inclusive upper bound of the ·value space· for a datatype with the ·ordered· property. The value of maxInclusive must be equal to some value in the ·value space· of the ·base type·.

·maxInclusive· provides for:

Constraining a ·value space· to values with a specific inclusive upper bound.

Example

The following is the definition of a ·user-defined· datatype which limits values to integers less than or equal to 100, using ·maxInclusive·.

<simpleType name='one-hundred-or-less'>
  <restriction base='integer'>
    <maxInclusive value='100'/>
  </restriction>
</simpleType>

4.3.7.1 The maxInclusive Schema Component

Schema Component: maxInclusive, a kind of Constraining Facet

{annotations}

A sequence of Annotation components.

{value}

Required.

A value from the ·value space· of the {base type definition}.

{fixed}

An xs:boolean value. Required.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for maxInclusive other than {value}.

4.3.7.2 XML Representation of maxInclusive Schema Components

The XML representation for a maxInclusive schema component is a <maxInclusive> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: maxInclusive Element Information Item

<maxInclusive
  fixed = boolean : false
  id = ID
  value = anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</maxInclusive>

{value} must be equal to some value in the ·value space· of {base type definition}.

maxInclusive Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

The annotation mapping of the <maxInclusive> element, as defined in section XML Representation of Annotation Schema Components of [XSD 1.1 Part 1: Structures].

4.3.7.3 maxInclusive Validation Rules

Validation Rule: maxInclusive Valid

A value in an ·ordered· ·value space· is facet-valid with respect to ·maxInclusive· if and only if the value is less than or equal to {value}, according to the datatype's order relation.

4.3.7.4 Constraints on maxInclusive Schema Components

Schema Component Constraint: minInclusive <= maxInclusive

It is an ·error· for the value specified for ·minInclusive· to be greater than the value specified for ·maxInclusive· for the same datatype.

Schema Component Constraint: maxInclusive valid restriction

It is an ·error· if any of the following conditions is true:

1 maxInclusive is among the members of {facets} of {base type definition} and {value} is greater than the {value} of that maxInclusive.

2 maxExclusive is among the members of {facets} of {base type definition} and {value} is greater than or equal to the {value} of that maxExclusive.

3 minInclusive is among the members of {facets} of {base type definition} and {value} is less than the {value} of that minInclusive.

4 minExclusive is among the members of {facets} of {base type definition} and {value} is less than or equal to the {value} of that minExclusive.

4.3.8 maxExclusive

[Definition:] maxExclusive is the exclusive upper bound of the ·value space· for a datatype with the ·ordered· property. The value of maxExclusive must be equal to some value in the ·value space· of the ·base type· or be equal to {value} in {base type definition}.

·maxExclusive· provides for:

Constraining a ·value space· to values with a specific exclusive upper bound.

Example

The following is the definition of a ·user-defined· datatype which limits values to integers less than or equal to 100, using ·maxExclusive·.

<simpleType name='less-than-one-hundred-and-one'>
  <restriction base='integer'>
    <maxExclusive value='101'/>
  </restriction>
</simpleType>

Note that the ·value space· of this datatype is identical to the previous one (named 'one-hundred-or-less').

4.3.8.1 The maxExclusive Schema Component

Schema Component: maxExclusive, a kind of Constraining Facet

{annotations}

A sequence of Annotation components.

{value}

Required.

A value from the ·value space· of the {base type definition}.

{fixed}

An xs:boolean value. Required.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for maxExclusive other than {value}.

4.3.8.2 XML Representation of maxExclusive Schema Components

The XML representation for a maxExclusive schema component is a <maxExclusive> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: maxExclusive Element Information Item

<maxExclusive
  fixed = boolean : false
  id = ID
  value = anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</maxExclusive>

{value} must be equal to some value in the ·value space· of {base type definition}.

maxExclusive Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

The annotation mapping of the <maxExclusive> element, as defined in section XML Representation of Annotation Schema Components of [XSD 1.1 Part 1: Structures].

4.3.8.3 maxExclusive Validation Rules

Validation Rule: maxExclusive Valid

A value in an ·ordered· ·value space· is facet-valid with respect to ·maxExclusive· if and only if the value is less than {value}, according to the datatype's order relation.

4.3.8.4 Constraints on maxExclusive Schema Components

Schema Component Constraint: maxInclusive and maxExclusive

It is an ·error· for both ·maxInclusive· and ·maxExclusive· to be specified in the same derivation step of a Simple Type Definition.

Schema Component Constraint: minExclusive <= maxExclusive

It is an ·error· for the value specified for ·minExclusive· to be greater than the value specified for ·maxExclusive· for the same datatype.

Schema Component Constraint: maxExclusive valid restriction

It is an ·error· if any of the following conditions is true:

1 maxExclusive is among the members of {facets} of {base type definition} and {value} is greater than the {value} of that maxExclusive.

2 maxInclusive is among the members of {facets} of {base type definition} and {value} is greater than the {value} of that maxInclusive.

3 minInclusive is among the members of {facets} of {base type definition} and {value} is less than or equal to the {value} of that minInclusive.

4 minExclusive is among the members of {facets} of {base type definition} and {value} is less than or equal to the {value} of that minExclusive.

4.3.9 minExclusive

[Definition:] minExclusive is the exclusive lower bound of the ·value space· for a datatype with the ·ordered· property. The value of minExclusive must be equal to some value in the ·value space· of the ·base type· or be equal to {value} in {base type definition}.

·minExclusive· provides for:

Constraining a ·value space· to values with a specific exclusive lower bound.

Example

The following is the definition of a ·user-defined· datatype which limits values to integers greater than or equal to 100, using ·minExclusive·.

<simpleType name='more-than-ninety-nine'>
  <restriction base='integer'>
    <minExclusive value='99'/>
  </restriction>
</simpleType>

Note that the ·value space· of this datatype is identical to the following one (named 'one-hundred-or-more').

4.3.9.1 The minExclusive Schema Component

Schema Component: minExclusive, a kind of Constraining Facet

{annotations}

A sequence of Annotation components.

{value}

Required.

A value from the ·value space· of the {base type definition}.

{fixed}

An xs:boolean value. Required.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for minExclusive other than {value}.

4.3.9.2 XML Representation of minExclusive Schema Components

The XML representation for a minExclusive schema component is a <minExclusive> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: minExclusive Element Information Item

<minExclusive
  fixed = boolean : false
  id = ID
  value = anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</minExclusive>

{value} must be equal to some value in the ·value space· of {base type definition}.

minExclusive Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

The annotation mapping of the <minExclusive> element, as defined in section XML Representation of Annotation Schema Components of [XSD 1.1 Part 1: Structures].

4.3.9.3 minExclusive Validation Rules

Validation Rule: minExclusive Valid

A value in an ·ordered· ·value space· is facet-valid with respect to ·minExclusive· if and only if the value is greater than {value}, according to the datatype's order relation.

4.3.9.4 Constraints on minExclusive Schema Components

Schema Component Constraint: minInclusive and minExclusive

It is an ·error· for both ·minInclusive· and ·minExclusive· to be specified in the same derivation step of a Simple Type Definition.

Schema Component Constraint: minExclusive < maxInclusive

It is an ·error· for the value specified for ·minExclusive· to be greater than or equal to the value specified for ·maxInclusive· for the same datatype.

Schema Component Constraint: minExclusive valid restriction

It is an ·error· if any of the following conditions is true:

1 minExclusive is among the members of {facets} of {base type definition} and {value} is less than the {value} of that minExclusive.

2 minInclusive is among the members of {facets} of {base type definition} and {value} is less than the {value} of that minInclusive.

3 maxInclusive is among the members of {facets} of {base type definition} and {value} is greater than or equal to the {value} of that maxInclusive.

4 maxExclusive is among the members of {facets} of {base type definition} and {value} is greater than or equal to the {value} of that maxExclusive.

4.3.10 minInclusive

[Definition:] minInclusive is the inclusive lower bound of the ·value space· for a datatype with the ·ordered· property. The value of minInclusive must be equal to some value in the ·value space· of the ·base type·.

·minInclusive· provides for:

Constraining a ·value space· to values with a specific inclusive lower bound.

Example

The following is the definition of a ·user-defined· datatype which limits values to integers greater than or equal to 100, using ·minInclusive·.

<simpleType name='one-hundred-or-more'>
  <restriction base='integer'>
    <minInclusive value='100'/>
  </restriction>
</simpleType>

4.3.10.1 The minInclusive Schema Component

Schema Component: minInclusive, a kind of Constraining Facet

{annotations}

A sequence of Annotation components.

{value}

Required.

A value from the ·value space· of the {base type definition}.

{fixed}

An xs:boolean value. Required.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for minInclusive other than {value}.

4.3.10.2 XML Representation of minInclusive Schema Components

The XML representation for a minInclusive schema component is a <minInclusive> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: minInclusive Element Information Item

<minInclusive
  fixed = boolean : false
  id = ID
  value = anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</minInclusive>

{value} must be equal to some value in the ·value space· of {base type definition}.

minInclusive Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

The annotation mapping of the <minInclusive> element, as defined in section XML Representation of Annotation Schema Components of [XSD 1.1 Part 1: Structures].

4.3.10.3 minInclusive Validation Rules

Validation Rule: minInclusive Valid

A value in an ·ordered· ·value space· is facet-valid with respect to ·minInclusive· if and only if the value is greater than or equal to {value}, according to the datatype's order relation.

4.3.10.4 Constraints on minInclusive Schema Components

Schema Component Constraint: minInclusive < maxExclusive

It is an ·error· for the value specified for ·minInclusive· to be greater than or equal to the value specified for ·maxExclusive· for the same datatype.

Schema Component Constraint: minInclusive valid restriction

It is an ·error· if any of the following conditions is true:

1 minInclusive is among the members of {facets} of {base type definition} and {value} is less than the {value} of that minInclusive.

2 maxInclusive is among the members of {facets} of {base type definition} and {value} is greater the {value} of that maxInclusive.

3 minExclusive is among the members of {facets} of {base type definition} and {value} is less than or equal to the {value} of that minExclusive.

4 maxExclusive is among the members of {facets} of {base type definition} and {value} is greater than or equal to the {value} of that maxExclusive.

4.3.11 totalDigits

[Definition:] totalDigits restricts the magnitude and arithmetic precision of values in the ·value spaces· of decimal and datatypes derived from it.

For decimal, if the {value} of totalDigits is t, the effect is to require that values be equal to i / 10ⁿ, for some integers i and n, with | i | < 10^t and 0 ≤ n ≤ t. This has as a consequence that the values are expressible using at most t digits in decimal notation.

The {value} of totalDigits must be a positiveInteger.

The term 'totalDigits' is chosen to reflect the fact that it restricts the ·value space· to those values that can be represented lexically using at most totalDigits digits in decimal notation, or at most totalDigits digits for the coefficient, in scientific notation. Note that it does not restrict the ·lexical space· directly; a lexical representation that adds non-significant leading or trailing zero digits is still permitted. It also has no effect on the values NaN, INF, and -INF.

4.3.11.1 The totalDigits Schema Component

Schema Component: totalDigits, a kind of Constraining Facet

{annotations}

A sequence of Annotation components.

{value}

An xs:positiveInteger value. Required.

{fixed}

An xs:boolean value. Required.

If {fixed} is true, then types for which the current type is the {base type definition} must not specify a value for totalDigits other than {value}.

4.3.11.2 XML Representation of totalDigits Schema Components

The XML representation for a totalDigits schema component is a <totalDigits> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: totalDigits Element Information Item

<totalDigits
  fixed = boolean : false
  id = ID
  value = positiveInteger
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</totalDigits>

totalDigits Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

The annotation mapping of the <totalDigits> element, as defined in section XML Representation of Annotation Schema Components of [XSD 1.1 Part 1: Structures].

4.3.11.3 totalDigits Validation Rules

Validation Rule: totalDigits Valid

A value v is facet-valid with respect to a totalDigits facet with a {value} of t if and only if v is a decimal value equal to i / 10ⁿ, for some integers i and n, with | i | < 10^t and 0 ≤ n ≤ t.

4.3.11.4 Constraints on totalDigits Schema Components

Schema Component Constraint: totalDigits valid restriction

It is an ·error· if the ·owner·'s {base type definition} has a totalDigits facet among its {facets} and {value} is greater than the {value} of that totalDigits facet.

4.3.12 fractionDigits

[Definition:] fractionDigits places an upper limit on the arithmetic precision of decimal values: if the {value} of fractionDigits = f, then the value space is restricted to values equal to i / 10ⁿ for some integers i and n and 0 ≤ n ≤ f. The value of fractionDigits must be a nonNegativeInteger

The term fractionDigits is chosen to reflect the fact that it restricts the ·value space· to those values that can be represented lexically in decimal notation using at most fractionDigits to the right of the decimal point. Note that it does not restrict the ·lexical space· directly; a lexical representation that adds non-significant leading or trailing zero digits is still permitted.

Example

The following is the definition of a ·user-defined· datatype which could be used to represent the magnitude of a person's body temperature on the Celsius scale. This definition would appear in a schema authored by an "end-user" and shows how to define a datatype by specifying facet values which constrain the range of the ·base type·.

<simpleType name='celsiusBodyTemp'>
  <restriction base='decimal'>
    <fractionDigits value='1'/>
    <minInclusive value='32'/>
	 <maxInclusive value='41.7'/>
  </restriction>
</simpleType>

4.3.12.1 The fractionDigits Schema Component

Schema Component: fractionDigits, a kind of Constraining Facet

{annotations}

A sequence of Annotation components.

{value}

An xs:nonNegativeInteger value. Required.

{fixed}

An xs:boolean value. Required.

If {fixed} is true, then types for which the current type is the {base type definition} must not specify a value for fractionDigits other than {value}.

4.3.12.2 XML Representation of fractionDigits Schema Components

The XML representation for a fractionDigits schema component is a <fractionDigits> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: fractionDigits Element Information Item

<fractionDigits
  fixed = boolean : false
  id = ID
  value = nonNegativeInteger
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</fractionDigits>

fractionDigits Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

The annotation mapping of the <fractionDigits> element, as defined in section XML Representation of Annotation Schema Components of [XSD 1.1 Part 1: Structures].

4.3.12.3 fractionDigits Validation Rules

Validation Rule: fractionDigits Valid

A value is facet-valid with respect to ·fractionDigits· if and only if that value is equal to i / 10ⁿ for integer i and n, with 0 ≤ n ≤ {value}.

4.3.12.4 Constraints on fractionDigits Schema Components

Schema Component Constraint: fractionDigits less than or equal to totalDigits

It is an ·error· for the {value} of fractionDigits to be greater than that of totalDigits.

Schema Component Constraint: fractionDigits valid restriction

It is an ·error· if ·fractionDigits· is among the members of {facets} of {base type definition} and {value} is greater than the {value} of that ·fractionDigits·.

4.3.13 Assertions

[Definition:] Assertions constrain the ·value space· by requiring the values to satisfy specified XPath ([XPath 2.0]) expressions. The value of the assertions facet is a sequence of Assertion components as defined in [XSD 1.1 Part 1: Structures].

Example

The following is the definition of a ·user-defined· datatype which allows all integers but 0 by using an assertion to disallow the value 0.

<simpleType name='nonZeroInteger'>
  <restriction base='integer'>
    <assertion test='$value ne 0'/>
  </restriction>
</simpleType>

Example

The following example defines the datatype "triple", whose ·value space· is the set of integers evenly divisible by three.

<simpleType name='triple'>
  <restriction base='integer'>
    <assertion test='$value mod 3 eq 0'/>
  </restriction>
</simpleType>

The same datatype can be defined without the use of assertions, but the pattern necessary to represent the set of triples is long and error-prone:

<simpleType name='triple'>
  <restriction base='integer'>
    <pattern value=
    "([0369]|[147][0369]*[258]|(([258]|[147][0369]*[147])([0369]|[258][0369]*[147])*([147]|[258][0369]*[258]))*"/>
  </restriction>
</simpleType>

The assertion used in the first version of "triple" is likely to be clearer for many readers of the schema document.

4.3.13.1 The assertions Schema Component

Schema Component: assertions, a kind of Constraining Facet

{annotations}

A sequence of Annotation components.

{value}

A sequence of Assertion components.

4.3.13.2 XML Representation of assertions Schema Components

The XML representation for an assertions schema component is one or more <assertion> element information items. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: assertion Element Information Item

<assertion
  id = ID
  test = an XPath expression
  xpathDefaultNamespace = (anyURI | (##defaultNamespace | ##targetNamespace | ##local))
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</assertion>

assertions Schema Component

Property

Representation

A sequence whose members are Assertions drawn from the following sources, in order:

1 If the {base type definition} of the ·owner· has an assertions facet among its {facets}, then the Assertions which appear in the {value} of that assertions facet.

2 Assertions corresponding to the <assertion> element information items among the [children] of <restriction>, if any, in document order. For details of the construction of the Assertion components, see section 3.13.2 of [XSD 1.1 Part 1: Structures].

The empty sequence.

Note: Annotations specified within an <assertion> element are captured by the individual Assertion component to which it maps.

4.3.13.3 Assertions Validation Rules

The following rule refers to "the nearest built-in" datatype and to the "XDM representation" of a value under a datatype. [Definition:] For any datatype T, the nearest built-in datatype to T is the first ·built-in· datatype encountered in following the chain of links connecting each datatype to its ·base type·. If T is a ·built-in· datatype, then the nearest built-in datatype of T is T itself; otherwise, it is the nearest built-in datatype of T's ·base type·.

[Definition:] For any value V and any datatype T, the XDM representation of V under T is defined recursively as follows. Call the XDM representation X. Then

1 If T = ·xs:anySimpleType· or ·xs:anyAtomicType· then X is V, and the dynamic type of X is xs:untypedAtomic.

2 If T . {variety} = atomic, then let T2 be the ·nearest built-in datatype· to T. If V is a member of the ·value space· of T2, then X is V and the dynamic type of X is T2. Otherwise (i.e. if V is not a member of the ·value space· of T2), X is the ·XDM representation· of V under T2 . {base type definition}.

3 If T . {variety} = list, then X is a sequence of atomic values, each atomic value being the ·XDM representation· of the corresponding item in the list V under T . {item type definition}.

4 If T . {variety} = union, then X is the ·XDM representation· of V under the ·active basic member· of V when validated against T. If there is no ·active basic member·, then V has no ·XDM representation· under T.

Note: If the {item type definition} of a ·list· is a ·union·, or the ·active basic member· is a ·list·, then several steps may be necessary before the ·atomic· datatype which serves as the dynamic type of X is found.

Because the {item type definition} of a ·list· is required to be an ·atomic· or ·union· datatype, and the ·active basic member· of a ·union· which accepts the value V is by definition not a ·union·, the recursive rule given above is guaranteed to terminate in a sequence of one or more ·atomic· values, each belonging to an ·atomic· datatype.

Validation Rule: Assertions Valid

A value V is facet-valid with respect to an assertions facet belonging to a simple type T if and only if the {test} property of each Assertion in its {value} evaluates to true under the conditions laid out below, without raising any dynamic error or type error.

Evaluation of {test} is performed as defined in [XPath 2.0], with the following conditions:

1 The XPath expression {test} is evaluated, following the rules given in XPath Evaluation of [XSD 1.1 Part 1: Structures], with the following modifications.

1.1 The in-scope variables in the static context is a set with a single member. The expanded QName of that member has no namespace URI and has 'value' as the local name. The (static) type of the member is anyAtomicType*.

Note: The XDM type label anyAtomicType* simply says that for static typing purposes the variable $value will have a value consisting of a sequence of zero or more atomic values.

1.2 There is no context item for the evaluation of the XPath expression.

Note: In the terminology of [XPath 2.0], the context item is "undefined".

Note: As a consequence the expression '.', or any implicit or explicit reference to the context item, will raise a dynamic error, which will cause the assertion to be treated as false. If an error is detected statically, then the assertion violates the schema component constraint XPath Valid and causes an error to be flagged in the schema.

The variable "$value" can be used to refer to the value being checked.

1.3 There is likewise no value for the context size and the context position in the dynamic context used for evaluation of the assertion.

1.4 The variable values in the dynamic context is a set with a single member. The expanded QName of that member has no namespace URI and 'value' as the local name. The value of the member is the ·XDM representation· of V under T.

1.5 If V has no ·XDM representation· under T, then the XPath expression cannot usefully be evaluated, and V is not facet-valid against the assertions facet of T.

2 The evaluation result is converted to either true or false as if by a call to the XPath fn:boolean function.

4.3.13.4 Constraints on assertions Schema Components

Schema Component Constraint: Valid restriction of assertions

The {value} of the assertions facet on the {base type definition} must be a prefix of the {value}.

Note: For components constructed from XML representations in schema documents, the satisfaction of this constraint is a consequence of the XML mapping rules: any assertion imposed by a simple type definition S will always also be imposed by any type derived from S by ·facet-based restriction·. This constraint ensures that components constructed by other means (so-called "born-binary" components) similarly preserve assertions facets across ·facet-based restriction·.

4.3.14 explicitTimezone

[Definition:] explicitTimezone is a three-valued facet which can can be used to require or prohibit the time zone offset in date/time datatypes.

Example

The following ·user-defined· datatype accepts only date values without a time zone offset, using the explicitTimezone facet.

<simpleType name='bare-date'>
  <restriction base='date'>
    <explicitTimezone value='prohibited'/>
  </restriction>
</simpleType>

The same effect could also be achieved using the pattern facet, as shown below, but it is somewhat less clear what is going on in this derivation, and it is better practice to use the more straightforward explicitTimezone for this purpose.

<simpleType name='bare-date'>
  <restriction base='date'>
    <pattern value='[^:Z]*'/>
  </restriction>
</simpleType>

4.3.14.1 The explicitTimezone Schema Component

Schema Component: explicitTimezone, a kind of Constraining Facet

{annotations}

A sequence of Annotation components.

{value}

One of {required, prohibited, optional}. Required.

{fixed}

An xs:boolean value. Required.

If {fixed} is true, then datatypes for which the current type is the {base type definition} cannot specify a value for explicitTimezone other than {value}.

Note: It is a consequence of timezone valid restriction (§4.3.14.4) that the value of the explicitTimezone facet cannot be changed unless that value is optional, regardless of whether {fixed} is true or false. Accordingly, {fixed} is relevant only when {value} is optional.

4.3.14.2 XML Representation of explicitTimezone Schema Components

The XML representation for an explicitTimezone schema component is an <explicitTimezone> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: explicitTimezone Element Information Item

<explicitTimezone
  fixed = boolean : false
  id = ID
  value = NCName
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</explicitTimezone>

explicitTimezone Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false