<?xml version="1.0"?>
<!DOCTYPE xsd:schema SYSTEM "http://www.w3.org/1999/XMLSchema.dtd"[
<!ENTITY % p "xsd:" >
<!ENTITY % s ":xsd" >
<!-- keep this schema XML 1.0 valid -->
<!ATTLIST xsd:schema
    xmlns:html CDATA #FIXED "http://www.w3.org/1999/xhtml"
>

<!--================ Character Entities for XHTML ==========================-->

<!ENTITY % xhtml-lat1 PUBLIC
   "-//W3C//ENTITIES Latin 1 for XHTML//EN"
   "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-lat1.ent">
%xhtml-lat1;

<!ENTITY % xhtml-symbol PUBLIC
   "-//W3C//ENTITIES Symbols for XHTML//EN"
   "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-symbol.ent">
%xhtml-symbol;

<!ENTITY % xhtml-special PUBLIC
   "-//W3C//ENTITIES Special for XHTML//EN"
   "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-special.ent">
%xhtml-special;
]>
<xsd:schema
  xmlns:xsd="http://www.w3.org/1999/XMLSchema"
  targetNamespace="http://www.w3.org/1999/xhtml"
  xmlns:html="http://www.w3.org/1999/xhtml"
  elementFormDefault="unqualified"
  attributeFormDefault="unqualified">

  <xsd:annotation>
    <xsd:documentation>
	XHTML 1.1, reformulated in XML Schema

	Author: Masayasu Ishikawa (mimasa@w3.org)
	$Id: xhtml11-f.xsd,v 1.6 2000/07/11 14:54:09 mimasa Exp $

	DISCLAIMER: This schema is at the moment merely an author's
	  personal experiment.  Author doesn't guarantee at all whether
	  this schema properly reformulate XHTML 1.1 in XML Schema.

	This is XHTML, a reformulation of HTML as a modular XML application.

	Original copyright of DTD:

	The Extensible HyperText Markup Language (XHTML)
	Copyright 1998-2000 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 DTD and its 
	accompanying 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 the DTD for any purpose.

	It is provided "as is" without expressed or implied warranty.

	   Author:     Murray M. Altheim (altheim@eng.sun.com)

	Please use this formal public identifier to identify it:

	    "-//W3C//DTD XHTML 1.1//EN"

	% XHTML.version  "-//W3C//DTD XHTML 1.1//EN"

	Use this URI to identify the default namespace:

	    "http://www.w3.org/1999/xhtml"
    </xsd:documentation>
  </xsd:annotation>

  <xsd:import namespace="http://www.w3.org/XML/1998/namespace"
              schemaLocation="http://www.w3.org/XML/1998/xml.xsd">
    <xsd:annotation>
      <xsd:documentation>
	Get access to the xml: attribute groups for xml:lang
      </xsd:documentation>
    </xsd:annotation>
  </xsd:import>

  <xsd:annotation>
    <xsd:documentation>
	Bidirectional Text features
	This feature-test entity is used to declare elements
	and attributes used for bidirectional text support.

	% XHTML.bidi  "INCLUDE"
    </xsd:documentation>
  </xsd:annotation>

  <xsd:annotation>
    <xsd:documentation>
	% xhtml-events.module "INCLUDE"
    </xsd:documentation>
  </xsd:annotation>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Datatypes Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	   PUBLIC "-//W3C//ENTITIES XHTML Datatypes 1.0//EN"
	   SYSTEM "xhtml-datatypes-1.mod"

	Datatypes

	defines containers for the following datatypes, many of
	these imported from other specifications and standards.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:simpleType name="Length.datatype" base="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
	Length defined for cellpadding/cellspacing

	nn for pixels or nn% for percentage length
	% Length.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:simpleType name="LinkTypes.datatype" base="xsd:NMTOKENS">
    <xsd:annotation>
      <xsd:documentation>
	space-separated list of link types
	% LinkTypes.datatype "NMTOKENS"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:simpleType name="MediaDesc.datatype" base="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
	single or comma-separated list of media descriptors
	% MediaDesc.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:simpleType name="MultiLength.datatype" base="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
	pixel, percentage, or relative
	% MultiLength.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:pattern value="\d+|(100|[1-9]?\d(\.\d+)?)%|[1-9]?(\d+)?\*"/>
  </xsd:simpleType>

  <xsd:simpleType name="Number.datatype" base="xsd:nonNegativeInteger">
    <xsd:annotation>
      <xsd:documentation>
	one or more digits (NUMBER)
	% Number.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:simpleType name="tabindexNumber.datatype" base="xsd:nonNegativeInteger">
    <xsd:annotation>
      <xsd:documentation>
	tabindex attribute specifies the position of the current element
	in the tabbing order for the current document. This value must be
	a number between 0 and 32767. User agents should ignore leading zeros. 
      </xsd:documentation>
    </xsd:annotation>

    <xsd:minInclusive value="0"/>
    <xsd:maxInclusive value="32767"/>
  </xsd:simpleType>

  <xsd:simpleType name="Pixels.datatype" base="xsd:nonNegativeInteger">
    <xsd:annotation>
      <xsd:documentation>
	integer representing length in pixels
	% Pixels.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:simpleType name="Script.datatype" base="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
	script expression
	% Script.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:simpleType name="Text.datatype" base="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
	textual content
	% Text.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:annotation>
    <xsd:documentation>Imported Datatypes</xsd:documentation>
  </xsd:annotation>

  <xsd:simpleType name="Character.datatype" base="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
	a single character from [ISO10646]
	% Character.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:length value="1"/>
  </xsd:simpleType>

  <xsd:simpleType name="Charset.datatype" base="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
	a character encoding, as per [RFC2045]
	% Charset.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:simpleType name="Charsets.datatype" base="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
	a space separated list of character encodings, as per [RFC2045]
	% Charsets.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:simpleType name="ContentType.datatype" base="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
	media type, as per [RFC2045]
	% ContentType.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:simpleType name="ContentTypes.datatype" base="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
	comma-separated list of media types, as per [RFC2045]
	% ContentTypes.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:simpleType name="Datetime.datatype" base="xsd:timeInstant">
    <xsd:annotation>
      <xsd:documentation>
	date and time information. ISO date format
	% Datetime.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:simpleType name="FPI.datatype" base="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
	formal public identifier, as per [ISO8879]
	% FPI.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:simpleType name="LanguageCode.datatype" base="xsd:language">
    <xsd:annotation>
      <xsd:documentation>
	a language code, as per [RFC1766]
	% LanguageCode.datatype "NMTOKEN"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:simpleType name="URI.datatype" base="xsd:uriReference">
    <xsd:annotation>
      <xsd:documentation>
	a Uniform Resource Identifier, see [URI]
	% URI.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:simpleType name="URIs.datatype" base="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
	a space-separated list of Uniform Resource Identifiers, see [URI]
	% URIs.datatype "CDATA"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:simpleType>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Intrinsic Events Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ENTITIES XHTML Intrinsic Events 1.0//EN"
	  SYSTEM "xhtml-events-1.mod"

	Intrinsic Event Attributes

	These are the event attributes defined in HTML 4.0,
	Section 18.2.3 "Intrinsic Events". This module must be
	instantiated prior to the Attributes Module but after
	the Datatype Module in the Modular Framework module.

	"Note: Authors of HTML documents are advised that changes
	are likely to occur in the realm of intrinsic events
	(e.g., how scripts are bound to events). Research in
	this realm is carried on by members of the W3C Document
	Object Model Working Group (see the W3C Web site at
	http://www.w3.org/ for more information)."

	NOTE: Because the ATTLIST declarations in this module occur
	before their respective ELEMENT declarations in other
	modules, there may be a dependency on this module that
	should be considered if any of the parameter entities used
	for element type names (eg., %foo.qname;) are redeclared.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:attributeGroup name="Events.attrib">
    <xsd:attribute name="onclick" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="ondblclick" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onmousedown" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onmouseup" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onmouseover" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onmousemove" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onmouseout" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onkeypress" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onkeydown" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onkeyup" type="html:Script.datatype" use="optional"/>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="a.events.attrib">
    <xsd:annotation>
      <xsd:documentation>
	additional attributes on anchor element
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="onfocus" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onblur" type="html:Script.datatype" use="optional"/>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="form.events.attrib">
    <xsd:annotation>
      <xsd:documentation>
	additional attributes on form element
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="onsubmit" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onreset" type="html:Script.datatype" use="optional"/>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="label.events.attrib">
    <xsd:annotation>
      <xsd:documentation>
	additional attributes on label element
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="onfocus" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onblur" type="html:Script.datatype" use="optional"/>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="input.events.attrib">
    <xsd:annotation>
      <xsd:documentation>
	additional attributes on input element
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="onfocus" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onblur" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onselect" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onchange" type="html:Script.datatype" use="optional"/>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="select.events.attrib">
    <xsd:annotation>
      <xsd:documentation>
	additional attributes on select element
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="onfocus" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onblur" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onchange" type="html:Script.datatype" use="optional"/>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="texarea.events.attrib">
    <xsd:annotation>
      <xsd:documentation>
	additional attributes on textarea element
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="onfocus" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onblur" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onselect" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onchange" type="html:Script.datatype" use="optional"/>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="button.events.attrib">
    <xsd:annotation>
      <xsd:documentation>
	additional attributes on button element
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="onfocus" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onblur" type="html:Script.datatype" use="optional"/>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="body.events.attrib">
    <xsd:annotation>
      <xsd:documentation>
	additional attributes on body element
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="onload" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onunload" type="html:Script.datatype" use="optional"/>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="area.events.attrib">
    <xsd:annotation>
      <xsd:documentation>
	additional attributes on area element
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="onfocus" type="html:Script.datatype" use="optional"/>
    <xsd:attribute name="onblur" type="html:Script.datatype" use="optional"/>
  </xsd:attributeGroup>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Common Attributes Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ENTITIES XHTML Common Attributes 1.0//EN"
	  SYSTEM "xhtml-attribs-1.mod"

	Common Attributes

	This module declares many of the common attributes for the XHTML DTD.
	%NS.decl.attrib; is declared in the XHTML Qname module.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:attributeGroup name="Core.attrib">
    <xsd:annotation>
      <xsd:documentation>
	core attributes common to most elements
	  id       document-wide unique id
	  class    space separated list of classes
	  title    advisory title/amplification
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="id" type="xsd:ID" use="optional"/>
    <xsd:attribute name="class" type="xsd:string" use="optional"/>
    <xsd:attribute name="title" type="html:Text.datatype" use="optional"/>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="I18n.attrib">
    <xsd:annotation>
      <xsd:documentation>
	internationalization attributes
	  xml:lang    language code (as per XML 1.0 spec)
	  dir         direction for weak/neutral text
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute ref="xml:lang"/>
    <xsd:attribute name="dir" use="optional">
      <xsd:simpleType base="xsd:string">
        <xsd:enumeration value="ltr"/>
        <xsd:enumeration value="rtl"/>
      </xsd:simpleType>
    </xsd:attribute>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="Common.attrib">
    <xsd:annotation>
      <xsd:documentation>Common attribute sets</xsd:documentation>
    </xsd:annotation>

    <xsd:attributeGroup ref="html:Core.attrib"/>
    <xsd:attributeGroup ref="html:I18n.attrib"/>
    <xsd:attributeGroup ref="html:Events.attrib"/>
  </xsd:attributeGroup>

  <xsd:complexType name="Common">
    <xsd:annotation>
      <xsd:documentation>define "Common" type for XHTML</xsd:documentation>
    </xsd:annotation>

    <xsd:attributeGroup ref="html:Core.attrib"/>
    <xsd:attributeGroup ref="html:I18n.attrib"/>
    <xsd:attributeGroup ref="html:Events.attrib"/>
  </xsd:complexType>

  <xsd:annotation>
    <xsd:documentation>
	XHTML 1.1 Document Model Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ENTITIES XHTML 1.1 Document Model 1.0//EN"
	  SYSTEM "xhtml11-model-1.mod"

	XHTML 1.1 Document Model

	This module describes the groupings of elements that make up
	common content models for XHTML elements.

	XHTML has three basic content models:

	    %Inline.mix;  character-level elements
	    %Block.mix;   block-like elements, eg., paragraphs and lists
	    %Flow.mix;    any block or inline elements

	Any parameter entities declared in this module may be used
	to create element content models, but the above three are
	considered 'global' (insofar as that term applies here).

	The reserved word '#PCDATA' (indicating a text string) is now
	included explicitly with each element declaration that is
	declared as mixed content, as XML requires that this token
	occur first in a content model specification.

	Extending the Model

	While in some cases this module may need to be rewritten to
	accommodate changes to the document model, minor extensions
	may be accomplished by redeclaring any of the three *.extra;
	parameter entities to contain extension element types as follows:

	    %Misc.extra;    whose parent may be any block or
	                    inline element.

	    %Inline.extra;  whose parent may be any inline element.

	    %Block.extra;   whose parent may be any block element.

	If used, these parameter entities must be an OR-separated
	list beginning with an OR separator ("|"), eg., "| a | b | c"

	All block and inline *.class parameter entities not part
	of the *struct.class classes begin with "| " to allow for
	exclusion from mixes.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="HeadOpts.mix" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	Optional Elements in head

	"( script | style | meta | link | object )*"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>Miscellaneous Elements</xsd:documentation>
  </xsd:annotation>

  <xsd:element name="Edit.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	ins and del are used to denote editing changes

	"| ins | del"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="Script.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	script and noscript are used to contain scripts
	and alternative content

	"| script | noscript"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="Misc.extra" abstract="true">
    <xsd:annotation>
      <xsd:documentation>(not defined in XHTML 1.1)</xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="Misc.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	These elements are neither block nor inline, and can
	essentially be used anywhere in the document body.

	% Misc.class
	     "%Edit.class;
	      %Script.class;
	      %Misc.extra;"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>Inline Elements</xsd:documentation>
  </xsd:annotation>

  <xsd:element name="InlStruct.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	"br | span"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="InlPhras.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	"| em | strong | dfn | code | samp | kbd | var | cite
	 | abbr | acronym | q"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="InlPres.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	"| tt | i | b | big | small | sub | sup"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="I18n.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	"| bdo"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="Anchor.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	"| a"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="InlSpecial.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	"| img | map | applet | object"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="InlForm.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	"| input | select | textarea | label | button"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="Inline.extra" abstract="true">
    <xsd:annotation>
      <xsd:documentation>(not defined in XHTML 1.1)</xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="Ruby.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	"| ruby"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:complexType name="NoRuby.content" content="mixed"
                   base="html:Common" derivedBy="restriction">
    <xsd:annotation>
      <xsd:documentation>
	%InlNoRuby.class; includes all inline elements 
	except ruby, used as a component in mixes

	% InlNoRuby.class
	     "%InlStruct.class;
	      %InlPhras.class;
	      %InlPres.class;
	      %I18n.class;
	      %Anchor.class;
	      %InlSpecial.class;
	      %InlForm.class;
	      %Inline.extra;"

	%NoRuby.content; includes all inlines except ruby

	% NoRuby.content
	     "( #PCDATA 
	      | %InlNoRuby.class;
	      %Misc.class; )*"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:choice minOccurs="0" maxOccurs="unbounded">
      <xsd:element ref="html:InlStruct.class"/>
      <xsd:element ref="html:InlPhras.class"/>
      <xsd:element ref="html:InlPres.class"/>
      <xsd:element ref="html:I18n.class"/>
      <xsd:element ref="html:Anchor.class"/>
      <xsd:element ref="html:InlSpecial.class"/>
      <xsd:element ref="html:InlForm.class"/>
      <xsd:element ref="html:Inline.extra"/>
      <xsd:element ref="html:Edit.class"/>
      <xsd:element ref="html:Script.class"/>
      <xsd:element ref="html:Misc.extra"/>
    </xsd:choice>
  </xsd:complexType>

  <xsd:complexType name="InlNoAnchor.mix" content="mixed"
                   base="html:Common" derivedBy="restriction">
    <xsd:annotation>
      <xsd:documentation>
	%InlNoAnchor.class; includes all non-anchor inlines,
	used as a component in mixes

	% InlNoAnchor.class
	     "%InlStruct.class;
	      %InlPhras.class;
	      %InlPres.class;
	      %I18n.class;
	      %InlSpecial.class;
	      %InlForm.class;
	      %Ruby.class;
	      %Inline.extra;"

	%InlNoAnchor.mix; includes all non-anchor inlines

	% InlNoAnchor.mix
	     "%InlNoAnchor.class;
	      %Misc.class;"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:choice minOccurs="0" maxOccurs="unbounded">
      <xsd:element ref="html:InlStruct.class"/>
      <xsd:element ref="html:InlPhras.class"/>
      <xsd:element ref="html:InlPres.class"/>
      <xsd:element ref="html:I18n.class"/>
      <xsd:element ref="html:InlSpecial.class"/>
      <xsd:element ref="html:InlForm.class"/>
      <xsd:element ref="html:Inline.extra"/>
      <xsd:element ref="html:Ruby.class"/>
      <xsd:element ref="html:Edit.class"/>
      <xsd:element ref="html:Script.class"/>
      <xsd:element ref="html:Misc.extra"/>
    </xsd:choice>
  </xsd:complexType>

  <xsd:complexType name="Inline.mix" content="mixed"
                   base="html:Common" derivedBy="restriction">
    <xsd:annotation>
      <xsd:documentation>
	%Inline.class; includes all inline elements,
	used as a component in mixes

	% Inline.class
	     "%InlStruct.class;
	      %InlPhras.class;
	      %InlPres.class;
	      %I18n.class;
	      %Anchor.class;
	      %InlSpecial.class;
	      %InlForm.class;
	      %Ruby.class;
	      %Inline.extra;"

	%Inline.mix; includes all inline elements, including %Misc.class;

	% Inline.mix
	     "%Inline.class;
	      %Misc.class;"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:choice minOccurs="0" maxOccurs="unbounded">
      <xsd:element ref="html:InlStruct.class"/>
      <xsd:element ref="html:InlPhras.class"/>
      <xsd:element ref="html:InlPres.class"/>
      <xsd:element ref="html:I18n.class"/>
      <xsd:element ref="html:Anchor.class"/>
      <xsd:element ref="html:InlSpecial.class"/>
      <xsd:element ref="html:InlForm.class"/>
      <xsd:element ref="html:Inline.extra"/>
      <xsd:element ref="html:Ruby.class"/>
      <xsd:element ref="html:Edit.class"/>
      <xsd:element ref="html:Script.class"/>
      <xsd:element ref="html:Misc.extra"/>
    </xsd:choice>
  </xsd:complexType>

  <xsd:annotation>
    <xsd:documentation>
	Block Elements

	In the HTML 4.0 DTD, heading and list elements were included
	in the %block; parameter entity. The %Heading.class; and
	%List.class; parameter entities must now be included explicitly
	on element declarations where desired.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="Heading.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	"h1 | h2 | h3 | h4 | h5 | h6"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="List.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	"ul | ol | dl"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="BlkStruct.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	"p | div"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="BlkPhras.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	"| pre | blockquote | address"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="BlkPres.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	"| hr"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="BlkSpecial.class" abstract="true">
    <xsd:annotation>
      <xsd:documentation>
	"| table | form | fieldset"
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="Block.extra" abstract="true">
    <xsd:annotation>
      <xsd:documentation>(not defined in XHTML 1.1)</xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:complexType name="Block.mix" content="elementOnly"
                   base="html:Common" derivedBy="restriction">
    <xsd:annotation>
      <xsd:documentation>
	%Block.class; includes all block elements,
	used as an component in mixes

	% Block.class
	     "%BlkStruct.class;
	      %BlkPhras.class;
	      %BlkPres.class;
	      %BlkSpecial.class;
	      %Block.extra;"

	%Block.mix; includes all block elements plus %Misc.class;

	% Block.mix
	     "%Heading.class;
	      | %List.class;
	      | %Block.class;
	      %Misc.class;"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:choice minOccurs="0" maxOccurs="unbounded">
      <xsd:element ref="html:Heading.class"/>
      <xsd:element ref="html:List.class"/>
      <xsd:element ref="html:BlkStruct.class"/>
      <xsd:element ref="html:BlkPhras.class"/>
      <xsd:element ref="html:BlkPres.class"/>
      <xsd:element ref="html:BlkSpecial.class"/>
      <xsd:element ref="html:Block.extra"/>
      <xsd:element ref="html:Edit.class"/>
      <xsd:element ref="html:Script.class"/>
      <xsd:element ref="html:Misc.extra"/>
    </xsd:choice>
  </xsd:complexType>

  <xsd:annotation>
    <xsd:documentation>All Content Elements</xsd:documentation>
  </xsd:annotation>

  <xsd:complexType name="Flow.mix" content="mixed"
                   base="html:Common" derivedBy="restriction">
    <xsd:annotation>
      <xsd:documentation>
	%Flow.mix; includes all text content, block and inline

	% Flow.mix
	     "%Heading.class;
	      | %List.class;
	      | %Block.class;
	      | %Inline.class;
	      %Misc.class;"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:choice minOccurs="0" maxOccurs="unbounded">
      <xsd:element ref="html:Heading.class"/>
      <xsd:element ref="html:List.class"/>
      <xsd:element ref="html:BlkStruct.class"/>
      <xsd:element ref="html:BlkPhras.class"/>
      <xsd:element ref="html:BlkPres.class"/>
      <xsd:element ref="html:BlkSpecial.class"/>
      <xsd:element ref="html:Block.extra"/>
      <xsd:element ref="html:InlStruct.class"/>
      <xsd:element ref="html:InlPhras.class"/>
      <xsd:element ref="html:InlPres.class"/>
      <xsd:element ref="html:I18n.class"/>
      <xsd:element ref="html:Anchor.class"/>
      <xsd:element ref="html:InlSpecial.class"/>
      <xsd:element ref="html:InlForm.class"/>
      <xsd:element ref="html:Inline.extra"/>
      <xsd:element ref="html:Ruby.class"/>
      <xsd:element ref="html:Edit.class"/>
      <xsd:element ref="html:Script.class"/>
      <xsd:element ref="html:Misc.extra"/>
    </xsd:choice>
  </xsd:complexType>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Character Entities Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ENTITIES XHTML Character Entities 1.0//EN"
	  SYSTEM "xhtml-charent-1.mod"

	Character Entities for XHTML

	This module declares the set of character entities for XHTML,
	including the Latin 1, Symbol and Special character collections.

	XML Schema doesn't directly support character entities.
	To use them, use ENTITY declarations (whether in internal or
	external DTD subsets)

	XML-compatible ISO Latin 1 Character Entity Set for XHTML

	  PUBLIC "-//W3C//ENTITIES Latin 1 for XHTML//EN"
	  SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-lat1.ent"

	ISO Math, Greek and Symbolic Character Entity Set for XHTML
	
	  PUBLIC "-//W3C//ENTITIES Symbols for XHTML//EN"
	  SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-symbol.ent"

	XML-compatible ISO Special Character Entity Set for XHTML

	  PUBLIC "-//W3C//ENTITIES Special for XHTML//EN"
	  SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-special.ent"
    </xsd:documentation>
  </xsd:annotation>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Text Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Text 1.0//EN"
	  SYSTEM "xhtml-text-1.mod"

	Textual Content

	The Text module includes declarations for all core 
	text container elements and their attributes.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Inline Structural Module

	Inline Structural

	   br, span

	This module declares the elements and their attributes 
	used to support inline-level structural markup.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="br" equivClass="html:InlStruct.class">
    <xsd:annotation>
      <xsd:documentation>br: forced line break</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="empty">
      <xsd:attributeGroup ref="html:Core.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="span" equivClass="html:InlStruct.class"
               type="html:Inline.mix">
    <xsd:annotation>
      <xsd:documentation>span: generic inline container</xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Inline Phrasal Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Inline Phrasal 1.0//EN"
	  SYSTEM "xhtml-inlphras-1.mod"

	Inline Phrasal

	   abbr, acronym, cite, code, dfn, em, kbd, q, samp, strong, var

	This module declares the elements and their attributes used to
	support inline-level phrasal markup.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="abbr" equivClass="html:InlPhras.class"
               type="html:Inline.mix"/>

  <xsd:element name="acronym" equivClass="html:InlPhras.class"
               type="html:Inline.mix"/>

  <xsd:element name="cite" equivClass="html:InlPhras.class"
               type="html:Inline.mix"/>

  <xsd:element name="code" equivClass="html:InlPhras.class"
               type="html:Inline.mix"/>

  <xsd:element name="dfn" equivClass="html:InlPhras.class"
               type="html:Inline.mix"/>

  <xsd:element name="em" equivClass="html:InlPhras.class"
               type="html:Inline.mix"/>

  <xsd:element name="kbd" equivClass="html:InlPhras.class"
               type="html:Inline.mix"/>

  <xsd:element name="q" equivClass="html:InlPhras.class">
    <xsd:complexType base="html:Inline.mix" derivedBy="extension">
      <xsd:attribute name="cite" type="html:URI.datatype" use="optional"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="samp" equivClass="html:InlPhras.class"
               type="html:Inline.mix"/>

  <xsd:element name="strong" equivClass="html:InlPhras.class"
               type="html:Inline.mix"/>

  <xsd:element name="var" equivClass="html:InlPhras.class"
               type="html:Inline.mix"/>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Block Structural Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Block Structural 1.0//EN"
	  SYSTEM "xhtml-blkstruct-1.mod"

	Block Structural

	   div, p

	This module declares the elements and their attributes used to
	support block-level structural markup.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="div" equivClass="html:BlkStruct.class"
               type="html:Flow.mix"/>

  <xsd:element name="p" equivClass="html:BlkStruct.class"
               type="html:Inline.mix"/>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Block Phrasal Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Block Phrasal 1.0//EN"
	  SYSTEM "xhtml-blkphras-1.mod"

	Block Phrasal

	   address, blockquote, pre, h1, h2, h3, h4, h5, h6

	This module declares the elements and their attributes used to
	support block-level phrasal markup.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="address" equivClass="html:BlkPhras.class"
               type="html:Inline.mix"/>

  <xsd:element name="blockquote" equivClass="html:BlkPhras.class">
    <xsd:complexType base="html:Block.mix" derivedBy="extension">
      <xsd:attribute name="cite" type="html:URI.datatype" use="optional"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="pre" equivClass="html:BlkPhras.class">
    <xsd:complexType content="mixed"
                     base="html:Common" derivedBy="restriction">
      <xsd:choice minOccurs="0" maxOccurs="unbounded">
        <xsd:element ref="html:InlStruct.class"/>
        <xsd:element ref="html:InlPhras.class"/>
        <xsd:element ref="html:Anchor.class"/>
        <xsd:element ref="html:Inline.extra"/>
      </xsd:choice>
      <xsd:attribute ref="xml:space" use="fixed" value="preserve"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>Heading Elements</xsd:documentation>
  </xsd:annotation>

  <xsd:element name="h1" equivClass="html:Heading.class"
               type="html:Inline.mix"/>

  <xsd:element name="h2" equivClass="html:Heading.class"
               type="html:Inline.mix"/>

  <xsd:element name="h3" equivClass="html:Heading.class"
               type="html:Inline.mix"/>

  <xsd:element name="h4" equivClass="html:Heading.class"
               type="html:Inline.mix"/>

  <xsd:element name="h5" equivClass="html:Heading.class"
               type="html:Inline.mix"/>

  <xsd:element name="h6" equivClass="html:Heading.class"
               type="html:Inline.mix"/>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Hypertext Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Hypertext 1.0//EN"
	  SYSTEM "xhtml-hypertext-1.mod"

	Hypertext

	   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.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="a" equivClass="html:Anchor.class">
    <xsd:complexType base="html:InlNoAnchor.mix" derivedBy="extension">
      <xsd:attribute name="href" type="html:URI.datatype" use="optional"/>
      <xsd:attribute name="charset" type="html:Charset.datatype" use="optional"/>
      <xsd:attribute name="type" type="html:ContentType.datatype" use="optional"/>
      <xsd:attribute name="hreflang" type="html:LanguageCode.datatype" use="optional"/>
      <xsd:attribute name="rel" type="html:LinkTypes.datatype" use="optional"/>
      <xsd:attribute name="rev" type="html:LinkTypes.datatype" use="optional"/>
      <xsd:attribute name="accesskey" type="html:Character.datatype" use="optional"/>
      <xsd:attribute name="tabindex" type="html:tabindexNumber.datatype" use="optional"/>
      <xsd:attributeGroup ref="html:a.events.attrib"/>
      <xsd:attributeGroup ref="html:a.csismap.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Lists Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Lists 1.0//EN"
	  SYSTEM "xhtml-list-1.mod"

	Lists

	   dl, dt, dd, ol, ul, li

	This module declares the list-oriented element types
	and their attributes.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="dl" equivClass="html:List.class">
    <xsd:annotation>
      <xsd:documentation>dl: Definition List</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="elementOnly"
                     base="html:Common" derivedBy="restriction">
      <xsd:choice minOccurs="1" maxOccurs="unbounded">
        <xsd:element ref="html:dt"/>
        <xsd:element ref="html:dd"/>
      </xsd:choice>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="dt" type="html:Inline.mix">
    <xsd:annotation>
      <xsd:documentation>dt: Definition Term</xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="dd" type="html:Flow.mix">
    <xsd:annotation>
      <xsd:documentation>dd: Definition Description</xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:complexType name="listType" content="elementOnly"
                   base="html:Common" derivedBy="restriction">
    <xsd:annotation>
      <xsd:documentation>
	define a complexType for lists (suitable for ul and ol)
      </xsd:documentation>
    </xsd:annotation>

    <xsd:sequence minOccurs="1" maxOccurs="unbounded">
      <xsd:element ref="html:li"/>
    </xsd:sequence>
  </xsd:complexType>

  <xsd:element name="ol" type="html:listType" equivClass="html:List.class">
    <xsd:annotation>
      <xsd:documentation>ol: Ordered List (numbered styles)</xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="ul" type="html:listType" equivClass="html:List.class">
    <xsd:annotation>
      <xsd:documentation>ul: Unordered List (bullet styles)</xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="li" type="html:Flow.mix">
    <xsd:annotation>
      <xsd:documentation>li: List Item</xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Editing Elements Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Editing Markup 1.0//EN"
	  SYSTEM "xhtml-edit-1.mod"

	Editing Elements

	   ins, del

	This module declares element types and attributes used to indicate
	inserted and deleted content while editing a document.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="editType" equivClass="html:Edit.class">
    <xsd:annotation>
      <xsd:documentation>Editing Elements (ins, del)</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType base="html:Flow.mix" derivedBy="extension">
      <xsd:attribute name="cite" type="html:URI.datatype" use="optional"/>
      <xsd:attribute name="datetime" type="html:Datetime.datatype" use="optional"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="ins" type="html:editType">
    <xsd:annotation>
      <xsd:documentation>ins: Inserted Text</xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="del" type="html:editType">
    <xsd:annotation>
      <xsd:documentation>del: Deleted Text</xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML BDO Element Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML BDO Element 1.0//EN"
	  SYSTEM "xhtml-bdo-1.mod"

	Bidirectional Override (bdo) Element

	This modules declares the element 'bdo', used to override the
	Unicode bidirectional algorithm for selected fragments of text.

	DEPENDENCIES:
	Relies on the conditional section keyword %XHTML.bidi; declared
	as "INCLUDE". Bidirectional text support includes both the bdo 
	element and the 'dir' attribute.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="bdo" equivClass="html:I18n.class">
    <xsd:complexType base="html:Inline.mix" derivedBy="restriction">
      <xsd:attribute name="dir" use="required">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="ltr"/>
          <xsd:enumeration value="rtl"/>
        </xsd:simpleType>
      </xsd:attribute>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Ruby Module

	This module is based on the W3C Ruby Annotation Specification:

	   http://www.w3.org/TR/ruby

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Ruby 1.0//EN"
	  SYSTEM "xhtml-ruby-1.mod"

	Ruby Elements

	   ruby, rbc, rtc, rb, rt, rp

	This module declares the elements and their attributes used to
	support ruby annotation markup.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="ruby" equivClass="html:Ruby.class">
    <xsd:annotation>
      <xsd:documentation>ruby element</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="elementOnly"
                     base="html:Common" derivedBy="restriction">
      <xsd:choice>
        <xsd:sequence>
          <xsd:element ref="html:rb"/>
          <xsd:choice>
            <xsd:element ref="html:rt"/>
            <xsd:sequence>
              <xsd:element ref="html:rp"/>
              <xsd:element ref="html:rt"/>
              <xsd:element ref="html:rp"/>
            </xsd:sequence>
          </xsd:choice>
        </xsd:sequence>
        <xsd:sequence>
          <xsd:element ref="html:rbc"/>
          <xsd:element ref="html:rtc"/>
          <xsd:element ref="html:rtc" minOccurs="0" maxOccurs="1"/>
        </xsd:sequence>
      </xsd:choice>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="rbc">
    <xsd:annotation>
      <xsd:documentation>rbc (ruby base component) element</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="elementOnly"
                     base="html:Common" derivedBy="restriction">
      <xsd:sequence minOccurs="1" maxOccurs="unbounded">
        <xsd:element ref="html:rb"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="rtc">
    <xsd:annotation>
      <xsd:documentation>rtc (ruby text component) element</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="elementOnly"
                     base="html:Common" derivedBy="restriction">
      <xsd:sequence minOccurs="1" maxOccurs="unbounded">
        <xsd:element ref="html:rt"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="rb" type="html:NoRuby.content">
    <xsd:annotation>
      <xsd:documentation>
	rb (ruby base) element

	%rb.content; uses %NoRuby.content; as its content model,
	which is '( #PCDATA )' by default. It may be overridden
	by other modules to allow other inline-level elements
	of its parent markup language, but it should not include
	ruby descendent elements.
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="rt">
    <xsd:annotation>
      <xsd:documentation>
	rt (ruby text) element

	%rt.content; uses %NoRuby.content; as its content model,
	which is '( #PCDATA )' by default. It may be overridden
	by other modules to allow other inline-level elements
	of its parent markup language, but it should not include
	ruby descendent elements.

	rbspan attribute is used for group ruby only

	Note: rbspan attribute is defined to have Number.datatype
	as attribute value, but it should be xsd:positiveInteger
      </xsd:documentation>
    </xsd:annotation>

    <xsd:complexType base="html:NoRuby.content" derivedBy="extension">
      <xsd:attribute name="rbspan" type="xsd:positiveInteger"
                     use="default" value="1"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="rp">
    <xsd:annotation>
      <xsd:documentation>rp (ruby parenthesis) element</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="textOnly">
      <xsd:attributeGroup ref="html:Core.attrib"/>
      <xsd:attributeGroup ref="html:I18n.attrib"/>
      <xsd:attributeGroup ref="html:Events.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Presentation Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Presentation 1.0//EN"
	  SYSTEM "xhtml-pres-1.mod"

	Presentational Elements

	This module defines elements and their attributes for
	simple presentation-related markup.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Inline Presentation Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Inline Presentation 1.0//EN"
	  SYSTEM "xhtml-inlpres-1.mod"

	Inline Presentational Elements

	   b, big, i, small, sub, sup, tt

	This module declares the elements and their attributes used to
	support inline-level presentational markup.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="b" equivClass="html:InlPres.class"
               type="html:Inline.mix"/>

  <xsd:element name="big" equivClass="html:InlPres.class"
               type="html:Inline.mix"/>

  <xsd:element name="i" equivClass="html:InlPres.class"
               type="html:Inline.mix"/>

  <xsd:element name="small" equivClass="html:InlPres.class"
               type="html:Inline.mix"/>

  <xsd:element name="sub" equivClass="html:InlPres.class"
               type="html:Inline.mix"/>

  <xsd:element name="sup" equivClass="html:InlPres.class"
               type="html:Inline.mix"/>

  <xsd:element name="tt" equivClass="html:InlPres.class"
               type="html:Inline.mix"/>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Block Presentation Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Block Presentation 1.0//EN"
	  SYSTEM "xhtml-blkpres-1.mod"

	Block Presentational Elements

	   hr

	This module declares the elements and their attributes used to
	support block-level presentational markup.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="hr" equivClass="html:BlkPres.class">
    <xsd:complexType content="empty">
      <xsd:attributeGroup ref="html:Core.attrib"/>
      <xsd:attributeGroup ref="html:I18n.attrib"/>
      <xsd:attributeGroup ref="html:Events.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Link Element Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Link Element 1.0//EN"
	  SYSTEM "xhtml-link-1.mod"

	Link element

	   link

	This module declares the link element type and its attributes,
	which could (in principle) be used to define document-level links
	to external resources such as:

	a) for document specific toolbars/menus, e.g. start, contents,
	   previous, next, index, end, help
	b) to link to a separate style sheet (rel="stylesheet")
	c) to make a link to a script (rel="script")
	d) by stylesheets to control how collections of html nodes are
	   rendered into printed documents
	e) to make a link to a printable version of this document
	   e.g. a postscript or pdf version (rel="alternate" media="print")
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="link" equivClass="html:HeadOpts.mix">
    <xsd:annotation>
      <xsd:documentation>link: Media-Independent Link</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="empty">
      <xsd:attributeGroup ref="html:Core.attrib"/>
      <xsd:attributeGroup ref="html:I18n.attrib"/>
      <xsd:attributeGroup ref="html:Events.attrib"/>
      <xsd:attribute name="charset" type="html:Charset.datatype" use="optional"/>
      <xsd:attribute name="href" type="html:URI.datatype" use="optional"/>
      <xsd:attribute name="hreflang" type="html:LanguageCode.datatype" use="optional"/>
      <xsd:attribute name="type" type="html:ContentType.datatype" use="optional"/>
      <xsd:attribute name="rel" type="html:LinkTypes.datatype" use="optional"/>
      <xsd:attribute name="rev" type="html:LinkTypes.datatype" use="optional"/>
      <xsd:attribute name="media" type="html:MediaDesc.datatype" use="optional"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Document Metainformation Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Metainformation 1.0//EN"
	  SYSTEM "xhtml-meta-1.mod"

	Meta Information

	   meta

	This module declares the meta element type and its attributes,
	used to provide declarative document metainformation.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="meta" equivClass="html:HeadOpts.mix">
    <xsd:annotation>
      <xsd:documentation>meta: Generic Metainformation</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="empty">
      <xsd:attributeGroup ref="html:I18n.attrib"/>
      <xsd:attribute name="http-equiv" type="xsd:NMTOKEN" use="optional"/>
      <xsd:attribute name="name" type="xsd:NMTOKEN" use="optional"/>
      <xsd:attribute name="content" type="xsd:string" use="required"/>
      <xsd:attribute name="scheme" type="xsd:string" use="optional"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Base Element Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Base Element 1.0//EN"
	  SYSTEM "xhtml-base-1.mod"

	Base element

	   base

	This module declares the base element type and its attributes,
	used to define a base URI against which relative URIs in the
	document will be resolved.

	Note that this module also redeclares the content model for
	the head element to include the base element.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="base">
    <xsd:annotation>
      <xsd:documentation>base: Document Base URI</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="empty">
      <xsd:attribute name="href" type="html:URI.datatype" use="required"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	% head.content
	    "( %HeadOpts.mix;,
	     ( ( title, %HeadOpts.mix;, ( base, %HeadOpts.mix; )? )
	     | ( base;, %HeadOpts.mix;, ( title, %HeadOpts.mix; ))))"

	Note: object and script should be equivalents of HeadOpts.mix,
	but they're equivalents of InlSpecial.class and Script.class
	respectively, so they cannot be equivalents of HeadOpts.mix
    </xsd:documentation>
  </xsd:annotation>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Document Scripting Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Scripting 1.0//EN"
	  SYSTEM "xhtml-script-1.mod"

	Scripting

	   script, noscript

	This module declares element types and attributes used to provide
	support for executable scripts as well as an alternate content
	container where scripts are not supported.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="script" equivClass="html:Script.class">
    <xsd:annotation>
      <xsd:documentation>script: Scripting Statement</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="textOnly">
      <xsd:attribute name="charset" type="html:Charset.datatype" use="optional"/>
      <xsd:attribute name="type" type="html:ContentType.datatype" use="required"/>
      <xsd:attribute name="src" type="html:URI.datatype" use="optional"/>
      <xsd:attribute name="defer" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="defer"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute ref="xml:space" use="fixed" value="preserve"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="noscript" equivClass="html:Script.class">
    <xsd:annotation>
      <xsd:documentation>
	noscript: No-Script Alternate Content

	The content is html:Block.mix, but minOccurs is set to "1"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:complexType base="html:Block.mix" derivedBy="restriction">
      <xsd:choice minOccurs="1" maxOccurs="unbounded">
        <xsd:element ref="html:Heading.class"/>
        <xsd:element ref="html:List.class"/>
        <xsd:element ref="html:BlkStruct.class"/>
        <xsd:element ref="html:BlkPhras.class"/>
        <xsd:element ref="html:BlkPres.class"/>
        <xsd:element ref="html:BlkSpecial.class"/>
        <xsd:element ref="html:Block.extra"/>
        <xsd:element ref="html:Edit.class"/>
        <xsd:element ref="html:Script.class"/>
        <xsd:element ref="html:Misc.extra"/>
      </xsd:choice>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Document Stylesheet Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//DTD XHTML Stylesheets 1.0//EN"
	  SYSTEM "xhtml-style-1.mod"

	Stylesheets

	   style

	This module declares the style element type and its attributes,
	used to embed stylesheet information in the document head element.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="style" equivClass="html:HeadOpts.mix">
    <xsd:annotation>
      <xsd:documentation>style: Stylesheet Information</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="mixed">
      <xsd:attribute name="title" type="html:Text.datatype" use="optional"/>
      <xsd:attributeGroup ref="html:I18n.attrib"/>
      <xsd:attribute name="type" type="html:ContentType.datatype" use="required"/>
      <xsd:attribute name="media" type="html:MediaDesc.datatype" use="optional"/>
      <xsd:attribute ref="xml:space" use="fixed" value="preserve"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	Image Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Images 1.0//EN"
	  SYSTEM "xhtml-image-1.mod"

	Images

	   img

	This module provides markup to support basic image embedding.

	To avoid problems with text-only UAs as well as to make
	image content understandable and navigable to users of
	non-visual UAs, you need to provide a description with
	the 'alt' attribute, and avoid server-side image maps.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="img" equivClass="html:InlSpecial.class">
    <xsd:complexType content="empty">
      <xsd:attributeGroup ref="html:Core.attrib"/>
      <xsd:attributeGroup ref="html:I18n.attrib"/>
      <xsd:attributeGroup ref="html:Events.attrib"/>
      <xsd:attribute name="src" type="html:URI.datatype" use="required"/>
      <xsd:attribute name="alt" type="html:Text.datatype" use="required"/>
      <xsd:attribute name="longdesc" type="html:URI.datatype" use="optional"/>
      <xsd:attribute name="height" type="html:Length.datatype" use="optional"/>
      <xsd:attribute name="width" type="html:Length.datatype" use="optional"/>
      <xsd:attributeGroup ref="html:img.csismap.attrib"/>
      <xsd:attributeGroup ref="html:img.ssismap.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Client-side Image Map Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Client-side Image Maps 1.0//EN"
	  SYSTEM "xhtml-csismap-1.mod"

	Client-side Image Maps

	   area, map

	This module declares elements and attributes to support client-side
	image maps. This requires that the Image Module (or a module
	declaring the img element type) be included in the DTD.

	These can be placed in the same document or grouped in a
	separate document, although the latter isn't widely supported
    </xsd:documentation>
  </xsd:annotation>

  <xsd:simpleType name="Shape.datatype" base="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
	% Shape "(rect|circle|poly|default)"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:enumeration value="rect"/>
    <xsd:enumeration value="circle"/>
    <xsd:enumeration value="poly"/>
    <xsd:enumeration value="default"/>
  </xsd:simpleType>

  <xsd:simpleType name="Coords.datatype" base="xsd:string"/>

  <xsd:element name="area">
    <xsd:complexType content="empty">
      <xsd:attributeGroup ref="html:Core.attrib"/>
      <xsd:attributeGroup ref="html:I18n.attrib"/>
      <xsd:attributeGroup ref="html:Events.attrib"/>
      <xsd:attribute name="href" type="html:URI.datatype" use="optional"/>
      <xsd:attribute name="shape" type="html:Shape.datatype"
                     use="default" value="rect"/>
      <xsd:attribute name="coords" type="html:Coords.datatype" use="optional"/>
      <xsd:attribute name="nohref" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="nohref"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="alt" type="html:Text.datatype" use="required"/>
      <xsd:attribute name="tabindex" type="html:tabindexNumber.datatype" use="optional"/>
      <xsd:attribute name="accesskey" type="html:Character.datatype" use="optional"/>
      <xsd:attributeGroup ref="html:area.events.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:attributeGroup name="a.csismap.attrib">
    <xsd:annotation>
      <xsd:documentation>
	modify anchor attribute definition list
	to allow for client-side image maps
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="shape" type="html:Shape.datatype" use="default" value="rect"/>
    <xsd:attribute name="coords" type="html:Coords.datatype" use="optional"/>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="img.csismap.attrib">
    <xsd:annotation>
      <xsd:documentation>
	modify img attribute definition list
	to allow for client-side image maps
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="usemap" type="xsd:IDREF" use="optional"/>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="input.csismap.attrib">
    <xsd:annotation>
      <xsd:documentation>
	modify form input attribute definition list
	to allow for client-side image maps
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="usemap" type="xsd:IDREF" use="optional"/>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="object.csismap.attrib">
    <xsd:annotation>
      <xsd:documentation>
	modify object attribute definition list
	to allow for client-side image maps
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="usemap" type="xsd:IDREF" use="optional"/>
  </xsd:attributeGroup>

  <xsd:annotation>
    <xsd:documentation>
	'usemap' points to the 'id' attribute of a MAP element,
	which must be in the same document; support for external
	document maps was not widely supported in HTML and is
	eliminated in XHTML.

	It is considered an error for the element pointed to by
	a usemap IDREF to occur in anything but a map element.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="map" equivClass="html:InlSpecial.class">
    <xsd:complexType content="elementOnly">
      <xsd:choice minOccurs="1" maxOccurs="unbounded">
        <xsd:choice>
          <xsd:element ref="html:Heading.class"/>
          <xsd:element ref="html:List.class"/>
          <xsd:element ref="html:BlkStruct.class"/>
          <xsd:element ref="html:BlkPhras.class"/>
          <xsd:element ref="html:BlkPres.class"/>
          <xsd:element ref="html:BlkSpecial.class"/>
          <xsd:element ref="html:Block.extra"/>
          <xsd:element ref="html:Edit.class"/>
          <xsd:element ref="html:Script.class"/>
          <xsd:element ref="html:Misc.extra"/>
        </xsd:choice>
        <xsd:element ref="html:area"/>
      </xsd:choice>
      <xsd:attribute name="id" type="xsd:ID" use="required"/>
      <xsd:attribute name="class" type="xsd:string" use="optional"/>
      <xsd:attribute name="title" type="html:Text.datatype" use="optional"/>
      <xsd:attributeGroup ref="html:I18n.attrib"/>
      <xsd:attributeGroup ref="html:Events.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Server-side Image Map Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Server-side Image Maps 1.0//EN"
	  SYSTEM "xhtml-ssismap-1.mod"

	Server-side Image Maps

	This adds the 'ismap' attribute to the img element to 
	support server-side processing of a user selection.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:attributeGroup name="img.ssismap.attrib">
    <xsd:attribute name="ismap" use="optional">
      <xsd:simpleType base="xsd:string">
        <xsd:enumeration value="ismap"/>
      </xsd:simpleType>
    </xsd:attribute>
  </xsd:attributeGroup>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Param Element Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Param Element 1.0//EN"
	  SYSTEM "xhtml-param-1.mod"

	Parameters for Java Applets and Embedded Objects

	   param

	This module provides declarations for the param element, 
	used to provide named property values for the applet
	and object elements. 
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="param">
    <xsd:annotation>
      <xsd:documentation>param: Named Property Value</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="empty">
      <xsd:attribute name="id" type="xsd:ID" use="optional"/>
      <xsd:attribute name="name" type="xsd:string" use="required"/>
      <xsd:attribute name="value" type="xsd:string" use="optional"/>
      <xsd:attribute name="valuetype" use="default" value="data">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="data"/>
          <xsd:enumeration value="ref"/>
          <xsd:enumeration value="object"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="type" type="html:ContentType.datatype" use="optional"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Java Applet Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Java Applets 1.0//EN"
	  SYSTEM "xhtml-applet-1.mod"

	Java Applets

	   applet

	This module declares the applet element type and its attributes, 
	used to provide support for Java applets. The 'alt' attribute 
	is now required (as it is on images). One of either code or 
	object attributes must be present. In the document, place param 
	elements before the object elements that require their content.

	Note that use of this module requires instantiation of the 
	Param Element Module prior to this module.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="applet" equivClass="html:InlSpecial.class">
    <xsd:annotation>
      <xsd:documentation>
	applet: Java Applet

	content model is "( param | %Flow.mix; )*"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="elementOnly">
      <xsd:choice minOccurs="0" maxOccurs="unbounded">
        <xsd:element ref="html:param"/>
        <xsd:element ref="html:Heading.class"/>
        <xsd:element ref="html:List.class"/>
        <xsd:element ref="html:BlkStruct.class"/>
        <xsd:element ref="html:BlkPhras.class"/>
        <xsd:element ref="html:BlkPres.class"/>
        <xsd:element ref="html:BlkSpecial.class"/>
        <xsd:element ref="html:Block.extra"/>
        <xsd:element ref="html:InlStruct.class"/>
        <xsd:element ref="html:InlPhras.class"/>
        <xsd:element ref="html:InlPres.class"/>
        <xsd:element ref="html:I18n.class"/>
        <xsd:element ref="html:Anchor.class"/>
        <xsd:element ref="html:InlSpecial.class"/>
        <xsd:element ref="html:InlForm.class"/>
        <xsd:element ref="html:Inline.extra"/>
        <xsd:element ref="html:Ruby.class"/>
        <xsd:element ref="html:Edit.class"/>
        <xsd:element ref="html:Script.class"/>
        <xsd:element ref="html:Misc.extra"/>
      </xsd:choice>
      <xsd:attributeGroup ref="html:Core.attrib"/>
      <xsd:attribute name="alt" type="html:Text.datatype" use="required"/>
      <xsd:attribute name="archive" type="xsd:string" use="optional"/>
      <xsd:attribute name="code" type="xsd:string" use="optional"/>
      <xsd:attribute name="codebase" type="html:URI.datatype" use="optional"/>
      <xsd:attribute name="object" type="xsd:string" use="optional"/>
      <xsd:attribute name="width" type="html:Length.datatype" use="required"/>
      <xsd:attribute name="height" type="html:Length.datatype" use="required"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Embedded Object Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Embedded Object 1.0//EN"
	  SYSTEM "xhtml-object-1.mod"

	Embedded Objects

	   object

	This module declares the object element type and its attributes,
	used to embed external objects as part of XHTML pages. In the
	document, place param elements prior to the object elements 
	that require their content.

	Note that use of this module requires instantiation of the 
	Param Element Module prior to this module.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="object" equivClass="html:InlSpecial.class">
    <xsd:annotation>
      <xsd:documentation>
	object: Generic Embedded Object

	content model is "( #PCDATA | %Flow.mix; | param )*"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="mixed"
                     base="html:Common" derivedBy="extension">
      <xsd:choice minOccurs="0" maxOccurs="unbounded">
        <xsd:element ref="html:Heading.class"/>
        <xsd:element ref="html:List.class"/>
        <xsd:element ref="html:BlkStruct.class"/>
        <xsd:element ref="html:BlkPhras.class"/>
        <xsd:element ref="html:BlkPres.class"/>
        <xsd:element ref="html:BlkSpecial.class"/>
        <xsd:element ref="html:Block.extra"/>
        <xsd:element ref="html:InlStruct.class"/>
        <xsd:element ref="html:InlPhras.class"/>
        <xsd:element ref="html:InlPres.class"/>
        <xsd:element ref="html:I18n.class"/>
        <xsd:element ref="html:Anchor.class"/>
        <xsd:element ref="html:InlSpecial.class"/>
        <xsd:element ref="html:InlForm.class"/>
        <xsd:element ref="html:Inline.extra"/>
        <xsd:element ref="html:Ruby.class"/>
        <xsd:element ref="html:Edit.class"/>
        <xsd:element ref="html:Script.class"/>
        <xsd:element ref="html:Misc.extra"/>
        <xsd:element ref="html:param"/>
      </xsd:choice>
      <xsd:attribute name="declare" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="declare"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="classid" type="html:URI.datatype" use="optional"/>
      <xsd:attribute name="codebase" type="htmlURI.datatype:" use="optional"/>
      <xsd:attribute name="data" type="html:URI.datatype" use="optional"/>
      <xsd:attribute name="type" type="html:ContentType.datatype" use="optional"/>
      <xsd:attribute name="codetype" type="html:ContentType.datatype" use="optional"/>
      <xsd:attribute name="archive" type="html:URIs.datatype" use="optional"/>
      <xsd:attribute name="standby" type="html:Text.datatype" use="optional"/>
      <xsd:attribute name="height" type="html:Length.datatype" use="optional"/>
      <xsd:attribute name="width" type="html:Length.datatype" use="optional"/>
      <xsd:attribute name="name" type="xsd:string" use="optional"/>
      <xsd:attribute name="tabindex" type="html:tabindexNumber.datatype" use="optional"/>
      <xsd:attributeGroup ref="html:object.csismap.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Table Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Tables 1.0//EN"
	  SYSTEM "xhtml-table-1.mod"

	Tables

	   table, caption, thead, tfoot, tbody, colgroup, col, tr, th, td

	This module declares element types and attributes used to provide
	table markup similar to HTML 4.0, including features that enable
	better accessibility for non-visual user agents.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:attributeGroup name="frame.attrib">
    <xsd:annotation>
      <xsd:documentation>
	The frame attribute specifies which parts of the frame around
	the table should be rendered. The values are not the same as
	CALS to avoid a name clash with the valign attribute.

	% frame.attrib
	     "frame        ( void
	                   | above
	                   | below
	                   | hsides
	                   | lhs
	                   | rhs
	                   | vsides
	                   | box
	                   | border )               #IMPLIED"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="frame" use="optional">
      <xsd:simpleType base="xsd:string">
        <xsd:enumeration value="void"/>
        <xsd:enumeration value="above"/>
        <xsd:enumeration value="below"/>
        <xsd:enumeration value="hsides"/>
        <xsd:enumeration value="lhs"/>
        <xsd:enumeration value="rhs"/>
        <xsd:enumeration value="vsides"/>
        <xsd:enumeration value="box"/>
        <xsd:enumeration value="border"/>
      </xsd:simpleType>
    </xsd:attribute>
  </xsd:attributeGroup>


  <xsd:attributeGroup name="rules.attrib">
    <xsd:annotation>
      <xsd:documentation>
	The rules attribute defines which rules to draw between cells:

	If rules is absent then assume:

	  "none" if border is absent or border="0" otherwise "all"

	% rules.attrib
	     "rules        ( none
	                   | groups
	                   | rows
	                   | cols
	                   | all )                  #IMPLIED"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="rules" use="optional">
      <xsd:simpleType base="xsd:string">
        <xsd:enumeration value="none"/>
        <xsd:enumeration value="groups"/>
        <xsd:enumeration value="rows"/>
        <xsd:enumeration value="cols"/>
        <xsd:enumeration value="all"/>
      </xsd:simpleType>
    </xsd:attribute>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="CellHAlign.attrib">
    <xsd:annotation>
      <xsd:documentation>
	horizontal alignment attributes for cell contents

	% CellHAlign.attrib
	     "align        ( left
	                   | center
	                   | right
	                   | justify
	                   | char )                 #IMPLIED
	      char         %Character.datatype;     #IMPLIED
	      charoff      %Length.datatype;        #IMPLIED"
      </xsd:documentation>
    </xsd:annotation>

      <xsd:attribute name="align" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="left"/>
          <xsd:enumeration value="center"/>
          <xsd:enumeration value="right"/>
          <xsd:enumeration value="justify"/>
          <xsd:enumeration value="char"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="char" type="html:Character.datatype" use="optional"/>
      <xsd:attribute name="charoff" type="html:Length.datatype" use="optional"/>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="CellVAlign.attrib">
    <xsd:annotation>
      <xsd:documentation>
	vertical alignment attribute for cell contents

	% CellVAlign.attrib
	     "valign       ( top
	                   | middle
	                   | bottom
	                   | baseline )             #IMPLIED"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="valign" use="optional">
      <xsd:simpleType base="xsd:string">
        <xsd:enumeration value="top"/>
        <xsd:enumeration value="middle"/>
        <xsd:enumeration value="bottom"/>
        <xsd:enumeration value="baseline"/>
      </xsd:simpleType>
    </xsd:attribute>
  </xsd:attributeGroup>

  <xsd:attributeGroup name="scope.attrib">
    <xsd:annotation>
      <xsd:documentation>
	scope is simpler than axes attribute for common tables

	% scope.attrib
	     "scope        ( row
	                   | col
	                   | rowgroup
	                   | colgroup )             #IMPLIED"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="scope" use="optional">
      <xsd:simpleType base="xsd:string">
        <xsd:enumeration value="row"/>
        <xsd:enumeration value="col"/>
        <xsd:enumeration value="rowgroup"/>
        <xsd:enumeration value="colgroup"/>
      </xsd:simpleType>
    </xsd:attribute>
  </xsd:attributeGroup>

  <xsd:element name="table" equivClass="html:BlkSpecial.class">
    <xsd:annotation>
      <xsd:documentation>
	table: Table Element

	% table.content
	     "( caption?, ( col* | colgroup* ),
	      (( thead?, tfoot?, tbody+ ) | ( tr+ )))"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="elementOnly"
                     base="html:Common" derivedBy="restriction">
      <xsd:element ref="html:caption" minOccurs="0" maxOccurs="1"/>
      <xsd:choice>
        <xsd:element ref="html:col" minOccurs="0" maxOccurs="unbounded"/>
        <xsd:element ref="html:colgroup" minOccurs="0" maxOccurs="unbounded"/>
      </xsd:choice>
      <xsd:choice>
        <xsd:sequence>
          <xsd:element ref="html:thead" minOccurs="0" maxOccurs="1"/>
          <xsd:element ref="html:tfoot" minOccurs="0" maxOccurs="1"/>
            <xsd:element ref="html:tbody" minOccurs="1" maxOccurs="unbounded"/>
        </xsd:sequence>
        <xsd:sequence>
          <xsd:element ref="html:tr" minOccurs="1" maxOccurs="unbounded"/>
        </xsd:sequence>
      </xsd:choice>
      <xsd:attribute name="summary" type="html:Text.datatype" use="optional"/>
      <xsd:attribute name="width" type="html:Length.datatype" use="optional"/>
      <xsd:attribute name="border" type="html:Pixels.datatype" use="optional"/>
      <xsd:attributeGroup ref="html:frame.attrib"/>
      <xsd:attributeGroup ref="html:rules.attrib"/>
      <xsd:attribute name="cellspacing" type="html:Length.datatype" use="optional"/>
      <xsd:attribute name="cellpadding" type="html:Length.datatype" use="optional"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="caption" type="html:Inline.mix">
    <xsd:annotation>
      <xsd:documentation>caption: Table Caption</xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:complexType name="rowGroupType" content="elementOnly"
                   base="html:Common" derivedBy="restriction">
    <xsd:annotation>
      <xsd:documentation>
	define a complexType for row groups (thead, tfoot, tbody)
      </xsd:documentation>
    </xsd:annotation>

      <xsd:sequence minOccurs="1" maxOccurs="unbounded">
        <xsd:element ref="html:tr"/>
      </xsd:sequence>
      <xsd:attributeGroup ref="html:CellHAlign.attrib"/>
      <xsd:attributeGroup ref="html:CellVAlign.attrib"/>
  </xsd:complexType>

  <xsd:element name="thead" type="html:rowGroupType">
    <xsd:annotation>
      <xsd:documentation>
	thead: Table Header

	Use thead to duplicate headers when breaking table
	across page boundaries, or for static headers when
	tbody sections are rendered in scrolling panel.
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="tfoot" type="html:rowGroupType">
    <xsd:annotation>
      <xsd:documentation>
	tfoot: Table Footer

	Use tfoot to duplicate footers when breaking table
	across page boundaries, or for static footers when
	tbody sections are rendered in scrolling panel.
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="tbody" type="html:rowGroupType">
    <xsd:annotation>
      <xsd:documentation>
	tbody: Table Body

	Use multiple tbody sections when rules are needed
	between groups of table rows.
      </xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="colgroup">
    <xsd:annotation>
      <xsd:documentation>
	colgroup: Table Column Group

	colgroup groups a set of col elements. It allows you
	to group several semantically-related columns together.
      </xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="elementOnly"
                     base="html:Common" derivedBy="restriction">

      <xsd:sequence minOccurs="0" maxOccurs="unbounded">
        <xsd:element ref="html:col"/>
      </xsd:sequence>
      <xsd:attribute name="span" type="xsd:positiveInteger" use="default" value="1"/>
      <xsd:attribute name="width" type="html:MultiLength.datatype" use="optional"/>
      <xsd:attributeGroup ref="html:CellHAlign.attrib"/>
      <xsd:attributeGroup ref="html:CellVAlign.attrib"/>
    </xsd:complexType>
  </xsd:element>


  <xsd:element name="col">
    <xsd:annotation>
      <xsd:documentation>
	col: Table Column

	col elements define the alignment properties for
	cells in one or more columns.

	The width attribute specifies the width of the
	columns, e.g.

	  width="64"        width in screen pixels
	  width="0.5*"      relative width of 0.5

	The span attribute causes the attributes of one
	col element to apply to more than one column.
      </xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="empty">
      <xsd:attributeGroup ref="html:Core.attrib"/>
      <xsd:attributeGroup ref="html:I18n.attrib"/>
      <xsd:attributeGroup ref="html:Events.attrib"/>
      <xsd:attribute name="span" type="xsd:positiveInteger" use="default" value="1"/>
      <xsd:attribute name="width" type="html:MultiLength.datatype" use="optional"/>
      <xsd:attributeGroup ref="html:CellHAlign.attrib"/>
      <xsd:attributeGroup ref="html:CellVAlign.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="tr">
    <xsd:annotation>
      <xsd:documentation>tr: Table Row</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="elementOnly"
                     base="html:Common" derivedBy="restriction">
      <xsd:choice minOccurs="1" maxOccurs="unbounded">
        <xsd:element ref="html:th"/>
        <xsd:element ref="html:td"/>
      </xsd:choice>
      <xsd:attributeGroup ref="html:CellHAlign.attrib"/>
      <xsd:attributeGroup ref="html:CellVAlign.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:complexType name="tableCellType" content="mixed"
                     base="html:Flow.mix" derivedBy="extension">
    <xsd:annotation>
      <xsd:documentation>
	define a complexType for table cells (th and td)

	th is for header cells, td for data,
	but for cells acting as both use td

	attribute value for rowspan and colspan attributes is defined as
	Number.datatype (= xsd:nonNegativeInteger) in DTD, but it should be
	xsd:positiveInteger
      </xsd:documentation>
    </xsd:annotation>

    <xsd:attribute name="abbr" type="html:Text.datatype" use="optional"/>
    <xsd:attribute name="axis" type="xsd:string" use="optional"/>
    <xsd:attribute name="headers" type="xsd:IDREFS" use="optional"/>
    <xsd:attributeGroup ref="html:scope.attrib"/>
    <xsd:attribute name="rowspan" type="xsd:positiveInteger" use="default" value="1"/>
    <xsd:attribute name="colspan" type="xsd:positiveInteger" use="default" value="1"/>
    <xsd:attributeGroup ref="html:CellHAlign.attrib"/>
    <xsd:attributeGroup ref="html:CellVAlign.attrib"/>
  </xsd:complexType>

  <xsd:element name="th" type="html:tableCellType">
    <xsd:annotation>
      <xsd:documentation>th: Table Header Cell</xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:element name="td" type="html:tableCellType">
    <xsd:annotation>
      <xsd:documentation>td: Table Data Cell</xsd:documentation>
    </xsd:annotation>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>

    </xsd:documentation>
  </xsd:annotation>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Forms Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Forms 1.0//EN"
	  SYSTEM "xhtml-form-1.mod"

	Forms

	   form, label, input, select, optgroup, option,
	   textarea, fieldset, legend, button

	This module declares markup to provide support for online
	forms, based on the features found in HTML 4.0 forms.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:complexType name="BlkNoForm.mix" content="mixed"
                   base="html:Common" derivedBy="restriction">
    <xsd:annotation>
      <xsd:documentation>
	%BlkNoForm.mix; includes all non-form block elements,
	plus %Misc.class;

	% BlkNoForm.mix
	     "%Heading.class;
	      | %List.class;
	      | %BlkStruct.class;
	      %BlkPhras.class;
	      %BlkPres.class;
	      | table
	      %Block.extra;
	      %Misc.class;"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:choice minOccurs="0" maxOccurs="unbounded">
      <xsd:element ref="html:Heading.class"/>
      <xsd:element ref="html:List.class"/>
      <xsd:element ref="html:BlkStruct.class"/>
      <xsd:element ref="html:BlkPhras.class"/>
      <xsd:element ref="html:BlkPres.class"/>
      <xsd:element ref="html:table"/>
      <xsd:element ref="html:Block.extra"/>
      <xsd:element ref="html:Edit.class"/>
      <xsd:element ref="html:Script.class"/>
      <xsd:element ref="html:Misc.extra"/>
    </xsd:choice>
  </xsd:complexType>

  <xsd:element name="form" equivClass="html:BlkSpecial.class">
    <xsd:annotation>
      <xsd:documentation>
	form: Form Element

	% form.content
	     "( %BlkNoForm.mix; | fieldset )+"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="elementOnly"
                     base="html:Common" derivedBy="extension">
      <xsd:choice minOccurs="1" maxOccurs="unbounded">
        <xsd:element ref="html:Heading.class"/>
        <xsd:element ref="html:List.class"/>
        <xsd:element ref="html:BlkStruct.class"/>
        <xsd:element ref="html:BlkPhras.class"/>
        <xsd:element ref="html:BlkPres.class"/>
        <xsd:element ref="html:table"/>
        <xsd:element ref="html:Block.extra"/>
        <xsd:element ref="html:Edit.class"/>
        <xsd:element ref="html:Script.class"/>
        <xsd:element ref="html:Misc.extra"/>
        <xsd:element ref="html:fieldset"/>
      </xsd:choice>
      <xsd:attribute name="action" type="html:URI.datatype" use="required"/>
      <xsd:attribute name="method" use="default" value="get">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="get"/>
          <xsd:enumeration value="post"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="enctype" type="html:ContentType.datatype"
                     use="default" value="application/x-www-form-urlencoded"/>
      <xsd:attribute name="accept-charset" type="html:Charsets.datatype"
                     use="optional"/>
      <xsd:attribute name="accept" type="html:ContentTypes.datatype"
                     use="optional"/>
      <xsd:attributeGroup ref="html:form.events.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="label" equivClass="html:InlForm.class">
    <xsd:annotation>
      <xsd:documentation>
	label: Form Field Label Text

	Each label must not contain more than ONE field
      </xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="mixed"
                     base="html:Common" derivedBy="extension">
      <xsd:choice minOccurs="0" maxOccurs="unbounded">
        <xsd:element ref="html:input"/>
        <xsd:element ref="html:select"/>
        <xsd:element ref="html:textarea"/>
        <xsd:element ref="html:button"/>
        <xsd:element ref="html:InlStruct.class"/>
        <xsd:element ref="html:InlPhras.class"/>
        <xsd:element ref="html:I18n.class"/>
        <xsd:element ref="html:InlPres.class"/>
        <xsd:element ref="html:Anchor.class"/>
        <xsd:element ref="html:InlSpecial.class"/>
        <xsd:element ref="html:Inline.extra"/>
        <xsd:element ref="html:Edit.class"/>
        <xsd:element ref="html:Script.class"/>
        <xsd:element ref="html:Misc.extra"/>
      </xsd:choice>
      <xsd:attribute name="for" type="xsd:IDREF" use="optional"/>
      <xsd:attribute name="accesskey" type="html:Character.datatype"
                     use="optional"/>
      <xsd:attributeGroup ref="html:label.events.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:simpleType name="InputType.class" base="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
	% InputType.class
	     "( text | password | checkbox | radio | submit 
	      | reset | file | hidden | image | button )"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:enumeration value="text"/>
    <xsd:enumeration value="password"/>
    <xsd:enumeration value="checkbox"/>
    <xsd:enumeration value="radio"/>
    <xsd:enumeration value="submit"/>
    <xsd:enumeration value="reset"/>
    <xsd:enumeration value="file"/>
    <xsd:enumeration value="hidden"/>
    <xsd:enumeration value="image"/>
    <xsd:enumeration value="button"/>
  </xsd:simpleType>

  <xsd:element name="input" equivClass="html:InlForm.class">
    <xsd:annotation>
      <xsd:documentation>
	input: Form Control

	attribute value for maxlength attribute is defined as
	Number.datatype (= xsd:nonNegativeInteger) in DTD, but it should be
	xsd:positiveInteger
      </xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="empty">
      <xsd:attributeGroup ref="html:Core.attrib"/>
      <xsd:attributeGroup ref="html:I18n.attrib"/>
      <xsd:attributeGroup ref="html:Events.attrib"/>
      <xsd:attribute name="type" use="default" value="text"
                     type="html:InputType.class"/>
      <xsd:attribute name="name" type="xsd:string" use="optional"/>
      <xsd:attribute name="value" type="xsd:string" use="optional"/>
      <xsd:attribute name="checked" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="checked"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="disabled" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="disabled"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="readonly" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="readonly"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="size" type="html:Number.datatype" use="optional"/>
      <xsd:attribute name="maxlength" type="xsd:positiveInteger" use="optional"/>
      <xsd:attribute name="src" type="html:URI.datatype" use="optional"/>
      <xsd:attribute name="alt" type="xsd:string" use="optional"/>
      <xsd:attribute name="tabindex" type="html:tabindexNumber.datatype"
                     use="optional"/>
      <xsd:attribute name="accesskey" type="html:Character.datatype"
                     use="optional"/>
      <xsd:attribute name="accept" type="html:ContentTypes.datatype"
                     use="optional"/>
      <xsd:attributeGroup ref="html:input.events.attrib"/>
      <xsd:attributeGroup ref="html:input.csismap.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="select" equivClass="html:InlForm.class">
    <xsd:annotation>
      <xsd:documentation>select: Option Selector</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="elementOnly"
                     base="html:Common" derivedBy="restriction">
      <xsd:choice minOccurs="1" maxOccurs="unbounded">
        <xsd:element ref="html:optgroup"/>
        <xsd:element ref="html:option"/>
      </xsd:choice>
      <xsd:attribute name="name" type="xsd:string" use="optional"/>
      <xsd:attribute name="size" type="html:Number.datatype" use="optional"/>
      <xsd:attribute name="multiple" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="multiple"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="disabled" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="disabled"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="tabindex" type="html:tabindexNumber.datatype"
                     use="optional"/>
      <xsd:attributeGroup ref="html:select.events.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="optgroup">
    <xsd:annotation>
      <xsd:documentation>optgroup: Option Group</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="elementOnly"
                     base="html:Common" derivedBy="restriction">
      <xsd:sequence minOccurs="1" maxOccurs="unbounded">
        <xsd:element ref="html:option"/>
      </xsd:sequence>
      <xsd:attribute name="disabled" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="disabled"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="label" type="html:Text.datatype" use="required"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="option">
    <xsd:annotation>
      <xsd:documentation>option: Selectable Choice</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="textOnly">
      <xsd:attributeGroup ref="html:Core.attrib"/>
      <xsd:attributeGroup ref="html:I18n.attrib"/>
      <xsd:attributeGroup ref="html:Events.attrib"/>
      <xsd:attribute name="selected" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="selected"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="disabled" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="disabled"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="label" type="html:Text.datatype" use="required"/>
      <xsd:attribute name="value" type="xsd:string" use="optional"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="textarea" equivClass="html:InlForm.class">
    <xsd:annotation>
      <xsd:documentation>textarea: Multi-Line Text Field</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="mixed"
                     base="html:Common" derivedBy="extension">
      <xsd:attribute name="name" type="xsd:string" use="optional"/>
      <xsd:attribute name="rows" type="html:Number.datatype" use="required"/>
      <xsd:attribute name="cols" type="html:Number.datatype" use="required"/>
      <xsd:attribute name="disabled" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="disabled"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="readonly" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="readonly"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="accesskey" type="html:Character.datatype"
                     use="optional"/>
      <xsd:attribute name="tabindex" type="html:tabindexNumber.datatype"
                     use="optional"/>
      <xsd:attributeGroup ref="html:texarea.events.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="fieldset" equivClass="html:BlkSpecial.class">
    <xsd:annotation>
      <xsd:documentation>
	fieldset: Form Control Group

	#PCDATA is to solve the mixed content problem,
	per specification only whitespace is allowed

	% fieldset.content
	     "( #PCDATA | legend | %Flow.mix; )*"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="mixed"
                     base="html:Common" derivedBy="restriction">
      <xsd:choice minOccurs="0" maxOccurs="unbounded">
        <xsd:element ref="html:legend"/>
        <xsd:element ref="html:Heading.class"/>
        <xsd:element ref="html:List.class"/>
        <xsd:element ref="html:BlkStruct.class"/>
        <xsd:element ref="html:BlkPhras.class"/>
        <xsd:element ref="html:BlkPres.class"/>
        <xsd:element ref="html:BlkSpecial.class"/>
        <xsd:element ref="html:Block.extra"/>
        <xsd:element ref="html:InlStruct.class"/>
        <xsd:element ref="html:InlPhras.class"/>
        <xsd:element ref="html:InlPres.class"/>
        <xsd:element ref="html:I18n.class"/>
        <xsd:element ref="html:Anchor.class"/>
        <xsd:element ref="html:InlSpecial.class"/>
        <xsd:element ref="html:InlForm.class"/>
        <xsd:element ref="html:Inline.extra"/>
        <xsd:element ref="html:Ruby.class"/>
        <xsd:element ref="html:Edit.class"/>
        <xsd:element ref="html:Script.class"/>
        <xsd:element ref="html:Misc.extra"/>
      </xsd:choice>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="legend">
    <xsd:annotation>
      <xsd:documentation>legend: Fieldset Legend</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="mixed"
                     base="html:Inline.mix" derivedBy="extension">
      <xsd:attribute name="accesskey" type="html:Character.datatype"
                     use="optional"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:complexType name="button.content" content="mixed"
                   base="html:Common" derivedBy="restriction">
    <xsd:annotation>
      <xsd:documentation>
	% button.content
	     "( #PCDATA
	      | %BlkNoForm.mix;
	      | %InlStruct.class;
	      %InlPhras.class;
	      %InlPres.class;
	      %I18n.class;
	      %InlSpecial.class;
	      %Inline.extra; )*"
      </xsd:documentation>
    </xsd:annotation>

    <xsd:choice minOccurs="0" maxOccurs="unbounded">
      <xsd:element ref="html:Heading.class"/>
      <xsd:element ref="html:List.class"/>
      <xsd:element ref="html:BlkStruct.class"/>
      <xsd:element ref="html:BlkPhras.class"/>
      <xsd:element ref="html:BlkPres.class"/>
      <xsd:element ref="html:table"/>
      <xsd:element ref="html:Block.extra"/>
      <xsd:element ref="html:Edit.class"/>
      <xsd:element ref="html:Script.class"/>
      <xsd:element ref="html:Misc.extra"/>
      <xsd:element ref="html:InlStruct.class"/>
      <xsd:element ref="html:InlPhras.class"/>
      <xsd:element ref="html:InlPres.class"/>
      <xsd:element ref="html:I18n.class"/>
      <xsd:element ref="html:InlSpecial.class"/>
      <xsd:element ref="html:Inline.extra"/>
    </xsd:choice>
  </xsd:complexType>

  <xsd:element name="button" equivClass="html:InlForm.class">
    <xsd:annotation>
      <xsd:documentation>button: Push Button</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="mixed"
                     base="html:button.content" derivedBy="extension">
      <xsd:attribute name="name" type="xsd:string" use="optional"/>
      <xsd:attribute name="value" type="xsd:string" use="optional"/>
      <xsd:attribute name="type" use="default" value="submit">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="button"/>
          <xsd:enumeration value="submit"/>
          <xsd:enumeration value="reset"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="disabled" use="optional">
        <xsd:simpleType base="xsd:string">
          <xsd:enumeration value="disabled"/>
        </xsd:simpleType>
      </xsd:attribute>
      <xsd:attribute name="tabindex" type="html:tabindexNumber.datatype"
                     use="optional"/>
      <xsd:attribute name="accesskey" type="html:Character.datatype"
                     use="optional"/>
      <xsd:attributeGroup ref="html:button.events.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:annotation>
    <xsd:documentation>
	XHTML Structure Module

	This DTD module is identified by the PUBLIC and SYSTEM identifiers:

	  PUBLIC "-//W3C//ELEMENTS XHTML Document Structure 1.0//EN"
	  SYSTEM "xhtml-struct-1.mod"

	Document Structure

	   title, head, body, html

	The Structure Module defines the major structural elements and 
	their attributes.

	Note that the content model of the head element type is redeclared 
	when the Base Module is included in the DTD.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="title">
    <xsd:annotation>
      <xsd:documentation>
	title: Document Title

	The title element is not considered part of the flow of text.
	It should be displayed, for example as the page header or
	window title. Exactly one title is required per document.
      </xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="textOnly">
      <xsd:attributeGroup ref="html:I18n.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="head">
    <xsd:annotation>
      <xsd:documentation>
	head: Document Head

	Note: profile attribute is defined to have %XHTML.profile;
	as default value, but for the moment it's defined to be optional
      </xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="elementOnly">
      <xsd:choice minOccurs="0" maxOccurs="unbounded">
        <xsd:element ref="html:script"/>
        <xsd:element ref="html:HeadOpts.mix"/>
        <xsd:element ref="html:object"/>
      </xsd:choice>
      <xsd:choice>
        <xsd:sequence>
          <xsd:element ref="html:title"/>
          <xsd:choice minOccurs="0" maxOccurs="unbounded">
            <xsd:element ref="html:script"/>
            <xsd:element ref="html:HeadOpts.mix"/>
            <xsd:element ref="html:object"/>
          </xsd:choice>
          <xsd:sequence minOccurs="0" maxOccurs="1">
            <xsd:element ref="html:base"/>
            <xsd:choice minOccurs="0" maxOccurs="unbounded">
              <xsd:element ref="html:script"/>
              <xsd:element ref="html:HeadOpts.mix"/>
              <xsd:element ref="html:object"/>
            </xsd:choice>
          </xsd:sequence>
        </xsd:sequence>
        <xsd:sequence>
          <xsd:element ref="html:base"/>
          <xsd:choice minOccurs="0" maxOccurs="unbounded">
            <xsd:element ref="html:script"/>
            <xsd:element ref="html:HeadOpts.mix"/>
            <xsd:element ref="html:object"/>
          </xsd:choice>
          <xsd:sequence>
            <xsd:element ref="html:title"/>
            <xsd:choice minOccurs="0" maxOccurs="unbounded">
              <xsd:element ref="html:script"/>
              <xsd:element ref="html:HeadOpts.mix"/>
              <xsd:element ref="html:object"/>
            </xsd:choice>
          </xsd:sequence>
        </xsd:sequence>
      </xsd:choice>
      <xsd:attributeGroup ref="html:I18n.attrib"/>
      <xsd:attribute name="profile" type="html:URI.datatype" use="optional"/>
    </xsd:complexType>
  </xsd:element>


  <xsd:complexType name="body.content"
                   base="html:Block.mix" derivedBy="restriction">
    <xsd:annotation>
      <xsd:documentation>
	The content is html:Block.mix, but minOccurs is set to "1"
      </xsd:documentation>
    </xsd:annotation>

      <xsd:choice minOccurs="1" maxOccurs="unbounded">
        <xsd:element ref="html:Heading.class"/>
        <xsd:element ref="html:List.class"/>
        <xsd:element ref="html:BlkStruct.class"/>
        <xsd:element ref="html:BlkPhras.class"/>
        <xsd:element ref="html:BlkPres.class"/>
        <xsd:element ref="html:BlkSpecial.class"/>
        <xsd:element ref="html:Block.extra"/>
        <xsd:element ref="html:Edit.class"/>
        <xsd:element ref="html:Script.class"/>
        <xsd:element ref="html:Misc.extra"/>
      </xsd:choice>
    </xsd:complexType>

  <xsd:element name="body">
    <xsd:annotation>
      <xsd:documentation>body: Document Body</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType base="html:body.content" derivedBy="extension">
      <xsd:attributeGroup ref="html:body.events.attrib"/>
    </xsd:complexType>
  </xsd:element>

  <xsd:element name="html">
    <xsd:annotation>
      <xsd:documentation>html: XHTML Document Element</xsd:documentation>
    </xsd:annotation>

    <xsd:complexType content="elementOnly">
      <xsd:element ref="html:head"/>
      <xsd:element ref="html:body"/>
      <xsd:attribute name="version" type="html:FPI.datatype" use="fixed"
                     value="-//W3C//DTD XHTML 1.1//EN"/>
      <xsd:attributeGroup ref="html:I18n.attrib"/>
    </xsd:complexType>
  </xsd:element>
</xsd:schema>
