W3C

Modularization of XHTML™ in XML Schema

W3C Working Draft 3 October 2003

This version:
http://www.w3.org/TR/2003/WD-xhtml-m12n-schema-20031003
Latest version:
http://www.w3.org/TR/xhtml-m12n-schema
Previous version:
http://www.w3.org/TR/2002/WD-xhtml-m12n-schema-20021209
Diff-marked version:
xhtml-m12n-schema-diff.html
Editors:
Daniel Austin , W. W. Grainger, Inc.
Subramanian Peruvemba, Oracle Corporation
Shane McCarron , Applied Testing and Technology, Inc.
Masayasu Ishikawa , W3C

This document is also available in these non-normative formats: Single XHTML file , PostScript version , PDF version , ZIP archive , and Gzip'd TAR archive .

Copyright © 2003 W3C ® ( MIT , ERCIM , Keio ), All Rights Reserved. W3C liability , trademark , document use and software licensing rules apply.

Abstract

This document describes a methodology for modularization of XHTML using XML Schema. The document also provides a XML Schema implementation of the abstract modules defined in Modularization of XHTML [ XHTMLMOD ].

Status of This Document

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 at http://www.w3.org/TR/.

This is the Last Call Working Draft of "Modularization of XHTML™ in XML Schema" for review by members of the W3C and other interested parties in the general public. It is a stand-alone document to ease its review. It is being re-submitted for last call because of substantial changes in the way the Schemas are implemented to ease their use in non-XHTML contexts. After going through Last Call again, this document will be integrated into a new edition of Modularization of XHTML [ XHTMLMOD ]. The Last Call review period ends 14 November 2003.

Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.

Patent disclosures relevant to this specification may be found on the Working Group's public patent disclosure page .

Please send review comments to www-html-editor@w3.org ( archive ). Public discussion on XHTML takes place on the mailing list www-html@w3.org ( archive ).

This document has been produced by the W3C HTML Working Group ( members only ) as part of the HTML Activity . The goals of the HTML Working Group are discussed in the HTML Working Group charter .

Quick Table of Contents

Full Table of Contents

1. Introduction

This section is informative .

1.1. Purpose of this document

The purpose of this document is to describe a modularization framework for languages within the XHTML Namespace using XML Schema [ XMLSCHEMA ].

The Modularization of XHTML [ XHTMLMOD ] specifies well-defined sets of abstract modules that can be combined and extended allowing the creation of a new XHTML-family document types that are portable among XHTML-family user agents. This document provides XML Schema implementation of the abstract modules defined in Modularization of XHTML [ XHTMLMOD ]. In addition to the schema modules themselves, the framework presented here describes a means of further extending and modifying XHTML.

To a large extent, the modularization framework presented here attempts to duplicate the modularization concepts used in XHTMLMOD. Here and throughout this document, the term "XHTMLMOD" is used to refer to [ XHTMLMOD ]).

2. Terms and Definitions

This section is normative .

This document is the XML Schema implemantaion of abstract modules defined in XHTML Modularization [ XHTMLMOD ] and terms used in the document are defined in Terms and Definitions section of XHTML Modularization [ XHTMLMOD ].

3. Conformance Definition

This section is normative .

This document is the XML Schema implemantaion of abstract modules defined in XHTML Modularization [ XHTMLMOD ] and defines conformance requirements as defined in Conformance Definition section of XHTML Modularization [ XHTMLMOD ]

A. Building Schema Modules

This chapter is normative .

This chapter contains instructions on how to define XML Schema modules that are compatible with the XHTML Modularization implementation via XML Schema [ XMLSCHEMA ]. This is in an appendix so that it can be a drop in replacement for the corresponding appendix in XHTML Modularization [ XHTMLMOD ].

XHTML Schema modules are implemented as fragments. When these fragments are assembled in a specific manner (described in Developing Schemas with defined and extended modules ), the resulting Schema is a representation of a complete document type. This representation can then be used for validation of instances of the document type.

The key to combining these fragments into a meaningful, cohesive Schema is the rules used to define the fragments. This section defines those rules. When these rules are followed, markup language authors can be confident that their modules will interface cleanly with other XHTML-compatible modules.

Modules conforming to these rules also need to satisfy the conformance requirements defined in XHTML Family Module Conformance of XHTML Modularization [ XHTMLMOD ] in order to be called XHTML Family Modules .

A.1. Named Content Models

This specification classifies named content model into categories and names them consistently using the following suffixes

.content
model group definitions use the suffix .content when they are used to represent the content model of an element type.
.class
model group definitions use the suffix .class when they are used to represent elements of the same class.
.mix
model group definitions use the suffix .mix when they are used to represent a collection of element types from different classes.
.extra
model group definitions use the suffix .extra when they are used to extend other groups above.
.type
named complex type definitions use the suffix .type when they are used to represent type of an element.
.attlist
attribute groups use the suffix .attlist when they are used to represent the attributes for a specific element.
.attrib
attribute groups use the suffix .attrib when they are used to represent a group of tokens representing one or more complete attribute specifications within an .attlist declaration.

For example, in HTML 4, the %block; parameter entity is defined to represent the heterogeneous collection of element types that are block-level elements. In this specification, the corollary named content model is Block.mix .

When defining named content model in the classes defined here, modules should scope the names of the model group definitions and attribute groups by using unique prefixes. For example, the content model for the element myelement in the module mymodule could be named myelement.content . Other schemes are possible. Regardless of the scheme used, module authors should strive to ensure that named content model they define are named uniquely so that they do not collide with other named content model and so that the interface methods for the module are obvious to its users.

A.2. Defining the Namespace of a Module

XHTML requires that the elements and attributes declared in a module be within a defined XML namespace [XMLNAMES] . The identification of this namespace is an arbitrary URI. XHTML requires that when a module is implemented using an XML Schema, the module declare its target namespace.

A.2.1. Global and Local Element Declarations

While XML Schema allows an the definition of global and local element declarations, to be compatible with DTD definitions of XHTML Modularization module implementations must not declare local elements.

A.2.2. Global and Local Attribute Declarations

While the approach defined here permits the definition of global as well as attributes declarations, schema authors should consider the consequences of such definitions on an document instance. Global attributes must always be explicitly prefixed in a instance document by declaring a namespace prefix xmlns:prefix , while local attributes depending on the schema implementation may be be explicitly prefixed.

A.3. Content model Redefinitions

Quite often modules change the content model of elements defined by other modules. For example, XHTML Events module add event attributes to element defined by forms module. It is also possible multiple modules may change the content model of a single element defined by a third module, for example both XHTML Events Module and XHTML Image Map module add attributes to elements in form module.

XML Schemas allows for changes to a declared content model using the redefine element. While XML Schema supports redefine element that redefines the named content model and type definition, XML Schema does not directly support redefintion of an element or attribute declaration.

To support element content model redefinitions,

B. Developing Schema with defined and extended modules

This chapter is informative .

The primary purpose of defining XHTML modules and a general modularization methodology is to ease the development of document types that are based upon XHTML. These document types may extend XHTML by integrating additional capabilities (e.g., [SMIL] ), or they may define a subset of XHTML for use in a specialized device. This section describes the techniques that document type designers must use in order to take advantage of the XML Schema implementation of this modularization architecture. It does this by applying the XHTML Modularization techniques in progressively more complex ways, culminating in the creation of a complete document type from disparate modules.

Note that in no case do these examples require the modification of the XHTML-provided module file entities themselves. The XHTML module file entities are completely parameterized, so that it is possible through separate module definitions and driver files to customize the definition and the content model of each element and each element's hierarchy.

Finally, remember that most users of XHTML are not expected to be XML Schema authors. XML Schema authors are generally people who are defining specialized markup that will improve the readability, simplify the rendering of a document, or ease machine-processing of documents, or they are client designers that need to define the specialized markup language for their specific client. Consider these cases:

B.1. Defining additional attributes

In some cases, an extension to XHTML can be as simple as additional attributes. Schema authors should an provide the attribute definitions for each attribute, for example: 

<xs:attributeGroup name="myattrs.attrib">
    <xs:attribute name="myattribute" type="xs:string"/>
</xs:attributeGroup>

would declare an attribute "myattr" and attribute group "myattrs.attrib" in the target namespace of the schema ("xs" is the prefix for XML Schema Namespace). Authors should note that the attribute is created as local attribute (as part attribute group) Alternatively, declaring an attribute by placing the attribute declaration as direct child of schema element creates an Global attribute (and would require the document instances to use a qualified attribute names such as xlink:show). For a discussion of qualified names and Namespace prefixes, see Defining the Namespace of a Module .

To add this attribute to the content model of an element, the attribute group (that makes the content model of the element) would need to be redefined to include the new attribute. for example: 

<xs:redefine schemaLocation="xhtml-hypertext-1.xsd">
    <xs:attributeGroup name="xhtml:a.attlist">
        <xs:attributeGroup ref="xhtml:a.attlist"/>
        <xs:attributeGroup ref="myml:myattrs.attrib"/>
    </xs:attributeGroup>
</xs:redefine>

where "xhtml" is the prefix for XHTML Namespace. The schema modularization requires such redefinitions be defined as part of the markup language definition and the strategies for those are addressed in the later sections. Naturally, adding an attribute to a schema does not mean that any new behavior is defined for arbitrary clients. However, a content developer could use an extra attribute to store information that is accessed by associated scripts via the Document Object Model (for example).

B.2. Defining additional elements

Defining additional elements is similar to attributes, but a typical XHTML module would define the element as a global element (as a direct child of schema element) Schema authors should first write the element declaration for each element: 

<!-- In the myml-module-1.xsd -->
<xs:group name="myelement.content">
    <xs:choice>
        <xs:element ref="myotherelement"/>
    </xs:choice>
</xs:group>
    
<xs:attributeGroup name="myelement.attlist">
    <xs:attribute name="myattribute" type="xs:string"/>
</xs:attributeGroup>
    
<xs:complexType name="myelement.type" mixed="true">
    <xs:choice>
        <xs:group ref="myelement.content" minOccurs="0" maxOccurs="1"/>
    </xs:choice>
    <xs:attributeGroup ref="myelement.attlist"/>
</xs:complexType>
  
<xs:element name="myelement" type="myelement.type"/>

The element "myelement" is declared in the target namespace of the schema document and "xs" is the prefix for XML Schema Namespace. After the elements are defined, they need to be integrated into the content model. Strategies for integrating new elements or sets of elements into the content model are addressed in the next section.

B.3. Defining the content model for a collection of modules

Since the content model of XHTML modules is fully parameterized using named content models, Schema authors may modify the content model for every element in every module. The details of the schema module interface are defined in Building Schema Modules . Basically there are two ways to approach this modification:

  1. Re-define the named content model, .content, for each element.
  2. Define one or more of the global named content model entities to include the element in those named model definitions (normally via the named content model, .extras ).

The strategy taken will depend upon the nature of the modules being combined and the nature of the elements being integrated. The remainder of this section describes techniques for integrating two different classes of modules.

B.3.1. Integrating a stand-alone module into XHTML

When a module (and remember, a module can be a collection of other modules) contains elements that only reference each other in their content model, it is said to be "internally complete". As such, the module can be used on its own; (for example, you could define a schema that was just that module, and use one of its elements as the root element). Integrating such a module into XHTML is a three step process:

  1. Decide what element(s) can be thought of as the root(s) of the new module.
  2. Decide where these elements need to attach in the XHTML content tree.
  3. Then, for each attachment point in the content tree, add the root element(s) to the content definition for the XHTML elements.

Consider attaching the elements defined above . In that example, the element myelement is the root. To attach this element under the img element, and only the img element, of XHTML, the following redefinition would work: 

<xs:redefine schemaLocation="xhtml-image-1.xsd">
    <xs:group name="img.content">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:element ref="myml:myelement"/>
        </xs:choice>
    </xs:group>  
</xs:redefine>

Such redefinition must not included in the module definitions, but instead provided as part of the markup model definition. A schema defined with this content model would allow a document like the following fragment: 

<img src="...">
  <myml:myelement >This is content of a locally defined element</myml:myelement>
</img>

It is important to note that normally the img element has a content model of EMPTY . By adding myelement to that content model, we are really just replacing EMPTY with myelement . In the case of other elements that already have content models defined, the addition of an element would require the restating of the existing content model in addition to myelement .

B.3.2. Mixing a new module throughout the modules in XHTML

Extending the example above, to attach this module everywhere that the %Flow.mix content model group is permitted, would require something like the following in the schema that defines the document model of the document type: 

<xs:redefine schemaLocation="xhtml11-model.xsd">
    <xs:group name="Misc.extra">
        <xs:choice>
            <xs:group ref="Misc.extra"/>
            <xs:element ref="xhtml:myelement"/>
        </xs:choice>
    </xs:group>
</xs:redefine>

Since the %Misc.extra content model class is used in the content model the named model Misc.class, and that named model is used throughout the XHTML modules, the new module would become available throughout an extended XHTML document type.

B.4. Creating a new Document Type

So far the examples in this section have described the methods of extending XHTML and XHTML's content model. Once this is done, the next step is to collect the modules that comprise the Document Type into a schema driver and schema file that provides the content model redefinitions of included modules, incorporating the new definitions so that they override and augment the basic XHTML definitions as appropriate.

B.4.1. Creating a simple Docoment Type

Using the trivial example above, it is possible to define a new schema that uses and extends the XHTML modules pretty easily. First, define the new elements and their content model in a module: 

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.example.com/xmlns/simpleml1"
           xmlns="http://www.example.com/xmlns/simpleml1">

  <xs:annotation>
    <xs:documentation>
      This is the XML Schema module for module SimpleML
      $Id: simpleml-module-1.xsd,v 1.3 2003/09/23 21:13:11 speruvem Exp $
    </xs:documentation>
    <xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
  </xs:annotation>
    
  <xs:attributeGroup name="Common.attrib">
    <xs:attribute name="id" type="xs:ID"/>
  </xs:attributeGroup> 

  <xs:group name="otherelement.content">
     <xs:sequence/>
  </xs:group>
  
  <xs:attributeGroup name="otherelement.attlist">
    <xs:attributeGroup ref="Common.attrib"/>    
  </xs:attributeGroup>
  
  <xs:complexType name="otherelement.type">
    <xs:group ref="otherelement.content"/>
    <xs:attributeGroup ref="otherelement.attlist"/> 
  </xs:complexType>
  
  <xs:element name="otherelement" type="otherelement.type"/>
  
  <xs:group name="element.content">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element ref="otherelement"/>
    </xs:choice>
  </xs:group>
  
  <xs:attributeGroup name="element.attlist">
    <xs:attributeGroup ref="Common.attrib"/>    
  </xs:attributeGroup>
  
  <xs:complexType name="element.type">
    <xs:group ref="element.content"/>
    <xs:attributeGroup ref="element.attlist"/> 
  </xs:complexType>
  
  <xs:element name="element" type="element.type"/>
    
  <!-- Note: Global attribute -->
  <xs:attribute name="myattr" type="xs:string"/>

</xs:schema>

Now, define the schema module that redefines the content model of modules included in XHTML Basic 1.0 

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.w3.org/1999/xhtml"
           xmlns="http://www.w3.org/1999/xhtml"
           xmlns:simpleml="http://www.example.com/xmlns/simpleml1">

  <xs:annotation>
    <xs:documentation>
      This is the XML Schema that redefines the
      individual XHTML modules (image module) and
      redefines a named content model of XHTML modularization
      $Id: simpleml-module-redefines-1.xsd,v 1.2 2003/09/23 21:13:11 speruvem Exp $
    </xs:documentation>
    <xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
  </xs:annotation>
    
  <xs:redefine schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-basic10-model-1.xsd">
    <xs:group name="Misc.class">
      <xs:choice>
        <xs:group ref="Misc.class"/>
        <xs:element ref="simpleml:element"/>
      </xs:choice>
    </xs:group>
  </xs:redefine>
 
  <xs:redefine schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-image-1.xsd">
    <xs:attributeGroup name="img.attlist">
       <xs:attributeGroup ref="img.attlist"/>
       <xs:attribute ref="simpleml:myattr"/>
    </xs:attributeGroup>  
  </xs:redefine> 
  
</xs:schema>

Now, define the schema driver for the new language: 

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.example.com/xmlns/simpleml1"
           xmlns:xhtml="http://www.w3.org/1999/xhtml"           
           xmlns="http://www.example.com/xmlns/simpleml1"
           blockDefault="#all">

  <xs:annotation>
    <xs:documentation>
      This is the XML Schema Driver for new 
      Document Type XHTML Basic 1.0 + SimpleML
      $Id: simpleml-1_0.xsd,v 1.4 2003/09/23 21:13:11 speruvem Exp $
    </xs:documentation>
    <xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
  </xs:annotation>
  
  <xs:include schemaLocation="simpleml-module-1.xsd"/>
  
  <xs:import namespace="http://www.w3.org/1999/xhtml" 
             schemaLocation="simpleml-module-redefines-1.xsd"/>
  
  <xs:import namespace="http://www.w3.org/1999/xhtml" 
             schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-basic10.xsd"/>
  
</xs:schema>

B.4.2. Creating a Language by extending XHTML

Next, there is the situation where a complete, additional, and complex module is added to XHTML (or to a subset of XHTML). In essence, this is the same as in the example above, the only difference being that the module being added is incorporated in the schema by reference rather than explicitly including the new definitions in the Schema.

One such complex module is the Schema for [MATHML] . In order to combine MathML and XHTML into a single Schema, an author would just decide where MathML content should be legal in the document, and add the MathML root element to the content model at that point. First, define a new document model that instantiates the MathML Schema and connects it to the content XHTML content model by redefining the XHTML content model. Providing a redefintion of the XHTML content model by implication includes the XHTML content model in the new document content model : 

<!-- File: math-model.xsd -->
<xs:import namespace="http://www.w3.org/1998/Math/MathML" 
            schemaLocation="http://www.w3.org/Math/XMLSchema/mathml2/mathml2.xsd"/>

<xs:redefine schemaLocation="xhtml11-model.xsd">
    <xs:group name="InlSpecial.class">
        <xs:choice>
            <xs:group ref="InlSpecial.class"/>
            <xs:element ref="math:math"/>
        </xs:choice>
    </xs:group>
</xs:redefine>

Next, define a Schema driver that includes our new dcoument content model and hands off processing to the XHTML 1.1 driver (for example): 

<!-- File: xhtml+mathml.xsd -->
<xs:include schemaLocation="mathml-model.xsd"/>

<xs:include schemaLocation="xhtml11.xsd"/>

B.4.3. Creating a Language by removing and replacing XHTML modules

Another way in which Schema authors may use XHTML modules is to define a Schema that is a subset of an XHTML family document type (because, for example, they are building devices or software that only supports a subset of XHTML). To do this simple create a Schema driver that does not include the relevant modules. Schema author should note that redefine in schema by default includes all the content modelof the referenced schema, authors should also not include any redefinitions of modules that they do not wish to include. The basic steps to follow are:

  1. Take an XHTML family Schema as the basis of the new document type (e.g. XHML 1.1).
  2. Select the modules to remove from that Schema.
  3. Physically, remove include elements that include the non relevant modules from the Schema driver file.
  4. Physically, remove redefine elements that redefine any non relevant modules from module redefinitions file.
  5. Introduce some new modules

B.4.4. Creating a the new Document Type

Finally, some Schema authors may wish to start from scratch, using the XHTML Modularization framework as a toolkit for building a new markup language. This language must be made up of the minimal, required modules from XHTML. It may also contain other XHTML-defined modules or any other module that the author wishes to employ. In this example, we will take the XHTML required modules, add some XHTML-defined modules, and also add in the module we defined above.

The first step is to define a module that defines the elements and attributes using the XHTML provided template .


<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.example.com/xmlns/myml"
           xmlns="http://www.example.com/xmlns/myml">

  <xs:annotation>
    <xs:documentation>
      This is XML Schema template for MLML module    
      $Id: myml-module-1.xsd,v 1.2 2003/09/23 21:13:11 speruvem Exp $
    </xs:documentation>
    <xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
  </xs:annotation>

  <xs:annotation>
    <xs:documentation>
      My Elements Module
        + myelement
        + myotherelement
    
       This module has no purpose other than to provide structure for some
       PCDATA content.        
    </xs:documentation>
  </xs:annotation>
  
  <xs:attributeGroup name="myotherelement.attlist"/>
  
  <xs:group name="myotherelement.content">
    <xs:sequence/>
  </xs:group>
  
  <xs:complexType name="myotherelement.type">
    <xs:group ref="myotherelement.content"/>
    <xs:attributeGroup ref="myotherelement.attlist"/>
  </xs:complexType>
     
  <xs:element name="myotherelement" type="myotherelement.type"/>
  
  <xs:group name="myelement.content">
    <xs:choice>
       <xs:element ref="myotherelement"/>
    </xs:choice>
  </xs:group>    
  
  <xs:attributeGroup name="myelement.attlist">
       <xs:attribute name="myattribute" type="xs:string"/>
  </xs:attributeGroup>
    
  <xs:complexType name="myelement.type" mixed="true">
     <xs:choice>
        <xs:group ref="myelement.content" minOccurs="0" maxOccurs="1"/>
     </xs:choice>
     <xs:attributeGroup ref="myelement.attlist"/>             
  </xs:complexType>    
  
  <xs:element name="myelement" type="myelement.type"/>
  
  <!-- Note: Global attribute -->
  <xs:attribute name="myattr" type="xs:string"/>  

</xs:schema>

Now, build a content model description that hooks the new elements and attributes into the other XHTML elements. The following example is patterned after the XHTML Basic content model, but is a complete, free-standing content model module: 


<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.w3.org/1999/xhtml"
           xmlns="http://www.w3.org/1999/xhtml"
           xmlns:myml="http://www.example.com/xmlns/myml">

  <xs:annotation>
    <xs:documentation>
      This is the XML Schema module of common content models for MyML
      $Id: myml-model-1.xsd,v 1.3 2003/09/23 21:17:44 speruvem Exp $
    </xs:documentation>
    <xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
  </xs:annotation>
  
  <xs:annotation>
    <xs:documentation>
      XHTML Document Model

      This module describes the groupings of elements/attributes that make up
      common content models for XHTML elements.

      XHTML has following basic content models:

          Inline.mix;          character-level elements
          Block.mix;           block-like elements, eg., paragraphs and lists
          Flow.mix;            any block or inline elements
          HeadOpts.mix;        Head Elements
          InlinePre.mix;     Special class for pre content model
          InlineNoAnchor.mix;  Content model for Anchor
      
      Any groups declared in this module may be used
      to create element content models, but the above are
      considered 'global' (insofar as that term applies here).
      
      XHTML has the following Attribute Groups
           Core.extra.attrib
           I18n.extra.attrib
           Common.extra
           
      The above attribute Groups are considered Global
         
    </xs:documentation>
  </xs:annotation>  

   <xs:attributeGroup name="I18n.extra.attrib">
      <xs:annotation>
        <xs:documentation>
          Extended I18n attribute
        </xs:documentation>
      </xs:annotation>  
   </xs:attributeGroup>
  
   <xs:attributeGroup name="Core.extra.attrib">
      <xs:annotation>
        <xs:documentation>
           Extended Core Attributes
        </xs:documentation>
      </xs:annotation>
   </xs:attributeGroup>
  
   <xs:attributeGroup name="Common.extra">
      <xs:annotation>
        <xs:documentation>
           Extended Common Attributes
        </xs:documentation>
      </xs:annotation>
   </xs:attributeGroup>
         
  <xs:group name="HeadOpts.mix">
    <xs:choice>
      <xs:element ref="meta"/>
      <xs:element ref="link"/>
      <xs:element ref="object"/>
    </xs:choice>
  </xs:group>

  <!--
    These elements are neither block nor inline, and can
    essentially be used anywhere in the document body.
  -->
  <xs:group name="Misc.class">
    <xs:choice>
      <xs:element ref="myml:myelement"/>
    </xs:choice>
  </xs:group>

  <!-- Inline Elements -->
  <xs:group name="InlStruct.class">
    <xs:choice>
      <xs:element ref="br"/>
      <xs:element ref="span"/>
    </xs:choice>
  </xs:group>

  <xs:group name="InlPhras.class">
    <xs:choice>
      <xs:element ref="em"/>
      <xs:element ref="strong"/>
      <xs:element ref="dfn"/>
      <xs:element ref="code"/>
      <xs:element ref="samp"/>
      <xs:element ref="kbd"/>
      <xs:element ref="var"/>
      <xs:element ref="cite"/>
      <xs:element ref="abbr"/>
      <xs:element ref="acronym"/>
      <xs:element ref="q"/>
    </xs:choice>
  </xs:group>

  <xs:group name="InlPres.class">
    <xs:choice/>
  </xs:group>

  <xs:group name="I18n.class">
    <xs:sequence/>
  </xs:group>

  <xs:group name="Anchor.class">
    <xs:sequence>
      <xs:element ref="a"/>
    </xs:sequence>
  </xs:group>

  <xs:group name="InlSpecial.class">
    <xs:choice>
      <xs:element ref="img"/>
      <xs:element ref="object"/>
    </xs:choice>
  </xs:group>

  <xs:group name="InlForm.class">
    <xs:choice>
      <xs:element ref="input"/>
      <xs:element ref="select"/>
      <xs:element ref="textarea"/>
      <xs:element ref="label"/>
    </xs:choice>
  </xs:group>

  <xs:group name="Inline.extra">
    <xs:choice/>
  </xs:group>

  <!--xs:group name="Ruby.class">
    <xs:sequence/>
  </xs:group-->

  <!--
   Inline.class includes all inline elements,
   used as a component in mixes
  -->
  <xs:group name="Inline.class">
    <xs:choice>
      <xs:group ref="InlStruct.class"/>
      <xs:group ref="InlPhras.class"/>
      <xs:group ref="Anchor.class"/>      
      <xs:group ref="InlSpecial.class"/>
      <xs:group ref="InlForm.class"/>
      <xs:group ref="Inline.extra"/>
    </xs:choice>
  </xs:group>
  
  <!-- 
    InlinePre.class  
    Used as a component in pre model
  -->
  <xs:group name="InlinePre.mix">
    <xs:choice>
      <xs:group ref="InlStruct.class"/>
      <xs:group ref="InlPhras.class"/>
      <xs:group ref="Anchor.class"/>
      <xs:group ref="Inline.extra"/>
    </xs:choice>
  </xs:group>  

  
  <!--
    InlNoAnchor.class includes all non-anchor inlines,
    used as a component in mixes
  -->
  <xs:group name="InlNoAnchor.class">
    <xs:choice>
      <xs:group ref="InlStruct.class"/>    
      <xs:group ref="InlPhras.class"/>
      <xs:group ref="InlSpecial.class"/>
      <xs:group ref="InlForm.class"/>
      <xs:group ref="Inline.extra"/>
    </xs:choice>
  </xs:group>

  <!--
   InlNoAnchor.mix includes all non-anchor inlines
  -->
  <xs:group name="InlNoAnchor.mix">
    <xs:choice>
      <xs:group ref="InlNoAnchor.class"/>
      <xs:group ref="Misc.class"/>
    </xs:choice>
  </xs:group>

  <!--
   Inline.mix includes all inline elements, including Misc.class
  -->
  <xs:group name="Inline.mix">
    <xs:choice>
      <xs:group ref="Inline.class"/>
      <xs:group ref="Misc.class"/>
    </xs:choice>
  </xs:group>

  <!--
   In the HTML 4 DTD, heading and list elements were included
   in the block group. The Heading.class and
   List.class groups must now be included explicitly
   on element declarations where desired.
  -->
  <xs:group name="Heading.class">
    <xs:choice>
      <xs:element ref="h1"/>
      <xs:element ref="h2"/>
      <xs:element ref="h3"/>
      <xs:element ref="h4"/>
      <xs:element ref="h5"/>
      <xs:element ref="h6"/>
    </xs:choice>
  </xs:group>

  <xs:group name="List.class">
    <xs:choice>
      <xs:element ref="ul"/>
      <xs:element ref="ol"/>
      <xs:element ref="dl"/>
    </xs:choice>
  </xs:group>
  
  <xs:group name="Table.class">
    <xs:choice>
      <xs:element ref="table"/>
    </xs:choice>
  </xs:group>
  
  <xs:group name="Form.class">
    <xs:choice>
      <xs:element ref="form"/>
    </xs:choice>
  </xs:group>
  
  <xs:group name="BlkStruct.class">
    <xs:choice>
      <xs:element ref="p"/>
      <xs:element ref="div"/>
    </xs:choice>
  </xs:group>

  <xs:group name="BlkPhras.class">
    <xs:choice>
      <xs:element ref="pre"/>
      <xs:element ref="blockquote"/>
      <xs:element ref="address"/>
    </xs:choice>
  </xs:group>
  
  <xs:group name="BlkPres.class">
     <xs:choice/>
  </xs:group>  

  <xs:group name="BlkSpecial.class">
    <xs:choice>
      <xs:group ref="Table.class"/>
      <xs:group ref="Form.class"/>
    </xs:choice>
  </xs:group>
  
  <xs:group name="Block.extra">
     <xs:choice/>
  </xs:group>  

  <!--
   Block.class includes all block elements,
    used as an component in mixes
  -->
  <xs:group name="Block.class">
    <xs:choice>
      <xs:group ref="BlkStruct.class"/>
      <xs:group ref="BlkPhras.class"/>
      <xs:group ref="BlkSpecial.class"/>
      <xs:group ref="Block.extra"/>      
    </xs:choice>
  </xs:group>
  
  <!--
   Block.mix includes all block elements plus %Misc.class;
  -->
  <xs:group name="Block.mix">
    <xs:choice>
      <xs:group ref="Heading.class"/>
      <xs:group ref="List.class"/>
      <xs:group ref="Block.class"/>
      <xs:group ref="Misc.class"/>
    </xs:choice>
  </xs:group>

  <!-- 
    All Content Elements 

   Flow.mix includes all text content, block and inline
   Note that the "any" element included here allows us
   to add data from any other namespace, a necessity
   for compound document creation.
   Note however that it is not possible to add
   to any head level element without further
   modification. To add RDF metadata to the head
   of a document, modify the structure module.
  -->
  <xs:group name="Flow.mix">
    <xs:choice>
      <xs:group ref="Heading.class"/>
      <xs:group ref="List.class"/>
      <xs:group ref="Block.class"/>
      <xs:group ref="Inline.class"/>
      <xs:group ref="Misc.class"/>
    </xs:choice>
  </xs:group>
  

  <xs:group name="FlowNoTable.mix">
    <xs:choice>
      <xs:group ref="Heading.class"/>
      <xs:group ref="List.class"/>
      <xs:group ref="BlkStruct.class"/>
      <xs:group ref="BlkPhras.class"/>      
      <xs:group ref="Form.class"/>            
      <xs:group ref="Inline.class"/>
      <xs:group ref="Misc.class"/>
    </xs:choice>
  </xs:group>  
      
  <!-- 
    BlkNoForm.mix includes all non-form block elements,
    plus Misc.class
  -->
  <xs:group name="BlkNoForm.mix">
    <xs:choice>
      <xs:group ref="Heading.class"/>
      <xs:group ref="List.class"/>
      <xs:group ref="BlkStruct.class"/>
      <xs:group ref="BlkPhras.class"/>
      <xs:group ref="BlkPres.class"/>
      <xs:group ref="Table.class"/>
      <xs:group ref="Misc.class"/>
    </xs:choice>
  </xs:group>  
    
</xs:schema>

Now, build a list of redefinitions that change the content model of various included modules. The following example is patterned after the redefinitions in XHTML Basic document type and modified as appropriate for our new markup language: 


<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.w3.org/1999/xhtml"
           xmlns="http://www.w3.org/1999/xhtml"
           xmlns:myml="http://www.example.com/xmlns/myml">

  <xs:annotation>
    <xs:documentation>
      This is the XML Schema changes to the content models
      of modules included in XHTML Basic 1.0 + MyML
      $Id: myml-module-redefines-1.xsd,v 1.2 2003/09/23 21:13:11 speruvem Exp $
    </xs:documentation>
    <xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
  </xs:annotation>
  
  <xs:annotation>
    <xs:documentation>
      Module Content Model Redefinitions 
      
      This schema describes the changes (Redefinitions) to
      content model of individual modules as they are instantiated as part of 
      XHTML Basic 1.0 + MyML document
    </xs:documentation>
  </xs:annotation>
  
  <!-- Changes to Structural Module -->
  <xs:redefine schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-struct-1.xsd">
     <xs:group name="head.content">
       <xs:annotation>
         <xs:documentation>
           Redefinition by Base module
         </xs:documentation>
       </xs:annotation>      
       <xs:sequence>
           <xs:group ref="HeadOpts.mix" minOccurs="0" maxOccurs="unbounded"/>
           <xs:choice>
             <xs:sequence>
                <xs:element ref="title"/>
                <xs:group ref="HeadOpts.mix" minOccurs="0" maxOccurs="unbounded"/>
                <xs:element ref="base" minOccurs="0"/>                
             </xs:sequence>
             <xs:sequence>
               <xs:element ref="base"/>
               <xs:group ref="HeadOpts.mix" minOccurs="0" maxOccurs="unbounded"/>               
               <xs:element ref="title"/>
             </xs:sequence>           
           </xs:choice>
           <xs:group ref="HeadOpts.mix" minOccurs="0" maxOccurs="unbounded"/>           
       </xs:sequence>
     </xs:group>
     
     <xs:attributeGroup name="version.attrib">
       <xs:annotation>
         <xs:documentation>
            Redefinition by the XHTML11 Markup (for value of version attr)
         </xs:documentation>
       </xs:annotation>         
       <xs:attribute name="version" type="FPI" fixed="-//W3C//DTD XHTML Basic 1.0 + MyML//EN"/>
     </xs:attributeGroup>
  </xs:redefine>  

  <xs:redefine schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-image-1.xsd">
    <xs:attributeGroup name="img.attlist">
      <xs:attributeGroup ref="img.attlist"/>
      <xs:attribute ref="myml:myattr"/>
    </xs:attributeGroup>  
  </xs:redefine>      
  
</xs:schema>

Finally, build a driver for a new SCHEMA. The following example is patterned after the XHTML Basic content model and modified as appropriate for our new markup language: 


<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
           xmlns:xs="http://www.w3.org/2001/XMLSchema"
           xmlns="http://www.w3.org/1999/xhtml"
           xmlns:myml="http://www.example.com/xmlns/myml"
           blockDefault="#all">

  <xs:annotation>
    <xs:documentation>
      This is the XML Schema driver for XHTML Basic 1.0.
      Please use this namespace for XHTML elements:    
         "http://www.w3.org/1999/xhtml"

      $Id: myml-1_0.xsd,v 1.3 2003/09/23 21:13:11 speruvem Exp $
    </xs:documentation>
  </xs:annotation>

  <xs:annotation>
    <xs:documentation>
      This is XHTML, a reformulation of HTML as a modular XML application
      The Extensible HyperText Markup Language (XHTML)
      Copyright &#169;1998-2003 World Wide Web Consortium
      (Massachusetts Institute of Technology, Institut National de
      Recherche en Informatique et en Automatique, Keio University).
      All Rights Reserved.
    
      Permission to use, copy, modify and distribute the XHTML Schema
      modules and their accompanying xs:documentation for any purpose
      and without fee is hereby granted in perpetuity, provided that the above
      copyright notice and this paragraph appear in all copies.  
      The copyright holders make no representation about the suitability of
      these XML Schema modules for any purpose.
    
      They are provided "as is" without expressed or implied warranty.
    </xs:documentation>
  </xs:annotation>

  <xs:annotation>
    <xs:documentation>
      This is the Schema Driver file for 
      XHTML Basic 1.0  + MyML Document Type
    
      This schema includes    
        + modules for XHTML Basic 1.0 Document Type.
        
        + module MyML (MyML Namespace)
        
        + schema that defines all the named model for 
          the XHTML Basic 1.0 + MyML Document Type
        
        + schema that redefines the content model of 
          individual elements defined in the Module 
          implementations.
    
      This Document Type includes the following Modules
      
        XHTML Core modules (Required for XHTML Family Conformance)
            +  text
            +  hypertext
            +  lists
            +  structure
            
        Other XHTML modules
          +  Link                   
          +  Meta
          +  Base          
          +  Image           
          +  Object 
          +  Param         
          +  Basic forms
          +  Basic tables        
         
        Other Modules
          + MyML Module
          
    </xs:documentation>
  </xs:annotation>

  <xs:include schemaLocation="myml-module-redefines-1.xsd">
    <xs:annotation>
      <xs:documentation>
         This schema redefines the content model 
         defined by the individual modules for 
         XHTML Basic 1.0Document Type
      </xs:documentation>
    </xs:annotation>
  </xs:include>    
 
  <xs:include schemaLocation="myml-model-1.xsd">
    <xs:annotation>
      <xs:documentation>
        Document Model module for the XHTML Basic 1.0 Document Type
        This schema file defines all named models used by XHTML 
        Modularization Framework for XHTML Basic 1.0 Document Type
      </xs:documentation>
    </xs:annotation>
  </xs:include>
  
  <xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-framework-1.xsd">
    <xs:annotation>
      <xs:documentation>
        Schema Framework Component Modules:
            +  notations
            +  datatypes
            +  common attributes
            +  character entities
      </xs:documentation>
      <xs:documentation 
         source="http://www.w3.org/TR/xhtml-modularization/abstract_modules.html#s_commonatts"/>
    </xs:annotation>
  </xs:include>  
     
  <xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-text-1.xsd">
    <xs:annotation>
      <xs:documentation>
        Text module
      
        The Text module includes declarations for all core 
        text container elements and their attributes.
      
            +  block phrasal
            +  block structural
            +  inline phrasal
            +  inline structural
      
        Elements defined here:
          * address, blockquote, pre, h1, h2, h3, h4, h5, h6
          * div, p
          * abbr, acronym, cite, code, dfn, em, kbd, q, samp, strong, var
          * br, span
      </xs:documentation>
      <xs:documentation 
        source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_textmodule"/>      
    </xs:annotation>
  </xs:include>

  <xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-hypertext-1.xsd">
    <xs:annotation>
      <xs:documentation>
         Hypertext module

         Elements defined here:
          * a
      </xs:documentation>
      <xs:documentation
        source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_hypertextmodule"/>
    </xs:annotation>
  </xs:include>

  <xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-list-1.xsd">
    <xs:annotation>
      <xs:documentation>
        Lists module

        Elements defined here:
          * dt, dd, dl, ol, ul, li
      </xs:documentation>
      <xs:documentation
        source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_listmodule"/>
    </xs:annotation>
  </xs:include>

  <xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-struct-1.xsd">
    <xs:annotation>
      <xs:documentation>
        Structural module

        Elements defined here:
          * title, head, body, html
      </xs:documentation>
      <xs:documentation
        source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_structuremodule"/>
    </xs:annotation>
  </xs:include>
    
  <xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-link-1.xsd">
    <xs:annotation>
      <xs:documentation>
        Link module
         
        Elements defined here:
          * link
      </xs:documentation>
    </xs:annotation>
  </xs:include>

  <xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-meta-1.xsd">
    <xs:annotation>
      <xs:documentation>
        Meta module
        
        Elements defined here:
        * meta
      </xs:documentation>
    </xs:annotation>
  </xs:include>

  <xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-base-1.xsd">
    <xs:annotation>
      <xs:documentation>
        Base module
        
        Elements defined here:
          * base
      </xs:documentation>
    </xs:annotation>
  </xs:include>

  <xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-image-1.xsd">
    <xs:annotation>
      <xs:documentation>
        Image module
        
        Elements defined here:
          * img
      </xs:documentation>
    </xs:annotation>
  </xs:include>

  <xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-object-1.xsd">
    <xs:annotation>
      <xs:documentation>
        Object module

        Elements defined here:
          * object
      </xs:documentation>
    </xs:annotation>
  </xs:include>

  <xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-param-1.xsd">
    <xs:annotation>
      <xs:documentation>
        Param module
        
        Elements defined here:
          * param
      </xs:documentation>
    </xs:annotation>
  </xs:include> 
  
  <xs:include  schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-basic-form-1.xsd">
    <xs:annotation>
      <xs:documentation>
        Basic Forms module
        
        Note that this module is not used in XHTML 1.1. It is designed
        for use with XHTML Basic
        
        Elements defined here:
          * form, label, input, select, option, textarea
      </xs:documentation>
    </xs:annotation>
  </xs:include>

  <xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-basic-table-1.xsd">
    <xs:annotation>
      <xs:documentation>
        Basic Tables module
        
        Note that this module is not used in XHTML It is designed
        for use with XHTML Basic
        
        Elements defined here:
          * table, caption, tr, th, td
      </xs:documentation>
    </xs:annotation>
  </xs:include>
  
  <xs:import namespace="http://www.example.com/xmlns/myml"
             schemaLocation="myml-module-1.xsd">
    <xs:annotation>
      <xs:documentation>
        MyML Module
                
        Elements defined here:
          * myelement, myotherelement
      </xs:documentation>
    </xs:annotation>
  </xs:import>  

</xs:schema>

Once a new SCHEMA has been developed, it can be used in any document. Using the Schema is as simple as just referencing it in the schemaLocation attribute of a document root element: 

<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:myml="http://www.example.com/xmlns/myml"
      xmlns:schemaLocation="http://www.w3.org/1999/xhtml myml-1_0.xsd">
<head>
<title>An example using defaults</title>
</head>
<body>
<p>This is content in the XHTML namespace</p>
<myml:myelement>
  This is content in the myml namespace.
  <myml:myotherelement />
</myml:myelement>
<p><img src="missing" alt="Missing image" myml:myattr="value" /></p>
</body>
</html>

C. XHTML Schema Module Implementations

This appendix is normative .

This appendix will contain implementations of the modules defined in XHTML Abstract Modules via XML Schemas. These module implementations can be used by XHTML Family Document Types.

C.1. Character Entities

XML Schema uses DTDs to support character entities. The DTD implementation of XHTML Modularization [XHTMLMOD] defines the required character entities for XHTML. The schema implementation includes the set of character entities for XHTML, including the Latin 1, Symbol and Special character collections defined as part the DTD implementation of XHTML Modularization [XHTMLMOD].

Even though the named character entities are defined using DTDs and included in the Schema Modularization Framework, schema processors typically do not expand the named character entities in an XML document instance. The html DOCTYPE declaration must still be present if one wishes to use named entities defined by this Framework module

C.2. XHTML Schema Modular Framework

The Framework modules instantiates a set of support model that define the common Datatypes, Notations, Common attribute definitions and character entities. These are are defined in a set of support modules, instantiated by a main Framework module: 

<?xml version="1.0" encoding="UTF-8"?>   

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.w3.org/1999/xhtml"
           xmlns="http://www.w3.org/1999/xhtml">

  <xs:annotation>
    <xs:documentation>
      XHTML Modular Framework    
      This is the XML Schema Modular Framework module for XHTML
            
      This required module instantiates the necessary modules
      needed to support the XHTML modularization framework.
      
      The Schema modules instantiated are:  

        +  notations
        +  datatypes
        +  common attributes
        +  character entities
      
      $Id: xhtml-framework-1.xsd,v 1.8 2003/09/20 01:41:37 speruvem Exp $

    </xs:documentation>
    <xs:documentation source="xhtml-copyright-1.xsd"/>

  </xs:annotation>
  <xs:import namespace="http://www.w3.org/XML/1998/namespace" 
             schemaLocation="http://www.w3.org/2001/xml.xsd">

    <xs:annotation>
      <xs:documentation>
        Common Attributes       
        This import brings in the attributes 
        xml:lang and xml:space in the XML namespace.

      </xs:documentation>
     </xs:annotation>
  </xs:import>  
    
  <xs:include schemaLocation="xhtml-notations-1.xsd">

    <xs:annotation>
      <xs:documentation>
         Notations module
         Declares XHTML notations for Attribute data types 

      </xs:documentation>
    </xs:annotation>
  </xs:include>
  <xs:include schemaLocation="xhtml-datatypes-1.xsd">

    <xs:annotation>
      <xs:documentation>
        This module defines XHTML Attribute DataTypes

      </xs:documentation>
      <xs:documentation 
          source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstraction.html#s_common_attrtypes"/>

    </xs:annotation>
  </xs:include>
  <xs:include schemaLocation="xhtml-attribs-1.xsd">

    <xs:annotation>
      <xs:documentation>
        This module defines Common attributes for XHTML

      </xs:documentation>
      <xs:documentation 
          source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_commonatts"/>      

    </xs:annotation>
  </xs:include>
  <xs:include schemaLocation="xhtml-charent-1.xsd">

    <xs:annotation>
      <xs:documentation>
        Character entities module
        Note: Entities are not supported in XML Schema
        The Schema Module uses DTDs to define Entities
        
        This module defines
          + XHTML Latin 1 Character Entities
          + XHTML Special Characters
          + XHTML Mathematical, Greek, and Symbolic Characters

    </xs:documentation>
    </xs:annotation>
  </xs:include>
</xs:schema>

The Modular Schema framework also relies upon the following component modules:

C.2.1. XHTML Notations 

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.w3.org/1999/xhtml"
           xmlns="http://www.w3.org/1999/xhtml">

  <xs:annotation>
    <xs:documentation>
      Notations module

      This is the XML Schema module for data type notations for XHTML
      Defines the following notations, many of these imported from 
      other specifications and standards. When an existing FPI is
      known, it is incorporated here.
            
      $Id: xhtml-notations-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
    </xs:documentation>
    <xs:documentation source="xhtml-copyright-1.xsd"/>

  </xs:annotation>
  <!-- W3C XML 1.0 Recommendation -->
  <xs:notation name="w3c-xml"
    public="ISO 8879//NOTATION Extensible Markup Language (XML) 1.0//EN"/>
  <!-- XML 1.0 CDATA -->
  <xs:notation name="cdata" public="-//W3C//NOTATION XML 1.0: CDATA//EN"/>
  

  <!-- SGML Formal Public Identifiers -->
  <xs:notation name="fpi"
    public="ISO 8879:1986//NOTATION Formal Public Identifier//EN"/>
  <!-- XHTML Notations ... -->
  <!-- Length defined for cellpadding/cellspacing -->
  <!-- nn for pixels or nn% for percentage length -->
  <!-- a single character, as per section 2.2 of [XML] -->

  <xs:notation name="character"
    public="-//W3C//NOTATION XHTML Datatype: Character//EN"/>
  <!-- a character encoding, as per [RFC2045] -->
  <xs:notation name="charset"
    public="-//W3C//NOTATION XHTML Datatype: Charset//EN"/>
  <!-- a space separated list of character encodings, as per [RFC2045] -->
  <xs:notation name="charsets"
    public="-//W3C//NOTATION XHTML Datatype: Charsets//EN"/>
  <!-- media type, as per [RFC2045] -->
  <xs:notation name="contentType"
    public="-//W3C//NOTATION XHTML Datatype: ContentType//EN"/>
  <!-- comma-separated list of media types, as per [RFC2045] -->
  <xs:notation name="contentTypes"
    public="-//W3C//NOTATION XHTML Datatype: ContentTypes//EN"/>
  <!-- date and time information. ISO date format -->
  <xs:notation name="datetime"
    public="-//W3C//NOTATION XHTML Datatype: Datetime//EN"/>
  <!-- a language code, as per [RFC3066] -->
  <xs:notation name="languageCode"
    public="-//W3C//NOTATION XHTML Datatype: LanguageCode//EN"/>
  <!-- nn for pixels or nn% for percentage length -->
  <xs:notation name="length"
    public="-//W3C//NOTATION XHTML Datatype: Length//EN"/>
  <!-- space-separated list of link types -->
  <xs:notation name="linkTypes"
    public="-//W3C//NOTATION XHTML Datatype: LinkTypes//EN"/>
  <!-- single or comma-separated list of media descriptors -->
  <xs:notation name="mediaDesc"
    public="-//W3C//NOTATION XHTML Datatype: MediaDesc//EN"/>
  <!-- pixel, percentage, or relative -->
  <xs:notation name="multiLength"
    public="-//W3C//NOTATION XHTML Datatype: MultiLength//EN"/>
  <!-- one or more digits (NUMBER) -->
  <xs:notation name="number"
    public="-//W3C//NOTATION XHTML Datatype: Number//EN"/>
  <!-- one or more digits (NUMBER) -->
  <xs:notation name="pixels"
    public="-//W3C//NOTATION XHTML Datatype: Pixels//EN"/>
  <!-- script expression -->
  <xs:notation name="script"
    public="-//W3C//NOTATION XHTML Datatype: Script//EN"/>
  <!-- textual content -->
  <xs:notation name="text" public="-//W3C//NOTATION XHTML Datatype: Text//EN"/>
  <!-- a Uniform Resource Identifier, see [URI] -->
  <xs:notation name="uri" public="-//W3C//NOTATION XHTML Datatype: URI//EN"/>
  <!-- a space-separated list of Uniform Resource Identifiers, see [URI] -->
  <xs:notation name="uris" public="-//W3C//NOTATION XHTML Datatype: URIs//EN"/>
</xs:schema>

C.2.2. XHTML Datatypes 

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
            targetNamespace="http://www.w3.org/1999/xhtml"
            xmlns="http://www.w3.org/1999/xhtml">

    <xs:annotation>
        <xs:documentation>
          XHTML Datatypes
          This is the XML Schema datatypes module for XHTML
          
          Defines containers for the XHTML datatypes, many of
          these imported from other specifications and standards.
          
          $Id: xhtml-datatypes-1.xsd,v 1.3 2003/09/20 01:41:37 speruvem Exp $
        </xs:documentation>
        <xs:documentation source="xhtml-copyright-1.xsd"/>
        <xs:documentation 
            source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstraction.html#s_common_attrtypes"/>        
    </xs:annotation>
    
    <!-- nn for pixels or nn% for percentage length -->
    <xs:simpleType name="Length">
        <xs:union memberTypes="xs:nonNegativeInteger">
           <xs:simpleType>
             <xs:restriction base="xs:token">
               <xs:pattern value="\d+[%]|\d*\.\d+[%]"/>
              </xs:restriction>
           </xs:simpleType>         
        </xs:union>
    </xs:simpleType>
    
    <!-- space-separated list of link types -->
    <xs:simpleType name="LinkTypes">
        <xs:list itemType="xs:NMTOKEN"/>
    </xs:simpleType>
    
    <!-- single or comma-separated list of media descriptors -->
    <xs:simpleType name="MediaDesc">
        <xs:restriction base="xs:string"/>
    </xs:simpleType>
    
    <!-- pixel, percentage, or relative -->
    <xs:simpleType name="MultiLength">
        <xs:union memberTypes="Length">
           <xs:simpleType>
             <xs:restriction base="xs:token">
               <xs:pattern value="\d*\*"/>
             </xs:restriction>
           </xs:simpleType>         
        </xs:union>
    </xs:simpleType>
    
    <!-- one or more digits (NUMBER) -->
    <xs:simpleType name="Number">
        <xs:restriction base="xs:nonNegativeInteger"/>
    </xs:simpleType>
    
    <!-- integer representing length in pixels -->
    <xs:simpleType name="Pixels">
        <xs:restriction base="xs:nonNegativeInteger"/>
    </xs:simpleType>
    
    <!-- script expression -->
    <xs:simpleType name="Script">
        <xs:restriction base="xs:string"/>
    </xs:simpleType>
    
    <!-- sixteen color names or RGB color expression-->
    <xs:simpleType name="Color">
        <xs:union memberTypes="xs:NMTOKEN">    
           <xs:simpleType>                      
              <xs:restriction base="xs:token">
                 <xs:pattern value="#[0-9a-fA-F]{6}"/>
              </xs:restriction>
           </xs:simpleType>         
        </xs:union>
    </xs:simpleType>
    
    <!-- textual content -->
    <xs:simpleType name="Text">
        <xs:restriction base="xs:string"/>
    </xs:simpleType>
    
    <!-- Imported Datatypes  -->
    <!-- a single character, as per section 2.2 of [XML] -->
    <xs:simpleType name="Character">
        <xs:restriction base="xs:string">
           <xs:length value="1" fixed="true"/>
        </xs:restriction>
    </xs:simpleType>
    
    <!-- a character encoding, as per [RFC2045] -->
    <xs:simpleType name="Charset">
        <xs:restriction base="xs:string"/>
    </xs:simpleType>
    
    <!-- a space separated list of character encodings, as per [RFC2045] -->
    <xs:simpleType name="Charsets">
        <xs:list itemType="Charset"/>
    </xs:simpleType>
    
    <!-- media type, as per [RFC2045] -->
    <xs:simpleType name="ContentType">
        <xs:list itemType="xs:string"/>
    </xs:simpleType>
    
    <!-- comma-separated list of media types, as per [RFC2045] -->
    <xs:simpleType name="ContentTypes">
        <xs:list itemType="xs:string"/>
    </xs:simpleType>
    
    <!-- date and time information. ISO date format -->
    <xs:simpleType name="Datetime">
        <xs:restriction base="xs:dateTime"/>
    </xs:simpleType>
    
    <!-- formal public identifier, as per [ISO8879] -->
    <xs:simpleType name="FPI">
        <xs:restriction base="xs:normalizedString"/>
    </xs:simpleType>
    
    <!-- a language code, as per [RFC3066] -->
    <xs:simpleType name="LanguageCode">
        <xs:restriction base="xs:language"/>
    </xs:simpleType>
    
    <!-- a Uniform Resource Identifier, see [URI] -->
    <xs:simpleType name="URI">
        <xs:restriction base="xs:anyURI"/>
    </xs:simpleType>
    
    <!-- a space-separated list of Uniform Resource Identifiers, see [URI] -->
    <xs:simpleType name="URIs">
        <xs:list itemType="xs:anyURI"/>
    </xs:simpleType>
    
    <!-- comma-separated list of MultiLength -->
    <xs:simpleType name="MultiLengths">
        <xs:restriction base="xs:string"/>
    </xs:simpleType>
    
    <!-- character Data -->
    <xs:simpleType name="CDATA">
        <xs:restriction base="xs:string"/>
    </xs:simpleType>
        

</xs:schema>

C.2.3. XHTML Common Attribute Definitions 

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.w3.org/1999/xhtml"
           xmlns:xml="http://www.w3.org/XML/1998/namespace"            
           xmlns="http://www.w3.org/1999/xhtml">

  <xs:annotation>
    <xs:documentation>
      This is the XML Schema common attributes module for XHTML
      $Id: xhtml-attribs-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $

    </xs:documentation>
    <xs:documentation source="xhtml-copyright-1.xsd"/>

  </xs:annotation>
  <xs:attributeGroup name="id">
    <xs:attribute name="id" type="xs:ID"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="class">
    <xs:attribute name="class" type="xs:NMTOKENS"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="title">
    <xs:attribute name="title" type="xs:string"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="Core.attrib">
    <xs:attributeGroup ref="id"/>
    <xs:attributeGroup ref="class"/>
    <xs:attributeGroup ref="title"/>
    <xs:attributeGroup ref="Core.extra.attrib"/>
  </xs:attributeGroup>
  

  <xs:attributeGroup name="I18n.attrib">
    <xs:attribute ref="xml:lang"/>
    <xs:attributeGroup ref="I18n.extra.attrib"/>

  </xs:attributeGroup>
  

  <xs:attributeGroup name="Common.attrib">
    <xs:attributeGroup ref="Core.attrib"/>
    <xs:attributeGroup ref="I18n.attrib"/>
    <xs:attributeGroup ref="Common.extra"/>
  </xs:attributeGroup>      

</xs:schema>

C.2.4. XHTML Character Entities 

<?xml version="1.0" encoding="UTF-8"?>
<!--
  This schema module includes three named character entity files.

-->
<!DOCTYPE xs:schema [
<!-- These are the entity sets for ISO Latin 1 characters for the XHTML -->
<!ENTITY % HTMLlat1 PUBLIC

   "-//W3C//ENTITIES Latin 1 for XHTML//EN"
   "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-lat1.ent">

%HTMLlat1;
<!-- These are the entity sets for special characters for the XHTML -->
<!ENTITY % HTMLsymbol PUBLIC

   "-//W3C//ENTITIES Symbols for XHTML//EN"
   "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-symbol.ent">

%HTMLsymbol;
<!-- These are the entity sets for symbol characters for the XHTML -->
<!ENTITY % HTMLspecial PUBLIC

   "-//W3C//ENTITIES Special for XHTML//EN"
   "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-special.ent">

%HTMLspecial;
]>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.w3.org/1999/xhtml"
           xmlns="http://www.w3.org/1999/xhtml">

  <xs:annotation>
    <xs:documentation>
      Character Entities for XHTML    

      This is the XML Schema Character Entities module for XHTML
      This module declares the set of character entities for XHTML,
      including the Latin 1, Symbol and Special character collections.
      XML Schema does not support Entities, hence Entities are enable
      through an Internal DTD Subset.
      
      $Id: xhtml-charent-1.xsd,v 1.3 2003/09/23 21:32:35 speruvem Exp $
    </xs:documentation>
    <xs:documentation source="xhtml-copyright-1.xsd"/>

  </xs:annotation>
</xs:schema>

C.3. XHTML Module Implementations

This section contains the formal definition of each of the XHTML Abstract Modules as a Schema module.

C.3.1. XHTML Core Modules

C.3.1.1. Structure 

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
           xmlns="http://www.w3.org/1999/xhtml" 
           xmlns:xs="http://www.w3.org/2001/XMLSchema" >

   <xs:annotation>
      <xs:documentation>
        This is the XML Schema Document Structure module for XHTML
        Document Structure

    
          * title, head, body, html

    
        The Structure Module defines the major structural elements and 
        their attributes.
        
        $Id: xhtml-struct-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $     
      </xs:documentation>
      <xs:documentation source="xhtml-copyright-1.xsd"/>    
      <xs:documentation
        source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_structuremodule"/>
    </xs:annotation>

    
    <xs:attributeGroup name="title.attlist">
      <xs:attributeGroup ref="I18n.attrib"/>
    </xs:attributeGroup>
    
    <xs:group name="title.content">
      <xs:sequence/>
    </xs:group>    
    
    <xs:complexType name="title.type" mixed="true">
      <xs:group ref="title.content"/>
      <xs:attributeGroup ref="title.attlist"/>
    </xs:complexType>
    
        
    <xs:element name="title" type="title.type"/>
    
    <xs:group name="head.content">
      <xs:sequence>
        <xs:group ref="HeadOpts.mix" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element ref="title"/>
        <xs:group ref="HeadOpts.mix" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:group>

    <xs:attributeGroup name="profile.attrib">
      <xs:attribute name="profile" type="URI"/>
    </xs:attributeGroup>
        
    <xs:attributeGroup name="head.attlist">
      <xs:attributeGroup ref="profile.attrib"/>
      <xs:attributeGroup ref="I18n.attrib"/>
    </xs:attributeGroup>
    
    <xs:complexType name="head.type">
      <xs:group ref="head.content"/>
      <xs:attributeGroup ref="head.attlist"/>
    </xs:complexType>
    
    <xs:element name="head" type="head.type"/>
    
    <xs:attributeGroup name="body.attlist">
      <xs:attributeGroup ref="Common.attrib"/>
    </xs:attributeGroup>

    <xs:group name="body.content">
      <xs:sequence>
        <xs:group ref="Block.mix" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:group>                
    
    <xs:complexType name="body.type">
      <xs:group ref="body.content"/>
      <xs:attributeGroup ref="body.attlist"/>
    </xs:complexType>  
    
    <xs:element name="body" type="body.type"/>
    
    <xs:attributeGroup name="version.attrib">
      <xs:attribute name="version" type="FPI"/>
    </xs:attributeGroup>

    <xs:attributeGroup name="html.attlist">
      <xs:attributeGroup ref="version.attrib"/>
      <xs:attributeGroup ref="I18n.attrib"/>
    </xs:attributeGroup>
    
    <xs:group name="html.content">
      <xs:sequence>
         <xs:element ref="head"/>
         <xs:element ref="body"/>
      </xs:sequence>
    </xs:group>
    
    <xs:complexType name="html.type">
       <xs:group ref="html.content"/>
       <xs:attributeGroup ref="html.attlist"/>
    </xs:complexType>
    
    <xs:element name="html" type="html.type"/>
    

</xs:schema>

C.3.1.2. Text 

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.w3.org/1999/xhtml"
           xmlns="http://www.w3.org/1999/xhtml">

  <xs:annotation>
    <xs:documentation>
      Textual Content
      This is the XML Schema Text module for XHTML
      The Text module includes declarations for all core

      text container elements and their attributes.
    
        +  block phrasal
        +  block structural
        +  inline phrasal
        +  inline structural
      
      $Id: xhtml-text-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $

    </xs:documentation>
    <xs:documentation source="xhtml-copyright-1.xsd"/>
    <xs:documentation 
        source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_textmodule"/>          

  </xs:annotation>
  <xs:include schemaLocation="xhtml-blkphras-1.xsd">

    <xs:annotation>
      <xs:documentation>
        Block Phrasal module
        Elements defined here:
          * address, blockquote, pre, h1, h2, h3, h4, h5, h6
    </xs:documentation>
    </xs:annotation>
  </xs:include>
  <xs:include schemaLocation="xhtml-blkstruct-1.xsd">

    <xs:annotation>
      <xs:documentation>
        Block Structural module 
        Elements defined here:
          * div, p
    </xs:documentation>
    </xs:annotation>
  </xs:include>
  <xs:include schemaLocation="xhtml-inlphras-1.xsd">

    <xs:annotation>
      <xs:documentation>
        Inline Phrasal module
        Elements defined here:
          * abbr, acronym, cite, code, dfn, em, kbd, q, samp, strong, var
    </xs:documentation>
    </xs:annotation>
  </xs:include>
  <xs:include schemaLocation="xhtml-inlstruct-1.xsd">

    <xs:annotation>
      <xs:documentation>
        Inline Structural module 
        Elements defined here:
          * br,span
    </xs:documentation>
    </xs:annotation>
  </xs:include>
</xs:schema>

C.3.1.3. Hypertext 

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.w3.org/1999/xhtml"
           xmlns="http://www.w3.org/1999/xhtml">

  <xs:annotation>
    <xs:documentation>
      Hypertext Module

      This is the XML Schema Hypertext module for XHTML
            
        * a
            
      This module declares the anchor ('a') element type, which
      defines the source of a hypertext link. The destination
      (or link 'target') is identified via its 'id' attribute 
      rather than the 'name' attribute as was used in HTML.
      $Id: xhtml-hypertext-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
    </xs:documentation>
    <xs:documentation source="xhtml-copyright-1.xsd"/>
    <xs:documentation
        source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_hypertextmodule"/>    

  </xs:annotation>
  <xs:attributeGroup name="a.attlist">
    <xs:attributeGroup ref="Common.attrib"/>
    <xs:attribute name="href" type="URI"/>
    <xs:attribute name="charset" type="Charset"/>
    <xs:attribute name="type" type="ContentType"/>
    <xs:attribute name="hreflang" type="LanguageCode"/>
    <xs:attribute name="rel" type="LinkTypes"/>
    <xs:attribute name="rev" type="LinkTypes"/>
    <xs:attribute name="accesskey" type="Character"/>
    <xs:attribute name="tabindex" type="Number"/>
  </xs:attributeGroup>
   
  <xs:group name="a.content">
     <xs:sequence>
        <xs:group ref="InlNoAnchor.mix" minOccurs="0" maxOccurs="unbounded"/>     
     </xs:sequence>
  </xs:group>  

  <xs:complexType name="a.type" mixed="true">
     <xs:group ref="a.content"/>
     <xs:attributeGroup ref="a.attlist"/>

  </xs:complexType>
 

  <xs:element name="a" type="a.type"/>
</xs:schema>

C.3.1.4. Lists 

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.w3.org/1999/xhtml"
           xmlns="http://www.w3.org/1999/xhtml">

  <xs:annotation>
    <xs:documentation>
      List Module

      This is the XML Schema Lists module for XHTML
      List Module Elements

    
        * dl, dt, dd, ol, ul, li
    
      This module declares the list-oriented element types
      and their attributes.
      $Id: xhtml-list-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $      
    </xs:documentation>
    <xs:documentation source="xhtml-copyright-1.xsd"/>
    <xs:documentation
      source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_listmodule"/>      

  </xs:annotation>
  <xs:attributeGroup name="dt.attlist">
    <xs:attributeGroup ref="Common.attrib"/>
  </xs:attributeGroup>
  
  <xs:group name="dt.content">
    <xs:sequence>
      <xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:group>

  <xs:complexType name="dt.type" mixed="true">
    <xs:group ref="dt.content"/>

    <xs:attributeGroup ref="dt.attlist"/>
  </xs:complexType>
  <xs:element name="dt" type="dt.type"/>
  <xs:attributeGroup name="dd.attlist">
    <xs:attributeGroup ref="Common.attrib"/>
  </xs:attributeGroup>
  
  <xs:group name="dd.content">
    <xs:sequence>
      <xs:group ref="Flow.mix" minOccurs="0" maxOccurs="unbounded"/>  
    </xs:sequence>
  </xs:group>

  <xs:complexType name="dd.type" mixed="true">
    <xs:group ref="dd.content"/>

    <xs:attributeGroup ref="dd.attlist"/>
  </xs:complexType>
  <xs:element name="dd" type="dd.type"/>
  <xs:attributeGroup name="dl.attlist">
    <xs:attributeGroup ref="Common.attrib"/>
  </xs:attributeGroup>
  <xs:group name="dl.content">
    <xs:sequence>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="dt"/>
        <xs:element ref="dd"/>
      </xs:choice>
    </xs:sequence>

  </xs:group>
  <xs:complexType name="dl.type">
    <xs:group ref="dl.content"/>

    <xs:attributeGroup ref="dl.attlist"/>
  </xs:complexType>
  <xs:element name="dl" type="dl.type"/>
  <xs:attributeGroup name="li.attlist">
    <xs:attributeGroup ref="Common.attrib"/>
  </xs:attributeGroup>
  
  <xs:group name="li.content">
    <xs:sequence>
      <xs:group ref="Flow.mix" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>      
  </xs:group>

  <xs:complexType name="li.type" mixed="true">
    <xs:group ref="li.content"/>  

    <xs:attributeGroup ref="li.attlist"/>
  </xs:complexType>
  <xs:element name="li" type="li.type"/>
  <xs:attributeGroup name="ol.attlist">
    <xs:attributeGroup ref="Common.attrib"/>
  </xs:attributeGroup>
  <xs:group name="ol.content">

    <xs:sequence>
      <xs:element ref="li" maxOccurs="unbounded"/>

    </xs:sequence>
  </xs:group>
  <xs:complexType name="ol.type">
    <xs:group ref="ol.content"/>  

    <xs:attributeGroup ref="ol.attlist"/>
  </xs:complexType>
  <xs:element name="ol" type="ol.type"/>
  <xs:attributeGroup name="ul.attlist">
    <xs:attributeGroup ref="Common.attrib"/>
  </xs:attributeGroup>
  
  <xs:group name="ul.content">

    <xs:sequence>
      <xs:element ref="li" maxOccurs="unbounded"/>

    </xs:sequence>
  </xs:group>
  <xs:complex