xmlschema 2

XML Schema Part 2: Datatypes Second Edition code { font-family: monospace; }

div.constraint, div.issue, div.note, div.notice { margin-left: 2em; }

ol.enumar { list-style-type: decimal; } ol.enumla { list-style-type: lower-alpha; } ol.enumlr { list-style-type: lower-roman; } ol.enumua { list-style-type: upper-alpha; } ol.enumur { list-style-type: upper-roman; }

div.exampleInner pre { margin-left: 1em; margin-top: 0em; margin-bottom: 0em} div.exampleOuter {border: 4px double gray; margin: 0em; padding: 0em} div.exampleInner { background-color: #d5dee3; border-top-width: 4px; border-top-style: double; border-top-color: #d3d3d3; border-bottom-width: 4px; border-bottom-style: double; border-bottom-color: #d3d3d3; padding: 4px; margin: 0em } div.exampleWrapper { margin: 4px } div.exampleHeader { font-weight: bold; margin: 4px}

img { color: white; border: none } span.nav { float: right} span.arrow { font-style: normal; font-weight: bold } code { font-family: monospace; font-size: 100%} span.propdef { font-weight: bold; font-family: monospace } span.termdef {color: #850021} a.termref:visited, a.termref:link {font-family: sans-serif; font-style: normal; color: black; text-decoration: none } a.eltref:visited, a.eltref:link { font-family: sans-serif; color: black; text-decoration: none } a.propref:visited, a.xpropref:visited, a.propref:link, a.xpropref:link { color: black; text-decoration: none; font-family: sans-serif } dl.props, dl.psvi {margin-bottom: .5em; margin-top: 0em} div.toc1 {margin-left: 5ex} div.toc2 {margin-left: 2ex} div.tocLine{margin: 0em; text-indent: -6ex} h3.withToc {margin-bottom: 0em} div.constraintnote { margin-top: 1em } div.constraint { margin-left: 1em; } div.constraintlist { margin-left: 1em; margin-bottom: 0em } div.clnumber { text-indent: -1em; margin-top: 0em; margin-bottom: 0em } div.schemaComp { border: 4px double gray; margin: 0em 1em; padding: 0em } div.compHeader { margin: 4px; font-weight: bold } span.schemaComp { color: #A52A2A } div.compBody { border-top-width: 4px; border-top-style: double; border-top-color: #d3d3d3; padding: 4px ; margin: 0em} div.psviDef { border: 4px double gray; margin: 1em 1em; padding: 0em } div.psviHeader { margin: 4px; font-weight: bold } span.psviDef { color: #A52A2A } div.psviBody { border-top-width: 4px; border-top-style: double; border-top-color: #d3d3d3; padding: 4px ; margin: 0em} div.reprdef { border: 4px double gray; margin: 0em 1em; padding: 0em } div.reprHeader { margin: 4px; font-weight: bold } span.reprdef { color: #A52A2A } div.reprBody, div.reprcomp, div.reprdep { border-top-width: 4px; border-top-style: double; border-top-color: #d3d3d3; padding: 4px ; margin: 0em} table.reprcomp { margin-bottom: -.5em} p.element-syntax-1 { font-family: monospace; margin-top: 0em; margin-bottom: .5em } p.element-syntax { font-family: monospace; border-top-width: 1px; border-top-style: solid; border-top-color: #d3d3d3; padding: 4px ; margin: 0em} div.exampleInner pre { margin-left: 1em; margin-top: 0em; margin-bottom: 0em} div.exampleOuter {border: 4px double gray; margin: 0em; padding: 0em} div.exampleInner { background-color: #d5dee3; border-top-width: 4px; border-top-style: double; border-top-color: #d3d3d3; border-bottom-width: 4px; border-bottom-style: double; border-bottom-color: #d3d3d3; padding: 4px; margin: 0em } div.exampleWrapper { margin: 4px } div.exampleHeader { font-weight: bold; margin: 4px} span.edtext { color: red } table.restricts { margin-top: 1em; margin-bottom: 1em; margin-left: -2em} table.restricts th { margin-left: 0em } table.ubc td, table.ubc th { font-size: smaller } table.dtdemo th { text-align: center; background-color: #d5dee3} table.dtdemo pre { margin-left: 0em; margin-bottom: 0em} table.dtdemo td {background-color: #bedce6} table.scrap {background-color: #f5dcb3} img { color: white; border: none } span.nav { float: right} span.arrow { font-style: normal; font-weight: bold } This version: http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/ Latest version: http://www.w3.org/TR/xmlschema-2/ Previous version: http://www.w3.org/TR/2004/PER-xmlschema-2-20040318/ Editors: Paul V. Biron, Kaiser Permanente, for Health Level Seven <[email protected]> Ashok Malhotra, Microsoft (formerly of IBM) <[email protected]> Please refer to the errata This document is also available in these non-normative formats: XML XHTML with visible change markup Independent copy of the schema for schema documents A schema for built-in datatypes only, in a separate namespace Independent copy of the DTD for schema documents translations Copyright W3C ® MIT ERCIM Keio liability trademark document use XML Schema: Datatypes This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index This is a W3C Recommendation This document has been produced by the W3C XML Schema Working Group XML Activity XML Schema Requirements This document was produced under the 24 January 2002 Current Patent Practice (CPP) W3C Patent Policy Transition Procedure public list of patent disclosures section 6 of the W3C Patent Policy The English version of this specification is the only normative version. Information about translations of this document is available at http://www.w3.org/2001/05/xmlschema-translations This second edition is not first edition http://www.w3.org/2001/05/xmlschema-errata The errata list for this second edition is available at http://www.w3.org/2004/03/xmlschema-errata Please report errors in this document to [email protected] archive Note: <[email protected]> 1 Introduction Purpose Requirements Scope Terminology Constraints and Contributions Type System Datatype Value space Lexical space Facets Datatype dichotomies Built-in datatypes Namespace considerations Primitive datatypes Derived datatypes Datatype components Simple Type Definition Fundamental Facets Constraining Facets Conformance A Schema for Datatype Definitions (normative) DTD for Datatype Definitions (non-normative) Datatypes and Facets Fundamental Facets ISO 8601 Date and Time Formats ISO 8601 Conventions Truncated and Reduced Formats Deviations from ISO 8601 Formats Adding durations to dateTimes Algorithm Commutativity and Associativity Regular Expressions Character Classes Glossary (non-normative) References Normative Non-normative Acknowledgements (non-normative) The [XML 1.0 (Second Edition)] documents data The table below offers two typical examples of XML instances in which datatypes are implicit: the instance on the left represents a billing invoice, the instance on the right a memo or perhaps an email message in XML. Data oriented Document oriented <invoice> <orderDate>1999-01-21</orderDate> <shipDate>1999-01-25</shipDate> <billingAddress> <name>Ashok Malhotra</name> <street>123 Microsoft Ave.</street> <city>Hawthorne</city> <state>NY</state> <zip>10532-0000</zip> </billingAddress> <voice>555-1234</voice> <fax>555-4321</fax> </invoice> <memo importance='high' date='1999-03-23'> <from>Paul V. Biron</from> <to>Ashok Malhotra</to> <subject>Latest draft</subject> <body> We need to discuss the latest draft <emph>immediately</emph>. Either email me at <email> mailto:[email protected]</email> or call <phone>555-9876</phone> </body> </memo> The invoice contains several dates and telephone numbers, the postal abbreviation for a state (which comes from an enumerated list of sanctioned values), and a ZIP code (which takes a definable regular form). The memo contains many of the same types of information: a date, telephone number, email address and an "importance" value (from an enumerated list, such as "low", "medium" or "high"). Applications which process invoices and memos need to raise exceptions if something that was supposed to be a date or telephone number does not conform to the rules for valid dates or telephone numbers. In both cases, validity constraints exist on the content of the instances that are not expressible in XML DTDs. The limited datatyping facilities in XML have prevented validating XML processors from supplying the rigorous type checking required in these situations. The result has been that individual applications writers have had to implement type checking in an ad hoc manner. This specification addresses the need of both document authors and applications writers for a robust, extensible datatype system for XML which could be incorporated into XML processors. As discussed below, these datatypes could be used in other XML-related standards as well. The [XML Schema Requirements] provide for primitive data typing, including byte, date, integer, sequence, SQL and Java primitive datatypes, etc.; define a type system that is adequate for import/export from database systems (e.g., relational, object, OLAP); distinguish requirements relating to lexical data representation vs. those governing an underlying information set; allow creation of user-defined datatypes, such as datatypes that are derived from existing datatypes and which may constrain certain of its properties (e.g., range, precision, length, format). This portion of the XML Schema Language discusses datatypes that can be used in an XML Schema. These datatypes can be specified for element content that would be specified as #PCDATA various types [XSL] [RDF Schema] The terminology used to describe XML Schema Datatypes is defined in the body of this specification. The terms defined in the following list are used in building those definitions and in describing the actions of a datatype processor: [Definition:] A feature of this specification included solely to ensure that schemas which use this feature remain compatible with [XML 1.0 (Second Edition)] [Definition:] may Conforming documents and processors are permitted to but need not behave as described. [Definition:] match (Of strings or names:) Two strings or names being compared must be identical. Characters with multiple possible representations in ISO/IEC 10646 (e.g. characters with both precomposed and base+diacritic forms) match only if they have the same representation in both strings. No case folding is performed. (Of strings and rules in the grammar:) A string matches a grammatical production if it belongs to the language generated by that production. [Definition:] must Conforming documents and processors are required to behave as described; otherwise they are in · · [Definition:] error A violation of the rules of this specification; results are undefined. Conforming software · · error · · This specification provides three different kinds of normative statements about schema components, their representations in XML and their contribution to the schema-validation of information items: [Definition:] Constraint on Schemas Constraints on the schema components themselves, i.e. conditions components · · Datatype components (§4) [Definition:] Schema Representation Constraint Constraints on the representation of schema components in XML. Some but not all of these are expressed in Schema for Datatype Definitions (normative) (§A) DTD for Datatype Definitions (non-normative) (§B) [Definition:] Validation Rule Constraints expressed by schema components which information items · · Datatype components (§4) This section describes the conceptual framework behind the type system defined in this specification. The framework has been influenced by the [ISO 11404] [SQL] The datatypes discussed in this specification are computer representations of well known abstract concepts such as integer date [Definition:] datatype · · · · · · · · [Definition:] value space value space · · The · · defined axiomatically from fundamental notions (intensional definition) [see · · enumerated outright (extensional definition) [see · · defined by restricting the · · · · defined as a combination of values from one or more already defined · · · · · · · · · · equality · · · · · · Fundamental facets (§2.4.1) In addition to its · · [Definition:] lexical space literals For example, "100" and "1.0E2" are two different literals from the · · float Note: · · Interoperability: The number of literals for each value has been kept small; for many datatypes there is a one-to-one mapping between literals and values. This makes it easy to exchange the values between different systems. In many cases, conversion from locale-dependent representations will be required on both the originator and the recipient side, both for computer processing and for interaction with humans. Basic readability: Textual, rather than binary, literals are used. This makes hand editing, debugging, and similar activities possible. Ease of parsing and serializing: Where possible, literals correspond to those found in common programming languages and libraries. While the datatypes defined in this specification have, for the most part, a single lexical representation i.e. each value in the datatype's · · · · float · · [Definition:] canonical lexical representation canonical lexical representation · · 2.4.1 Fundamental facets Constraining or Non-fundamental facets [Definition:] facet · · · · The facets of a datatype serve to distinguish those aspects of one datatype which differ synthesis · · Facets are of two types: fundamental non-fundamental constraining [Definition:] fundamental facet · · All fundamental facets Fundamental Facets (§4.2) [Definition:] constraining facet · · Constraining the · · · · · · · · Derivation by restriction (§4.1.2.1) All constraining facets Constraining Facets (§4.3) 2.5.1 Atomic vs. list vs. union datatypes Primitive vs. derived datatypes Built-in vs. user-derived datatypes It is useful to categorize the datatypes defined in this specification along various dimensions, forming a set of characterization dichotomies. The first distinction to be made is that between · · · · · · [Definition:] Atomic [Definition:] List · · [Definition:] Union · · · · · · · · For example, a single token which · · Nmtoken [XML 1.0 (Second Edition)] · · NMTOKEN · · NMTOKENS · · · · · · · · · · · · · · literals Several type systems (such as the one described in [ISO 11404] · · · · · · · · · · · · · · · · · · · · [Definition:] · · · · · · itemType · · Example <simpleType name='sizes'> <list itemType='decimal'/> </simpleType> <cerealSizes xsi:type='sizes'> 8 10.5 12 </cerealSizes> A · · · · · · · · string anyURI · · {member type definitions} · · Example <simpleType name='listOfString'> <list itemType='string'/> </simpleType> <someElement xsi:type='listOfString'> this is not list item 1 this is not list item 2 this is not list item 3 </someElement> In the above example, the value of the someElement · · · · · · · · When a datatype is · · · · · · · · · · · · · · · · · · For each of · · · · · · unit of length · · collapse For · · · · · · · · · · · · · · · · Example <xs:simpleType name='myList'> <xs:list itemType='xs:integer'/> </xs:simpleType> <xs:simpleType name='myRestrictedList'> <xs:restriction base='myList'> <xs:pattern value='123 (\d+\s)*456'/> </xs:restriction> </xs:simpleType> <someElement xsi:type='myRestrictedList'>123 456</someElement> <someElement xsi:type='myRestrictedList'>123 987 456</someElement> <someElement xsi:type='myRestrictedList'>123 987 567 456</someElement> The canonical-lexical-representation · · · · · · The · · · · · · · · · · · · · · · · · · · · Example A prototypical example of a · · maxOccurs attribute element element <attributeGroup name="occurs"> <attribute name="minOccurs" type="nonNegativeInteger" use="optional" default="1"/> <attribute name="maxOccurs"use="optional" default="1"> <simpleType> <union> <simpleType> <restriction base='nonNegativeInteger'/> </simpleType> <simpleType> <restriction base='string'> <enumeration value='unbounded'/> </restriction> </simpleType> </union> </simpleType> </attribute> </attributeGroup> Any number (greater than 1) of · · · · · · · · [Definition:] · · memberTypes · · The order in which the · · QName memberTypes · · xsi:type Example For example, given the definition below, the first instance of the <size> element validates correctly as an integer (§3.3.13) string (§3.2.1) <xsd:element name='size'> <xsd:simpleType> <xsd:union> <xsd:simpleType> <xsd:restriction base='integer'/> </xsd:simpleType> <xsd:simpleType> <xsd:restriction base='string'/> </xsd:simpleType> </xsd:union> </xsd:simpleType> </xsd:element> <size>1</size> <size>large</size> <size xsi:type='xsd:string'>1</size> The canonical-lexical-representation · · · · Note: · · · · · · Next, we distinguish between · · · · [Definition:] Primitive ab initio [Definition:] Derived For example, in this specification, float integer decimal [Definition:] ur-type definition anySimpleType anySimpleType · · · · anySimpleType · · · · · · · · · · The datatypes defined by this specification fall into both the · · · · · · · · In the example above, integer · · decimal Note: · · · · As described in more detail in XML Representation of Simple Type Definition Schema Components (§4.1.2) · · · · · · restrict · · · · · · · · · · · · · · · · · · · · [Definition:] · · restriction · · · · · · · · [Definition:] · · restriction base type base type · · · · A · · · · · · · · · · One datatype can be · · · · · · · · [Definition:] Built-in · · · · [Definition:] User-derived · · Conceptually there is no difference between the · · · · · · · · · · · · Note: · · · · Each built-in datatype in this specification (both · · · · the base URI is the URI of the XML Schema namespace the fragment identifier is the name of the datatype For example, to address the int http://www.w3.org/2001/XMLSchema#int Additionally, each facet definition element can be uniquely addressed via a URI constructed as follows: the base URI is the URI of the XML Schema namespace 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: the base URI is the URI of the XML Schema namespace 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 The · · · · http://www.w3.org/2001/XMLSchema To facilitate usage in specifications other than the XML Schema definition language, such as those that do not want to know anything about aspects of the XML Schema definition language other than the datatypes, each · · http://www.w3.org/2001/XMLSchema-datatypes This applies to both · · · · · · · · Each · · · · XML Representation of Schemas [XML Schema Part 1: Structures] 3.2.1 string boolean decimal float double duration dateTime time date gYearMonth gYear gMonthDay gDay gMonth hexBinary base64Binary anyURI QName NOTATION The · · · · · · · · · · · · [Definition:] string · · string character [XML 1.0 (Second Edition)] · · Char [XML 1.0 (Second Edition)] character character Note: [Ruby] Overriding the bidirectional algorithm: the BDO element [HTML 4.01] string Any Element, Any Attribute [XML Schema Language: Part 0 Primer] Note: ordered · · · · string · · length minLength maxLength pattern enumeration whiteSpace The following · · · · string normalizedString [Definition:] boolean · · An instance of a datatype that is defined as · · The canonical representation for boolean boolean · · pattern whiteSpace [Definition:] decimal · · decimal i × 10^-n i n n >= 0 · · decimal Note: · · · · · · · · · · · · decimal -1.23, 12678967.543233, +100000.00, 210 The canonical representation for decimal Lexical representation (§3.2.3.1) decimal · · totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive The following · · · · decimal integer [Definition:] float [IEEE 754-1985] · · float m × 2^e m 2^24 e · · · · float special values · · float x < y iff y - x · · · · Note: · · [IEEE 754-1985] · · · · · · · · · · · · float · · · · · · [IEEE 754-1985] [IEEE 754-1985] A literal in the · · d · · float d [Clinger, WD (1990)] d float · · integer decimal integer decimal The special values INF -INF NaN For example, -1E4, 1267.43233E12, 12.78e-2, 12 , -0, 0 INF float The canonical representation for float Lexical representation (§3.2.4.1) float · · pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive [Definition:] double [IEEE 754-1985] · · double m × 2^e m 2^53 e · · · · double special values · · double x < y iff y - x · · · · Note: · · [IEEE 754-1985] · · · · · · · · · · · · double · · · · · · [IEEE 754-1985] [IEEE 754-1985] A literal in the · · d · · double d d best approximation d [Clinger, WD (1990)] [Gay, DM (1990)] [IEEE 754-1985] double · · integer decimal The special values INF -INF NaN For example, -1E4, 1267.43233E12, 12.78e-2, 12 , -0, 0 INF double The canonical representation for double Lexical representation (§3.2.5.1) double · · pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive [Definition:] duration · · duration [ISO 8601] Note: · · · · YYYY s.sss · · · · · · The lexical representation for duration [ISO 8601] n n n n n n n n n n n n The values of the Year, Month, Day, Hour and Minutes components are not restricted but allow an arbitrary unsigned integer, i.e., an integer that conforms to the pattern [0-9]+ [ISO 8601] [0-9]+(\.[0-9]+)? duration [ISO 8601] An optional preceding minus sign ('-') is allowed, to indicate a negative duration. If the sign is omitted a positive duration is indicated. See also ISO 8601 Date and Time Formats (§D) For example, to indicate a duration of 1 year, 2 months, 3 days, 10 hours, and 30 minutes, one would write: P1Y2M3DT10H30M -P120D Reduced precision and truncated representations of this format are allowed provided they conform to the following: If the number of years, months, days, hours, minutes, or seconds in any expression equals zero, the number and its corresponding designator · · · · The seconds part · · The designator 'T' must be absent if and only if all of the time items are absent. The designator 'P' must always be present. For example, P1347Y, P1347M and P1Y2MT2H are all allowed; P0Y1347M and P0Y1347M0D are allowed. P-1347M is not allowed although -P1347M is allowed. P1Y2MT is not allowed. In general, the · · duration · · duration x y x < y iff s+x < s+y dateTime s s Adding durations to dateTimes (§E) 1696-09-01T00:00:00Z 1697-02-01T00:00:00Z 1903-03-01T00:00:00Z 1903-07-01T00:00:00Z The following table shows the strongest relationship that can be determined between example durations. The symbol <> means that the order relation is indeterminate. Note that because of leap-seconds, a seconds field can vary from 59 to 60. However, because of the way that addition is defined in Adding durations to dateTimes (§E) Relation P 1Y > P 364D <> P 365D <> P 366D < P 367D P 1M > P 27D <> P 28D <> P 29D <> P 30D <> P 31D < P 32D P 5M > P 149D <> P 150D <> P 151D <> P 152D <> P 153D < P 154D Implementations are free to optimize the computation of the ordering relationship. For example, the following table can be used to compare durations of a small number of months against days. Months 1 2 3 4 5 6 7 8 9 10 11 12 13 ... Days Minimum 28 59 89 120 150 181 212 242 273 303 334 365 393 ... Maximum 31 62 92 123 153 184 215 245 276 306 337 366 397 ... In comparing duration minInclusive minExclusive maxInclusive maxExclusive Certain derived datatypes of durations can be guaranteed have a total order. For this, they must have fields from only one row in the list below and the time zone must either be required or prohibited. year, month day, hour, minute, second For example, a datatype could be defined to correspond to the [SQL] <simpleType name='SQL-Year-Month-Interval'> <restriction base='duration'> <pattern value='P\p{Nd}{4}Y\p{Nd}{2}M'/> </restriction> </simpleType> duration · · pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive [Definition:] dateTime dateTime · · decimal The · · dateTime · · All timezoned times are Coordinated Universal Time (UTC, sometimes called "Greenwich Mean Time"). Other timezones indicated in lexical representations are converted to UTC during conversion of literals to values. "Local" or untimezoned times are presumed to be the time in the timezone of some unspecified locality as prescribed by the appropriate legal authority; currently there are no legally prescribed timezones which are durations whose magnitude is greater than 14 hours. The value of each numeric-valued property (other than timeOnTimeline) is limited to the maximum value within the interval determined by the next-higher property. For example, the day value can never be 32, and cannot even be 29 for month 02 and year 2002 (February 2002). Note: [ISO 8601] '-' [ISO 8601] [ISO 8601:1998 Draft Revision] [ISO 8601:2000 Second Edition] dateTime date gYear gYearMonth Note: (§3.2.6) The · · dateTime '-'? yyyy '-' mm '-' dd 'T' hh ':' mm ':' ss ('.' s+)? (zzzzzz)? '-'? yyyy (§3.2.7) not the remaining '-'s are separators between parts of the date portion; the first mm dd 'T' is a separator indicating that time-of-day follows; hh dateTime dateTime · · ':' is a separator between parts of the time-of-day portion; the second mm ss '.' s+ zzzzzz For example, 2002-10-10T12:00:00-05:00 (noon on 10 October 2002, Central Daylight Savings Time as well as Eastern Standard Time in the U.S.) is 2002-10-10T17:00:00Z, five hours later than 2002-10-10T12:00:00Z. For further guidance on arithmetic with dateTime Adding durations to dateTimes (§E) Except for trailing fractional zero digits in the seconds representation, '24:00:00' time representations, and timezone (for timezoned values), the mapping from literals to values is one-to-one. Where there is more than one possible representation, the canonical representation is as follows: The 2-digit numeral representing the hour must not be ' 24 The fractional second string, if present, must not end in ' 0 for timezoned values, the timezone must be represented with ' Z dateTime Timezones are durations with (integer-valued) hour and minute properties (with the hour magnitude limited to at most 14, and the minute magnitude limited to at most 59, except that if the hour magnitude is 14, the minute value must be 0); they may be both positive or both negative. The lexical representation of a timezone is a string of the form: (('+' | '-') hh ':' mm) | 'Z' hh mm '+' indicates a nonnegative duration, '-' indicates a nonpositive duration. The mapping so defined is one-to-one, except that '+00:00', '-00:00', and 'Z' all represent the same zero-length duration timezone, UTC; 'Z' is its canonical representation. When a timezone is added to a UTC dateTime dateTime dateTime · · In general, the · · dateTime Z The following definition uses the notation S[year] to represent the year field of S, S[month] to represent the month field, and so on. The notation (Q & "-14:00") means adding the timezone -14:00 to Q, where Q did not already have a timezone. This is a logical explanation of the process. Actual implementations are free to optimize as long as they produce the same results. The ordering between two dateTime A.Normalize P and Q. That is, if there is a timezone present, but it is not Z, convert it to Z using the addition operation defined in Adding durations to dateTimes (§E) Thus 2000-03-04T23:00:00+03:00 normalizes to 2000-03-04T20:00:00Z B. If P and Q either both have a time zone or both do not have a time zone, compare P and Q field by field from the year field down to the second field, and return a result as soon as it can be determined. That is: For each i in {year, month, day, hour, minute, second} If P[i] and Q[i] are both not specified, continue to the next i If P[i] is not specified and Q[i] is, or vice versa, stop and return P <> Q If P[i] < Q[i], stop and return P < Q If P[i] > Q[i], stop and return P > Q Stop and return P = Q C.Otherwise, if P contains a time zone and Q does not, compare as follows: P < Q if P < (Q with time zone +14:00) P > Q if P > (Q with time zone -14:00) P <> Q otherwise, that is, if (Q with time zone +14:00) < P < (Q with time zone -14:00) D. Otherwise, if P does not contain a time zone and Q does, compare as follows: P < Q if (P with time zone -14:00) < Q. P > Q if (P with time zone +14:00) > Q. P <> Q otherwise, that is, if (P with time zone +14:00) < Q < (P with time zone -14:00) Examples: Determinate Indeterminate 2000-01-15T00:00:00 < 2000-01-01T12:00:00 <> 2000-01-15T12:00:00 < 2000-01-16T12:00:00 <> 2000-01-16T00:00:00 <> Certain derived types from dateTime dateTime · · pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive [Definition:] time · · time time of day [ISO 8601] Since the lexical representation allows an optional time zone indicator, time time Order relation on dateTime (§3.2.7.4) Adding durations to dateTimes (§E) time Note: (§3.2.6) The lexical representation for time dateTime ISO 8601 Date and Time Formats (§D) The canonical representation for time Lexical representation (§3.2.8.1) time · · pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive [Definition:] · · date dateTime A "date object" is an object with year, month, and day properties just like those of dateTime timezone-valued dateTime dateTime date Timezoned date [Definition:] recoverable timezone date date · · date · · Lexical representation (§3.2.9.1) For example: the first moment of 2002-10-10+13:00 is 2002-10-10T00:00:00+13, which is 2002-10-09T11:00:00Z, which is also the first moment of 2002-10-09-11:00. Therefore 2002-10-10+13:00 is 2002-10-09-11:00; they are the same interval Note: dateTime date date date date date Note: (§3.2.6) For the following discussion, let the "date portion" of a dateTime date dateTime date dateTime date The · · date '-'? yyyy '-' mm '-' dd zzzzzz? date dateTime '-' yyyy '-' mm '-' dd 'T00:00:00' zzzzzz? '-' yyyy '-' mm '-' dd 'T24:00:00' zzzzzz? Note: · · date dateTime date date · · date Given a member of the date · · date date dateTime dateTime · · [Definition:] gYearMonth · · gYearMonth [ISO 8601] Since the lexical representation allows an optional time zone indicator, gYearMonth gYearMonth gYearMonth Order relation on dateTime (§3.2.7.4) Adding durations to dateTimes (§E) gYearMonth Note: Note: (§3.2.6) The lexical representation for gYearMonth dateTime For example, to indicate the month of May 1999, one would write: 1999-05. See also ISO 8601 Date and Time Formats (§D) gYearMonth · · pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive [Definition:] gYear · · gYear [ISO 8601] Since the lexical representation allows an optional time zone indicator, gYear gYear gYear Order relation on dateTime (§3.2.7.4) Adding durations to dateTimes (§E) gYear Note: Note: (§3.2.6) The lexical representation for gYear dateTime dateTime For example, to indicate 1999, one would write: 1999. See also ISO 8601 Date and Time Formats (§D) gYear · · pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive [Definition:] gMonthDay · · gMonthDay calendar dates [ISO 8601] Since the lexical representation allows an optional time zone indicator, gMonthDay gMonthDay gMonthDay Order relation on dateTime (§3.2.7.4) Adding durations to dateTimes (§E) gMonthDay Note: The lexical representation for gMonthDay date date ISO 8601 Date and Time Formats (§D) This datatype can be used to represent a specific day in a month. To say, for example, that my birthday occurs on the 14th of September ever year. gMonthDay · · pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive [Definition:] gDay · · gDay calendar dates [ISO 8601] This datatype can be used to represent a specific day of the month. To say, for example, that I get my paycheck on the 15th of each month. Since the lexical representation allows an optional time zone indicator, gDay gDay gDay Order relation on dateTime (§3.2.7.4) Adding durations to dateTimes (§E) gDay Note: The lexical representation for gDay date date ISO 8601 Date and Time Formats (§D) gDay · · pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive [Definition:] gMonth · · gMonth calendar months [ISO 8601] This datatype can be used to represent a specific month. To say, for example, that Thanksgiving falls in the month of November. Since the lexical representation allows an optional time zone indicator, gMonth gMonth gMonth Order relation on dateTime (§3.2.7.4) Adding durations to dateTimes (§E) gMonth Note: The lexical representation for gMonth date date ISO 8601 Date and Time Formats (§D) gMonth · · pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive [Definition:] hexBinary · · hexBinary hexBinary hex The canonical representation for hexBinary Lexical Representation (§3.2.15.1) hexBinary · · length minLength maxLength pattern enumeration whiteSpace [Definition:] base64Binary · · base64Binary base64Binary [RFC 2045] The lexical forms of base64Binary [RFC 2045] a-z A-Z 0-9 [XML 1.0 (Second Edition)] For compatibility with older mail gateways, [RFC 2045] base64Binary The lexical space of base64Binary [XML 1.0 (Second Edition)] Base64Binary Base64Binary  ::=  ((B64S B64S B64S B64S)* Note that this grammar requires the number of non-whitespace characters in the lexical form to be a multiple of four, and for equals signs to appear only at the end of the lexical form; strings which do not meet these constraints are not legal lexical forms of base64Binary Note: [RFC 2045] · · collapse before The canonical lexical form of a base64Binary Canonical-base64Binary  ::=  (B64 B64 B64 B64)* Note: [RFC 2045] The length of a base64Binary lex2    := killwhitespace(lexform)    -- remove whitespace characters Note on encoding: [RFC 2045] base64Binary [XML 1.0 (Second Edition)] base64Binary · · length minLength maxLength pattern enumeration whiteSpace [Definition:] anyURI anyURI [RFC 2396] [RFC 2732] The mapping from anyURI Locator Attribute [XML Linking Language] Character Encoding in URI References [Character Model] anyURI [RFC 2396] [RFC 2732] Note: Locator Attribute [XML Linking Language] [XML Base] · · · · anyURI Note: [RFC 2396] [RFC 2732] · · · · The · · anyURI [XML Linking Language] [RFC 2396] [RFC 2732] Note: · · anyURI anyURI · · length minLength maxLength pattern enumeration whiteSpace [Definition:] QName XML qualified names · · QName namespace name local part namespace name anyURI local part NCName · · QName · · QName [Namespaces in XML] Note: · · · · QName QName QName · · length minLength maxLength pattern enumeration whiteSpace The use of · · · · · · · · QName [Definition:] NOTATION NOTATION [XML 1.0 (Second Edition)] · · NOTATION QName · · NOTATION notations QName Schema Component Constraint: enumeration facet value required for NOTATION It is an · · NOTATION · · NOTATION · · For compatibility (see Terminology (§1.4) NOTATION NOTATION · · length minLength maxLength pattern enumeration whiteSpace The use of · · · · · · · · NOTATION 3.3.1 normalizedString token language NMTOKEN NMTOKENS Name NCName ID IDREF IDREFS ENTITY ENTITIES integer nonPositiveInteger negativeInteger long int short byte nonNegativeInteger unsignedLong unsignedInt unsignedShort unsignedByte positiveInteger This section gives conceptual definitions for all · · · · · · · · · · XML Representation of Simple Type Definition Schema Components (§4.1.2) · · · · Schema for Datatype Definitions (normative) (§A) [Definition:] normalizedString · · normalizedString · · normalizedString · · normalizedString string normalizedString · · length minLength maxLength pattern enumeration whiteSpace The following · · · · normalizedString token [Definition:] token · · token · · token · · token normalizedString token · · length minLength maxLength pattern enumeration whiteSpace The following · · · · token language NMTOKEN Name [Definition:] language [RFC 3066] · · language [RFC 3066] · · language [a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})* · · language token language · · length minLength maxLength pattern enumeration whiteSpace [Definition:] NMTOKEN NMTOKEN attribute type [XML 1.0 (Second Edition)] · · NMTOKEN · · Nmtoken [XML 1.0 (Second Edition)] · · NMTOKEN · · Nmtoken [XML 1.0 (Second Edition)] · · NMTOKEN token For compatibility (see Terminology (§1.4) NMTOKEN NMTOKEN · · length minLength maxLength pattern enumeration whiteSpace The following · · · · NMTOKEN NMTOKENS [Definition:] NMTOKENS NMTOKENS attribute type [XML 1.0 (Second Edition)] · · NMTOKENS · · · · NMTOKENS · · NMTOKEN · · NMTOKENS NMTOKEN For compatibility (see Terminology (§1.4) NMTOKENS NMTOKENS · · length minLength maxLength enumeration whiteSpace pattern [Definition:] Name XML Names · · Name · · Name [XML 1.0 (Second Edition)] · · Name · · Name [XML 1.0 (Second Edition)] · · Name token Name · · length minLength maxLength pattern enumeration whiteSpace The following · · · · Name NCName [Definition:] NCName · · NCName · · NCName [Namespaces in XML] · · NCName · · NCName [Namespaces in XML] · · NCName Name NCName · · length minLength maxLength pattern enumeration whiteSpace The following · · · · NCName ID IDREF ENTITY [Definition:] ID ID attribute type [XML 1.0 (Second Edition)] · · ID · · NCName [Namespaces in XML] · · ID · · NCName [Namespaces in XML] · · ID NCName For compatibility (see Terminology (§1.4) ID ID · · length minLength maxLength pattern enumeration whiteSpace [Definition:] IDREF IDREF attribute type [XML 1.0 (Second Edition)] · · IDREF · · NCName [Namespaces in XML] · · IDREF · · NCName [Namespaces in XML] · · IDREF NCName For compatibility (see Terminology (§1.4) IDREF · · length minLength maxLength pattern enumeration whiteSpace The following · · · · IDREF IDREFS [Definition:] IDREFS IDREFS attribute type [XML 1.0 (Second Edition)] · · IDREFS IDREF · · IDREFS · · IDREF · · IDREFS IDREF For compatibility (see Terminology (§1.4) IDREFS IDREFS · · length minLength maxLength enumeration whiteSpace pattern [Definition:] ENTITY ENTITY [XML 1.0 (Second Edition)] · · ENTITY · · NCName [Namespaces in XML] unparsed entity document type definition · · ENTITY · · NCName [Namespaces in XML] · · ENTITY NCName Note: · · ENTITY For compatibility (see Terminology (§1.4) ENTITY ENTITY · · length minLength maxLength pattern enumeration whiteSpace The following · · · · ENTITY ENTITIES [Definition:] ENTITIES ENTITIES attribute type [XML 1.0 (Second Edition)] · · ENTITIES · · unparsed entities document type definition · · ENTITIES · · ENTITY · · ENTITIES ENTITY Note: · · ENTITIES For compatibility (see Terminology (§1.4) ENTITIES ENTITIES · · length minLength maxLength enumeration whiteSpace pattern [Definition:] integer · · decimal · · · · integer · · integer decimal integer The canonical representation for integer Lexical representation (§3.3.13.1) integer · · totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive The following · · · · integer nonPositiveInteger long nonNegativeInteger [Definition:] nonPositiveInteger · · integer · · · · nonPositiveInteger · · nonPositiveInteger integer nonPositiveInteger The canonical representation for nonPositiveInteger Lexical representation (§3.3.14.1) nonPositiveInteger · · totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive The following · · · · nonPositiveInteger negativeInteger [Definition:] negativeInteger · · nonPositiveInteger · · · · negativeInteger · · negativeInteger nonPositiveInteger negativeInteger The canonical representation for negativeInteger Lexical representation (§3.3.15.1) negativeInteger · · totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive [Definition:] long · · integer · · · · · · long integer long The canonical representation for long Lexical representation (§3.3.16.1) long · · totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive The following · · · · long int [Definition:] int · · long · · · · · · int long int The canonical representation for int Lexical representation (§3.3.17.1) int · · totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive The following · · · · int short [Definition:] short · · int · · · · · · short int short The canonical representation for short Lexical representation (§3.3.18.1) short · · totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive The following · · · · short byte [Definition:] byte · · short · · · · · · byte short byte The canonical representation for byte Lexical representation (§3.3.19.1) byte · · totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive [Definition:] nonNegativeInteger · · integer · · · · nonNegativeInteger · · nonNegativeInteger integer nonNegativeInteger The canonical representation for nonNegativeInteger Lexical representation (§3.3.20.1) nonNegativeInteger · · totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive The following · · · · nonNegativeInteger unsignedLong positiveInteger [Definition:] unsignedLong · · nonNegativeInteger · · · · unsignedLong nonNegativeInteger unsignedLong The canonical representation for unsignedLong Lexical representation (§3.3.21.1) unsignedLong · · totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive The following · · · · unsignedLong unsignedInt [Definition:] unsignedInt · · unsignedLong · · · · unsignedInt unsignedLong unsignedInt The canonical representation for unsignedInt Lexical representation (§3.3.22.1) unsignedInt · · totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive The following · · · · unsignedInt unsignedShort [Definition:] unsignedShort · · unsignedInt · · · · unsignedShort unsignedInt unsignedShort The canonical representation for unsignedShort Lexical representation (§3.3.23.1) unsignedShort · · totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive The following · · · · unsignedShort unsignedByte [Definition:] unsignedByte · · unsignedShort · · · · unsignedByte unsignedShort unsignedByte The canonical representation for unsignedByte Lexical representation (§3.3.24.1) unsignedByte · · totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive [Definition:] positiveInteger · · nonNegativeInteger · · · · positiveInteger · · positiveInteger nonNegativeInteger positiveInteger The canonical representation for positiveInteger Lexical representation (§3.3.25.1) positiveInteger · · totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive The following sections provide full details on the properties and significance of each kind of schema component involved in datatype definitions. For each property, the kinds of values it is allowed to have is specified. Any property not identified as optional is required to be present; optional properties which are not present have absent · · absent For more information on the notion of datatype (schema) components, see Schema Component Details [XML Schema Part 1: Structures] 4.1.1 The Simple Type Definition Schema Component XML Representation of Simple Type Definition Schema Components Constraints on XML Representation of Simple Type Definition Simple Type Definition Validation Rules Constraints on Simple Type Definition Schema Components Simple Type Definition for anySimpleType Simple Type definitions provide for: Establishing the · · · · · · Attaching a unique name (actually a QName · · · · The Simple Type Definition schema component has the following properties: Schema Component Simple Type Definition {name} Optional. An NCName as defined by [Namespaces in XML] {target namespace} Either absent [Namespaces in XML] {variety} One of { atomic list union {variety} atomic {primitive type definition} A · · · · list {item type definition} An · · · · union {member type definitions} A non-empty sequence of simple type definitions. {facets} A possibly empty set of Facets (§2.4) {fundamental facets} A set of Fundamental facets (§2.4.1) {base type definition} If the datatype has been · · · · Simple Type Definition · · Simple Type Definition for anySimpleType (§4.1.6) {final} A subset of {restriction, list, union} {annotation} Optional. An annotation Datatypes are identified by their {name} {target namespace} {name} · · If {variety} · · · · · · {base type definition} · · {primitive type definition} {variety} · · · · · · {item type definition} {variety} · · · · · · {member type definitions} If {variety} · · {variety} {base type definition} · · {variety} · · {variety} {item type definition} · · · · {variety} · · {member type definitions} The value of {facets} · · {facets} {base type definition} The value of {fundamental facets} · · If {final} restriction list union · · · · · · The XML representation for a Simple Type Definition <simpleType> XML Representation Summary simpleType <simpleType #all list union restriction ID name NCName {any attributes with non-schema namespace . . .} Content: annotation restriction list union Datatype Definition Schema Component Property Representation {name} The actual value name [attribute] null {final} A set corresponding to the actual value final [attribute] actual value finalDefault [attribute] schema the empty string the empty set; #all {restriction, list, union} otherwise a set with members drawn from the set above, each being present or absent depending on whether the string contains an equivalently named space-delimited substring. Note: finalDefault [attribute] schema restriction list union {final} {target namespace} The actual value targetNamespace [attribute] schema {annotation} The annotation corresponding to the <annotation> [children] null A · · · · · · · · restriction list union XML Representation Summary restriction <restriction QName ID {any attributes with non-schema namespace . . .} Content: annotation simpleType minExclusive minInclusive maxExclusive maxInclusive totalDigits fractionDigits length minLength maxLength enumeration whiteSpace pattern Simple Type Definition Schema Component Property Representation {variety} The actual value {variety} {base type definition} {facets} The union of the set of Facets (§2.4) [children] {facets} {base type definition} Facets (§2.4) {base type definition} The Simple Type Definition actual value base [attribute] <simpleType> [children] Example An electronic commerce schema might define a datatype called Sku · · string · · <simpleType name='Sku'> <restriction base='string'> <pattern value='\d{3}-[A-Z]{2}'/> </restriction> </simpleType> In this case, Sku · · string · · · · XML Representation Summary list <list ID QName {any attributes with non-schema namespace . . .} Content: annotation simpleType Simple Type Definition Schema Component Property Representation {variety} list {item type definition} The Simple Type Definition actual value itemType [attribute] <simpleType> [children] A · · · · · · · · · · · · · · · · · · · · · · Example A system might want to store lists of floating point values. <simpleType name='listOfFloat'> <list itemType='float'/> </simpleType> In this case, listOfFloat · · float · · · · As mentioned in List datatypes (§2.5.1.2) · · · · · · · · · · · · · · · · · · regardless of the · · · · · · · · For each of · · · · · · unit of length · · collapse XML Representation Summary union <union ID QName {any attributes with non-schema namespace . . .} Content: annotation simpleType Simple Type Definition Schema Component Property Representation {variety} union {member type definitions} The sequence of Simple Type Definition actual value memberTypes [attribute] Simple Type Definition <simpleType> [children] {variety} union Simple Type Definition Simple Type Definition {member type definitions} A · · · · · · · · · · · · · · 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 · · <xsd:attribute name="size"> <xsd:simpleType> <xsd:union> <xsd:simpleType> <xsd:restriction base="xsd:positiveInteger"> <xsd:minInclusive value="8"/> <xsd:maxInclusive value="72"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType> <xsd:restriction base="xsd:NMTOKEN"> <xsd:enumeration value="small"/> <xsd:enumeration value="medium"/> <xsd:enumeration value="large"/> </xsd:restriction> </xsd:simpleType> </xsd:union> </xsd:simpleType> </xsd:attribute> <p> <font size='large'>A header</font> </p> <p> <font size='12'>this is a test</font> </p> As mentioned in Union datatypes (§2.5.1.3) · · · · · · · · · · regardless of the · · · · Schema Representation Constraint: Single Facet Value Unless otherwise specifically allowed by this specification ( Multiple patterns (§4.3.4.3) Multiple enumerations (§4.3.5.3) · · Schema Representation Constraint: itemType attribute or simpleType child Either the itemType [attribute] <simpleType> [child] <list> Schema Representation Constraint: base attribute or simpleType child Either the base [attribute] simpleType [child] <restriction> Schema Representation Constraint: memberTypes attribute or simpleType children Either the memberTypes [attribute] <union> simpleType [child] Validation Rule: Facet Valid A value in a · · · · 1 the value is facet-valid with respect to the particular · · Validation Rule: Datatype Valid A string is datatype-valid with respect to a datatype definition if: 1 it · · · · 1.1 if · · {facets} pattern valid (§4.3.4.4) 1.2 if · · {facets} 1.2.1 if {variety} · · · · · · {base type definition} 1.2.2 if {variety} · · · · · · {item type definition} 1.2.3 if {variety} · · · · · · {member type definitions} 2 the value denoted by the literal · · · · Facet Valid (§4.1.4) {facets} · · Schema Component Constraint: applicable facets The · · {facets} {base type definition} {base type definition} applicable {facets} If {variety} list [all datatypes] length minLength maxLength pattern enumeration whiteSpace If {variety} union [all datatypes] pattern enumeration else if {variety} atomic string length minLength maxLength pattern enumeration whiteSpace boolean pattern whiteSpace float pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive double pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive decimal totalDigits fractionDigits pattern whiteSpace enumeration maxInclusive maxExclusive minInclusive minExclusive duration pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive dateTime pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive time pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive date pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive gYearMonth pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive gYear pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive gMonthDay pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive gDay pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive gMonth pattern enumeration whiteSpace maxInclusive maxExclusive minInclusive minExclusive hexBinary length minLength maxLength pattern enumeration whiteSpace base64Binary length minLength maxLength pattern enumeration whiteSpace anyURI length minLength maxLength pattern enumeration whiteSpace QName length minLength maxLength pattern enumeration whiteSpace NOTATION length minLength maxLength pattern enumeration whiteSpace Schema Component Constraint: list of atomic If {variety} · · {variety} {item type definition} · · · · · · Schema Component Constraint: no circular unions If {variety} · · · · {name} {target namespace} · · {name} {target namespace} {member type definitions} There is a simple type definition nearly equivalent to the simple version of the ur-type definition Schema Component anySimpleType {name} anySimpleType {target namespace} http://www.w3.org/2001/XMLSchema {basetype definition} the ur-type definition {final} the empty set {variety} absent 4.2.1 equal ordered bounded cardinality numeric Every · · for any a b · · a b a = b a b a != b there is no pair a b · · a = b a != b for all a · · a = a for any a b · · a = b b = a for any a b c · · a = b b = c a = c for any a b · · a = b a b the · · · · On every datatype, the operation Equal is defined in terms of the equality property of the · · a, b · · Equal(a,b) a = b Note that in consequence of the above: given · · A · · B A B a A b B a != b two values which are members of the · · · · if a datatype T · · · · · · A, B, ... · · T · · · · A, B, ... · · T · · A · · T · · B · · T · · A · · A T B · · if a datatype T' · · · · T · · T' · · T · · T T' if datatypes T' T'' · · · · T · · T' T'' · · T' T'' Note: equal · · [Definition:] order relation · · · · · · · · [Definition:] · · ordered · · · · [Definition:] partial order · · irreflexive asymmetric transitive A · · for no a · · a < a for all a b · · a < b b < a for all a b c · · a < b b < c a < c The notation a <> b a != b a < b b < a a b · · · · a <> b [Definition:] a <> b a b incomparable [Definition:] comparable [Definition:] total order · · a b a <> b A · · · · for all a b · · a < b b < a a = b Note: · · · · indicating whether an · · · · · · · · · · Schema Component ordered {value} One of {false, partial, total} {value} {variety} {facets} {member type definitions} Simple Type Definition · · {fundamental facets} When {variety} · · {value} {value} {base type definition} · · {value} Fundamental Facets (§C.1) When {variety} · · {value} false When {variety} · · {value} partial If every member of {member type definitions} {value} ordered If every member of {member type definitions} {value} false ordered {value} false [Definition:] u · · · · U inclusive upper bound · · V V U v V u v [Definition:] u · · · · U exclusive upper bound · · V V U v V u v [Definition:] l · · · · L inclusive lower bound · · V V L v V l v [Definition:] l · · · · L exclusive lower bound · · V V L v V l v [Definition:] bounded · · · · · · · · · · · · indicating whether a · · · · Schema Component bounded {value} A boolean {value} {variety} {facets} {member type definitions} Simple Type Definition · · {fundamental facets} When {variety} · · · · · · · · · · {facets} {value} true {value} false When {variety} · · · · · · · · {facets} {value} true {value} false When {variety} · · {value} true {member type definitions} {member type definitions} {value} true {value} false [Definition:] · · cardinality · · · · · · It is sometimes useful to categorize · · · · · · · · indicating whether the · · · · finite countably infinite Schema Component cardinality {value} One of {finite, countably infinite} {value} {variety} {facets} {member type definitions} Simple Type Definition · · {fundamental facets} When {variety} · · {value} {base type definition} finite {value} finite When {variety} · · {value} {base type definition} countably infinite either {value} finite {value} countably infinite one of · · · · · · {facets} all one of · · · · {facets} one of · · · · {facets} either · · {facets} {base type definition} date gYearMonth gYear gMonthDay gDay gMonth · · When {variety} · · · · · · · · {facets} {value} finite {value} countably infinite When {variety} · · {value} finite {member type definitions} {value} finite {value} countably infinite [Definition:] numeric [Definition:] · · non-numeric · · indicating whether a · · · · Schema Component numeric {value} A boolean {value} {variety} {facets} {base type definition} {member type definitions} Simple Type Definition · · {fundamental facets} When {variety} · · {value} {value} {base type definition} · · {value} Fundamental Facets (§C.1) When {variety} · · {value} false When {variety} · · {value} true {member type definitions} {value} true {value} false 4.3.1 length minLength maxLength pattern enumeration whiteSpace maxInclusive maxExclusive minExclusive minInclusive totalDigits fractionDigits [Definition:] length units of length units of length · · length · · nonNegativeInteger For string · · string length character [XML 1.0 (Second Edition)] anyURI length string hexBinary base64Binary · · length · · · · length Note: string · · string length length length · · Constraining a · · units of length units of length {base type definition} Example The following is the definition of a · · length pattern <simpleType name='productCode'> <restriction base='string'> <length value='8' fixed='true'/> </restriction> </simpleType> Schema Component length {value} A nonNegativeInteger {fixed} A boolean {annotation} Optional. An annotation If {fixed} true {base type definition} length {value} The XML representation for a length <length> XML Representation Summary length <length boolean ID value nonNegativeInteger {any attributes with non-schema namespace . . .} Content: annotation length Schema Component Property Representation {value} The actual value value [attribute] {fixed} The actual value fixed [attribute] {annotation} The annotations corresponding to all the <annotation> [children] Validation Rule: Length Valid A value in a · · · · 1 if the {variety} · · 1.1 if {primitive type definition} string anyURI character · · {value} 1.2 if {primitive type definition} hexBinary base64Binary · · {value} 1.3

if {primitive type definition} QName NOTATION {value} 2 if the {variety} · · · · {value} The use of · · · · QName NOTATION Schema Component Constraint: length and minLength or maxLength If length {facets} 1 It is an error for minLength {facets} 1.1 the {value} minLength {value} length 1.2 there is type definition from which this one is derived by one or more restriction steps in which minLength {value} length 2 It is an error for maxLength {facets} 2.1 the {value} length {value} maxLength 2.2 there is type definition from which this one is derived by one or more restriction steps in which maxLength {value} length Schema Component Constraint: length valid restriction It is an · · length {facets} {base type definition} {value} {value} length [Definition:] minLength units of length units of length · · minLength · · nonNegativeInteger For string · · string minLength character [XML 1.0 (Second Edition)] hexBinary base64Binary · · minLength · · · · minLength Note: string · · string minLength minLength minLength · · Constraining a · · units of length units of length {base type definition} Example The following is the definition of a · · · · <simpleType name='non-empty-string'> <restriction base='string'> <minLength value='1'/> </restriction> </simpleType> Schema Component minLength {value} A nonNegativeInteger {fixed} A boolean {annotation} Optional. An annotation If {fixed} true {base type definition} minLength {value} The XML representation for a minLength <minLength> XML Representation Summary minLength <minLength boolean ID value nonNegativeInteger {any attributes with non-schema namespace . . .} Content: annotation minLength Schema Component Property Representation {value} The actual value value [attribute] {fixed} The actual value fixed [attribute] {annotation} The annotations corresponding to all the <annotation> [children] Validation Rule: minLength Valid A value in a · · · · 1 if the {variety} · · 1.1 if {primitive type definition} string anyURI character · · {value} 1.2 if {primitive type definition} hexBinary base64Binary · · {value} 1.3

if {primitive type definition} QName NOTATION {value} 2 if the {variety} · · · · {value} The use of · · · · QName NOTATION Schema Component Constraint: minLength <= maxLength If both minLength maxLength {facets} {value} minLength · · {value} maxLength Schema Component Constraint: minLength valid restriction It is an · · minLength {facets} {base type definition} {value} {value} minLength [Definition:] maxLength units of length units of length · · maxLength · · nonNegativeInteger For string · · string maxLength character [XML 1.0 (Second Edition)] hexBinary base64Binary · · maxLength · · · · maxLength Note: string · · string maxLength maxLength maxLength · · Constraining a · · units of length units of length {base type definition} Example The following is the definition of a · · <simpleType name='form-input'> <restriction base='string'> <maxLength value='50'/> </restriction> </simpleType> Schema Component maxLength {value} A nonNegativeInteger {fixed} A boolean {annotation} Optional. An annotation If {fixed} true {base type definition} maxLength {value} The XML representation for a maxLength <maxLength> XML Representation Summary maxLength <maxLength boolean ID value nonNegativeInteger {any attributes with non-schema namespace . . .} Content: annotation maxLength Schema Component Property Representation {value} The actual value value [attribute] {fixed} The actual value fixed [attribute] {annotation} The annotations corresponding to all the <annotation> [children] Validation Rule: maxLength Valid A value in a · · · · 1 if the {variety} · · 1.1 if {primitive type definition} string anyURI character · · {value} 1.2 if {primitive type definition} hexBinary base64Binary · · {value} 1.3

if {primitive type definition} QName NOTATION {value} 2 if the {variety} · · · · {value} The use of · · · · QName NOTATION Schema Component Constraint: maxLength valid restriction It is an · · maxLength {facets} {base type definition} {value} {value} maxLength [Definition:] pattern · · · · pattern · · · · · · Constraining a · · · · Example The following is the definition of a · · · · <simpleType name='better-us-zipcode'> <restriction base='string'> <pattern value='[0-9]{5}(-[0-9]{4})?'/> </restriction> </simpleType> Schema Component pattern {value} A · · {annotation} Optional. An annotation The XML representation for a pattern <pattern> XML Representation Summary pattern <pattern ID value string {any attributes with non-schema namespace . . .} Content: annotation {value} · · · · pattern Schema Component Property Representation {value} The actual value value [attribute] {annotation} The annotations corresponding to all the <annotation> [children] Schema Representation Constraint: Multiple patterns If multiple <pattern> [children] <simpleType> [value] · · · · Note: Multiple patterns (§4.3.4.3) · · · · same OR · · different AND · · · · · · · · Validation Rule: pattern valid A literal in a · · · · 1 the literal is among the set of character sequences denoted by the · · {value} [Definition:] enumeration · · enumeration · · · · · · · · · · Constraining a · · Example The following example is a datatype definition for a · · · · · · <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> Schema Component enumeration {value} A set of values from the · · {base type definition} {annotation} Optional. An annotation The XML representation for an enumeration <enumeration> XML Representation Summary enumeration <enumeration ID value anySimpleType {any attributes with non-schema namespace . . .} Content: annotation {value} · · · · {base type definition} enumeration Schema Component Property Representation {value} The actual value value [attribute] {annotation} The annotations corresponding to all the <annotation> [children] Schema Representation Constraint: Multiple enumerations If multiple <enumeration> [children] <simpleType> {value} enumeration [value] Validation Rule: enumeration valid A value in a · · · · {value} Schema Component Constraint: enumeration valid restriction It is an · · {value} · · {base type definition} [Definition:] whiteSpace · · · · string Attribute Value Normalization [XML 1.0 (Second Edition)] whiteSpace preserve No normalization is done, the value is not changed (this is the behavior required by [XML 1.0 (Second Edition)] 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 Note: hexadecimal A &#xA; character reference whiteSpace · · · · · · string · · · · whiteSpace collapse string whiteSpace preserve · · · · string whiteSpace · · · · whiteSpace collapse · · · · whiteSpace · · whiteSpace · · · · Note: whiteSpace Schema Component Details [XML Schema Part 1: Structures] · · Constraining a · · Example The following example is the datatype definition for the token · · · · <simpleType name='token'> <restriction base='normalizedString'> <whiteSpace value='collapse'/> </restriction> </simpleType> Schema Component whiteSpace {value} One of {preserve, replace, collapse} {fixed} A boolean {annotation} Optional. An annotation If {fixed} true {base type definition} whiteSpace {value} The XML representation for a whiteSpace <whiteSpace> XML Representation Summary whiteSpace <whiteSpace boolean ID value collapse preserve replace {any attributes with non-schema namespace . . .} Content: annotation whiteSpace Schema Component Property Representation {value} The actual value value [attribute] {fixed} The actual value fixed [attribute] {annotation} The annotations corresponding to all the <annotation> [children] Note: · · · · Schema Component Details [XML Schema Part 1: Structures] Schema Component Constraint: whiteSpace valid restriction It is an · · whiteSpace {facets} {base type definition} 1 {value} replace preserve {value} whiteSpace collapse 2 {value} preserve {value} whiteSpace replace [Definition:] maxInclusive · · · · · · maxInclusive · · · · · · · · Constraining a · · · · Example The following is the definition of a · · · · <simpleType name='one-hundred-or-less'> <restriction base='integer'> <maxInclusive value='100'/> </restriction> </simpleType> Schema Component maxInclusive {value} A value from the · · {base type definition} {fixed} A boolean {annotation} Optional. An annotation If {fixed} true {base type definition} maxInclusive {value} The XML representation for a maxInclusive <maxInclusive> XML Representation Summary maxInclusive <maxInclusive boolean ID value anySimpleType {any attributes with non-schema namespace . . .} Content: annotation {value} · · · · {base type definition} maxInclusive Schema Component Property Representation {value} The actual value value [attribute] {fixed} The actual value fixed [attribute] {annotation} The annotations corresponding to all the <annotation> [children] Validation Rule: maxInclusive Valid A value in an · · · · · · 1 if the · · {fundamental facets} true · · {value} 2 if the · · {fundamental facets} false {base type definition} · · {value} Schema Component Constraint: minInclusive <= maxInclusive It is an · · · · · · Schema Component Constraint: maxInclusive valid restriction It is an · · 1 maxInclusive {facets} {base type definition} {value} {value} maxInclusive 2 maxExclusive {facets} {base type definition} {value} {value} maxExclusive 3 minInclusive {facets} {base type definition} {value} {value} minInclusive 4 minExclusive {facets} {base type definition} {value} {value} minExclusive [Definition:] maxExclusive · · · · · · maxExclusive · · · · · · {value} {base type definition} · · Constraining a · · · · Example The following is the definition of a · · · · <simpleType name='less-than-one-hundred-and-one'> <restriction base='integer'> <maxExclusive value='101'/> </restriction> </simpleType> Note that the · · Schema Component maxExclusive {value} A value from the · · {base type definition} {fixed} A boolean {annotation} Optional. An annotation If {fixed} true {base type definition} maxExclusive {value} The XML representation for a maxExclusive <maxExclusive> XML Representation Summary maxExclusive <maxExclusive boolean ID value anySimpleType {any attributes with non-schema namespace . . .} Content: annotation {value} · · · · {base type definition} maxExclusive Schema Component Property Representation {value} The actual value value [attribute] {fixed} The actual value fixed [attribute] {annotation} The annotations corresponding to all the <annotation> [children] Validation Rule: maxExclusive Valid A value in an · · · · · · 1 if the · · {fundamental facets} true · · {value} 2 if the · · {fundamental facets} false {base type definition} · · {value} Schema Component Constraint: maxInclusive and maxExclusive It is an · · · · · · Schema Component Constraint: minExclusive <= maxExclusive It is an · · · · · · Schema Component Constraint: maxExclusive valid restriction It is an · · 1 maxExclusive {facets} {base type definition} {value} {value} maxExclusive 2 maxInclusive {facets} {base type definition} {value} {value} maxInclusive 3 minInclusive {facets} {base type definition} {value} {value} minInclusive 4 minExclusive {facets} {base type definition} {value} {value} minExclusive [Definition:] minExclusive · · · · · · minExclusive · · · · · · {value} {base type definition} · · Constraining a · · · · Example The following is the definition of a · · · · <simpleType name='more-than-ninety-nine'> <restriction base='integer'> <minExclusive value='99'/> </restriction> </simpleType> Note that the · · Schema Component minExclusive {value} A value from the · · {base type definition} {fixed} A boolean {annotation} Optional. An annotation If {fixed} true {base type definition} minExclusive {value} The XML representation for a minExclusive <minExclusive> XML Representation Summary minExclusive <minExclusive boolean ID value anySimpleType {any attributes with non-schema namespace . . .} Content: annotation {value} · · · · {base type definition} minExclusive Schema Component Property Representation {value} The actual value value [attribute] {fixed} The actual value fixed [attribute] {annotation} The annotations corresponding to all the <annotation> [children] Validation Rule: minExclusive Valid A value in an · · · · · · 1 if the · · {fundamental facets} true · · {value} 2 if the · · {fundamental facets} false {base type definition} · · {value} Schema Component Constraint: minInclusive and minExclusive It is an · · · · · · Schema Component Constraint: minExclusive < maxInclusive It is an · · · · · · Schema Component Constraint: minExclusive valid restriction It is an · · 1 minExclusive {facets} {base type definition} {value} {value} minExclusive 2 maxInclusive {facets} {base type definition} {value} {value} maxInclusive 3 minInclusive {facets} {base type definition} {value} {value} minInclusive 4 maxExclusive {facets} {base type definition} {value} {value} maxExclusive [Definition:] minInclusive · · · · · · minInclusive · · · · · · · · Constraining a · · · · Example The following is the definition of a · · · · <simpleType name='one-hundred-or-more'> <restriction base='integer'> <minInclusive value='100'/> </restriction> </simpleType> Schema Component minInclusive {value} A value from the · · {base type definition} {fixed} A boolean {annotation} Optional. An annotation If {fixed} true {base type definition} minInclusive {value} The XML representation for a minInclusive <minInclusive> XML Representation Summary minInclusive <minInclusive boolean ID value anySimpleType {any attributes with non-schema namespace . . .} Content: annotation {value} · · · · {base type definition} minInclusive Schema Component Property Representation {value} The actual value value [attribute] {fixed} The actual value fixed [attribute] {annotation} The annotations corresponding to all the <annotation> [children] Validation Rule: minInclusive Valid A value in an · · · · · · 1 if the · · {fundamental facets} true · · {value} 2 if the · · {fundamental facets} false {base type definition} · · {value} Schema Component Constraint: minInclusive < maxExclusive It is an · · · · · · Schema Component Constraint: minInclusive valid restriction It is an · · 1 minInclusive {facets} {base type definition} {value} {value} minInclusive 2 maxInclusive {facets} {base type definition} {value} {value} maxInclusive 3 minExclusive {facets} {base type definition} {value} {value} minExclusive 4 maxExclusive {facets} {base type definition} {value} {value} maxExclusive [Definition:] totalDigits · · · · decimal i × 10^-n i n |i| < 10^totalDigits 0 <= n <= totalDigits totalDigits · · positiveInteger The term totalDigits · · totalDigits · · Schema Component totalDigits {value} A positiveInteger {fixed} A boolean {annotation} Optional. An annotation If {fixed} true {base type definition} totalDigits {value} The XML representation for a totalDigits <totalDigits> XML Representation Summary totalDigits <totalDigits boolean ID value positiveInteger {any attributes with non-schema namespace . . .} Content: annotation totalDigits Schema Component Property Representation {value} The actual value value [attribute] {fixed} The actual value fixed [attribute] {annotation} The annotations corresponding to all the <annotation> [children] Validation Rule: totalDigits Valid A value in a · · · · 1

that value is expressible as i × 10^-n i n |i| < 10^ {value} 0 <= n <= {value} Schema Component Constraint: totalDigits valid restriction It is an · · totalDigits {facets} {base type definition} {value} {value} totalDigits [Definition:] fractionDigits · · · · decimal · · i × 10^-n i n 0 <= n <= fractionDigits fractionDigits · · nonNegativeInteger The term fractionDigits · · fractionDigits · · · · Example The following is the definition of a · · · · <simpleType name='celsiusBodyTemp'> <restriction base='decimal'> <totalDigits value='4'/> <fractionDigits value='1'/> <minInclusive value='36.4'/> <maxInclusive value='40.5'/> </restriction> </simpleType> Schema Component fractionDigits {value} A nonNegativeInteger {fixed} A boolean {annotation} Optional. An annotation If {fixed} true {base type definition} fractionDigits {value} The XML representation for a fractionDigits <fractionDigits> XML Representation Summary fractionDigits <fractionDigits boolean ID value nonNegativeInteger {any attributes with non-schema namespace . . .} Content: annotation fractionDigits Schema Component Property Representation {value} The actual value value [attribute] {fixed} The actual value fixed [attribute] {annotation} The annotations corresponding to all the <annotation> [children] Validation Rule: fractionDigits Valid A value in a · · · · 1

that value is expressible as i × 10^-n i n 0 <= n <= {value} Schema Component Constraint: fractionDigits less than or equal to totalDigits It is an · · · · · · Schema Component Constraint: fractionDigits valid restriction It is an · · · · {facets} {base type definition} {value} {value} · · This specification describes two levels of conformance for datatype processors. The first is required of all processors. Support for the other will depend on the application environments for which the processor is intended. [Definition:] Minimally conforming · · · · · · [Definition:] XML Representation of Simple Type Definition Schema Components (§4.1.2) Datatype components (§4) conformance to the XML Representation of Schemas · · · · · · XML Representation of Simple Type Definition Schema Components (§4.1.2) Datatype components (§4) schema components Note: · · · · <!DOCTYPE xs:schema PUBLIC "-//W3C//DTD XMLSCHEMA 200102//EN" "XMLSchema.dtd" [

<!-- keep this schema XML1.0 DTD valid --> <!ENTITY % schemaAttrs 'xmlns:hfp CDATA #IMPLIED'>

<!ELEMENT hfp:hasFacet EMPTY> <!ATTLIST hfp:hasFacet name NMTOKEN #REQUIRED>

<!ELEMENT hfp:hasProperty EMPTY> <!ATTLIST hfp:hasProperty name NMTOKEN #REQUIRED value CDATA #REQUIRED> <!-- Make sure that processors that do not read the external subset will know about the various IDs we declare --> <!ATTLIST xs:simpleType id ID #IMPLIED> <!ATTLIST xs:maxExclusive id ID #IMPLIED> <!ATTLIST xs:minExclusive id ID #IMPLIED> <!ATTLIST xs:maxInclusive id ID #IMPLIED> <!ATTLIST xs:minInclusive id ID #IMPLIED> <!ATTLIST xs:totalDigits id ID #IMPLIED> <!ATTLIST xs:fractionDigits id ID #IMPLIED> <!ATTLIST xs:length id ID #IMPLIED> <!ATTLIST xs:minLength id ID #IMPLIED> <!ATTLIST xs:maxLength id ID #IMPLIED> <!ATTLIST xs:enumeration id ID #IMPLIED> <!ATTLIST xs:pattern id ID #IMPLIED> <!ATTLIST xs:appinfo id ID #IMPLIED> <!ATTLIST xs:documentation id ID #IMPLIED> <!ATTLIST xs:list id ID #IMPLIED> <!ATTLIST xs:union id ID #IMPLIED> ]>

<?xml version='1.0'?> <xs:schema xmlns:hfp="http://www.w3.org/2001/XMLSchema-hasFacetAndProperty" xmlns:xs="http://www.w3.org/2001/XMLSchema" blockDefault="#all" elementFormDefault="qualified" xml:lang="en" targetNamespace="http://www.w3.org/2001/XMLSchema" version="Id: datatypes.xsd,v 1.4 2004/05/29 10:26:33 ht Exp "> <xs:annotation> <xs:documentation source="../datatypes/datatypes-with-errata.html"> The schema corresponding to this document is normative, with respect to the syntactic constraints it expresses in the XML Schema language. The documentation (within &lt;documentation> elements) below, is not normative, but rather highlights important aspects of the W3C Recommendation of which this is a part </xs:documentation> </xs:annotation> <xs:annotation> <xs:documentation> First the built-in primitive datatypes. These definitions are for information only, the real built-in definitions are magic. </xs:documentation> <xs:documentation> 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

</xs:documentation> </xs:annotation> <xs:simpleType name="string" id="string"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#string"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace value="preserve" id="string.preserve"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="boolean" id="boolean"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#boolean"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="boolean.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="float" id="float"> <xs:annotation> <xs:appinfo> <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="true"/> <hfp:hasProperty name="cardinality" value="finite"/> <hfp:hasProperty name="numeric" value="true"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#float"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="float.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="double" id="double"> <xs:annotation> <xs:appinfo> <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="true"/> <hfp:hasProperty name="cardinality" value="finite"/> <hfp:hasProperty name="numeric" value="true"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#double"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="double.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="decimal" id="decimal"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#decimal"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="decimal.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="duration" id="duration"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#duration"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="duration.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="dateTime" id="dateTime"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#dateTime"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="dateTime.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="time" id="time"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#time"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="time.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="date" id="date"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#date"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="date.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="gYearMonth" id="gYearMonth"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#gYearMonth"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="gYearMonth.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="gYear" id="gYear"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#gYear"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="gYear.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="gMonthDay" id="gMonthDay"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#gMonthDay"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="gMonthDay.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="gDay" id="gDay"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#gDay"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="gDay.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="gMonth" id="gMonth"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#gMonth"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="gMonth.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="hexBinary" id="hexBinary"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#binary"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="hexBinary.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="base64Binary" id="base64Binary"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#base64Binary"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="base64Binary.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="anyURI" id="anyURI"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#anyURI"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="anyURI.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="QName" id="QName"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#QName"/> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="QName.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="NOTATION" id="NOTATION"> <xs:annotation> <xs:appinfo> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#NOTATION"/> <xs:documentation> 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. </xs:documentation> </xs:annotation> <xs:restriction base="xs:anySimpleType"> <xs:whiteSpace fixed="true" value="collapse" id="NOTATION.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:annotation> <xs:documentation> Now the derived primitive types </xs:documentation> </xs:annotation> <xs:simpleType name="normalizedString" id="normalizedString"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#normalizedString"/> </xs:annotation> <xs:restriction base="xs:string"> <xs:whiteSpace value="replace" id="normalizedString.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="token" id="token"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#token"/> </xs:annotation> <xs:restriction base="xs:normalizedString"> <xs:whiteSpace value="collapse" id="token.whiteSpace"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="language" id="language"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#language"/> </xs:annotation> <xs:restriction base="xs:token"> <xs:pattern value="[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*" id="language.pattern"> <xs:annotation> <xs:documentation source="http://www.ietf.org/rfc/rfc3066.txt"> pattern specifies the content of section 2.12 of XML 1.0e2 and RFC 3066 (Revised version of RFC 1766). </xs:documentation> </xs:annotation> </xs:pattern> </xs:restriction> </xs:simpleType> <xs:simpleType name="IDREFS" id="IDREFS"> <xs:annotation> <xs:appinfo> <hfp:hasFacet name="length"/> <hfp:hasFacet name="minLength"/> <hfp:hasFacet name="maxLength"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="pattern"/> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#IDREFS"/> </xs:annotation> <xs:restriction> <xs:simpleType> <xs:list itemType="xs:IDREF"/> </xs:simpleType> <xs:minLength value="1" id="IDREFS.minLength"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="ENTITIES" id="ENTITIES"> <xs:annotation> <xs:appinfo> <hfp:hasFacet name="length"/> <hfp:hasFacet name="minLength"/> <hfp:hasFacet name="maxLength"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="pattern"/> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#ENTITIES"/> </xs:annotation> <xs:restriction> <xs:simpleType> <xs:list itemType="xs:ENTITY"/> </xs:simpleType> <xs:minLength value="1" id="ENTITIES.minLength"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="NMTOKEN" id="NMTOKEN"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#NMTOKEN"/> </xs:annotation> <xs:restriction base="xs:token"> <xs:pattern value="\c+" id="NMTOKEN.pattern"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/REC-xml#NT-Nmtoken"> pattern matches production 7 from the XML spec </xs:documentation> </xs:annotation> </xs:pattern> </xs:restriction> </xs:simpleType> <xs:simpleType name="NMTOKENS" id="NMTOKENS"> <xs:annotation> <xs:appinfo> <hfp:hasFacet name="length"/> <hfp:hasFacet name="minLength"/> <hfp:hasFacet name="maxLength"/> <hfp:hasFacet name="enumeration"/> <hfp:hasFacet name="whiteSpace"/> <hfp:hasFacet name="pattern"/> <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"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#NMTOKENS"/> </xs:annotation> <xs:restriction> <xs:simpleType> <xs:list itemType="xs:NMTOKEN"/> </xs:simpleType> <xs:minLength value="1" id="NMTOKENS.minLength"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="Name" id="Name"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#Name"/> </xs:annotation> <xs:restriction base="xs:token"> <xs:pattern value="\i\c*" id="Name.pattern"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/REC-xml#NT-Name"> pattern matches production 5 from the XML spec </xs:documentation> </xs:annotation> </xs:pattern> </xs:restriction> </xs:simpleType> <xs:simpleType name="NCName" id="NCName"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#NCName"/> </xs:annotation> <xs:restriction base="xs:Name"> <xs:pattern value="[\i-[:]][\c-[:]]*" id="NCName.pattern"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/REC-xml-names/#NT-NCName"> pattern matches production 4 from the Namespaces in XML spec </xs:documentation> </xs:annotation> </xs:pattern> </xs:restriction> </xs:simpleType> <xs:simpleType name="ID" id="ID"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#ID"/> </xs:annotation> <xs:restriction base="xs:NCName"/> </xs:simpleType> <xs:simpleType name="IDREF" id="IDREF"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#IDREF"/> </xs:annotation> <xs:restriction base="xs:NCName"/> </xs:simpleType> <xs:simpleType name="ENTITY" id="ENTITY"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#ENTITY"/> </xs:annotation> <xs:restriction base="xs:NCName"/> </xs:simpleType> <xs:simpleType name="integer" id="integer"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#integer"/> </xs:annotation> <xs:restriction base="xs:decimal"> <xs:fractionDigits fixed="true" value="0" id="integer.fractionDigits"/> <xs:pattern value="[\-+]?[0-9]+"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="nonPositiveInteger" id="nonPositiveInteger"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#nonPositiveInteger"/> </xs:annotation> <xs:restriction base="xs:integer"> <xs:maxInclusive value="0" id="nonPositiveInteger.maxInclusive"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="negativeInteger" id="negativeInteger"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#negativeInteger"/> </xs:annotation> <xs:restriction base="xs:nonPositiveInteger"> <xs:maxInclusive value="-1" id="negativeInteger.maxInclusive"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="long" id="long"> <xs:annotation> <xs:appinfo> <hfp:hasProperty name="bounded" value="true"/> <hfp:hasProperty name="cardinality" value="finite"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#long"/> </xs:annotation> <xs:restriction base="xs:integer"> <xs:minInclusive value="-9223372036854775808" id="long.minInclusive"/> <xs:maxInclusive value="9223372036854775807" id="long.maxInclusive"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="int" id="int"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#int"/> </xs:annotation> <xs:restriction base="xs:long"> <xs:minInclusive value="-2147483648" id="int.minInclusive"/> <xs:maxInclusive value="2147483647" id="int.maxInclusive"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="short" id="short"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#short"/> </xs:annotation> <xs:restriction base="xs:int"> <xs:minInclusive value="-32768" id="short.minInclusive"/> <xs:maxInclusive value="32767" id="short.maxInclusive"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="byte" id="byte"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#byte"/> </xs:annotation> <xs:restriction base="xs:short"> <xs:minInclusive value="-128" id="byte.minInclusive"/> <xs:maxInclusive value="127" id="byte.maxInclusive"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="nonNegativeInteger" id="nonNegativeInteger"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#nonNegativeInteger"/> </xs:annotation> <xs:restriction base="xs:integer"> <xs:minInclusive value="0" id="nonNegativeInteger.minInclusive"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="unsignedLong" id="unsignedLong"> <xs:annotation> <xs:appinfo> <hfp:hasProperty name="bounded" value="true"/> <hfp:hasProperty name="cardinality" value="finite"/> </xs:appinfo> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#unsignedLong"/> </xs:annotation> <xs:restriction base="xs:nonNegativeInteger"> <xs:maxInclusive value="18446744073709551615" id="unsignedLong.maxInclusive"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="unsignedInt" id="unsignedInt"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#unsignedInt"/> </xs:annotation> <xs:restriction base="xs:unsignedLong"> <xs:maxInclusive value="4294967295" id="unsignedInt.maxInclusive"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="unsignedShort" id="unsignedShort"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#unsignedShort"/> </xs:annotation> <xs:restriction base="xs:unsignedInt"> <xs:maxInclusive value="65535" id="unsignedShort.maxInclusive"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="unsignedByte" id="unsignedByte"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#unsignedByte"/> </xs:annotation> <xs:restriction base="xs:unsignedShort"> <xs:maxInclusive value="255" id="unsignedByte.maxInclusive"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="positiveInteger" id="positiveInteger"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#positiveInteger"/> </xs:annotation> <xs:restriction base="xs:nonNegativeInteger"> <xs:minInclusive value="1" id="positiveInteger.minInclusive"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="derivationControl"> <xs:annotation> <xs:documentation> A utility type, not for public use</xs:documentation> </xs:annotation> <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> <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> <xs:simpleType name="simpleDerivationSet"> <xs:annotation> <xs:documentation> #all or (possibly empty) subset of {restriction, union, list} </xs:documentation> <xs:documentation> A utility type, not for public use</xs:documentation> </xs:annotation> <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="list"/> <xs:enumeration value="union"/> <xs:enumeration value="restriction"/> </xs:restriction> </xs:simpleType> </xs:list> </xs:simpleType> </xs:union> </xs:simpleType> <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:annotation> <xs:documentation> Can be restricted to required or forbidden </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> <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:annotation> <xs:documentation> Required at the top level </xs:documentation> </xs:annotation> </xs:attribute> <xs:anyAttribute namespace="##other" processContents="lax"/> </xs:restriction> </xs:complexContent> </xs:complexType> <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:annotation> <xs:documentation> Forbidden when nested </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="final" use="prohibited"/> <xs:anyAttribute namespace="##other" processContents="lax"/> </xs:restriction> </xs:complexContent> </xs:complexType> <xs:element name="simpleType" type="xs:topLevelSimpleType" id="simpleType"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-simpleType"/> </xs:annotation> </xs:element> <xs:group name="facets"> <xs:annotation> <xs: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. </xs:documentation> </xs:annotation> <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> <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> <xs:element name="restriction" id="restriction"> <xs:complexType> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-restriction"> base attribute and simpleType child are mutually exclusive, but one or other is required </xs:documentation> </xs:annotation> <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> <xs:element name="list" id="list"> <xs:complexType> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-list"> itemType attribute and simpleType child are mutually exclusive, but one or other is required </xs:documentation> </xs:annotation> <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> <xs:element name="union" id="union"> <xs:complexType> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-union"> memberTypes attribute must be non-empty or there must be at least one simpleType child </xs:documentation> </xs:annotation> <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> <xs:complexType name="facet"> <xs:complexContent> <xs:extension base="xs:annotated"> <xs:attribute name="value" use="required"/> <xs:attribute name="fixed" type="xs:boolean" default="false" use="optional"/> </xs:extension> </xs:complexContent> </xs:complexType> <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> <xs:element name="minExclusive" type="xs:facet" id="minExclusive"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-minExclusive"/> </xs:annotation> </xs:element> <xs:element name="minInclusive" type="xs:facet" id="minInclusive"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-minInclusive"/> </xs:annotation> </xs:element> <xs:element name="maxExclusive" type="xs:facet" id="maxExclusive"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-maxExclusive"/> </xs:annotation> </xs:element> <xs:element name="maxInclusive" type="xs:facet" id="maxInclusive"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-maxInclusive"/> </xs:annotation> </xs:element> <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> <xs:element name="totalDigits" id="totalDigits"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-totalDigits"/> </xs:annotation> <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> <xs:element name="fractionDigits" type="xs:numFacet" id="fractionDigits"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-fractionDigits"/> </xs:annotation> </xs:element> <xs:element name="length" type="xs:numFacet" id="length"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-length"/> </xs:annotation> </xs:element> <xs:element name="minLength" type="xs:numFacet" id="minLength"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-minLength"/> </xs:annotation> </xs:element> <xs:element name="maxLength" type="xs:numFacet" id="maxLength"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-maxLength"/> </xs:annotation> </xs:element> <xs:element name="enumeration" type="xs:noFixedFacet" id="enumeration"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-enumeration"/> </xs:annotation> </xs:element> <xs:element name="whiteSpace" id="whiteSpace"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-whiteSpace"/> </xs:annotation> <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> <xs:element name="pattern" id="pattern"> <xs:annotation> <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#element-pattern"/> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:restriction base="xs:noFixedFacet"> <xs:sequence> <xs:element ref="xs:annotation" minOccurs="0"/> </xs:sequence> <xs:attribute name="value" type="xs:string" use="required"/> <xs:anyAttribute namespace="##other" processContents="lax"/> </xs:restriction> </xs:complexContent> </xs:complexType> </xs:element> </xs:schema> <!-- DTD for XML Schemas: Part 2: Datatypes Id: datatypes.dtd,v 1.1 2003/08/28 13:30:52 ht Exp Note this DTD is NOT normative, or even definitive. -->

<!-- This DTD cannot be used on its own, it is intended only for incorporation in XMLSchema.dtd, q.v. -->

<!-- Define all the element names, with optional prefix --> <!ENTITY % simpleType "%p;simpleType"> <!ENTITY % restriction "%p;restriction"> <!ENTITY % list "%p;list"> <!ENTITY % union "%p;union"> <!ENTITY % maxExclusive "%p;maxExclusive"> <!ENTITY % minExclusive "%p;minExclusive"> <!ENTITY % maxInclusive "%p;maxInclusive"> <!ENTITY % minInclusive "%p;minInclusive"> <!ENTITY % totalDigits "%p;totalDigits"> <!ENTITY % fractionDigits "%p;fractionDigits"> <!ENTITY % length "%p;length"> <!ENTITY % minLength "%p;minLength"> <!ENTITY % maxLength "%p;maxLength"> <!ENTITY % enumeration "%p;enumeration"> <!ENTITY % whiteSpace "%p;whiteSpace"> <!ENTITY % pattern "%p;pattern">

<!-- Customisation entities for the ATTLIST of each element type. Define one of these if your schema takes advantage of the anyAttribute='##other' in the schema for schemas -->

<!ENTITY % simpleTypeAttrs ""> <!ENTITY % restrictionAttrs ""> <!ENTITY % listAttrs ""> <!ENTITY % unionAttrs ""> <!ENTITY % maxExclusiveAttrs ""> <!ENTITY % minExclusiveAttrs ""> <!ENTITY % maxInclusiveAttrs ""> <!ENTITY % minInclusiveAttrs ""> <!ENTITY % totalDigitsAttrs ""> <!ENTITY % fractionDigitsAttrs ""> <!ENTITY % lengthAttrs ""> <!ENTITY % minLengthAttrs ""> <!ENTITY % maxLengthAttrs ""> <!ENTITY % enumerationAttrs ""> <!ENTITY % whiteSpaceAttrs ""> <!ENTITY % patternAttrs "">

<!-- Define some entities for informative use as attribute types --> <!ENTITY % URIref "CDATA"> <!ENTITY % XPathExpr "CDATA"> <!ENTITY % QName "NMTOKEN"> <!ENTITY % QNames "NMTOKENS"> <!ENTITY % NCName "NMTOKEN"> <!ENTITY % nonNegativeInteger "NMTOKEN"> <!ENTITY % boolean "(true|false)"> <!ENTITY % simpleDerivationSet "CDATA"> <!-- #all or space-separated list drawn from derivationChoice -->

<!-- Note that the use of 'facet' below is less restrictive than is really intended: There should in fact be no more than one of each of minInclusive, minExclusive, maxInclusive, maxExclusive, totalDigits, fractionDigits, length, maxLength, minLength within datatype, and the min- and max- variants of Inclusive and Exclusive are mutually exclusive. On the other hand, pattern and enumeration may repeat. --> <!ENTITY % minBound "(%minInclusive; | %minExclusive;)"> <!ENTITY % maxBound "(%maxInclusive; | %maxExclusive;)"> <!ENTITY % bounds "%minBound; | %maxBound;"> <!ENTITY % numeric "%totalDigits; | %fractionDigits;"> <!ENTITY % ordered "%bounds; | %numeric;"> <!ENTITY % unordered "%pattern; | %enumeration; | %whiteSpace; | %length; | %maxLength; | %minLength;"> <!ENTITY % facet "%ordered; | %unordered;"> <!ENTITY % facetAttr "value CDATA #REQUIRED id ID #IMPLIED"> <!ENTITY % fixedAttr "fixed %boolean; #IMPLIED"> <!ENTITY % facetModel "(%annotation;)?"> <!ELEMENT %simpleType; ((%annotation;)?, (%restriction; | %list; | %union;))> <!ATTLIST %simpleType; name %NCName; #IMPLIED final %simpleDerivationSet; #IMPLIED id ID #IMPLIED %simpleTypeAttrs;> <!-- name is required at top level --> <!ELEMENT %restriction; ((%annotation;)?, (%restriction1; | ((%simpleType;)?,(%facet;)*)), (%attrDecls;))> <!ATTLIST %restriction; base %QName; #IMPLIED id ID #IMPLIED %restrictionAttrs;> <!-- base and simpleType child are mutually exclusive, one is required.

restriction is shared between simpleType and simpleContent and complexContent (in XMLSchema.xsd). restriction1 is for the latter cases, when this is restricting a complex type, as is attrDecls. --> <!ELEMENT %list; ((%annotation;)?,(%simpleType;)?)> <!ATTLIST %list; itemType %QName; #IMPLIED id ID #IMPLIED %listAttrs;> <!-- itemType and simpleType child are mutually exclusive, one is required --> <!ELEMENT %union; ((%annotation;)?,(%simpleType;)*)> <!ATTLIST %union; id ID #IMPLIED memberTypes %QNames; #IMPLIED %unionAttrs;> <!-- At least one item in memberTypes or one simpleType child is required -->

<!ELEMENT %maxExclusive; %facetModel;> <!ATTLIST %maxExclusive; %facetAttr; %fixedAttr; %maxExclusiveAttrs;> <!ELEMENT %minExclusive; %facetModel;> <!ATTLIST %minExclusive; %facetAttr; %fixedAttr; %minExclusiveAttrs;>

<!ELEMENT %maxInclusive; %facetModel;> <!ATTLIST %maxInclusive; %facetAttr; %fixedAttr; %maxInclusiveAttrs;> <!ELEMENT %minInclusive; %facetModel;> <!ATTLIST %minInclusive; %facetAttr; %fixedAttr; %minInclusiveAttrs;>

<!ELEMENT %totalDigits; %facetModel;> <!ATTLIST %totalDigits; %facetAttr; %fixedAttr; %totalDigitsAttrs;> <!ELEMENT %fractionDigits; %facetModel;> <!ATTLIST %fractionDigits; %facetAttr; %fixedAttr; %fractionDigitsAttrs;>

<!ELEMENT %length; %facetModel;> <!ATTLIST %length; %facetAttr; %fixedAttr; %lengthAttrs;> <!ELEMENT %minLength; %facetModel;> <!ATTLIST %minLength; %facetAttr; %fixedAttr; %minLengthAttrs;> <!ELEMENT %maxLength; %facetModel;> <!ATTLIST %maxLength; %facetAttr; %fixedAttr; %maxLengthAttrs;>

<!-- This one can be repeated --> <!ELEMENT %enumeration; %facetModel;> <!ATTLIST %enumeration; %facetAttr; %enumerationAttrs;>

<!ELEMENT %whiteSpace; %facetModel;> <!ATTLIST %whiteSpace; %facetAttr; %fixedAttr; %whiteSpaceAttrs;>

<!-- This one can be repeated --> <!ELEMENT %pattern; %facetModel;> <!ATTLIST %pattern; %facetAttr; %patternAttrs;> The following table shows the values of the fundamental facets for each · · Datatype ordered bounded cardinality numeric primitive string false false countably infinite false boolean false false finite false float partial true finite true double partial true finite true decimal total false countably infinite true duration partial false countably infinite false dateTime partial false countably infinite false time partial false countably infinite false date partial false countably infinite false gYearMonth partial false countably infinite false gYear partial false countably infinite false gMonthDay partial false countably infinite false gDay partial false countably infinite false gMonth partial false countably infinite false hexBinary false false countably infinite false base64Binary false false countably infinite false anyURI false false countably infinite false QName false false countably infinite false NOTATION false false countably infinite false derived normalizedString false false countably infinite false token false false countably infinite false language false false countably infinite false IDREFS false false countably infinite false ENTITIES false false countably infinite false NMTOKEN false false countably infinite false NMTOKENS false false countably infinite false Name false false countably infinite false NCName false false countably infinite false ID false false countably infinite false IDREF false false countably infinite false ENTITY false false countably infinite false integer total false countably infinite true nonPositiveInteger total false countably infinite true negativeInteger total false countably infinite true long total true finite true int total true finite true short total true finite true byte total true finite true nonNegativeInteger total false countably infinite true unsignedLong total true finite true unsignedInt total true finite true unsignedShort total true finite true unsignedByte total true finite true positiveInteger total false countably infinite true The · · duration dateTime time date gYearMonth gMonthDay gDay gMonth gYear [ISO 8601] [ISO 8601] [ISO 8601] [ISO 8601] [ISO 8601] dateTime time date gYearMonth gMonthDay gDay gMonth gYear C -- represents a digit used in the thousands and hundreds components, the "century" component, of the time element "year". Legal values are from 0 to 9. Y -- represents a digit used in the tens and units components of the time element "year". Legal values are from 0 to 9. M -- represents a digit used in the time element "month". The two digits in a MM format can have values from 1 to 12. D -- represents a digit used in the time element "day". The two digits in a DD format can have values from 1 to 28 if the month value equals 2, 1 to 29 if the month value equals 2 and the year is a leap year, 1 to 30 if the month value equals 4, 6, 9 or 11, and 1 to 31 if the month value equals 1, 3, 5, 7, 8, 10 or 12. h -- represents a digit used in the time element "hour". The two digits in a hh format can have values from 0 to 24.

If the value of the hour element is 24 then the values of the minutes element and the seconds element must be 00 and 00. m -- represents a digit used in the time element "minute". The two digits in a mm format can have values from 0 to 59. s -- represents a digit used in the time element "second". The two digits in a ss format can have values from 0 to 60. In the formats described in this specification the whole number of seconds · · in UTC For all the information items indicated by the above characters, leading zeros are required where indicated. In addition to the above, certain characters are used as designators and appear as themselves in lexical formats. T -- is used as time designator to indicate the start of the representation of the time of day in dateTime Z -- is used as time-zone designator, immediately (without a space) following a data element expressing the time of day in Coordinated Universal Time (UTC) in dateTime time date gYearMonth gMonthDay gDay gMonth gYear In the lexical format for duration P -- is used as the time duration designator, preceding a data element representing a given duration of time. Y -- follows the number of years in a time duration. M -- follows the number of months or minutes in a time duration. D -- follows the number of days in a time duration. H -- follows the number of hours in a time duration. S -- follows the number of seconds in a time duration. The values of the Year, Month, Day, Hour and Minutes components are not restricted but allow an arbitrary integer. Similarly, the value of the Seconds component allows an arbitrary decimal. Thus, the lexical format for duration [ISO 8601] [ISO 8601] time dateTime gMonthDay gDay date gMonth date [ISO 8601] dateTime date gMonth gYear D.3.1 Sign Allowed No Year Zero More Than 9999 Years Time zone permitted An optional minus sign is allowed immediately preceding, without a space, the lexical representations for duration dateTime date gYearMonth gYear The year "0000" is an illegal year value. To accommodate year values greater than 9999, more than four digits are allowed in the year representations of dateTime date gYearMonth gYear [ISO 8601:2000 Second Edition] The lexical representations for the datatypes date gYearMonth gMonthDay gDay gMonth gYear Given a dateTime duration dateTime dateTime duration date gYearMonth gYear gDay gMonth dateTime dateTime This is a logical explanation of the process. Actual implementations are free to optimize as long as they produce the same results. fQuotient(a, b) = the greatest integer less than or equal to a/b fQuotient(-1,3) = -1 fQuotient(0,3)...fQuotient(2,3) = 0 fQuotient(3,3) = 1 fQuotient(3.123,3) = 1 modulo(a, b) = a - fQuotient(a,b)*b modulo(-1,3) = 2 modulo(0,3)...modulo(2,3) = 0...2 modulo(3,3) = 0 modulo(3.123,3) = 0.123 fQuotient(a, low, high) = fQuotient(a - low, high - low) fQuotient(0, 1, 13) = -1 fQuotient(1, 1, 13) ... fQuotient(12, 1, 13) = 0 fQuotient(13, 1, 13) = 1 fQuotient(13.123, 1, 13) = 1 modulo(a, low, high) = modulo(a - low, high - low) + low modulo(0, 1, 13) = 12 modulo(1, 1, 13) ... modulo(12, 1, 13) = 1...12 modulo(13, 1, 13) = 1 modulo(13.123, 1, 13) = 1.123 maximumDayInMonthFor(yearValue, monthValue) = M := modulo(monthValue, 1, 13) Y := yearValue + fQuotient(monthValue, 1, 13) Return a value based on M and Y: 31 M = January, March, May, July, August, October, or December 30 M = April, June, September, or November 29 M = February AND (modulo(Y, 400) = 0 OR (modulo(Y, 100) != 0) AND modulo(Y, 4) = 0) 28 Otherwise Essentially, this calculation is equivalent to separating D into <year,month> and <day,hour,minute,second> fields. The <year,month> is added to S. If the day is out of range, it is pinned Leap seconds are handled by the computation by treating them as overflows. Essentially, a value of 60 seconds in S is treated as if it were a duration of 60 seconds added to S (with a zero seconds field). All calculations thereafter use 60 seconds per minute. Thus the addition of either PT1M or PT60S to any dateTime will always produce the same result. This is a special definition of addition which is designed to match common practice, and -- most importantly -- be stable over time. A definition that attempted to take leap-seconds into account would need to be constantly updated, and could not predict the results of future implementation's additions. The decision to introduce a leap second in UTC is the responsibility of the [International Earth Rotation Service (IERS)] [U.S. Naval Observatory Time Service Department] The following is the precise specification. These steps must be followed in the same order. If a field in D is not specified, it is treated as if it were zero. If a field in S is not specified, it is treated in the calculation as if it were the minimum allowed value in that field, however, after the calculation is concluded, the corresponding field in E is removed (set to unspecified). Months (may be modified additionally below) temp := S[month] + D[month] E[month] := modulo(temp, 1, 13) carry := fQuotient(temp, 1, 13) Years (may be modified additionally below) E[year] := S[year] + D[year] + carry Zone E[zone] := S[zone] Seconds temp := S[second] + D[second] E[second] := modulo(temp, 60) carry := fQuotient(temp, 60) Minutes temp := S[minute] + D[minute] + carry E[minute] := modulo(temp, 60) carry := fQuotient(temp, 60) Hours temp := S[hour] + D[hour] + carry E[hour] := modulo(temp, 24) carry := fQuotient(temp, 24) Days if S[day] > maximumDayInMonthFor(E[year], E[month]) tempDays := maximumDayInMonthFor(E[year], E[month]) else if S[day] < 1 tempDays := 1 else tempDays := S[day] E[day] := tempDays + D[day] + carry START LOOP IF E[day] := E[day] + maximumDayInMonthFor(E[year], E[month] - 1) carry := -1 ELSE IF E[day] := E[day] - maximumDayInMonthFor(E[year], E[month]) carry := 1 ELSE EXIT LOOP temp := E[month] + carry E[month] := modulo(temp, 1, 13) E[year] := E[year] + fQuotient(temp, 1, 13) GOTO START LOOP Examples: dateTime duration result 2000-01-12T12:13:14Z P1Y3M5DT7H10M3.3S 2001-04-17T19:23:17.3Z 2000-01 -P3M 1999-10 2000-01-12 PT33H 2000-01-13 Time durations are added by simply adding each of their fields, respectively, without overflow. The order of addition of durations to instants is ((dateTime + duration1) + duration2) != ((dateTime + duration2) + duration1) Example: (2000-03-30 + P1D) + P1M = 2000-03-31 + P1M = 2000- 04-30 (2000-03-30 + P1M) + P1D = 2000-04-30 + P1D = 2000- 05-01 A · · R set of strings L(R) · · regular expression R L(R) Note: · · · · string A Z <simpleType name='myString'> <restriction base='string'> <pattern value='A.*Z'/> </restriction> </simpleType> ^A.*Z$ .* · · A #x41 <simpleType name='myString'> <restriction base='string'> <pattern value='.*AAA.*'/> </restriction> </simpleType> [Definition:] regular expression · · | Regular Expression regExp ::= branch branch For all · · S · · T · · R Denoting the set of strings L(R) (empty string) the set containing just the empty string S all strings in L(S) S T all strings in L(S) L(T) [Definition:] branch · · Branch branch ::= piece For all · · S · · T · · R Denoting the set of strings L(R) S all strings in L(S) S T all strings st s L(S) t L(T) [Definition:] piece · · · · Piece piece ::= atom quantifier For all · · S n m n <= m · · R Denoting the set of strings L(R) S all strings in L(S) S the empty string, and all strings in L(S) S All strings in L(S?) st s L(S*) t L(S) ( all concatenations of zero or more strings from L(S) ) S All strings st s L(S) t L(S*) ( all concatenations of one or more strings from L(S) ) S All strings st s L(S) t L(S{n-1,m-1}) ( All sequences of at least n, and at most m, strings from L(S) ) S All strings in L(S{n,n}) ( All sequences of exactly n strings from L(S) ) S All strings in L(S{n}S*) ( All sequences of at least n, strings from L(S) ) S All strings st s L(S?) t L(S{0,m-1}) ( All sequences of at most m, strings from L(S) ) S The set containing only the empty string Note: [Perl] S{,m} S{0,m} [Definition:] quantifier ? * + {n,m} {n,} Quanitifer quantifier ::= [?*+] | ( '{' quantity quantity ::= quantRange quantMin QuantExact quantRange ::= QuantExact QuantExact quantMin ::= QuantExact QuantExact ::= [0-9]+ [Definition:] atom · · · · · · Atom atom ::= Char charClass regExp For all · · c · · C · · S · · R Denoting the set of strings L(R) c the single string consisting only of c C all strings in L(C) ( S all strings in L(S) [Definition:] metacharacter . \ ? * + { } ( ) [ ] · · · · · · · · [Definition:] normal character · · Normal Character Char ::= [^.\?*+()|#x5B#x5D] Note that a · · character reference [Definition:] character class · · R set of characters C(R) L(R) R c c C(R) Character Class charClass ::= charClassEsc charClassExpr WildcardEsc A character class is either a · · · · [Definition:] character class expression · · [ ] G G character class expression C G C G Character Class Expression charClassExpr ::= '[' charGroup [Definition:] character group · · · · · · Character Group charGroup ::= posCharGroup negCharGroup charClassSub [Definition:] positive character group · · · · positive character group Positive Character Group posCharGroup ::= ( charRange charClassEsc For all · · R · · E · · P · · G Identifying the set of characters C(G) R all characters in C(R) E all characters in C(E) RP all characters in C(R) C(P) EP all characters in C(E) C(P) [Definition:] negative character group · · ^ · · P P negative character group C(^P) not C(P) Negative Character Group negCharGroup ::= '^' posCharGroup [Definition:] character class subtraction · · · · · · - Character Class Subtraction charClassSub ::= ( posCharGroup negCharGroup charClassExpr For any · · · · G · · C G-C · · C(G) C(C) [Definition:] character range R C(R) Character Range charRange ::= seRange XmlCharIncDash seRange ::= charOrEsc charOrEsc charOrEsc ::= XmlChar SingleCharEsc XmlChar ::= [^\#x2D#x5B#x5D] XmlCharIncDash ::= [^\#x5B#x5D] A single XML character is a · · The [ ] - \ The ^ · · · · The - · · Note: · · A · · · · s-e s e s-e s · · s \ If s is the first character in a · · s ^ e · · e \ [ The code point of e s Note: · · [Definition:] character class escape · · · · · · · · Character Class Escape charClassEsc ::= ( SingleCharEsc MultiCharEsc catEsc complEsc [Definition:] single character escape · · Single Character Escape SingleCharEsc ::= '\' [nrt\|.?*+(){}#x2D#x5B#x5D#x5E] The valid · · Identifying the set of characters C(R) \n the newline character (#xA) \r the return character (#xD) \t the tab character (#x9) \\ \ \| | \. . \- - \^ ^ \? ? \* * \+ + \{ { \} } \( ( \) ) \[ [ \] ] [Definition:] [Unicode Database] X category escape \p{X} category escape \P{X} [\P{X}] [^\p{X}] Category Escape catEsc ::= '\p{' charProp complEsc ::= '\P{' charProp charProp ::= IsCategory IsBlock Note: [Unicode Database] · · · · [Unicode Database] The following table specifies the recognized values of the "General Category" property. Category Property Meaning Letters L All Letters Lu uppercase Ll lowercase Lt titlecase Lm modifier Lo other Marks M All Marks Mn nonspacing Mc spacing combining Me enclosing Numbers N All Numbers Nd decimal digit Nl letter No other Punctuation P All Punctuation Pc connector Pd dash Ps open Pe close Pi initial quote (may behave like Ps or Pe depending on usage) Pf final quote (may behave like Ps or Pe depending on usage) Po other Separators Z All Separators Zs space Zl line Zp paragraph Symbols S All Symbols Sm math Sc currency Sk modifier So other Other C All Others Cc control Cf format Co private use Cn not assigned Categories IsCategory ::= Letters Marks Numbers Punctuation Separators Symbols Others Letters ::= 'L' [ultmo]? Marks ::= 'M' [nce]? Numbers ::= 'N' [dlo]? Punctuation ::= 'P' [cdseifo]? Separators ::= 'Z' [slp]? Symbols ::= 'S' [mcko]? Others ::= 'C' [cfon]? Note: Cs Cs [Definition:] [Unicode Database] X block escape \p{IsX} block escape \P{IsX} [\P{IsX}] [^\p{IsX}] Block Escape IsBlock ::= 'Is' [a-zA-Z0-9#x2D]+ The following table specifies the recognized block names (for more information, see the "Blocks.txt" file in [Unicode Database] Start Code End Code Block Name Start Code End Code Block Name #x0000 #x007F BasicLatin #x0080 #x00FF Latin-1Supplement #x0100 #x017F LatinExtended-A #x0180 #x024F LatinExtended-B #x0250 #x02AF IPAExtensions #x02B0 #x02FF SpacingModifierLetters #x0300 #x036F CombiningDiacriticalMarks #x0370 #x03FF Greek #x0400 #x04FF Cyrillic #x0530 #x058F Armenian #x0590 #x05FF Hebrew #x0600 #x06FF Arabic #x0700 #x074F Syriac #x0780 #x07BF Thaana #x0900 #x097F Devanagari #x0980 #x09FF Bengali #x0A00 #x0A7F Gurmukhi #x0A80 #x0AFF Gujarati #x0B00 #x0B7F Oriya #x0B80 #x0BFF Tamil #x0C00 #x0C7F Telugu #x0C80 #x0CFF Kannada #x0D00 #x0D7F Malayalam #x0D80 #x0DFF Sinhala #x0E00 #x0E7F Thai #x0E80 #x0EFF Lao #x0F00 #x0FFF Tibetan #x1000 #x109F Myanmar #x10A0 #x10FF Georgian #x1100 #x11FF HangulJamo #x1200 #x137F Ethiopic #x13A0 #x13FF Cherokee #x1400 #x167F UnifiedCanadianAboriginalSyllabics #x1680 #x169F Ogham #x16A0 #x16FF Runic #x1780 #x17FF Khmer #x1800 #x18AF Mongolian #x1E00 #x1EFF LatinExtendedAdditional #x1F00 #x1FFF GreekExtended #x2000 #x206F GeneralPunctuation #x2070 #x209F SuperscriptsandSubscripts #x20A0 #x20CF CurrencySymbols #x20D0 #x20FF CombiningMarksforSymbols #x2100 #x214F LetterlikeSymbols #x2150 #x218F NumberForms #x2190 #x21FF Arrows #x2200 #x22FF MathematicalOperators #x2300 #x23FF MiscellaneousTechnical #x2400 #x243F ControlPictures #x2440 #x245F OpticalCharacterRecognition #x2460 #x24FF EnclosedAlphanumerics #x2500 #x257F BoxDrawing #x2580 #x259F BlockElements #x25A0 #x25FF GeometricShapes #x2600 #x26FF MiscellaneousSymbols #x2700 #x27BF Dingbats #x2800 #x28FF BraillePatterns #x2E80 #x2EFF CJKRadicalsSupplement #x2F00 #x2FDF KangxiRadicals #x2FF0 #x2FFF IdeographicDescriptionCharacters #x3000 #x303F CJKSymbolsandPunctuation #x3040 #x309F Hiragana #x30A0 #x30FF Katakana #x3100 #x312F Bopomofo #x3130 #x318F HangulCompatibilityJamo #x3190 #x319F Kanbun #x31A0 #x31BF BopomofoExtended #x3200 #x32FF EnclosedCJKLettersandMonths #x3300 #x33FF CJKCompatibility #x3400 #x4DB5 CJKUnifiedIdeographsExtensionA #x4E00 #x9FFF CJKUnifiedIdeographs #xA000 #xA48F YiSyllables #xA490 #xA4CF YiRadicals #xAC00 #xD7A3 HangulSyllables #xE000 #xF8FF PrivateUse #xF900 #xFAFF CJKCompatibilityIdeographs #xFB00 #xFB4F AlphabeticPresentationForms #xFB50 #xFDFF ArabicPresentationForms-A #xFE20 #xFE2F CombiningHalfMarks #xFE30 #xFE4F CJKCompatibilityForms #xFE50 #xFE6F SmallFormVariants #xFE70 #xFEFE ArabicPresentationForms-B #xFEFF #xFEFF Specials #xFF00 #xFFEF HalfwidthandFullwidthForms #xFFF0 #xFFFD Specials Note: HighSurrogates LowSurrogates HighPrivateUseSurrogates Note: [Unicode Database] · · · · [Unicode Database] For example, the · · \p{IsBasicLatin} [Definition:] multi-character escape Multi-Character Escape MultiCharEsc ::= '\' [sSiIcCdDwW] WildcardEsc ::= '.' Character sequence Equivalent · · . [^\n\r] \s [#x20\t\n\r] \S [^\s] \i the set of initial name characters, those · · Letter \I [^\i] \c the set of name characters, those · · NameChar \C [^\c] \d \p{Nd} \D [^\d] \w [#x0000-#x10FFFF]-[\p{P}\p{Z}\p{C}] ( all characters except the set of "punctuation", "separator" and "other" characters \W [^\w] Note: · · [Unicode Regular Expression Guidelines] The listing below is for the benefit of readers of a printed version of this document: it collects together all the definitions which appear in the document above. atomic Atomic base type Every datatype that is · · restriction base type base type · · · · bounded A datatype is bounded · · · · · · · · · · built-in Built-in · · · · canonical lexical representation A canonical lexical representation canonical lexical representation · · cardinality Every · · cardinality · · · · · · comparable otherwise they are comparable conformance to the XML Representation of Schemas Processors which accept schemas in the form of XML documents as described in XML Representation of Simple Type Definition Schema Components (§4.1.2) Datatype components (§4) conformance to the XML Representation of Schemas · · · · · · XML Representation of Simple Type Definition Schema Components (§4.1.2) Datatype components (§4) schema components constraining facet A constraining facet · · Constraint on Schemas Constraint on Schemas datatype In this specification, a datatype · · · · · · · · derived Derived error error exclusive lower bound A value l · · · · L exclusive lower bound · · V V L v V l v exclusive upper bound A value u · · · · U exclusive upper bound · · V V U v V u v facet A facet · · · · for compatibility for compatibility fundamental facet A fundamental facet · · inclusive lower bound A value l · · · · L inclusive lower bound · · V V L v V l v inclusive upper bound A value u · · · · U inclusive upper bound · · V V U v V u v incomparable When a <> b a b incomparable itemType The · · · · · · itemType · · lexical space A lexical space literals list List · · match match may may memberTypes The datatypes that participate in the definition of a · · memberTypes · · minimally conforming Minimally conforming · · · · · · must must non-numeric A datatype whose values are not · · non-numeric numeric A datatype is said to be numeric order-relation An order relation · · · · · · · · ordered A · · ordered · · · · partial order A partial order · · irreflexive asymmetric transitive primitive Primitive ab initio regular expression A regular expression · · | restriction A datatype is said to be · · restriction · · · · · · · · Schema Representation Constraint Schema Representation Constraint total order A total order · · a b a <> b union Union · · · · · · · · user-derived User-derived · · Validation Rule Validation Rule value space A value space value space · · William D Clinger. How to Read Floating Point Numbers Accurately. Proceedings of Conference on Programming Language Design and Implementation ftp://ftp.ccs.neu.edu/pub/people/will/howtoread.ps IEEE. IEEE Standard for Binary Floating-Point Arithmetic. http://standards.ieee.org/reading/ieee/std_public/description/busarch/754-1985_desc.html World Wide Web Consortium. Namespaces in XML http://www.w3.org/TR/1999/REC-xml-names-19990114/ H. Alvestrand, ed. RFC 1766: Tags for the Identification of Languages http://www.ietf.org/rfc/rfc1766.txt N. Freed and N. Borenstein. RFC 2045: Multipurpose Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies http://www.ietf.org/rfc/rfc2045.txt Tim Berners-Lee, et. al. RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax. http://www.ietf.org/rfc/rfc2396.txt RFC 2732: Format for Literal IPv6 Addresses in URL's http://www.ietf.org/rfc/rfc2732.txt H. Alvestrand, ed. RFC 3066: Tags for the Identification of Languages http://www.ietf.org/rfc/rfc3066.txt The Unicode Consortium. The Unicode Character Database http://www.unicode.org/Public/3.1-Update/UnicodeCharacterDatabase-3.1.0.html World Wide Web Consortium. Extensible Markup Language (XML) 1.0, Second Edition. http://www.w3.org/TR/2000/WD-xml-2e-20000814 World Wide Web Consortium. XML Base. Available at: http://www.w3.org/TR/2001/REC-xmlbase-20010627/ World Wide Web Consortium. XML Linking Language (XLink). Available at: http://www.w3.org/TR/2001/REC-xlink-20010627/. XML Schema Part 1: Structures. Available at: http://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html World Wide Web Consortium. XML Schema Requirements. Available at: http://www.w3.org/TR/1999/NOTE-xml-schema-req-19990215 Martin J. Dürst and François Yergeau, eds. Character Model for the World Wide Web. World Wide Web Consortium Working Draft. 2001. Available at: http://www.w3.org/TR/2001/WD-charmod-20010126/ David M. Gay. Correctly Rounded Binary-Decimal and Decimal-Binary Conversions. http://cm.bell-labs.com/cm/cs/doc/90/4-10.ps.gz World Wide Web Consortium. Hypertext Markup Language, version 4.01. Available at: http://www.w3.org/TR/1999/REC-html401-19991224/ M. Dürst and M. Suignard . Internationalized Resource Identifiers http://www.w3.org/International/iri-edit/draft-duerst-iri-04.txt International Earth Rotation Service (IERS). See http://maia.usno.navy.mil ISO (International Organization for Standardization). Language-independent Datatypes. http://www.iso.ch/cate/d19346.html ISO (International Organization for Standardization). Representations of dates and times, 1988-06-15. ISO (International Organization for Standardization). Representations of dates and times, draft revision, 1998. ISO (International Organization for Standardization). Representations of dates and times, second edition, 2000-12-15. The Perl Programming Language. See http://www.perl.com/pub/language/info/software.html World Wide Web Consortium. RDF Schema Specification. http://www.w3.org/TR/2000/CR-rdf-schema-20000327/ World Wide Web Consortium. Ruby Annotation. Available at: http://www.w3.org/TR/2001/WD-ruby-20010216/ ISO (International Organization for Standardization). ISO/IEC 9075-2:1999, Information technology --- Database languages --- SQL --- Part 2: Foundation (SQL/Foundation) http://www.iso.ch/cate/d26197.html Information about Leap Seconds http://tycho.usno.navy.mil/leapsec.990505.html Mark Davis. Unicode Regular Expression Guidelines http://www.unicode.org/unicode/reports/tr18/ World Wide Web Consortium. XML Schema Language: Part 0 Primer. Available at: http://www.w3.org/TR/2004/REC-xmlschema-0-20041028/primer.html World Wide Web Consortium. Extensible Stylesheet Language (XSL). http://www.w3.org/TR/2000/CR-xsl-20001121/ The following have contributed material to the first edition of this specification: Asir S. Vedamuthu, webMethods, Inc Co-editor Ashok Malhotra's work on this specification from March 1999 until February 2001 was supported by IBM. From February 2001 until May 2004 it was supported by Microsoft. The editors acknowledge the members of the XML Schema Working Group, the members of other W3C Working Groups, and industry experts in other forums who have contributed directly or indirectly to the process or content of creating this document. The Working Group is particularly grateful to Lotus Development Corp. and IBM for providing teleconferencing facilities. At the time the first edition of this specification was published, the members of the XML Schema Working Group

were: Jim Barnette, Defense Information Systems Agency (DISA) Paul V. Biron, Health Level Seven Don Box, DevelopMentor Allen Brown, Microsoft Lee Buck, TIBCO Extensibility Charles E. Campbell, Informix Wayne Carr, Intel Peter Chen, Bootstrap Alliance and LSU David Cleary, Progress Software Dan Connolly, W3C ( staff contact Ugo Corda, Xerox Roger L. Costello, MITRE Haavard Danielson, Progress Software Josef Dietl, Mozquito Technologies David Ezell, Hewlett-Packard Company Alexander Falk, Altova GmbH David Fallside, IBM Dan Fox, Defense Logistics Information Service (DLIS) Matthew Fuchs, Commerce One Andrew Goodchild, Distributed Systems Technology Centre (DSTC Pty Ltd) Paul Grosso, Arbortext, Inc Martin Gudgin, DevelopMentor Dave Hollander, Contivo, Inc ( co-chair Mary Holstege, Invited Expert Jane Hunter, Distributed Systems Technology Centre (DSTC Pty Ltd) Rick Jelliffe, Academia Sinica Simon Johnston, Rational Software Bob Lojek, Mozquito Technologies Ashok Malhotra, Microsoft Lisa Martin, IBM Noah Mendelsohn, Lotus Development Corporation Adrian Michel, Commerce One Alex Milowski, Invited Expert Don Mullen, TIBCO Extensibility Dave Peterson, Graphic Communications Association Jonathan Robie, Software AG Eric Sedlar, Oracle Corp. C. M. Sperberg-McQueen, W3C ( co-chair Bob Streich, Calico Commerce William K. Stumbo, Xerox Henry S. Thompson, University of Edinburgh Mark Tucker, Health Level Seven Asir S. Vedamuthu, webMethods, Inc Priscilla Walmsley, XMLSolutions Norm Walsh, Sun Microsystems Aki Yoshida, SAP AG Kongyi Zhou, Oracle Corp. The XML Schema Working Group has benefited in its work from the participation and contributions of a number of people not currently members of the Working Group, including in particular those named below. Affiliations given are those current at the time of their work with the WG. Paula Angerstein, Vignette Corporation David Beech, Oracle Corp. Gabe Beged-Dov, Rogue Wave Software Greg Bumgardner, Rogue Wave Software Dean Burson, Lotus Development Corporation Mike Cokus, MITRE Andrew Eisenberg, Progress Software Rob Ellman, Calico Commerce George Feinberg, Object Design Charles Frankston, Microsoft Ernesto Guerrieri, Inso Michael Hyman, Microsoft Renato Iannella, Distributed Systems Technology Centre (DSTC Pty Ltd) Dianne Kennedy, Graphic Communications Association Janet Koenig, Sun Microsystems Setrag Khoshafian, Technology Deployment International (TDI) Ara Kullukian, Technology Deployment International (TDI) Andrew Layman, Microsoft Dmitry Lenkov, Hewlett-Packard Company John McCarthy, Lawrence Berkeley National Laboratory Murata Makoto, Xerox Eve Maler, Sun Microsystems Murray Maloney, Muzmo Communication, acting for Commerce One Chris Olds, Wall Data Frank Olken, Lawrence Berkeley National Laboratory Shriram Revankar, Xerox Mark Reinhold, Sun Microsystems John C. Schneider, MITRE Lew Shannon, NCR William Shea, Merrill Lynch Ralph Swick, W3C Tony Stewart, Rivcom Matt Timmermans, Microstar Jim Trezzo, Oracle Corp. Steph Tryphonas, Microstar The lists given above pertain to the first edition. At the time work on this second edition was completed, the membership of the Working Group was: Leonid Arbouzov, Sun Microsystems Jim Barnette, Defense Information Systems Agency (DISA) Paul V. Biron, Health Level Seven Allen Brown, Microsoft Charles E. Campbell, Invited expert Peter Chen, Invited expert Tony Cincotta, NIST David Ezell, National Association of Convenience Stores Matthew Fuchs, Invited expert Sandy Gao, IBM Andrew Goodchild, Distributed Systems Technology Centre (DSTC Pty Ltd) Xan Gregg, Invited expert Mary Holstege, Mark Logic Mario Jeckle, DaimlerChrysler Marcel Jemio, Data Interchange Standards Association Kohsuke Kawaguchi, Sun Microsystems Ashok Malhotra, Invited expert Lisa Martin, IBM Jim Melton, Oracle Corp Noah Mendelsohn, IBM Dave Peterson, Invited expert Anli Shundi, TIBCO Extensibility C. M. Sperberg-McQueen, W3C ( co-chair Hoylen Sue, Distributed Systems Technology Centre (DSTC Pty Ltd) Henry S. Thompson, University of Edinburgh Asir S. Vedamuthu, webMethods, Inc Priscilla Walmsley, Invited expert Kongyi Zhou, Oracle Corp. We note with sadness the accidental death of Mario Jeckle shortly after the completion of work on this document. In addition to those named above, several people served on the Working Group during the development of this second edition: Oriol Carbo, University of Edinburgh Tyng-Ruey Chuang, Academia Sinica Joey Coyle, Health Level 7 Tim Ewald, DevelopMentor Nelson Hung, Corel Melanie Kudela, Uniform Code Council Matthew MacKenzie, XML Global Cliff Schmidt, Microsoft John Stanton, Defense Information Systems Agency John Tebbutt, NIST Ross Thompson, Contivo Scott Vorthmann, TIBCO Extensibility

Related documents

• latn gap#649807
• grek gap#649808
• mong gap#649809
• nkoo gap#649810
• osge osa gap#649811