<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet href="hcl-stylesheet.css" type="text/css" media="screen"?>
<xs:schema xmlns:xfm="http://www.w3.org/2002/xforms" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:annotation>
        <xs:documentation>
            <title>Host Content Language - Version 1.0</title>
            <key>
                <about>Host Content Language (HCL) is a language to structure and describe generic content for human consumption sent over HTTP or a similar other method of transfer. The objective is to provide a vocabulary and structure that is semantic first and accessible second. The language allows for the integration of any other XML vocabulary as a namespace plugin.</about>
                <key-title>Visual Color Key (for visual users)</key-title><presentation-element/>
                <key-list>
                    <list-item>
                        <element>element</element>
                    </list-item>
                    <list-item>
                        <child-element>child element</child-element>
                    </list-item>
                    <list-item>
                        <group>element group</group>
                    </list-item>
                    <list-item>
                        <child-group>child group</child-group>
                    </list-item>
                    <list-item>
                        <attribute>attribute</attribute>
                    </list-item>
                    <list-item>
                        <attributeGroup>attribute group</attributeGroup>
                    </list-item>
                    <list-item>
                        <complexType>reusable complex type</complexType>
                    </list-item>
                    <list-item>
                        <name>element name</name>
                    </list-item>
                    <list-item>
                        <group-name>element group name</group-name>
                    </list-item>
                    <list-item>
                        <attribute-name>attribute name</attribute-name>
                    </list-item>
                    <list-item>
                        <attribute-group>attribute group name</attribute-group>
                    </list-item>
                    <list-item>
                        <example>element example</example>
                    </list-item>
                    <list-item>
                        <parent>element's parent</parent>
                    </list-item>
                </key-list>
                <presentation-element/>
            </key>
        </xs:documentation>
    </xs:annotation>
    <xs:import schemaLocation="XForms.xsd" namespace="http://www.w3.org/2002/xforms"/>
    <xs:include schemaLocation="mime.xsd"/>
    <xs:element name="hcl">
        <xs:annotation>
            <xs:documentation>
                <name>hcl</name>
                Element hcl is the root element of a HCL document.
                <example>&lt; hcl version="1.0" document-type="application/hcl+xml"&gt;&#8596;&lt; /hcl&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="about">
                    <xs:annotation>
                        <xs:documentation>about (required)</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element ref="content">
                    <xs:annotation>
                        <xs:documentation>content (required)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:sequence>
            <xs:attribute ref="version" use="required">
                <xs:annotation>
                    <xs:documentation>version (required)
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute ref="document-type" use="required">
                <xs:annotation>
                    <xs:documentation>document-type (required)
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:anyAttribute namespace="xmlns"/>
        </xs:complexType>
    </xs:element>
    <xs:attribute fixed="1.0" name="version">
        <xs:annotation>
            <xs:documentation>
                <name>version</name>
                Attribute version is required with a fixed value of "1.0".
                <example>version="1.0"</example>
            </xs:documentation>
        </xs:annotation>
    </xs:attribute>
    <xs:attribute fixed="application/hcl+xml" name="document-type">
        <xs:annotation>
            <xs:documentation>
                <name>document-type</name>
                Attribute document-type is required with a fixed value of "application/hcl+xml".
                <example>document-type="application/hcl+xml"</example>
            </xs:documentation>
        </xs:annotation>
    </xs:attribute>
    <xs:element name="about">
        <xs:annotation>
            <xs:documentation>
                <name>about</name>
                Element about is a child of root element
                <parent>&lt; hcl&gt;</parent>. This element represents a container of meta-data that either contains additional processing instructions for the user-agent software or describes the whole document.
                <example>&lt; about&gt;&lt; page-title/&gt;&lt; character/&gt;&lt; language/&gt;&lt; /about&gt;</example>
                <attribute>no attributes</attribute>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="page-title">
                    <xs:annotation>
                        <xs:documentation>page-title (required)</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element ref="character">
                    <xs:annotation>
                        <xs:documentation>character (required)</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element ref="language">
                    <xs:annotation>
                        <xs:documentation>language (required)</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element minOccurs="0" maxOccurs="unbounded" ref="user-agent">
                    <xs:annotation>
                        <xs:documentation>user-agent (optional)</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element minOccurs="0" ref="presentation">
                    <xs:annotation>
                        <xs:documentation>presentation (optional)</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other">
                    <xs:annotation>
                        <xs:documentation>custom namespace prefixed elements (optional)</xs:documentation>
                    </xs:annotation>
                </xs:any>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="page-title">
        <xs:annotation>
            <xs:documentation>
                <name>page-title</name>
                Element page-title is a child of element
                <parent>&lt; about&gt;</parent>. This element represents a title of the entire document for external use by the user-agent software and web crawling software. This elements stores a normalized string value.
                <example>&lt; page-title&gt;External title representing the entire document.&lt; /page-title&gt;</example>
                <attribute>no attributes</attribute>
                <element>no child elements</element>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:normalizedString"/>
        </xs:simpleType>
    </xs:element>
    <xs:element name="character">
        <xs:annotation>
            <xs:documentation>
                <name>character</name>
                Element character is a child of element
                <parent>&lt; about&gt;</parent>. This element contains the value of the character encoding reference the author intended the document to be processed in accordance with by the user-agent software. This value of this element should match the character encoding actually used by the author to write the document.
                <example>&lt; character&gt;utf-8&lt; /character&gt;</example>
                <value-list>This element may except the following values:
                    <value-item>iso-8859-1</value-item>
                    <value-item>iso-8859-2</value-item>
                    <value-item>iso-8859-3</value-item>
                    <value-item>iso-8859-4</value-item>
                    <value-item>iso-8859-5</value-item>
                    <value-item>iso-8859-6</value-item>
                    <value-item>iso-8859-7</value-item>
                    <value-item>iso-8859-8</value-item>
                    <value-item>iso-8859-9</value-item>
                    <value-item>iso-8859-10</value-item>
                    <value-item>iso-8859-15</value-item>
                    <value-item>iso-8859-16</value-item>
                    <value-item>iso-8859-jp</value-item>
                    <value-item>iso-8859-jp-2</value-item>
                    <value-item>iso-8859-kr</value-item>
                    <value-item>utf-8</value-item>
                    <value-item>utf-16</value-item>
                    <value-item>utf-16be</value-item>
                    <value-item>utf-16le</value-item>
                    <value-item>utf-32</value-item>
                    <value-item>utf-32be</value-item>
                    <value-item>utf-32le</value-item>
                    <value-item>usc-2</value-item>
                    <value-item>usc-2be</value-item>
                    <value-item>usc-2le</value-item>
                    <value-item>usc-4</value-item>
                    <value-item>usc-4be</value-item>
                    <value-item>usc-4le</value-item>
                    <value-item>iso-10646-ucs-2</value-item>
                    <value-item>iso-10646-ucs-4</value-item>
                    <value-item>shift-jis</value-item>
                    <value-item>euc-jp</value-item>
                </value-list>
                <attribute>no attributes</attribute>
                <element>no child elements</element>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:token">
                <xs:enumeration value="iso-8859-1"/>
                <xs:enumeration value="iso-8859-2"/>
                <xs:enumeration value="iso-8859-3"/>
                <xs:enumeration value="iso-8859-4"/>
                <xs:enumeration value="iso-8859-5"/>
                <xs:enumeration value="iso-8859-6"/>
                <xs:enumeration value="iso-8859-7"/>
                <xs:enumeration value="iso-8859-8"/>
                <xs:enumeration value="iso-8859-9"/>
                <xs:enumeration value="iso-8859-10"/>
                <xs:enumeration value="iso-8859-15"/>
                <xs:enumeration value="iso-8859-jp"/>
                <xs:enumeration value="iso-8859-jp-2"/>
                <xs:enumeration value="iso-8859-kr"/>
                <xs:enumeration value="utf-8"/>
                <xs:enumeration value="utf-16"/>
                <xs:enumeration value="utf-16be"/>
                <xs:enumeration value="utf-16le"/>
                <xs:enumeration value="utf-32"/>
                <xs:enumeration value="utf-32be"/>
                <xs:enumeration value="utf-32le"/>
                <xs:enumeration value="usc-2"/>
                <xs:enumeration value="usc-2be"/>
                <xs:enumeration value="usc-2le"/>
                <xs:enumeration value="iso-10646-ucs-2"/>
                <xs:enumeration value="iso-10646-ucs-4"/>
                <xs:enumeration value="shift-jis"/>
                <xs:enumeration value="euc-jp"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:element>
    <xs:element name="language">
        <xs:annotation>
            <xs:documentation>
                <name>language</name>
                Element language, a child of
                <parent>&lt; about&gt;</parent>
                accepts values conforming to XML Schema language simple data type, which is further expanded in RFC 3066. This element serves to identify the default natural, or human written, language of the entire document.
                <example>&lt; language&gt;en-US&lt; /language&gt;</example>
                <attribute>no attributes</attribute>
                <element>no child elements</element>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:language"/>
        </xs:simpleType>
    </xs:element>
    <xs:element name="user-agent">
        <xs:annotation>
            <xs:documentation>
                <name>user-agent</name>
                Element user-agent is a child of element
                <parent>&lt; about&gt;</parent>. This element represents a title of the entire document for external use by the user-agent software and web crawling software. This elements stores a normalized string value.
                <example>&lt; user-agent process="thing to process" function="how to process that thing"/&gt;</example>
                <element>no child elements</element>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute ref="function">
                <xs:annotation>
                    <xs:documentation>function (required)
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute ref="process">
                <xs:annotation>
                    <xs:documentation>process (required)
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:attribute name="function">
        <xs:annotation>
            <xs:documentation>
                <name>function</name>
                Attribute function is a required attribute of element
                <parent>user-agent</parent>
                containing a unique name value.
                <example>function="distribution"</example>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:ID"/>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="process">
        <xs:annotation>
            <xs:documentation>
                <name>process</name>
                Attribute process is a required attribute of element
                <parent>&lt; user-agent&gt;</parent>
                containing a normalized string.
                <example>process="British Virgin Islands"</example>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:normalizedString"/>
        </xs:simpleType>
    </xs:attribute>
    <xs:element name="presentation">
        <xs:annotation>
            <xs:documentation>
                <name>presentation</name>
                Element presentation is a child of element
                <parent>&lt; about&gt;</parent>. This element is a container of stylesheet elements.
                <example>&lt; presentation&gt;&lt; stylesheet/&gt;&lt; /presentation&gt;</example>
                <attribute>no attributes</attribute>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:element maxOccurs="unbounded" ref="stylesheet">
                    <xs:annotation>
                        <xs:documentation>stylesheet (1 or more required)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="stylesheet">
        <xs:annotation>
            <xs:documentation>
                <name>stylesheet</name>
                Element stylesheet is a child of element
                <parent>&lt; presentation&gt;</parent>. This element serves to specify a stylesheet. It excepts only a URI as content. If the content results in text that is not a URI or is a URI that cannot be resolved the failing &lt; stylesheet&gt; must be ignored.
                <example>&lt; stylesheet namespace="car" style-type="text/css"&gt;http://travelocity.com/assets/css/car.css&lt; /stylesheet&gt;</example>
                <element>no child elements</element>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:anyURI">
                    <xs:attribute ref="style-type" use="required">
                        <xs:annotation>
                            <xs:documentation>style-type (required)</xs:documentation>
                        </xs:annotation>
                    </xs:attribute>
                    <xs:attribute ref="style-namespace" use="required">
                        <xs:annotation>
                            <xs:documentation>style-namespace (required)</xs:documentation>
                        </xs:annotation>
                    </xs:attribute>
                    <xs:attribute default="screen" ref="media" use="optional">
                        <xs:annotation>
                            <xs:documentation>media (optional)</xs:documentation>
                        </xs:annotation>
                    </xs:attribute>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:attribute name="style-type">
        <xs:annotation>
            <xs:documentation>
                <name>style-type</name>
                Attribute style-type is a required attribute of
                <parent>style-type</parent>
                defines how the requested stylesheet must be processed. The appropriate values are:
                <example>style-type="text/css"</example>
                <value-list>
                    <value-item>text/css</value-item>
                    <value-item>application/xslt+xml</value-item>
                </value-list>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:token">
                <xs:enumeration value="text/css"/>
                <xs:enumeration value="application/xslt+xml"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="style-namespace">
        <xs:annotation>
            <xs:documentation>
                <name>style-namespace</name>
                Attribute style-namespace is a required attribute of
                <parent>stylesheet</parent>
                that defines a namespace prefix to designate which style reference is associated with which stylesheet.
                <example>style-namespace="hotels"</example>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:ID">
                <xs:pattern value="[a-zA-Z0-9]+"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="media">
        <xs:annotation>
            <xs:documentation>
                <name>media</name>
                Attribute media is an optional attribute of
                <parent>stylesheet</parent>
                that defines the intended output media the stylesheet is intended to provide presentation for. If this attribute is not specified a value of "screen" must be assumed. Acceptable values are:
                <example>media="braille"</example>
                <value-list>List defined by W3C: http://www.w3.org/TR/CSS2/media.html
                    <value-item>all</value-item>
                    <value-item>aural</value-item>
                    <value-item>braille</value-item>
                    <value-item>embossed</value-item>
                    <value-item>handheld</value-item>
                    <value-item>print</value-item>
                    <value-item>projection</value-item>
                    <value-item>screen</value-item>
                    <value-item>tty</value-item>
                    <value-item>tv</value-item>
                </value-list>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:token">
                <xs:enumeration value="all"/>
                <xs:enumeration value="aural"/>
                <xs:enumeration value="braille"/>
                <xs:enumeration value="embossed"/>
                <xs:enumeration value="handheld"/>
                <xs:enumeration value="print"/>
                <xs:enumeration value="projection"/>
                <xs:enumeration value="screen"/>
                <xs:enumeration value="tty"/>
                <xs:enumeration value="tv"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:element name="content">
        <xs:annotation>
            <xs:documentation>
                <name>content</name>
                Element content is a child of root element
                <parent>&lt; hcl&gt;</parent>. This element serves as a container for all human consumable content.
                <example>&lt; content&gt;&#8596;&lt; /content&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:choice maxOccurs="unbounded">
                    <xs:group ref="complex-blocks">
                        <xs:annotation>
                            <xs:documentation>complex-blocks</xs:documentation>
                        </xs:annotation>
                    </xs:group>
                    <xs:group ref="simple-blocks">
                        <xs:annotation>
                            <xs:documentation>simple-blocks</xs:documentation>
                        </xs:annotation>
                    </xs:group>
                    <xs:any namespace="##other">
                        <xs:annotation>
                            <xs:documentation>custom namespace prefixed elements (optional)</xs:documentation>
                        </xs:annotation>
                    </xs:any>
                </xs:choice>
                <xs:element maxOccurs="unbounded" minOccurs="0" ref="script">
                    <xs:annotation>
                        <xs:documentation>script (optional and may occur more than once, but must be the last child element of parent &lt; content&gt;)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:sequence>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
            <xs:attributeGroup ref="inter-attrs">
                <xs:annotation>
                    <xs:documentation>inter-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:attributeGroup name="core-attrs">
        <xs:annotation>
            <xs:documentation>
                <name>core-attrs</name>
                A group of universally allowed attributes.
            </xs:documentation>
        </xs:annotation>
        <xs:attribute ref="id" use="optional">
            <xs:annotation>
                <xs:documentation>id (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute ref="style" use="optional">
            <xs:annotation>
                <xs:documentation>style (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute ref="title" use="optional">
            <xs:annotation>
                <xs:documentation>title (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute ref="role" use="optional">
            <xs:annotation>
                <xs:documentation>role (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:attributeGroup>
    <xs:attributeGroup name="core-attrs-uri">
        <xs:annotation>
            <xs:documentation>
                <name>core-attrs-uri</name>
                A group of universally allowed attributes plue attribute "uri".
            </xs:documentation>
        </xs:annotation>
        <xs:attribute ref="id" use="optional">
            <xs:annotation>
                <xs:documentation>id (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute ref="style" use="optional">
            <xs:annotation>
                <xs:documentation>style (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute ref="title" use="optional">
            <xs:annotation>
                <xs:documentation>title (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute ref="role" use="optional">
            <xs:annotation>
                <xs:documentation>role (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute ref="uri" use="optional">
            <xs:annotation>
                <xs:documentation>uri (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:attributeGroup>
    <xs:attributeGroup name="inter-attrs">
        <xs:annotation>
            <xs:documentation>
                <name>inter-attrs</name>
                A group of internationalization attributes.
            </xs:documentation>
        </xs:annotation>
        <xs:attribute default="tl" ref="direction" use="optional">
            <xs:annotation>
                <xs:documentation>direction (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute default="horizontal" ref="orientation" use="optional">
            <xs:annotation>
                <xs:documentation>orientation (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute default="standard" ref="wrap" use="optional">
            <xs:annotation>
                <xs:documentation>wrap (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute default="en" ref="section-language" use="optional">
            <xs:annotation>
                <xs:documentation>section-language (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:attributeGroup>
    <xs:attributeGroup name="cell-attrs">
        <xs:annotation>
            <xs:documentation>
                <name>cell-attrs</name>
                A group of attributes for &lt; table-cell&gt; and &lt; head-cell&lt;  elements.
            </xs:documentation>
        </xs:annotation>
        <xs:attribute default="1" ref="span-column" use="optional">
            <xs:annotation>
                <xs:documentation>span-column (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute default="1" ref="span-row" use="optional">
            <xs:annotation>
                <xs:documentation>span-row (optional)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:attributeGroup>
    <xs:attribute name="id">
        <xs:annotation>
            <xs:documentation>
                <name>id</name>
                Attribute id is a member of
                <parent>core-attrs</parent>
                attribute group and
                <parent>core-attrs-uri</parent>
                attribute group. It allows a unique name value. If the value supplied is either not unique or a non-colonized name an error will be reported.
                <example>id="uniqueToken"</example>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:ID">
                <xs:minLength value="2"/>
                <xs:pattern value="[a-zA-Z0-9]+"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="style">
        <xs:annotation>
            <xs:documentation>
                <name>style</name>
                Attribute style is a member of
                <parent>core-attrs</parent>
                attribute group and
                <parent>core-attrs-uri</parent>
                attribute group that stores a name value to reference a presentation property from a stylesheet. The supplied value does not have to be unique. It does, however, have to be prefixed with the appropriate namespace prefix as specified in the &lt; style-namespace&gt; element of the stylesheet it is referencing.
                <example>style="cars:subtitle"</example>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:token">
                <xs:minLength value="4"/>
                <xs:pattern value="[a-zA-Z0-9]+:[a-zA-Z0-9]+"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="title">
        <xs:annotation>
            <xs:documentation>
                <name>title</name>
                Attribute title is a member of
                <parent>core-attrs</parent>
                attribute group and
                <parent>core-attrs-uri</parent>
                attribute group that stores a string value to represent any additional data an author may wish to supply to the markup without that content being explicitly processed as content output. The value supplied in this attribute will be available for data processing at the user-agent for the user's benefit, such as a tool tip, even if it is not explicitly parsed into the content.
                <example>title="The content of this element updated 31 October 2009 by employee #289532."</example>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:normalizedString">
                <xs:minLength value="2"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="role">
        <xs:annotation>
            <xs:documentation>
                <name>role</name>
                Attribute role is a member of
                <parent>core-attrs</parent>
                attribute group and
                <parent>core-attrs-uri</parent>
                attribute group that stores a name value, which may or may not be a namespace prefixed name and is not required to be unique. The value of this attribute can be used to include functional values from other namespaces, such as ARIA or RDF. If no namespace prefix is supplied for the given value then a semantic quality must be presumed, where the intent of value is to more specificly define the element opposed to the generic element name. A value should not be applied that contradicts or challenges the definition of the element name.
                <example>role="catalogue:undergraduate"</example>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:Name">
                <xs:minLength value="2"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="uri">
        <xs:annotation>
            <xs:documentation>
                <name>uri</name>
                Attribute uri is a member of
                <parent>core-attrs-uri</parent>
                attribute group and is a required attribute for several elements. This attribute supplies a URI value for hyperlinking. If this attribute is present a hyperlink must exist. If this attribute is not present a hyperlink must not exist. This value of this attribute should be a well formed URI according to RFC 3986 or RFC 2368 for email addresses. The value of this attribute does not have to resolve to a resource.
                <example>uri="http://www.travelocity.com/"</example>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:anyURI">
                <xs:minLength value="5"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="direction">
        <xs:annotation>
            <xs:documentation>
                <name>direction</name>
                Attribute direction, a member of
                <parent>inter-attrs</parent>
                attribute group, defines the direction of text within a given container.
                <example>direction="br"</example>
                <value-list>
                    There are two possible values:
                    <value-item>tl</value-item>
                    <value-item>br</value-item>
                </value-list>
                Value "tl" means that text starts from either the left or top depending upon the vertical or horizontal orientation of text in the given block. Value "br" indicates starts from the right or bottom of the containing block.</xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:token">
                <xs:enumeration value="tl"/>
                <xs:enumeration value="br"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="orientation">
        <xs:annotation>
            <xs:documentation>
                <name>orientation</name>
                Attribute orientation, a member of
                <parent>inter-attrs</parent>
                attribute group, defines the directional flow of text, horizontally or vertically, within the given block.
                <example>orientation="vertical"</example>
                <value-list>There are two possible values:
                    <value-item>horizontal</value-item>
                    <value-item>vertical</value-item>
                </value-list>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:token">
                <xs:enumeration value="horizontal"/>
                <xs:enumeration value="vertical"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="wrap">
        <xs:annotation>
            <xs:documentation>
                <name>wrap</name>
                Attribute wrap, a member of
                <parent>inter-attrs</parent>
                attribute group, defines the direction in which text wraps onto a new line.
                <example>wrap="reverse"</example>
                <value-list>The appropriate values are:
                    <value-item>standard</value-item>
                    <value-item>reverse</value-item>
                    <value-item>none</value-item>
                </value-list>
                A value of standard will cause text to wrap down if it is horizontally oriented or to the left if it is vertically oriented. The value "reverse" forces text to wrap in the direction opposite of the "standard" value. The value "none" prevents text from wrapping. If the value "none" is applied and the text line exceeds the width of the parent container, or height for vertically oriented text, then the containing block must stretch to accomodate the contained text.</xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:token">
                <xs:enumeration value="standard"/>
                <xs:enumeration value="reverse"/>
                <xs:enumeration value="none"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="section-language">
        <xs:annotation>
            <xs:documentation>
                <name>section-language</name>
                The attribute section-language, a member of
                <parent>inter-attrs</parent>
                attribute group, defines a change of natural human language from the default natural human language specified in the &lt; languge&gt; element.
                <example>section-language="en-US"</example>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:language">
                <xs:minLength value="2"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="refer">
        <xs:annotation>
            <xs:documentation>
                <name>refer</name>
                Attribute refer must have a value match the id attribute value of another element. If the supplied value for the refer attribute does not match the value of an id attribute on another element an error will be produced.
                <example>refer="vacationID-3456"</example>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:IDREF">
                <xs:minLength value="2"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="span-column">
        <xs:annotation>
            <xs:documentation>
                <name>span-column</name>
                Attribute span-column, a member of
                <parent>cell-attrs</parent>
                attribute group, allows a &lt; table-cell&gt; or &lt; head-cell&gt; element to span multiple columns. The value for this attribute must be a positive integer.
                <example>span-column="3"</example>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:positiveInteger"/>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="span-row">
        <xs:annotation>
            <xs:documentation>
                <name>span-row</name>
                Attribute span-row, a member of
                <parent>cell-attrs</parent>
                attribute group, allows a &lt; table-cell&gt; or &lt; head-cell&gt; element to span multiple rows. The value for this attribute must be a positive integer.
                <example>span-row="2"</example>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:positiveInteger"/>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="scope">
        <xs:annotation>
            <xs:documentation>
                <name>scope</name>
                Attribute scope is used in table
                <parent>&lt; head-cell&gt;</parent>
                elements to determine which &lt; table-cell&gt; elements the &lt; head-cell&gt; is providing a heading for.
                <example>scope="group-column"</example>
                <value-list>The acceptable values are:
                    <value-item>column</value-item>
                    <value-item>row</value-item>
                    <value-item>group-column</value-item>
                    <value-item>group-row</value-item>
                </value-list>
                The value "column" indicates the &lt; head-cell&gt; is providing meta-data for cells in the first single column occupied by that &lt; head-cell&gt; element. The value "row" indicates the &lt; head-cell&gt; is providing meta-data for the cells in the first single row occupied by that &lt; head-cell&gt; element. The value "group-column" indicates the &lt; head-cell&gt; is providing meta-data to all columns occupied by a &lt; head-cell&gt; element. The value "group-row" indicates the &lt; head-cell&gt; provides meta-data for all rows occupied by that &lt; head-cell&gt; element.
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:token">
                <xs:enumeration value="column"/>
                <xs:enumeration value="row"/>
                <xs:enumeration value="group-column"/>
                <xs:enumeration value="group-row"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="long-form">
        <xs:annotation>
            <xs:documentation>
                <name>long-form</name>
                Attribute long-form, used with element
                <parent>&lt; short&gt;</parent>, defines the designated expanded representation of condensed text, such as an abbrievation or an acronymn.
                <example>long-form="representational state transfer"</example>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:token">
                <xs:minLength value="5"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:attribute>
    <xs:group name="complex-blocks">
        <xs:annotation>
            <xs:documentation>
                <name>complex-blocks - (choice of the following)</name>
                A group of block elements capable of containing other block elements, but not text.
            </xs:documentation>
        </xs:annotation>
        <xs:choice>
            <xs:group ref="list-group">
                <xs:annotation>
                    <xs:documentation>list-group</xs:documentation>
                </xs:annotation>
            </xs:group>
            <xs:element ref="table">
                <xs:annotation>
                    <xs:documentation>table</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="section">
                <xs:annotation>
                    <xs:documentation>section</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="form">
                <xs:annotation>
                    <xs:documentation>form</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:choice>
    </xs:group>
    <xs:group name="simple-blocks">
        <xs:annotation>
            <xs:documentation>
                <name>simple-blocks - (choice of the following)</name>
                A group of block elements capable of containing text, but not other block elements.
            </xs:documentation>
        </xs:annotation>
        <xs:choice>
            <xs:element ref="block-code">
                <xs:annotation>
                    <xs:documentation>block-code</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="block-quote">
                <xs:annotation>
                    <xs:documentation>block-quote</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="citation">
                <xs:annotation>
                    <xs:documentation>citation</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="heading">
                <xs:annotation>
                    <xs:documentation>heading</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="object">
                <xs:annotation>
                    <xs:documentation>object</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="paragraph">
                <xs:annotation>
                    <xs:documentation>paragraph</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="separator">
                <xs:annotation>
                    <xs:documentation>separator</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:choice>
    </xs:group>
    <xs:complexType name="simple-blocks-type" mixed="true">
        <xs:annotation>
            <xs:documentation>
                <name>simple-blocks-type</name>
            </xs:documentation>
        </xs:annotation>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="inline">
            <xs:annotation>
                <xs:documentation>inline (optional, but may occur more than once)</xs:documentation>
            </xs:annotation>
        </xs:group>
        <xs:attributeGroup ref="core-attrs">
            <xs:annotation>
                <xs:documentation>core-attrs</xs:documentation>
            </xs:annotation>
        </xs:attributeGroup>
        <xs:attributeGroup ref="inter-attrs">
            <xs:annotation>
                <xs:documentation>inter-attrs</xs:documentation>
            </xs:annotation>
        </xs:attributeGroup>
    </xs:complexType>
    <xs:group name="inline">
        <xs:annotation>
            <xs:documentation>
                <name>inline - (choice of the following)</name>
                A group of elements capable of containing text only, except for element &lt; format&gt;.
            </xs:documentation>
        </xs:annotation>
        <xs:choice>
            <xs:group ref="xfm:Form.Controls">
                <xs:annotation>
                    <xs:documentation>xfm:Form.Controls</xs:documentation>
                </xs:annotation>
            </xs:group>
            <xs:element ref="short">
                <xs:annotation>
                    <xs:documentation>short</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="button">
                <xs:annotation>
                    <xs:documentation>button</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="cite">
                <xs:annotation>
                    <xs:documentation>cite</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="emphasis">
                <xs:annotation>
                    <xs:documentation>emphasis</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="identifier">
                <xs:annotation>
                    <xs:documentation>identifier</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="quote">
                <xs:annotation>
                    <xs:documentation>quote</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="format">
                <xs:annotation>
                    <xs:documentation>format</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="strong">
                <xs:annotation>
                    <xs:documentation>strong</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="title">
                <xs:annotation>
                    <xs:documentation>title</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:choice>
    </xs:group>
    <xs:group name="object-group">
        <xs:annotation>
            <xs:documentation>
                <name>object-group</name>
                A group of elements for the &lt; object&gt; element and &lt; nav-object&gt; element.
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="object-text">
                <xs:annotation>
                    <xs:documentation>object-text (required)</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="object-uri">
                <xs:annotation>
                    <xs:documentation>object-uri (required)</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="object-type">
                <xs:annotation>
                    <xs:documentation>object-type (required)</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:group minOccurs="0" maxOccurs="unbounded" ref="inline">
                <xs:annotation>
                    <xs:documentation>inline (optional, but may occur more than once)</xs:documentation>
                </xs:annotation>
            </xs:group>
        </xs:sequence>
    </xs:group>
    <xs:complexType name="inline-base">
        <xs:annotation>
            <xs:documentation>
                <name>inline-base</name>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attributeGroup ref="core-attrs-uri">
                    <xs:annotation>
                        <xs:documentation>core-attrs-uri</xs:documentation>
                    </xs:annotation>
                </xs:attributeGroup>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="inline-type">
        <xs:annotation>
            <xs:documentation>
                <name>inline-type</name>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleContent>
            <xs:restriction base="inline-base">
                <xs:minLength value="1"/>
            </xs:restriction>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="format-type" mixed="true">
        <xs:annotation>
            <xs:documentation>
                <name>format-type</name>
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="format">
                <xs:annotation>
                    <xs:documentation>format (optional, but may occur more than once)</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
        <xs:attributeGroup ref="core-attrs-uri">
            <xs:annotation>
                <xs:documentation>core-attrs-uri</xs:documentation>
            </xs:annotation>
        </xs:attributeGroup>
    </xs:complexType>
    <xs:group name="list-group">
        <xs:annotation>
            <xs:documentation>
                <name>list-group - (choice of the following)</name>
                A group of elements that are containing blocks for various forms of lists.
            </xs:documentation>
        </xs:annotation>
        <xs:choice>
            <xs:element ref="define-list">
                <xs:annotation>
                    <xs:documentation>define-list</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="navigation-list">
                <xs:annotation>
                    <xs:documentation>navigation-list</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="order-list">
                <xs:annotation>
                    <xs:documentation>order-list</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element ref="unorder-list">
                <xs:annotation>
                    <xs:documentation>unorder-list</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:choice>
    </xs:group>
    <xs:complexType name="nesting-block">
        <xs:annotation>
            <xs:documentation>
                <name>nesting-block</name>
                (unlimited choice of the following)</xs:documentation>
        </xs:annotation>
        <xs:choice maxOccurs="unbounded">
            <xs:group ref="complex-blocks">
                <xs:annotation>
                    <xs:documentation>complex-blocks</xs:documentation>
                </xs:annotation>
            </xs:group>
            <xs:group ref="simple-blocks">
                <xs:annotation>
                    <xs:documentation>simple-blocks</xs:documentation>
                </xs:annotation>
            </xs:group>
            <xs:any namespace="##other">
                <xs:annotation>
                    <xs:documentation>custom namespace prefixed elements (optional)</xs:documentation>
                </xs:annotation>
            </xs:any>
        </xs:choice>
    </xs:complexType>
    <xs:element name="define-list">
        <xs:annotation>
            <xs:documentation>
                <name>define-list</name>
                Element define-list is a member of
                <parent>list-group</parent>
                element group. This element is a list of definition items.
                <example>&lt; define-list&gt;&lt; define-item/&gt;&lt; /define-list&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:element maxOccurs="unbounded" ref="define-item">
                    <xs:annotation>
                        <xs:documentation>define-item (required and may occur more than once)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:sequence>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="define-item">
        <xs:annotation>
            <xs:documentation>
                <name>define-item</name>
                Element define-item, a child of
                <parent>&lt; define-item&gt;</parent>, is a single definition item in a definition list. This child elements are both allowed more than once because the relationship between a term and potential definitions may be one to one or one to many. A single definition may also represent multiple separate terms and as a result the relationship between a definition and its terms may be one to one or one to many.
                <example>&lt; define-item&gt;&lt; define-term&gt;a term to define&lt; /define-term&gt;&lt; definition&gt;The term's definition&lt; /definition&gt;&lt; /define-item&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:element maxOccurs="unbounded" ref="define-term">
                    <xs:annotation>
                        <xs:documentation>define-term (required and may occur more than once)</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element maxOccurs="unbounded" ref="definition">
                    <xs:annotation>
                        <xs:documentation>definition (required and may occur more than once)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:sequence>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="define-term">
        <xs:annotation>
            <xs:documentation>
                <name>define-term</name>
                Element define-term, a child of
                <parent>&lt; define-item&gt;</parent>, stores a defining term in the definition item. The value for this element must be a normalized string, which allows a term of more than one word to be represented.
                <example>&lt; define-term&gt;cognitive conservatism&lt; /define-term&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:normalizedString">
                    <xs:attributeGroup ref="core-attrs-uri">
                        <xs:annotation>
                            <xs:documentation>core-attrs-uri</xs:documentation>
                        </xs:annotation>
                    </xs:attributeGroup>
                    <xs:attributeGroup ref="inter-attrs">
                        <xs:annotation>
                            <xs:documentation>inter-attrs</xs:documentation>
                        </xs:annotation>
                    </xs:attributeGroup>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="definition">
        <xs:annotation>
            <xs:documentation>
                <name>definition</name>
                Element definition, a child of
                <parent>&lt; define-item&gt;</parent>, stores a definition in the definition item.
                <example>&lt; documentation&gt;A behaviorial state where a subject demonstrates an &lt; emphasis&gt;inability&lt; /emphasis&gt; to alter prior formed conclusions dispite rational evidence challenging such conclusions.&lt; /definition&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType mixed="true">
            <xs:group minOccurs="0" maxOccurs="unbounded" ref="inline">
                <xs:annotation>
                    <xs:documentation>inline</xs:documentation>
                </xs:annotation>
            </xs:group>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
            <xs:attributeGroup ref="inter-attrs">
                <xs:annotation>
                    <xs:documentation>inter-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="navigation-list">
        <xs:annotation>
            <xs:documentation>
                <name>navigation-list</name>
                Element navigation-list, a member of
                <parent>list-group</parent>
                element group, allows for the creation of a list of child elements whose purpose is to provide a system of navigation, such as a menu or site map.
                <example>&lt; navigation-list&gt;&lt; navigation-item/&gt;&lt; navigation-list&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:choice minOccurs="0">
                    <xs:element ref="heading">
                        <xs:annotation>
                            <xs:documentation>heading (optional, but is a choice between a &lt; heading&gt; element and a &lt; identifier&gt; element)</xs:documentation>
                        </xs:annotation>
                    </xs:element>
                    <xs:element ref="identifier">
                        <xs:annotation>
                            <xs:documentation>identifier (optional, but is a choice between a &lt; heading&gt; element and a &lt; identifier&gt; element)</xs:documentation>
                        </xs:annotation>
                    </xs:element>
                </xs:choice>
                <xs:element maxOccurs="unbounded" ref="navigation-item">
                    <xs:annotation>
                        <xs:documentation>navigation-item (required and may occur more than once)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:sequence>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="navigation-item">
        <xs:annotation>
            <xs:documentation>
                <name>navigation-item</name>
                Element navigation-item, a child of
                <parent>&lt; navigation-list&gt;</parent>, is a single navigation item in a navigation list.
                <example>&lt; navigation-item&gt;&lt; navigation-object&gt;&lt; /navigation-item&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:choice>
                <xs:element ref="navigation-object">
                    <xs:annotation>
                        <xs:documentation>navigation-object (required, but is a choice between a &lt; navigation-object&gt; element and a &lt; navigation-text&gt; element)</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element ref="navigation-text">
                    <xs:annotation>
                        <xs:documentation>navigation-text (required, but is a choice between a &lt; navigation-object&gt; element and a &lt; navigation-text&gt; element)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:choice>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
            <xs:attribute ref="uri" use="required">
                <xs:annotation>
                    <xs:documentation>uri (required)</xs:documentation>
                </xs:annotation>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="navigation-object">
        <xs:annotation>
            <xs:documentation>
                <name>navigation-object</name>
                Element navigation-object, a child of
                <parent>&lt; navigation-item&gt;</parent>, stores elements necessary to process a media object specifically used in a navigation list.
                <example>&lt; navigation-object&gt;&lt; object-text&gt;some text&lt; object-text&gt;&lt; object-uri&gt;http://www.travelocity.com/image.jpg&lt; object-uri&gt;&lt; object-type&gt;&lt; image&gt;jpeg&lt; image&gt;&lt; /object-type&gt;&lt; /navigation-object&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="object-text">
                    <xs:annotation>
                        <xs:documentation>object-text (required)</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element ref="object-uri">
                    <xs:annotation>
                        <xs:documentation>object-uri (required)</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element ref="object-type">
                    <xs:annotation>
                        <xs:documentation>object-type (required)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:sequence>
            <xs:attributeGroup ref="inter-attrs">
                <xs:annotation>
                    <xs:documentation>inter-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="object-text">
        <xs:annotation>
            <xs:documentation>
                <name>object-text</name>
                Element object-text stores a text representation of the media object requested by peer elements. The default presentation of this element is a decision left to the user-agent software, which means the text may appear by default as in a caption or may be hidden from visible view by default. If this element is not visible by default it should become visible if the requested media cannot be resolved or cannot be processed according to its defined mime-type.
                <example>&lt; object-text&gt;This is text that assists accessibility for persons unable to process the intended media and acts as alternate content.&lt; /object-text&gt;</example>
                <element>no child elements</element>
                <attribute>no attributes</attribute>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:normalizedString"/>
        </xs:simpleType>
    </xs:element>
    <xs:element name="object-uri">
        <xs:annotation>
            <xs:documentation>
                <name>object-uri</name>
                Element object-uri stores the URI location of a media object. It is not required that the provided URI be resolvable, but the URI must be well formed in accordance with RFC 3986. If the URI cannot be resolved then the text stored in the adjacent &lt; object-text&gt; element must be rendered as content.
                <example>&lt; object-uri&gt;http://www.travelocity.com/assets/images/car0567392.swf&lt; /object-uri&gt;</example>
                <element>no child elements</element>
                <attribute>no attributes</attribute>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleType>
            <xs:restriction base="xs:anyURI"/>
        </xs:simpleType>
    </xs:element>
    <xs:element name="object-type" type="mime-type">
        <xs:annotation>
            <xs:documentation>
                <name>object-type</name>
                Element object-type contains the mime type definition of the intended media. The media must be executed only according this specified type. If the media cannot be specified according to this media type then it must not be processed and the text stored in the adjacent &lt; object-text&gt; should be parsed as content instead. This element is of custom type "mime-type" as defined in the included mime.xsd schema.
                <example>&lt; object-type&gt;&lt; video&gt;H264&lt; /video&gt;&lt; /object-type&gt;</example>
                <attribute>no attributes</attribute>
            </xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:element name="navigation-text">
        <xs:annotation>
            <xs:documentation>
                <name>navigation-text</name>
                Element navigation-text, a child of
                <parent>navigation-item</parent>, stores text that is to represent a text hyperlink in a navigation list.
                <example>&lt; navigation-text&gt;Menu Link Text&lt; /navigation-text&gt;</example>
                <element>no child elements</element>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attributeGroup ref="inter-attrs">
                        <xs:annotation>
                            <xs:documentation>inter-attrs</xs:documentation>
                        </xs:annotation>
                    </xs:attributeGroup>
                    <xs:attributeGroup ref="core-attrs">
                        <xs:annotation>
                            <xs:documentation>core-attrs</xs:documentation>
                        </xs:annotation>
                    </xs:attributeGroup>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="order-list">
        <xs:annotation>
            <xs:documentation>
                <name>order-list</name>
                Element order-list, a member of
                <parent>list-group</parent>
                element group, is an ordered list where each list item is enumerated in the meta-data so that the relative placement of a particular list item relevant to a different list item of the same list is data valid to the description of the list items.
                <example>&lt; order-list&gt;&lt; list-item/&gt;&lt; /order-list&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:choice minOccurs="0">
                    <xs:element ref="heading">
                        <xs:annotation>
                            <xs:documentation>heading (optional, but is a choice between a &lt; heading&gt; element and a &lt; identifier&gt; element)</xs:documentation>
                        </xs:annotation>
                    </xs:element>
                    <xs:element ref="identifier">
                        <xs:annotation>
                            <xs:documentation>identifier (optional, but is a choice between a &lt; heading&gt; element and a &lt; identifier&gt; element)</xs:documentation>
                        </xs:annotation>
                    </xs:element>
                </xs:choice>
                <xs:element maxOccurs="unbounded" ref="list-item">
                    <xs:annotation>
                        <xs:documentation>list-item (required and may occur more than once)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:sequence>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="unorder-list">
        <xs:annotation>
            <xs:documentation>
                <name>unorder-list</name>
                Element unorder-list, a member of
                <parent>list-group</parent>
                element group, is an unorderd list where each list item is not enumerated in the list. This allows all list items to be of equal prominance and standing with regard to each of their relative positions in the list's order of items.
                <example>&lt; unorder-list&gt;&lt; list-item/&gt;&lt; /unorder-list&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:choice minOccurs="0">
                    <xs:element ref="heading">
                        <xs:annotation>
                            <xs:documentation>heading (optional, but is a choice between a &lt; heading&gt; element and a &lt; identifier&gt; element)</xs:documentation>
                        </xs:annotation>
                    </xs:element>
                    <xs:element ref="identifier">
                        <xs:annotation>
                            <xs:documentation>identifier (optional, but is a choice between a &lt; heading&gt; element and a &lt; identifier&gt; element)</xs:documentation>
                        </xs:annotation>
                    </xs:element>
                </xs:choice>
                <xs:element maxOccurs="unbounded" ref="list-item">
                    <xs:annotation>
                        <xs:documentation>list-item (required and may occur more than once)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:sequence>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="list-item">
        <xs:annotation>
            <xs:documentation>
                <name>list-item</name>
                Element list-item, a child of
                <parent>&lt; order-list&gt;</parent>
                and
                <parent>&lt; unorder-list&gt;</parent>, is a single listed item of either an ordered list or an unorderd list. This element may contain simple block elements or may contain text and inline elements.
                <example>&lt; list-item&gt;An &lt; strong&gt;item&lt; /strong&gt; in a list.&lt; /list-item&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType mixed="true">
            <xs:choice>
                <xs:group ref="simple-blocks">
                    <xs:annotation>
                        <xs:documentation>simple-blocks (choice between simple-blocks group and inline group)</xs:documentation>
                    </xs:annotation>
                </xs:group>
                <xs:group maxOccurs="unbounded" ref="inline">
                    <xs:annotation>
                        <xs:documentation>inline (choice between simple-blocks group and inline group, inline group elements may occur more than once)</xs:documentation>
                    </xs:annotation>
                </xs:group>
            </xs:choice>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
            <xs:attributeGroup ref="inter-attrs">
                <xs:annotation>
                    <xs:documentation>inter-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="form">
        <xs:annotation>
            <xs:documentation>
                <name>form</name>
                Element form, a member of
                <parent>complex-blocks</parent>
                element group, serves as a complex block container for XForms 1.1 model definitions and a complex block container for form elements and simple blocks.
                <example>&lt; form&gt;&lt; xfm:model/&gt;&lt; form-body/&gt;&lt; /form&gt;</example>
                <attribute>no attributes</attribute>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="xfm:model">
                    <xs:annotation>
                        <xs:documentation>xfm:model (required)</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element ref="form-body">
                    <xs:annotation>
                        <xs:documentation>form-body (required)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="form-body">
        <xs:annotation>
            <xs:documentation>
                <name>form-body</name>
                Element form-body, a child of
                <parent>&lt; form&gt;</parent>, represents the content body of the form available for consumption and interaction from participants of the user-agent software.
                <example>&lt; form-body&gt;&#8596;&lt; /form-body&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:choice maxOccurs="unbounded">
                <xs:group ref="list-group">
                    <xs:annotation>
                        <xs:documentation>list-group (optional)</xs:documentation>
                    </xs:annotation>
                </xs:group>
                <xs:group ref="simple-blocks">
                    <xs:annotation>
                        <xs:documentation>simple-blocks (optional)</xs:documentation>
                    </xs:annotation>
                </xs:group>
                <xs:group ref="xfm:UI.Common">
                    <xs:annotation>
                        <xs:documentation>xfm:UI.Common (optional)</xs:documentation>
                    </xs:annotation>
                </xs:group>
                <xs:element ref="table">
                    <xs:annotation>
                        <xs:documentation>table (optional)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:choice>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="table">
        <xs:annotation>
            <xs:documentation>
                <name>table</name>
                Element table, a member of
                <parent>complex-blocks</parent>
                element group, is a grid organized collection of data where units of that grid are referred to as cells.
                <example>&lt; table&gt;&lt; head-row/&gt;&lt; table-row/&gt;&lt; table-row/&gt;&lt; /table&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:element minOccurs="0" ref="head-row">
                    <xs:annotation>
                        <xs:documentation>head-row (optional, but must occur first)</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element maxOccurs="unbounded" ref="table-row">
                    <xs:annotation>
                        <xs:documentation>table-row (required and may occur more than once)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:sequence>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="head-row">
        <xs:annotation>
            <xs:documentation>
                <name>head-row</name>
                Element head-row, a child of
                <parent>&lt; table&gt;</parent>, is an optional structural component of a table where the contained child elements represent specific meta-data to the table and not raw data.
                <example>&lt; head-row&gt;&lt; head-cell/&gt;&lt; head-row&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:element maxOccurs="unbounded" ref="head-cell">
                    <xs:annotation>
                        <xs:documentation>head-cell (required and may occur more than once)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:sequence>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="head-cell">
        <xs:annotation>
            <xs:documentation>
                <name>head-cell</name>
                Element head-cell, a child of
                <parent>&lt; head-row&gt;</parent>
                or
                <parent>&lt; table-row&gt;</parent>, contains meta-data that describes other cells in the table.
                <example>&lt; head-cell&gt;cell heading&lt; /head-cell&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType mixed="true">
            <xs:choice>
                <xs:group ref="simple-blocks">
                    <xs:annotation>
                        <xs:documentation>simple blocks (choice between simple-blocks group and inline group)</xs:documentation>
                    </xs:annotation>
                </xs:group>
                <xs:group maxOccurs="unbounded" ref="inline">
                    <xs:annotation>
                        <xs:documentation>inline (choice between simple-blocks group and inline group, inline group elements may occur more than once)</xs:documentation>
                    </xs:annotation>
                </xs:group>
            </xs:choice>
            <xs:attribute default="column" ref="scope" use="optional">
                <xs:annotation>
                    <xs:documentation>scope (optional)</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attributeGroup ref="cell-attrs">
                <xs:annotation>
                    <xs:documentation>cell-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
            <xs:attributeGroup ref="inter-attrs">
                <xs:annotation>
                    <xs:documentation>inter-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="table-row">
        <xs:annotation>
            <xs:documentation>
                <name>table-row</name>
                Element table-row, a child of
                <parent>&lt; table&gt;</parent>
                is a row in a table that is intended to contain data cells. Cells for meta-data, &lt; head-cell&gt;, are allowed to provide more granular description of data.
                <example>&lt; table-row&gt;&lt; head-cell/&gt;&lt; table-cell/&gt;&lt; table-cell/&gt;&lt; /table-row&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:choice maxOccurs="unbounded">
                <xs:element ref="head-cell">
                    <xs:annotation>
                        <xs:documentation>head-cell (choice of &lt; head-cell&gt; or &lt; table-cell&gt;)</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element ref="table-cell">
                    <xs:annotation>
                        <xs:documentation>table-cell (choice of &lt; head-cell&gt; or &lt; table-cell&gt;)</xs:documentation>
                    </xs:annotation>
                </xs:element>
            </xs:choice>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>core-attrs</xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="table-cell">
        <xs:annotation>
            <xs:documentation>
                <name>table-cell</name>
                Element table-cell, a child of element
                <parent>&lt; table-row&gt;</parent>, is a single data unit container for a formal table.
                <example>&lt; table-cell&gt;&lt; block-quote&gt;some text&lt; /block-code&gt;&lt; /table-cell&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType mixed="true">
            <xs:choice>
                <xs:group ref="simple-blocks">
                    <xs:annotation>
                        <xs:documentation>
                            simple-blocks (choice between simple-blocks group and inline group)
                        </xs:documentation>
                    </xs:annotation>
                </xs:group>
                <xs:group maxOccurs="unbounded" ref="inline">
                    <xs:annotation>
                        <xs:documentation>
                            inline (choice between simple-blocks group and inline group, inline group elements may occur more than once)
                        </xs:documentation>
                    </xs:annotation>
                </xs:group>
            </xs:choice>
            <xs:attributeGroup ref="cell-attrs">
                <xs:annotation>
                    <xs:documentation>
                        cell-attrs
                    </xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>
                        core-attrs
                    </xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
            <xs:attributeGroup ref="inter-attrs">
                <xs:annotation>
                    <xs:documentation>
                        inter-attrs
                    </xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="section">
        <xs:annotation>
            <xs:documentation>
                <name>section</name>
                Element section, a member of
                <parent>complex-blocks</parent>
                element group, is a section or division of content where that content represents a contextual difference from other content in the document. Section is of custom type, nesting-block.
                <example>&lt; section&gt;&lt; heading/&gt;&lt; paragraph/&gt;&lt; paragraph/&gt;&lt; section/&gt;&lt; /section&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:complexContent mixed="false">
                <xs:extension base="nesting-block">
                    <xs:attributeGroup ref="core-attrs">
                        <xs:annotation>
                            <xs:documentation>
                                core-attrs
                            </xs:documentation>
                        </xs:annotation>
                    </xs:attributeGroup>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="block-code" type="simple-blocks-type">
        <xs:annotation>
            <xs:documentation>
                <name>block-code</name>
                Element block-code, a member of
                <parent>simple-blocks</parent>
                element group and of custom type simple-blocks-type, is a container for storing sample code as content published to the user.
                <example>&lt; block-code&gt;Sample &lt; emphasis&gt;code&lt; /emphasis&gt; would go here.&lt; /block-code&gt;</example>
            </xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:element name="block-quote" type="simple-blocks-type">
        <xs:annotation>
            <xs:documentation>
                <name>block-quote</name>
                Element block-code, a member of
                <parent>simple-blocks</parent>
                element group and of custom type simple-blocks-type, is a container for storing content that represents a large continuous quote or paraphase of content.
                <example>&lt; block-quote&gt;A long quote would go here.&lt; /block-quote&gt;</example>
            </xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:element name="citation">
        <xs:annotation>
            <xs:documentation>
                <name>citation</name>
                Element citation, a member of
                <parent>simple-blocks</parent>
                element group, is a container for storing a citation to an external source. The "id" attribute is required on this element so that it can be conviently referrenced in the content through use of inline element &lt; cite&gt;.
                <example>&lt; citation id="MMLSpecification"&gt;Cheney, Austin. "Mail Markup Language", Travelocity LLC, April 2009. &lt; strong uri="http://mailmarkup.org/mml.txt"&gt;http://mailmarkup.org/mml.txt&lt; /strong&gt;&lt; /citation&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType mixed="true">
            <xs:group minOccurs="0" maxOccurs="unbounded" ref="inline">
                <xs:annotation>
                    <xs:documentation>
                        inline (optional, but may occur more than once)
                    </xs:documentation>
                </xs:annotation>
            </xs:group>
            <xs:attribute ref="id" use="required">
                <xs:annotation>
                    <xs:documentation>
                        id (required)
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute ref="style" use="optional">
                <xs:annotation>
                    <xs:documentation>
                        style (optional)
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute ref="title" use="optional">
                <xs:annotation>
                    <xs:documentation>
                        title (optional)
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute ref="role" use="optional">
                <xs:annotation>
                    <xs:documentation>
                        role (optional)
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attributeGroup ref="inter-attrs">
                <xs:annotation>
                    <xs:documentation>
                        inter-attrs
                    </xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="heading" type="simple-blocks-type">
        <xs:annotation>
            <xs:documentation>
                <name>heading</name>
                Element heading, a member of
                <parent>simple-blocks</parent>
                element group and of custom type simple-blocks-type, is a container for storing content that represents a formal heading or section title. It is strongly recommended that a heading be included directly after the opening tag of any complex block.
                <example>&lt; heading&gt;A heading would go here.&lt; /heading&gt;</example>
            </xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:element name="object">
        <xs:annotation>
            <xs:documentation>
                <name>object</name>
                Element object, a member of
                <parent>simple-blocks</parent>
                element group, allows for the processing of a media object directly into the content of the page. A media object may be text, audio, video, or any other form of non-textual communication interface or binary large object (BLOB).
                <example>&lt; object&gt;&lt; object-text&gt;text&lt; /object-text&gt;&lt; object-uri&gt;http://wwwl.travelocity.com/hotels.jpg&lt; /object-uri&gt;&lt; object-type&gt;&lt; image&gt;jpeg&lt; /image&gt;&lt; /object-type&gt;&lt; /object&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:group ref="object-group">
                <xs:annotation>
                    <xs:documentation>
                        object-group
                    </xs:documentation>
                </xs:annotation>
            </xs:group>
            <xs:attributeGroup ref="inter-attrs">
                <xs:annotation>
                    <xs:documentation>
                        inter-attrs
                    </xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
            <xs:attributeGroup ref="core-attrs">
                <xs:annotation>
                    <xs:documentation>
                        core-attrs
                    </xs:documentation>
                </xs:annotation>
            </xs:attributeGroup>
        </xs:complexType>
    </xs:element>
    <xs:element name="paragraph" type="simple-blocks-type">
        <xs:annotation>
            <xs:documentation>
                <name>paragraph</name>
                Element paragraph, a member of
                <parent>simple-blocks</parent>
                element group and of custom type simple-blocks-type, is a container for storing content that represents a series of statements that together make up a single coherent thought.
                <example>&lt; paragraph&gt;This is a content statement.&lt; /paragraph&gt;</example>
            </xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:element name="separator" type="simple-blocks-type">
        <xs:annotation>
            <xs:documentation>
                <name>separator</name>
                Element separator, a member of
                <parent>simple-blocks</parent>
                element group and of custom type simple-blocks-type, exists to provide a break point between peer blocks of content where that separation might not be otherwise clear. This element may contain text to provide instructions that further expand upon the element's objective of block separation.
                <example>&lt; separator&gt;End of article, please return to the main menu.&lt; /separator&gt;</example>
            </xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:complexType name="short-type">
        <xs:annotation>
            <xs:documentation>
                <name>short-type</name>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute ref="long-form" use="required">
                    <xs:annotation>
                        <xs:documentation>
                            long-form (required)
                        </xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attributeGroup ref="core-attrs-uri">
                    <xs:annotation>
                        <xs:documentation>
                            core-attrs-uri
                        </xs:documentation>
                    </xs:annotation>
                </xs:attributeGroup>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:element name="short">
        <xs:annotation>
            <xs:documentation>
                <name>short</name>
                Element short, a member of
                <parent>inline</parent>
                element group and of custom complex type short-type, is an inline element for defining condensed text, such as an acronymn or abbreviation.
                <example>&lt; short long-form="ain't ready to be a marine yet"&gt;army&lt; /short&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:simpleContent>
                <xs:restriction base="short-type">
                    <xs:minLength value="1"/>
                    <xs:whiteSpace value="collapse"/>
                </xs:restriction>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:complexType name="button-type">
        <xs:annotation>
            <xs:documentation>
                <name>button-type</name>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute ref="refer" use="optional">
                    <xs:annotation>
                        <xs:documentation>
                            refer (optional)
                        </xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attributeGroup ref="core-attrs-uri">
                    <xs:annotation>
                        <xs:documentation>
                            core-attrs-uri
                        </xs:documentation>
                    </xs:annotation>
                </xs:attributeGroup>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:element name="button">
        <xs:annotation>
            <xs:documentation>
                <name>button</name>
                Element button, a member of
                <parent>inline</parent>
                element group and of custom complex type button-type, allows a button to be placed into the content. The functionality of that button may address any needs of the document author, however its text label should come only from the text contained by the button element.
                <example>&lt; button&gt;text that would appear on a button&lt; /button&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:simpleContent>
                <xs:restriction base="button-type">
                    <xs:minLength value="1"/>
                    <xs:whiteSpace value="collapse"/>
                </xs:restriction>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:complexType name="cite-type">
        <xs:annotation>
            <xs:documentation>
                <name>cite-type</name>
            </xs:documentation>
        </xs:annotation>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute ref="refer" use="required">
                    <xs:annotation>
                        <xs:documentation>
                            refer (required)
                        </xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attributeGroup ref="core-attrs">
                    <xs:annotation>
                        <xs:documentation>
                            core-attrs
                        </xs:documentation>
                    </xs:annotation>
                </xs:attributeGroup>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:element name="cite">
        <xs:annotation>
            <xs:documentation>
                <name>cite</name>
                Element cite, a member of
                <parent>inline</parent>
                element group and of custom complex type cite-type, defines text as a cite linked to a citation. The refer attribute is required and must have a value that matches the id attribute value of a citation element in the current document.
                <example>&lt; cite refer="MMLSpecification"&gt;Mail Markup Language&lt; /cite&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:simpleContent>
                <xs:restriction base="cite-type">
                    <xs:minLength value="1"/>
                    <xs:whiteSpace value="collapse"/>
                </xs:restriction>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="emphasis" type="inline-type">
        <xs:annotation>
            <xs:documentation>
                <name>emphasis</name>
                Element emphasis, a member of
                <parent>inline</parent>
                element group and of custom complex type inline-type, describes important text or text that demands more attention than the text around it.
                <example>&lt; emphasis&gt;This text is important.&lt; /emphasis&gt;</example>
            </xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:complexType name="identifier-type">
        <xs:documentation>
            <xs:annotation>
                <name>identifier-type</name>
            </xs:annotation>
        </xs:documentation>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute ref="refer" use="required">
                    <xs:annotation>
                        <xs:documentation>
                            refer (required)
                        </xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attributeGroup ref="core-attrs-uri">
                    <xs:annotation>
                        <xs:documentation>
                            core-attrs-uri
                        </xs:documentation>
                    </xs:annotation>
                </xs:attributeGroup>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:element name="identifier">
        <xs:annotation>
            <xs:documentation>
                <name>identifier</name>
                Element identifier, a member of
                <parent>inline</parent>
                element group and of custom complex type identifier-type, describes text that represents some other element such as text for a form control or text that describes a block of content without representing a more formal heading. The refer attribute is required and must refer to the id attribute value of another element.
                <example>&lt; identifier refer="sectionFooter"&gt;This text describes and references to sectionFooter.&lt; /identifier&gt;</example>
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:simpleContent>
                <xs:restriction base="identifier-type">
                    <xs:minLength value="1"/>
                    <xs:whiteSpace value="collapse"/>
                </xs:restriction>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="quote" type="inline-type">
        <xs:annotation>
            <xs:documentation>
                <name>quote</name>
                Element quote, a member of
                <parent>inline</parent>
                element group and of custom complex type inline-type, describes a quotation apart from the text content around it.
                <example>&lt; quote&gt;This text is a quotation.&lt; /quote&gt;</example>
            </xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:element name="format" type="format-type">
        <xs:annotation>
            <xs:documentation>
                <name>format</name>
                Element format, a member of
                <parent>inline</parent>
                element group and of custom complex type format-type, provides no semantic value. This element is provided to allow functional considerations without alteration of semantic interpretation onto the content. This element is unique in that it is an line element, but it may also have another format element as a child element.
                <example>&lt; format&gt;Allows for presentation without semantic alteration.&lt; /format&gt;</example>
            </xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:element name="strong" type="inline-type">
        <xs:annotation>
            <xs:documentation>
                <name>strong</name>
                Element strong, a member of
                <parent>inline</parent>
                element group and of custom complex type inline-type, describes text is that equivalent to a emotional distress, boldly spoken text, or a shout. Its text should be considered alarming and emergent compared to the text around it, but not superior. Superior text is described by the &lt; emphasis&gt; tag.
                <example>&lt; strong&gt;Oh no!&lt; /strong&gt;</example>
            </xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:element name="title" type="inline-type">
        <xs:annotation>
            <xs:documentation>
                <name>title</name>
                Element title, a member of
                <parent>inline</parent>
                element group and of custom complex type inline-type, describes a formal work or creative body.
                <example>&lt; title&gt;Julius Caesar&lt; /title&gt; by William Shakespeare</example>
            </xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:element name="script">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="script-type"/>
                <xs:element ref="script-uri"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="script-type" type="mime-type"/>
    <xs:element name="script-uri">
        <xs:simpleType>
            <xs:restriction base="xs:anyURI"/>
        </xs:simpleType>
    </xs:element>
    <xs:annotation>
        <xs:documentation>First draft completed by Austin Cheney on 27 October 2009.</xs:documentation>
    </xs:annotation>
</xs:schema>