namespace a = "http://relaxng.org/ns/compatibility/annotations/1.0"
namespace ctrl = "http://nwalsh.com/xmlns/schema-control/"
default namespace db = "http://docbook.org/ns/docbook"
namespace html = "http://www.w3.org/1999/xhtml"
namespace mml = "http://www.w3.org/1998/Math/MathML"
namespace rng = "http://relaxng.org/ns/structure/1.0"
namespace s = "http://www.ascc.net/xml/schematron"
namespace svg = "http://www.w3.org/2000/svg"
namespace xi = "http://www.w3.org/2001/XInclude"
namespace xlink = "http://www.w3.org/1999/xlink"

s:ns [
  prefix = "a"
  uri = "http://relaxng.org/ns/compatibility/annotations/1.0"
]
s:ns [ prefix = "ctrl" uri = "http://nwalsh.com/xmlns/schema-control/" ]
s:ns [ prefix = "db" uri = "http://docbook.org/ns/docbook" ]
s:ns [
  prefix = "dbx"
  uri =
    "http://sourceforge.net/projects/docbook/defguide/schema/extra-markup"
]
s:ns [ prefix = "html" uri = "http://www.w3.org/1999/xhtml" ]
s:ns [ prefix = "mml" uri = "http://www.w3.org/1998/Math/MathML" ]
s:ns [ prefix = "rng" uri = "http://relaxng.org/ns/structure/1.0" ]
s:ns [ prefix = "s" uri = "http://www.ascc.net/xml/schematron" ]
s:ns [ prefix = "svg" uri = "http://www.w3.org/2000/svg" ]
s:ns [ prefix = "xi" uri = "http://www.w3.org/2001/XInclude" ]
s:ns [ prefix = "xlink" uri = "http://www.w3.org/1999/xlink" ]
#  DocBook V5.0CR5

# See http://docbook.org/ns/docbook
start =
  (db.set
   | db.book
   | db.divisions
   | db.components
   | db.navigation.components
   | db.section
   | db.para)
  | (db.sect1 | db.sect2 | db.sect3 | db.sect4 | db.sect5)
  | (db.refentry | db.refsection)
  | (db.refsect1 | db.refsect2 | db.refsect3)
  | db.setindex
div {
  db._any.attribute =
    
    ## Any attribute including in any attribute in any namespace.
    attribute * { text }
  db._any =
    
    ## Any element from almost any namespace
    element * - (db:* | html:*) {
      (db._any.attribute | text | db._any)*
    }
}
db.arch.attribute =
  
  ## Designates the computer or chip architecture to which the element applies
  attribute arch { text }
db.audience.attribute =
  
  ## Designates the intended audience to which the element applies, for example, system administrators, programmers, or new users.
  attribute audience { text }
db.condition.attribute =
  
  ## provides a standard place for application-specific effectivity
  attribute condition { text }
db.conformance.attribute =
  
  ## Indicates standards conformance characteristics of the element
  attribute conformance { text }
db.os.attribute =
  
  ## Indicates the operating system to which the element is applicable
  attribute os { text }
db.revision.attribute =
  
  ## Indicates the editorial revision to which the element belongs
  attribute revision { text }
db.security.attribute =
  
  ## Indicates something about the security level associated with the element to which it applies
  attribute security { text }
db.userlevel.attribute =
  
  ## Indicates the level of user experience for which the element applies
  attribute userlevel { text }
db.vendor.attribute =
  
  ## Indicates the computer vendor to which the element applies.
  attribute vendor { text }
db.wordsize.attribute =
  
  ## Indicates the word size (width in bits) of the computer architecture to which the element applies
  attribute wordsize { text }
db.effectivity.attributes =
  db.arch.attribute?
  & db.audience.attribute?
  & db.condition.attribute?
  & db.conformance.attribute?
  & db.os.attribute?
  & db.revision.attribute?
  & db.security.attribute?
  & db.userlevel.attribute?
  & db.vendor.attribute?
  & db.wordsize.attribute?
db.endterm.attribute =
  
  ## Points to the element whose content is to be used as the text of the link
  attribute endterm { xsd:IDREF }
db.linkend.attribute =
  
  ## Points to an internal link target by identifying the value of its xml:id attribute
  attribute linkend { xsd:IDREF }
db.linkends.attribute =
  
  ## Points to one or more internal link targets by identifying the value of their xml:id attributes
  attribute linkends { xsd:IDREFS }
db.xlink.href.attribute =
  
  ## Identifies a link target with a URI
  attribute xlink:href { xsd:anyURI }
db.xlink.type.attribute =
  
  ## Identifies the XLink link type
  attribute xlink:type {
    
    ## An XLink simple link
    "simple"
  }
db.xlink.role.attribute =
  
  ## Identifies the XLink role of the link
  attribute xlink:role { xsd:anyURI }
db.xlink.arcrole.attribute =
  
  ## Identifies the XLink arcrole of the link
  attribute xlink:arcrole { xsd:anyURI }
db.xlink.title.attribute =
  
  ## Identifies the XLink title of the link
  attribute xlink:title { text }?
db.xlink.show.enumeration =
  
  ## An application traversing to the ending resource should load it in a new window, frame, pane, or other relevant presentation context.
  "new"
  | 
    ## An application traversing to the ending resource should load the resource in the same window, frame, pane, or other relevant presentation context in which the starting resource was loaded.
    "replace"
  | 
    ## An application traversing to the ending resource should load its presentation in place of the presentation of the starting resource.
    "embed"
  | 
    ## The behavior of an application traversing to the ending resource is unconstrained by XLink. The application should look for other markup present in the link to determine the appropriate behavior.
    "other"
  | 
    ## The behavior of an application traversing to the ending resource is unconstrained by this specification. No other markup is present to help the application determine the appropriate behavior.
    "none"
db.xlink.show.attribute =
  
  ## Identifies the XLink show behavior of the link
  attribute xlink:show { db.xlink.show.enumeration }
db.xlink.actuate.enumeration =
  
  ## An application should traverse to the ending resource immediately on loading the starting resource.
  "onLoad"
  | 
    ## An application should traverse from the starting resource to the ending resource only on a post-loading event triggered for the purpose of traversal.
    "onRequest"
  | 
    ## The behavior of an application traversing to the ending resource is unconstrained by this specification. The application should look for other markup present in the link to determine the appropriate behavior.
    "other"
  | 
    ## The behavior of an application traversing to the ending resource is unconstrained by this specification. No other markup is present to help the application determine the appropriate behavior.
    "none"
db.xlink.actuate.attribute =
  
  ## Identifies the XLink actuate behavior of the link
  attribute xlink:actuate { db.xlink.actuate.enumeration }
db.href.attributes =
  db.xlink.href.attribute
  & db.xlink.type.attribute?
  & db.xlink.role.attribute?
  & db.xlink.arcrole.attribute?
  & db.xlink.title.attribute?
  & db.xlink.show.attribute?
  & db.xlink.actuate.attribute?
db.xml.id.attribute =
  
  ## Identifies the unique ID value of the element
  attribute xml:id { xsd:ID }
db.version.attribute =
  
  ## Specifies the DocBook version of the element and its descendants
  attribute version { text }
db.xml.lang.attribute =
  
  ## Specifies the natural language of the element and its descendants
  attribute xml:lang { text }
db.xml.base.attribute =
  
  ## Specifies the base URI of the element and its descendants
  attribute xml:base { xsd:anyURI }
db.remap.attribute =
  
  ## Provides the name or similar semantic identifier assigned to the content in some previous markup scheme
  attribute remap { text }
db.xreflabel.attribute =
  
  ## Provides the text that is to be generated for a cross reference to the element
  attribute xreflabel { text }
db.xrefstyle.attribute =
  
  ## Specifies a keyword or keywords identifying additional style information
  attribute xrefstyle { text }
db.revisionflag.enumeration =
  
  ## The element has been changed.
  "changed"
  | 
    ## The element is new (has been added to the document).
    "added"
  | 
    ## The element has been deleted.
    "deleted"
  | 
    ## Explicitly turns off revision markup for this element.
    "off"
db.revisionflag.attribute =
  
  ## Identifies the revision status of the element
  attribute revisionflag { db.revisionflag.enumeration }
db.dir.enumeration =
  
  ## Left-to-right text
  "ltr"
  | 
    ## Right-to-left text
    "rtl"
  | 
    ## Left-to-right override
    "lro"
  | 
    ## Right-to-left override
    "rlo"
db.dir.attribute =
  
  ## Identifies the direction of text in an element
  attribute dir { db.dir.enumeration }
db.common.base.attributes =
  db.version.attribute?
  & db.xml.lang.attribute?
  & db.xml.base.attribute?
  & db.remap.attribute?
  & db.xreflabel.attribute?
  & db.revisionflag.attribute?
  & db.dir.attribute?
  & db.effectivity.attributes
db.common.attributes =
  db.xml.id.attribute?
  & db.common.base.attributes
  & db.annotations.attribute?
db.common.idreq.attributes =
  db.xml.id.attribute
  & db.common.base.attributes
  & db.annotations.attribute?
db.common.linking.attributes =
  (db.linkend.attribute | db.href.attributes)?
db.common.req.linking.attributes =
  db.linkend.attribute | db.href.attributes
db.common.data.attributes =
  
  ## Specifies the format of the data
  attribute format { text }?,
  (
   ## Indentifies the location of the data by URI
   attribute fileref { xsd:anyURI }
   | 
     ## Identifies the location of the data by external identifier (entity name)
     attribute entityref { xsd:ENTITY })
db.verbatim.continuation.enumeration =
  
  ## Line numbering continues from the immediately preceding element with the same name.
  "continues"
  | 
    ## Line numbering restarts (begins at 1, usually).
    "restarts"
db.verbatim.continuation.attribute =
  
  ## Determines whether line numbering continues from the previous element or restarts.
  attribute continuation { db.verbatim.continuation.enumeration }
db.verbatim.linenumbering.enumeration =
  
  ## Lines are numbered.
  "numbered"
  | 
    ## Lines are not numbered.
    "unnumbered"
db.verbatim.linenumbering.attribute =
  
  ## Determines whether lines are numbered.
  attribute linenumbering { db.verbatim.linenumbering.enumeration }
db.verbatim.startinglinenumber.attribute =
  
  ## Specifies the initial line number.
  attribute startinglinenumber { xsd:integer }
db.verbatim.language.attribute =
  
  ## Identifies the language (i.e. programming language) of the verbatim content.
  attribute language { text }
db.verbatim.xml.space.attribute =
  
  ## Can be used to indicate explicitly that whitespace in the verbatim environment is preserved. Whitespace must always be preserved in verbatim environments whether this attribute is specified or not.
  attribute xml:space {
    
    ## Whitespace must be preserved.
    "preserve"
  }
db.verbatim.attributes =
  db.verbatim.continuation.attribute?
  & db.verbatim.linenumbering.attribute?
  & db.verbatim.startinglinenumber.attribute?
  & db.verbatim.language.attribute?
  & db.verbatim.xml.space.attribute?
db.label.attribute =
  
  ## Specifies an identifying string for presentation purposes
  attribute label { text }
db.width.characters.attribute =
  
  ## Specifies the width (in characters) of the element
  attribute width { xsd:nonNegativeInteger }
db.spacing.enumeration =
  
  ## The spacing should be "compact".
  "compact"
  | 
    ## The spacing should be "normal".
    "normal"
db.spacing.attribute =
  
  ## Specifies (a hint about) the spacing of the content
  attribute spacing { db.spacing.enumeration }
db.pgwide.enumeration =
  
  ## The element should be rendered in the current text flow (with the flow column width).
  "0"
  | 
    ## The element should be rendered across the full text page.
    "1"
db.pgwide.attribute =
  
  ## Indicates if the element is rendered across the column or the page
  attribute pgwide { db.pgwide.enumeration }
db.language.attribute =
  
  ## Identifies the language (i.e. programming language) of the content.
  attribute language { text }
db.performance.enumeration =
  
  ## The content describes an optional step or steps.
  "optional"
  | 
    ## The content describes a required step or steps.
    "required"
db.performance.attribute =
  
  ## Specifies if the content is required or optional.
  attribute performance { db.performance.enumeration }
db.floatstyle.attribute =
  
  ## Specifies style information to be used when rendering the float
  attribute floatstyle { text }
db.width.attribute =
  
  ## Specifies the width of the element
  attribute width { text }
db.depth.attribute =
  
  ## Specifies the depth of the element
  attribute depth { text }
db.contentwidth.attribute =
  
  ## Specifies the width of the content rectangle
  attribute contentwidth { text }
db.contentdepth.attribute =
  
  ## Specifies the depth of the content rectangle
  attribute contentdepth { text }
db.scalefit.enumeration =
  
  ## False (do not scale-to-fit; anamorphic scaling may occur)
  "0"
  | 
    ## True (scale-to-fit; anamorphic scaling is forbidden)
    "1"
db.scale.attribute =
  
  ## Specifies the scaling factor
  attribute scale { xsd:positiveInteger }
db.halign.enumeration =
  
  ## Centered horizontally
  "center"
  | 
    ## Aligned horizontally on the specified character
    "char"
  | 
    ## Fully justified (left and right margins or edges)
    "justify"
  | 
    ## Left aligned
    "left"
  | 
    ## Right aligned
    "right"
db.valign.enumeration =
  
  ## Aligned on the bottom of the region
  "bottom"
  | 
    ## Centered vertically
    "middle"
  | 
    ## Aligned on the top of the region
    "top"
db.biblio.class.enumeration =
  
  ## A document object identifier.
  "doi"
  | 
    ## An international standard book number.
    "isbn"
  | 
    ## An international standard technical report number (ISO 10444).
    "isrn"
  | 
    ## An international standard serial number.
    "issn"
  | 
    ## A Library of Congress reference number.
    "libraryofcongress"
  | 
    ## A publication number (an internal number or possibly organizational standard).
    "pubsnumber"
  | 
    ## A Uniform Resource Identifier
    "uri"
db.biblio.class-enum.attribute =
  
  ## Identifies the kind of bibliographic identifier
  attribute class { db.biblio.class.enumeration }?
db.biblio.class-other.attribute =
  
  ## Identifies the nature of the non-standard bibliographic identifier
  attribute otherclass { xsd:NMTOKEN }
db.biblio.class-other.attributes =
  
  ## Identifies the kind of bibliographic identifier
  attribute class {
    
    ## Indicates that the identifier is some 'other' kind.
    "other"
  }
  & db.biblio.class-other.attribute
db.biblio.class.attribute =
  db.biblio.class-enum.attribute | db.biblio.class-other.attributes
db.ubiq.inlines =
  (db.inlinemediaobject
   | db.remark
   | db.superscript
   | db.subscript
   | db.link.inlines
   | db.alt)
  | db.annotation
  | db.indexterm
db._text = (text | db.ubiq.inlines | db._phrase | db.replaceable)*
db._title = db.title? & db.titleabbrev? & db.subtitle?
db._title.req = db.title & db.titleabbrev? & db.subtitle?
db._title.only = db.title? & db.titleabbrev?
db._title.onlyreq = db.title & db.titleabbrev?
db._info = (db._title, db.titleforbidden.info?) | db.info?
db._info.title.req =
  (db._title.req, db.titleforbidden.info?) | db.titlereq.info
db._info.title.only =
  (db._title.only, db.titleforbidden.info?) | db.titleonly.info
db._info.title.onlyreq =
  (db._title.onlyreq, db.titleforbidden.info?) | db.titleonlyreq.info
db._info.title.forbidden = db.titleforbidden.info?
db.all.inlines =
  (text
   | db.ubiq.inlines
   | db.general.inlines
   | db.domain.inlines
   | db.extension.inlines)
  | db.xi.include
db.general.inlines =
  db.publishing.inlines
  | db.product.inlines
  | db.bibliography.inlines
  | db.graphic.inlines
  | db.indexing.inlines
  | db.link.inlines
db.domain.inlines =
  db.technical.inlines
  | db.math.inlines
  | db.markup.inlines
  | db.gui.inlines
  | db.keyboard.inlines
  | db.os.inlines
  | db.programming.inlines
  | db.error.inlines
db.technical.inlines =
  (db.replaceable | db.package | db.parameter)
  | db.termdef
  | db.nonterminal
  | (db.systemitem | db.option | db.optional | db.property)
db.product.inlines =
  db.trademark
  | (db.productnumber
     | db.productname
     | db.database
     | db.application
     | db.hardware)
db.bibliography.inlines =
  db.citation
  | db.citerefentry
  | db.citetitle
  | db.citebiblioid
  | db.author
  | db.person
  | db.personname
  | db.org
  | db.orgname
  | db.editor
  | db.jobtitle
db.publishing.inlines =
  (db.abbrev
   | db.acronym
   | db.date
   | db.emphasis
   | db.footnote
   | db.footnoteref
   | db.foreignphrase
   | db.phrase
   | db.quote
   | db.subscript
   | db.superscript
   | db.wordasword)
  | db.glossary.inlines
  | db.coref
db.graphic.inlines = db.inlinemediaobject
db.indexing.inlines = notAllowed | db.indexterm
db.link.inlines =
  (db.xref | db.link | db.olink | db.anchor) | db.biblioref
db.extension.inlines = notAllowed
db.nopara.blocks =
  (db.list.blocks
   | db.formal.blocks
   | db.informal.blocks
   | db.publishing.blocks
   | db.graphic.blocks
   | db.technical.blocks
   | db.verbatim.blocks
   | db.bridgehead
   | db.remark
   | db.revhistory)
  | db.indexterm
  | db.synopsis.blocks
  | db.admonition.blocks
db.para.blocks = db.anchor | db.para | db.formalpara | db.simpara
db.all.blocks =
  (db.nopara.blocks | db.para.blocks | db.extension.blocks)
  | db.annotation
  | db.xi.include
db.formal.blocks = (db.example | db.figure | db.table) | db.equation
db.informal.blocks =
  (db.informalexample | db.informalfigure | db.informaltable)
  | db.informalequation
db.publishing.blocks =
  db.sidebar | db.blockquote | db.address | db.epigraph
db.graphic.blocks = db.mediaobject | db.screenshot
db.technical.blocks =
  db.procedure
  | db.task
  | (db.productionset | db.constraintdef)
  | db.msgset
db.list.blocks =
  (db.itemizedlist
   | db.orderedlist
   | db.procedure
   | db.simplelist
   | db.variablelist
   | db.segmentedlist)
  | db.glosslist
  | db.bibliolist
  | db.calloutlist
  | db.qandaset
db.verbatim.blocks =
  (db.screen | db.literallayout)
  | (db.programlistingco | db.screenco)
  | (db.programlisting | db.synopsis)
db.extension.blocks = notAllowed
db.info.extension = db._any
db.info.elements =
  (db.abstract
   | db.address
   | db.artpagenums
   | db.author
   | db.authorgroup
   | db.authorinitials
   | db.bibliocoverage
   | db.biblioid
   | db.bibliosource
   | db.collab
   | db.confgroup
   | db.contractsponsor
   | db.contractnum
   | db.copyright
   | db.cover
   | db.date
   | db.edition
   | db.editor
   | db.issuenum
   | db.keywordset
   | db.legalnotice
   | db.mediaobject
   | db.org
   | db.orgname
   | db.othercredit
   | db.pagenums
   | db.printhistory
   | db.pubdate
   | db.publisher
   | db.publishername
   | db.releaseinfo
   | db.revhistory
   | db.seriesvolnums
   | db.subjectset
   | db.volumenum
   | db.info.extension)
  | db.annotation
  | db.extendedlink
  | (db.bibliomisc | db.bibliomset | db.bibliorelation | db.biblioset)
  | db.itermset
  | (db.productname | db.productnumber)
  | db.xi.include
db.bibliographic.elements =
  db.info.elements
  | db.publishing.inlines
  | db.citerefentry
  | db.citetitle
  | db.citebiblioid
  | db.person
  | db.personblurb
  | db.personname
  | db.subtitle
  | db.title
  | db.titleabbrev
div {
  db.title.role.attribute = attribute role { text }
  db.title.attlist =
    db.title.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.title =
    
    ## The text of the title of a section of a document or of a formal block-level element
    element title { db.title.attlist, db.all.inlines* }
}
div {
  db.titleabbrev.role.attribute = attribute role { text }
  db.titleabbrev.attlist =
    db.titleabbrev.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.titleabbrev =
    
    ## The abbreviation of a title
    element titleabbrev { db.titleabbrev.attlist, db.all.inlines* }
}
div {
  db.subtitle.role.attribute = attribute role { text }
  db.subtitle.attlist =
    db.subtitle.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.subtitle =
    
    ## The subtitle of a document
    element subtitle { db.subtitle.attlist, db.all.inlines* }
}
div {
  db.info.role.attribute = attribute role { text }
  db.info.attlist = db.info.role.attribute? & db.common.attributes
  db.info =
    
    ## A wrapper for information about a component or other block
    element info { db.info.attlist, (db._title & db.info.elements*) }
}
div {
  db.titlereq.info.role.attribute = attribute role { text }
  db.titlereq.info.attlist =
    db.titlereq.info.role.attribute? & db.common.attributes
  db.titlereq.info =
    
    ## A wrapper for information about a component or other block with a required title
    element info {
      db.titlereq.info.attlist, (db._title.req & db.info.elements*)
    }
}
div {
  db.titleonly.info.role.attribute = attribute role { text }
  db.titleonly.info.attlist =
    db.titleonly.info.role.attribute? & db.common.attributes
  db.titleonly.info =
    
    ## A wrapper for information about a component or other block with only a title
    element info {
      db.titleonly.info.attlist, (db._title.only & db.info.elements*)
    }
}
div {
  db.titleonlyreq.info.role.attribute = attribute role { text }
  db.titleonlyreq.info.attlist =
    db.titleonlyreq.info.role.attribute? & db.common.attributes
  db.titleonlyreq.info =
    
    ## A wrapper for information about a component or other block with only a required title
    element info {
      db.titleonlyreq.info.attlist,
      (db._title.onlyreq & db.info.elements*)
    }
}
div {
  db.titleforbidden.info.role.attribute = attribute role { text }
  db.titleforbidden.info.attlist =
    db.titleforbidden.info.role.attribute? & db.common.attributes
  db.titleforbidden.info =
    
    ## A wrapper for information about a component or other block without a title
    element info { db.titleforbidden.info.attlist, db.info.elements* }
}
div {
  db.subjectset.role.attribute = attribute role { text }
  db.subjectset.scheme.attribute =
    
    ## Identifies the controlled vocabulary used by this set's terms
    attribute scheme { xsd:NMTOKEN }
  db.subjectset.attlist =
    db.subjectset.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.subjectset.scheme.attribute?
  db.subjectset =
    
    ## A set of terms describing the subject matter of a document
    element subjectset { db.subjectset.attlist, db.subject+ }
}
div {
  db.subject.role.attribute = attribute role { text }
  db.subject.weight.attribute =
    
    ## Specifies a ranking for this subject relative to other subjects in the same set
    attribute weight { text }
  db.subject.attlist =
    db.subject.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.subject.weight.attribute?
  db.subject =
    
    ## One of a group of terms describing the subject matter of a document
    element subject { db.subject.attlist, db.subjectterm+ }
}
div {
  db.subjectterm.role.attribute = attribute role { text }
  db.subjectterm.attlist =
    db.subjectterm.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.subjectterm =
    
    ## A term in a group of terms describing the subject matter of a document
    element subjectterm { db.subjectterm.attlist, text }
}
div {
  db.keywordset.role.attribute = attribute role { text }
  db.keywordset.attlist =
    db.keywordset.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.keywordset =
    
    ## A set of keywords describing the content of a document
    element keywordset { db.keywordset.attlist, db.keyword+ }
}
div {
  db.keyword.role.attribute = attribute role { text }
  db.keyword.attlist =
    db.keyword.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.keyword =
    
    ## One of a set of keywords describing the content of a document
    element keyword { db.keyword.attlist, text }
}
db.table.choice = notAllowed | db.cals.table | db.html.table
db.informaltable.choice =
  notAllowed | db.cals.informaltable | db.html.informaltable
db.table = db.table.choice
db.informaltable = db.informaltable.choice
div {
  db.procedure.role.attribute = attribute role { text }
  db.procedure.attlist =
    db.procedure.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.procedure.info = db._info.title.only
  db.procedure =
    
    ## A list of operations to be performed in a well-defined sequence
    element procedure {
      db.procedure.attlist, db.procedure.info, db.all.blocks*, db.step+
    }
}
div {
  db.step.role.attribute = attribute role { text }
  db.step.attlist =
    db.step.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.performance.attribute?
  db.step.info = db._info.title.only
  # 
  # This content model is blocks*, step|stepalternatives, blocks* but
  # expressed this way it avoids UPA issues in XSD and DTD versions
  db.step =
    
    ## A unit of action in a procedure
    element step {
      db.step.attlist,
      db.step.info,
      ((db.all.blocks+,
        ((db.substeps | db.stepalternatives), db.all.blocks*)?)
       | ((db.substeps | db.stepalternatives), db.all.blocks*))
    }
}
div {
  db.stepalternatives.role.attribute = attribute role { text }
  db.stepalternatives.attlist =
    db.stepalternatives.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.performance.attribute?
  db.stepalternatives.info = db._info.title.forbidden
  db.stepalternatives =
    
    ## Alternative steps in a procedure
    element stepalternatives {
      db.stepalternatives.attlist, db.stepalternatives.info, db.step+
    }
}
div {
  db.substeps.role.attribute = attribute role { text }
  db.substeps.attlist =
    db.substeps.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.performance.attribute?
  db.substeps =
    
    ## A wrapper for steps that occur within steps in a procedure
    element substeps { db.substeps.attlist, db.step+ }
}
div {
  db.sidebar.role.attribute = attribute role { text }
  db.sidebar.attlist =
    db.sidebar.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.sidebar.info = db._info.title.only
  db.sidebar =
    
    ## A portion of a document that is isolated from the main narrative flow
    [
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:sidebar"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:sidebar)"
            "sidebar must not occur in the descendants of sidebar"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element sidebar {
      db.sidebar.attlist, db.sidebar.info, db.all.blocks+
    }
}
div {
  db.abstract.role.attribute = attribute role { text }
  db.abstract.attlist =
    db.abstract.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.abstract.info = db._info.title.only
  db.abstract =
    
    ## A summary
    element abstract {
      db.abstract.attlist, db.abstract.info, db.para.blocks+
    }
}
div {
  db.personblurb.role.attribute = attribute role { text }
  db.personblurb.attlist =
    db.personblurb.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.personblurb.info = db._info.title.only
  db.personblurb =
    
    ## A short description or note about a person
    element personblurb {
      db.personblurb.attlist, db.personblurb.info, db.para.blocks+
    }
}
div {
  db.blockquote.role.attribute = attribute role { text }
  db.blockquote.attlist =
    db.blockquote.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.blockquote.info = db._info.title.only
  db.blockquote =
    
    ## A quotation set off from the main text
    element blockquote {
      db.blockquote.attlist,
      db.blockquote.info,
      db.attribution?,
      db.all.blocks+
    }
}
div {
  db.attribution.role.attribute = attribute role { text }
  db.attribution.attlist =
    db.attribution.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.attribution =
    
    ## The source of a block quote or epigraph
    element attribution {
      db.attribution.attlist,
      (db._text
       | db.person
       | db.personname
       | db.citetitle
       | db.citation)*
    }
}
div {
  db.bridgehead.renderas.enumeration =
    
    ## Render as a first-level section
    "sect1"
    | 
      ## Render as a second-level section
      "sect2"
    | 
      ## Render as a third-level section
      "sect3"
    | 
      ## Render as a fourth-level section
      "sect4"
    | 
      ## Render as a fifth-level section
      "sect5"
  db.bridgehead.renderas-enum.attribute =
    
    ## Indicates how the bridge head should be rendered
    attribute renderas { db.bridgehead.renderas.enumeration }?
  db.bridgehead.renderas-other.attribute =
    
    ## Identifies the nature of the non-standard rendering
    attribute otherrenderas { xsd:NMTOKEN }
  db.bridgehead.renderas-other.attributes =
    
    ## Indicates how the bridge head should be rendered
    attribute renderas {
      
      ## Identifies a non-standard rendering
      "other"
    }
    & db.bridgehead.renderas-other.attribute
  db.bridgehead.renderas.attribute =
    db.bridgehead.renderas-enum.attribute
    | db.bridgehead.renderas-other.attributes
  db.bridgehead.role.attribute = attribute role { text }
  db.bridgehead.attlist =
    db.bridgehead.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.bridgehead.renderas.attribute?
  db.bridgehead =
    
    ## A free-floating heading
    element bridgehead { db.bridgehead.attlist, db.all.inlines* }
}
div {
  db.remark.role.attribute = attribute role { text }
  db.remark.attlist =
    db.remark.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.remark =
    
    ## A remark (or comment) intended for presentation in a draft manuscript
    element remark { db.remark.attlist, db._text }
}
div {
  db.epigraph.role.attribute = attribute role { text }
  db.epigraph.attlist =
    db.epigraph.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.epigraph.info = db._info.title.forbidden
  db.epigraph =
    
    ## A short inscription at the beginning of a document or component
    element epigraph {
      db.epigraph.attlist,
      db.epigraph.info,
      db.attribution?,
      (db.para.blocks | db.literallayout)+
    }
}
div {
  db.footnote.role.attribute = attribute role { text }
  db.footnote.label.attribute =
    
    ## Identifies the desired footnote mark
    attribute label { xsd:NMTOKEN }
  db.footnote.attlist =
    db.footnote.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.footnote.label.attribute?
  db.footnote =
    
    ## A footnote
    [
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnote"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:footnote)"
            "footnote must not occur in the descendants of footnote"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnote"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:example)"
            "example must not occur in the descendants of footnote"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnote"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:figure)"
            "figure must not occur in the descendants of footnote"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnote"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:table)"
            "table must not occur in the descendants of footnote"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnote"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:equation)"
            "equation must not occur in the descendants of footnote"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnote"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:indexterm)"
            "indexterm must not occur in the descendants of footnote"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnote"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:sidebar)"
            "sidebar must not occur in the descendants of footnote"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnote"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:task)"
            "task must not occur in the descendants of footnote"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnote"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:epigraph)"
            "epigraph must not occur in the descendants of footnote"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnote"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:caution)"
            "caution must not occur in the descendants of footnote"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnote"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:important)"
            "important must not occur in the descendants of footnote"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnote"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:note)"
            "note must not occur in the descendants of footnote"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnote"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:tip)"
            "tip must not occur in the descendants of footnote"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnote"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:warning)"
            "warning must not occur in the descendants of footnote"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element footnote { db.footnote.attlist, db.all.blocks+ }
}
div {
  db.formalpara.role.attribute = attribute role { text }
  db.formalpara.attlist =
    db.formalpara.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.formalpara.info = db._info.title.onlyreq
  db.formalpara =
    
    ## A paragraph with a title
    element formalpara {
      db.formalpara.attlist,
      db.formalpara.info,
      db.indexing.inlines*,
      db.para
    }
}
div {
  db.para.role.attribute = attribute role { text }
  db.para.attlist =
    db.para.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.para.info = db._info.title.forbidden
  db.para =
    
    ## A paragraph
    [
      s:pattern [
        name = "Root must have version"
        "\x{a}" ~
        "          "
        s:rule [
          context = "/db:para"
          "\x{a}" ~
          "            "
          s:assert [
            test = "@version"
            "The root element must have a version attribute."
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element para {
      db.para.attlist,
      db.para.info,
      (db.all.inlines | db.nopara.blocks)*
    }
}
div {
  db.simpara.role.attribute = attribute role { text }
  db.simpara.attlist =
    db.simpara.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.simpara.info = db._info.title.forbidden
  db.simpara =
    
    ## A paragraph that contains only text and inline markup, no block elements
    element simpara {
      db.simpara.attlist, db.simpara.info, db.all.inlines*
    }
}
div {
  db.itemizedlist.role.attribute = attribute role { text }
  db.itemizedlist.mark.attribute =
    
    ## Identifies the type of mark to be used on items in this list
    attribute mark { xsd:NMTOKEN }
  db.itemizedlist.attlist =
    db.itemizedlist.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.spacing.attribute?
    & db.itemizedlist.mark.attribute?
  db.itemizedlist.info = db._info.title.only
  db.itemizedlist =
    
    ## A list in which each entry is marked with a bullet or other dingbat
    element itemizedlist {
      db.itemizedlist.attlist,
      db.itemizedlist.info,
      db.all.blocks*,
      db.listitem+
    }
}
div {
  db.orderedlist.role.attribute = attribute role { text }
  db.orderedlist.continuation.enumeration =
    
    ## Specifies that numbering should begin where the preceding list left off
    "continues"
    | 
      ## Specifies that numbering should begin again at 1
      "restarts"
  db.orderedlist.continuation.attribute =
    
    ## Indicates how list numbering should begin relative to the immediately preceding list
    attribute continuation { db.orderedlist.continuation.enumeration }
  db.orderedlist.startingnumber.attribute =
    
    ## Specifies the initial line number.
    attribute startingnumber { xsd:integer }
  db.orderedlist.inheritnum.enumeration =
    
    ## Specifies that numbering should ignore list nesting
    "ignore"
    | 
      ## Specifies that numbering should inherit from outer-level lists
      "inherit"
  db.orderedlist.inheritnum.attribute =
    
    ## Indicates whether or not item numbering should be influenced by list nesting
    attribute inheritnum { db.orderedlist.inheritnum.enumeration }
  db.orderedlist.numeration.enumeration =
    
    ## Specifies Arabic numeration (1, 2, 3, …)
    "arabic"
    | 
      ## Specifies upper-case alphabetic numeration (A, B, C, …)
      "upperalpha"
    | 
      ## Specifies lower-case alphabetic numeration (a, b, c, …)
      "loweralpha"
    | 
      ## Specifies upper-case Roman numeration (I, II, III, …)
      "upperroman"
    | 
      ## Specifies lower-case Roman numeration (i, ii, iii …)
      "lowerroman"
  db.orderedlist.numeration.attribute =
    
    ## Indicates the desired numeration
    attribute numeration { db.orderedlist.numeration.enumeration }
  db.orderedlist.attlist =
    db.orderedlist.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.spacing.attribute?
    & (db.orderedlist.continuation.attribute
       | db.orderedlist.startingnumber.attribute)?
    & db.orderedlist.inheritnum.attribute?
    & db.orderedlist.numeration.attribute?
  db.orderedlist.info = db._info.title.only
  db.orderedlist =
    
    ## A list in which each entry is marked with a sequentially incremented label
    element orderedlist {
      db.orderedlist.attlist,
      db.orderedlist.info,
      db.all.blocks*,
      db.listitem+
    }
}
div {
  db.listitem.role.attribute = attribute role { text }
  db.listitem.override.attribute =
    
    ## Specifies the keyword for the type of mark that should be used on this
    ##  item, instead of the mark that would be used by default
    attribute override { xsd:NMTOKEN }
  db.listitem.attlist =
    db.listitem.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.listitem.override.attribute?
  db.listitem =
    
    ## A wrapper for the elements of a list item
    element listitem { db.listitem.attlist, db.all.blocks+ }
}
div {
  db.segmentedlist.role.attribute = attribute role { text }
  db.segmentedlist.attlist =
    db.segmentedlist.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.segmentedlist.info = db._info.title.only
  db.segmentedlist =
    
    ## A segmented list, a list of sets of elements
    element segmentedlist {
      db.segmentedlist.attlist,
      db.segmentedlist.info,
      db.segtitle+,
      db.seglistitem+
    }
}
div {
  db.segtitle.role.attribute = attribute role { text }
  db.segtitle.attlist =
    db.segtitle.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.segtitle =
    
    ## The title of an element of a list item in a segmented list
    element segtitle { db.segtitle.attlist, db.all.inlines* }
}
div {
  db.seglistitem.role.attribute = attribute role { text }
  db.seglistitem.attlist =
    db.seglistitem.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.seglistitem =
    
    ## A list item in a segmented list
    [
      s:pattern [
        name = "Cardinality of segments and titles"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:seglistitem"
          "\x{a}" ~
          "            "
          s:assert [
            test = "count(db:seg) = count(../db:segtitle)"
            "The number of seg elements must be the same as the number of segtitle elements in the parent segmentedlist"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element seglistitem { db.seglistitem.attlist, db.seg+ }
}
div {
  db.seg.role.attribute = attribute role { text }
  db.seg.attlist =
    db.seg.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.seg =
    
    ## An element of a list item in a segmented list
    element seg { db.seg.attlist, db.all.inlines* }
}
div {
  db.simplelist.role.attribute = attribute role { text }
  db.simplelist.type.enumeration =
    
    ## A tabular presentation in row-major order.
    "horiz"
    | 
      ## A tabular presentation in column-major order.
      "vert"
    | 
      ## An inline presentation, usually a comma-delimited list.
      "inline"
  db.simplelist.type.attribute =
    
    ## Specifies the type of list presentation.
    [ a:defaultValue = "vert" ]
    attribute type { db.simplelist.type.enumeration }
  db.simplelist.columns.attribute =
    
    ## Specifies the number of columns for horizontal or vertical presentation
    attribute columns { xsd:integer }
  db.simplelist.attlist =
    db.simplelist.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.simplelist.type.attribute?
    & db.simplelist.columns.attribute?
  db.simplelist =
    
    ## An undecorated list of single words or short phrases
    element simplelist { db.simplelist.attlist, db.member+ }
}
div {
  db.member.role.attribute = attribute role { text }
  db.member.attlist =
    db.member.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.member =
    
    ## An element of a simple list
    element member { db.member.attlist, db.all.inlines* }
}
div {
  db.variablelist.role.attribute = attribute role { text }
  db.variablelist.termlength.attribute =
    
    ## Indicates a length beyond which the presentation system may consider a term too long and select an alternate presentation for that term, item, or list
    attribute termlength { text }
  db.variablelist.attlist =
    db.variablelist.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.spacing.attribute?
    & db.variablelist.termlength.attribute?
  db.variablelist.info = db._info.title.only
  db.variablelist =
    
    ## A list in which each entry is composed of a set of one or more terms and an associated description
    element variablelist {
      db.variablelist.attlist,
      db.variablelist.info,
      db.all.blocks*,
      db.varlistentry+
    }
}
div {
  db.varlistentry.role.attribute = attribute role { text }
  db.varlistentry.attlist =
    db.varlistentry.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.varlistentry =
    
    ## A wrapper for a set of terms and the associated description in a variable list
    element varlistentry {
      db.varlistentry.attlist, db.term+, db.listitem
    }
}
div {
  db.term.role.attribute = attribute role { text }
  db.term.attlist =
    db.term.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.term =
    
    ## The word or phrase being defined or described in a variable list
    element term { db.term.attlist, db.all.inlines* }
}
div {
  db.example.role.attribute = attribute role { text }
  db.example.label.attribute = db.label.attribute
  db.example.width.attribute = db.width.characters.attribute
  db.example.pgwide.attribute = db.pgwide.attribute
  db.example.floatstyle.attribute = db.floatstyle.attribute
  db.example.attlist =
    db.example.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.example.label.attribute?
    & db.example.floatstyle.attribute?
    & (db.example.width.attribute | db.example.pgwide.attribute)?
  db.example.info = db._info.title.onlyreq
  db.example =
    
    ## A formal example, with a title
    [
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:example"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:example)"
            "example must not occur in the descendants of example"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:example"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:figure)"
            "figure must not occur in the descendants of example"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:example"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:table)"
            "table must not occur in the descendants of example"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:example"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:equation)"
            "equation must not occur in the descendants of example"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:example"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:caution)"
            "caution must not occur in the descendants of example"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:example"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:important)"
            "important must not occur in the descendants of example"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:example"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:note)"
            "note must not occur in the descendants of example"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:example"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:tip)"
            "tip must not occur in the descendants of example"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:example"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:warning)"
            "warning must not occur in the descendants of example"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element example {
      db.example.attlist, db.example.info, db.all.blocks+, db.caption?
    }
}
div {
  db.informalexample.role.attribute = attribute role { text }
  db.informalexample.width.attribute = db.width.characters.attribute
  db.informalexample.floatstyle.attribute = db.floatstyle.attribute
  db.informalexample.attlist =
    db.informalexample.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.informalexample.floatstyle.attribute?
    & db.informalexample.width.attribute?
  db.informalexample.info = db._info.title.forbidden
  db.informalexample =
    
    ## A displayed example without a title
    element informalexample {
      db.informalexample.attlist,
      db.informalexample.info,
      db.all.blocks+,
      db.caption?
    }
}
db.verbatim.inlines = (db.all.inlines | db.lineannotation) | db.co
db.verbatim.contentmodel =
  db._info.title.forbidden, (db.textobject | db.verbatim.inlines*)
div {
  db.literallayout.role.attribute = attribute role { text }
  db.literallayout.class.enumeration =
    
    ## The literal layout should be formatted with a monospaced font
    "monospaced"
    | 
      ## The literal layout should be formatted with the current font
      "normal"
  db.literallayout.class.attribute =
    
    ## Specifies the class of literal layout
    attribute class { db.literallayout.class.enumeration }
  db.literallayout.attlist =
    db.literallayout.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.verbatim.attributes
    & db.literallayout.class.attribute?
  db.literallayout =
    
    ## A block of text in which line breaks and white space are to be reproduced faithfully
    element literallayout {
      db.literallayout.attlist, db.verbatim.contentmodel
    }
}
div {
  db.screen.role.attribute = attribute role { text }
  db.screen.width.attribute = db.width.characters.attribute
  db.screen.attlist =
    db.screen.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.verbatim.attributes
    & db.screen.width.attribute?
  db.screen =
    
    ## Text that a user sees or might see on a computer screen
    element screen { db.screen.attlist, db.verbatim.contentmodel }
}
div {
  db.screenshot.role.attribute = attribute role { text }
  db.screenshot.attlist =
    db.screenshot.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.screenshot.info = db._info
  db.screenshot =
    
    ## A representation of what the user sees or might see on a computer screen
    element screenshot {
      db.screenshot.attlist, db.screenshot.info, db.mediaobject
    }
}
div {
  db.figure.role.attribute = attribute role { text }
  db.figure.label.attribute = db.label.attribute
  db.figure.pgwide.attribute = db.pgwide.attribute
  db.figure.floatstyle.attribute = db.floatstyle.attribute
  db.figure.attlist =
    db.figure.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.figure.label.attribute?
    & db.figure.pgwide.attribute?
    & db.figure.floatstyle.attribute?
  db.figure.info = db._info.title.onlyreq
  db.figure =
    
    ## A formal figure, generally an illustration, with a title
    [
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:figure"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:example)"
            "example must not occur in the descendants of figure"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:figure"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:figure)"
            "figure must not occur in the descendants of figure"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:figure"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:table)"
            "table must not occur in the descendants of figure"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:figure"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:equation)"
            "equation must not occur in the descendants of figure"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:figure"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:caution)"
            "caution must not occur in the descendants of figure"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:figure"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:important)"
            "important must not occur in the descendants of figure"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:figure"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:note)"
            "note must not occur in the descendants of figure"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:figure"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:tip)"
            "tip must not occur in the descendants of figure"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:figure"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:warning)"
            "warning must not occur in the descendants of figure"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element figure {
      db.figure.attlist, db.figure.info, db.all.blocks+, db.caption?
    }
}
div {
  db.informalfigure.role.attribute = attribute role { text }
  db.informalfigure.label.attribute = db.label.attribute
  db.informalfigure.pgwide.attribute = db.pgwide.attribute
  db.informalfigure.floatstyle.attribute = db.floatstyle.attribute
  db.informalfigure.attlist =
    db.informalfigure.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.informalfigure.label.attribute?
    & db.informalfigure.pgwide.attribute?
    & db.informalfigure.floatstyle.attribute?
  db.informalfigure.info = db._info.title.forbidden
  db.informalfigure =
    
    ## A untitled figure
    element informalfigure {
      db.informalfigure.attlist,
      db.informalfigure.info,
      db.all.blocks+,
      db.caption?
    }
}
db.mediaobject.content =
  (db.videoobject | db.audioobject | db.imageobject | db.textobject)
  | db.imageobjectco
div {
  db.mediaobject.role.attribute = attribute role { text }
  db.mediaobject.attlist =
    db.mediaobject.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.mediaobject.info = db._info.title.forbidden
  db.mediaobject =
    
    ## A displayed media object (video, audio, image, etc.)
    element mediaobject {
      db.mediaobject.attlist,
      db.mediaobject.info,
      db.alt?,
      db.mediaobject.content+,
      db.caption?
    }
}
div {
  db.inlinemediaobject.role.attribute = attribute role { text }
  db.inlinemediaobject.attlist =
    db.inlinemediaobject.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.inlinemediaobject.info = db._info.title.forbidden
  db.inlinemediaobject =
    
    ## An inline media object (video, audio, image, and so on)
    element inlinemediaobject {
      db.inlinemediaobject.attlist,
      db.inlinemediaobject.info,
      db.alt?,
      db.mediaobject.content+
    }
}
div {
  db.videoobject.role.attribute = attribute role { text }
  db.videoobject.attlist =
    db.videoobject.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.videoobject.info = db._info.title.forbidden
  db.videoobject =
    
    ## A wrapper for video data and its associated meta-information
    element videoobject {
      db.videoobject.attlist, db.videoobject.info, db.videodata
    }
}
div {
  db.audioobject.role.attribute = attribute role { text }
  db.audioobject.attlist =
    db.audioobject.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.audioobject.info = db._info.title.forbidden
  db.audioobject =
    
    ## A wrapper for audio data and its associated meta-information
    element audioobject {
      db.audioobject.attlist, db.audioobject.info, db.audiodata
    }
}
db.imageobject.content =
  db.imagedata | db.imagedata.mathml | db.imagedata.svg
div {
  db.imageobject.role.attribute = attribute role { text }
  db.imageobject.attlist =
    db.imageobject.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.imageobject.info = db._info.title.forbidden
  db.imageobject =
    
    ## A wrapper for image data and its associated meta-information
    element imageobject {
      db.imageobject.attlist,
      db.imageobject.info,
      db.imageobject.content
    }
}
div {
  db.textobject.role.attribute = attribute role { text }
  db.textobject.attlist =
    db.textobject.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.textobject.info = db._info.title.forbidden
  db.textobject =
    
    ## A wrapper for a text description of an object and its associated meta-information
    element textobject {
      db.textobject.attlist,
      db.textobject.info,
      (db.phrase | db.textdata | db.all.blocks+)
    }
}
div {
  db.videodata.role.attribute = attribute role { text }
  db.videodata.align.enumeration = db.halign.enumeration
  db.videodata.align.attribute =
    
    ## Specifies the (horizontal) alignment of the video data
    attribute align { db.videodata.align.enumeration }
  db.videodata.valign.enumeration = db.valign.enumeration
  db.videodata.valign.attribute =
    
    ## Specifies the vertical alignment of the video data
    attribute valign { db.videodata.valign.enumeration }
  db.videodata.width.attribute = db.width.attribute
  db.videodata.depth.attribute = db.depth.attribute
  db.videodata.contentwidth.attribute = db.contentwidth.attribute
  db.videodata.contentdepth.attribute = db.contentdepth.attribute
  db.videodata.scalefit.enumeration = db.scalefit.enumeration
  db.videodata.scalefit.attribute =
    
    ## Determines if anamorphic scaling is forbidden
    attribute scalefit { db.videodata.scalefit.enumeration }
  db.videodata.scale.attribute = db.scale.attribute
  db.videodata.attlist =
    db.videodata.role.attribute?
    & db.common.attributes
    & db.common.data.attributes
    & db.videodata.align.attribute?
    & db.videodata.valign.attribute?
    & db.videodata.width.attribute?
    & db.videodata.contentwidth.attribute?
    & db.videodata.scalefit.attribute?
    & db.videodata.scale.attribute?
    & db.videodata.depth.attribute?
    & db.videodata.contentdepth.attribute?
  db.videodata.info = db._info.title.forbidden
  db.videodata =
    
    ## Pointer to external video data
    element videodata { db.videodata.attlist, db.videodata.info }
}
div {
  db.audiodata.role.attribute = attribute role { text }
  db.audiodata.attlist =
    db.audiodata.role.attribute?
    & db.common.attributes
    & db.common.data.attributes
  db.audiodata.info = db._info.title.forbidden
  db.audiodata =
    
    ## Pointer to external audio data
    element audiodata { db.audiodata.attlist, db.audiodata.info }
}
div {
  db.imagedata.role.attribute = attribute role { text }
  db.imagedata.align.enumeration = db.halign.enumeration
  db.imagedata.align.attribute =
    
    ## Specifies the (horizontal) alignment of the image data
    attribute align { db.imagedata.align.enumeration }
  db.imagedata.valign.enumeration = db.valign.enumeration
  db.imagedata.valign.attribute =
    
    ## Specifies the vertical alignment of the image data
    attribute valign { db.imagedata.valign.enumeration }
  db.imagedata.width.attribute = db.width.attribute
  db.imagedata.depth.attribute = db.depth.attribute
  db.imagedata.contentwidth.attribute = db.contentwidth.attribute
  db.imagedata.contentdepth.attribute = db.contentdepth.attribute
  db.imagedata.scalefit.enumeration = db.scalefit.enumeration
  db.imagedata.scalefit.attribute =
    
    ## Determines if anamorphic scaling is forbidden
    attribute scalefit { db.imagedata.scalefit.enumeration }
  db.imagedata.scale.attribute = db.scale.attribute
  db.imagedata.attlist =
    db.imagedata.role.attribute?
    & db.common.attributes
    & db.common.data.attributes
    & db.imagedata.align.attribute?
    & db.imagedata.valign.attribute?
    & db.imagedata.width.attribute?
    & db.imagedata.contentwidth.attribute?
    & db.imagedata.scalefit.attribute?
    & db.imagedata.scale.attribute?
    & db.imagedata.depth.attribute?
    & db.imagedata.contentdepth.attribute?
  db.imagedata.info = db._info.title.forbidden
  db.imagedata =
    
    ## Pointer to external image data
    element imagedata { db.imagedata.attlist, db.imagedata.info }
}
div {
  db.textdata.role.attribute = attribute role { text }
  db.textdata.encoding.attribute =
    
    ## Identifies the encoding of the text in the external file
    attribute encoding { text }
  db.textdata.attlist =
    db.textdata.role.attribute?
    & db.common.attributes
    & db.common.data.attributes
    & db.textdata.encoding.attribute?
  db.textdata.info = db._info.title.forbidden
  db.textdata =
    
    ## Pointer to external text data
    element textdata { db.textdata.attlist, db.textdata.info }
}
div {
  db.caption.role.attribute = attribute role { text }
  db.caption.attlist =
    db.caption.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.caption.info = db._info.title.forbidden
  db.caption =
    
    ## A caption
    [
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:caption"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:example)"
            "example must not occur in the descendants of caption"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:caption"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:figure)"
            "figure must not occur in the descendants of caption"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:caption"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:table)"
            "table must not occur in the descendants of caption"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:caption"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:equation)"
            "equation must not occur in the descendants of caption"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:caption"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:sidebar)"
            "sidebar must not occur in the descendants of caption"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:caption"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:task)"
            "task must not occur in the descendants of caption"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:caption"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:caution)"
            "caution must not occur in the descendants of caption"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:caption"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:important)"
            "important must not occur in the descendants of caption"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:caption"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:note)"
            "note must not occur in the descendants of caption"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:caption"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:tip)"
            "tip must not occur in the descendants of caption"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:caption"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:warning)"
            "warning must not occur in the descendants of caption"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element caption {
      db.caption.attlist, db.caption.info, db.all.blocks+
    }
}
div {
  db.address.role.attribute = attribute role { text }
  db.address.attlist =
    db.address.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.verbatim.attributes
  db.address =
    
    ## A real-world address, generally a postal address
    element address {
      db.address.attlist,
      (db._text
       | db.personname
       | db.pob
       | db.street
       | db.city
       | db.state
       | db.postcode
       | db.country
       | db.phone
       | db.fax
       | db.email
       | db.uri
       | db.otheraddr)*
    }
}
div {
  db.street.role.attribute = attribute role { text }
  db.street.attlist =
    db.street.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.street =
    
    ## A street address in an address
    element street { db.street.attlist, db._text }
}
div {
  db.pob.role.attribute = attribute role { text }
  db.pob.attlist =
    db.pob.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.pob =
    
    ## A post office box in an address
    element pob { db.pob.attlist, db._text }
}
div {
  db.postcode.role.attribute = attribute role { text }
  db.postcode.attlist =
    db.postcode.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.postcode =
    
    ## A postal code in an address
    element postcode { db.postcode.attlist, db._text }
}
div {
  db.city.role.attribute = attribute role { text }
  db.city.attlist =
    db.city.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.city =
    
    ## The name of a city in an address
    element city { db.city.attlist, db._text }
}
div {
  db.state.role.attribute = attribute role { text }
  db.state.attlist =
    db.state.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.state =
    
    ## A state or province in an address
    element state { db.state.attlist, db._text }
}
div {
  db.country.role.attribute = attribute role { text }
  db.country.attlist =
    db.country.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.country =
    
    ## The name of a country
    element country { db.country.attlist, db._text }
}
div {
  db.phone.role.attribute = attribute role { text }
  db.phone.attlist =
    db.phone.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.phone =
    
    ## A telephone number
    element phone { db.phone.attlist, db._text }
}
div {
  db.fax.role.attribute = attribute role { text }
  db.fax.attlist =
    db.fax.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.fax =
    
    ## A fax number
    element fax { db.fax.attlist, db._text }
}
div {
  db.otheraddr.role.attribute = attribute role { text }
  db.otheraddr.attlist =
    db.otheraddr.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.otheraddr =
    
    ## Uncategorized information in address
    element otheraddr { db.otheraddr.attlist, db._text }
}
div {
  db.affiliation.role.attribute = attribute role { text }
  db.affiliation.attlist =
    db.affiliation.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.affiliation =
    
    ## The institutional affiliation of an individual
    element affiliation {
      db.affiliation.attlist,
      db.shortaffil?,
      db.jobtitle*,
      (db.org? | (db.orgname?, db.orgdiv*, db.address*))
    }
}
div {
  db.shortaffil.role.attribute = attribute role { text }
  db.shortaffil.attlist =
    db.shortaffil.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.shortaffil =
    
    ## A brief description of an affiliation
    element shortaffil { db.shortaffil.attlist, db._text }
}
div {
  db.jobtitle.role.attribute = attribute role { text }
  db.jobtitle.attlist =
    db.jobtitle.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.jobtitle =
    
    ## The title of an individual in an organization
    element jobtitle { db.jobtitle.attlist, db._text }
}
div {
  db.orgname.class.enumeration =
    
    ## A consortium
    "consortium"
    | 
      ## A corporation
      "corporation"
    | 
      ## An informal organization
      "informal"
    | 
      ## A non-profit organization
      "nonprofit"
  db.orgname.class-enum.attribute =
    
    ## Specifies the nature of the organization
    attribute class { db.orgname.class.enumeration }
  db.orgname.class-other.attributes =
    
    ## Specifies the nature of the organization
    attribute class {
      
      ## Indicates a non-standard organization class
      "other"
    },
    
    ## Identifies the non-standard nature of the organization
    attribute otherclass { text }
  db.orgname.class.attribute =
    db.orgname.class-enum.attribute | db.orgname.class-other.attributes
  db.orgname.role.attribute = attribute role { text }
  db.orgname.attlist =
    db.orgname.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.orgname.class.attribute?
  db.orgname =
    
    ## The name of an organization other than a corporation 
    element orgname { db.orgname.attlist, db._text }
}
div {
  db.orgdiv.role.attribute = attribute role { text }
  db.orgdiv.attlist =
    db.orgdiv.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.orgdiv =
    
    ## A division of an organization
    element orgdiv { db.orgdiv.attlist, db.all.inlines* }
}
div {
  db.artpagenums.role.attribute = attribute role { text }
  db.artpagenums.attlist =
    db.artpagenums.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.artpagenums =
    
    ## The page numbers of an article as published
    element artpagenums { db.artpagenums.attlist, db._text }
}
div {
  db.personname.role.attribute = attribute role { text }
  db.personname.attlist =
    db.personname.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.personname =
    
    ## The personal name of an individual
    element personname {
      db.personname.attlist,
      (db._text
       | (db.honorific
          | db.firstname
          | db.surname
          | db.lineage
          | db.othername)+)
    }
}
db.person.author.contentmodel =
  db.personname,
  (db.personblurb
   | db.affiliation
   | db.email
   | db.uri
   | db.address
   | db.contrib)*
db.org.author.contentmodel =
  db.orgname,
  (db.orgdiv
   | db.affiliation
   | db.email
   | db.uri
   | db.address
   | db.contrib)*
db.credit.contentmodel =
  db.person.author.contentmodel | db.org.author.contentmodel
div {
  db.author.role.attribute = attribute role { text }
  db.author.attlist =
    db.author.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.author =
    
    ## The name of an individual author
    element author { db.author.attlist, db.credit.contentmodel }
}
div {
  db.authorgroup.role.attribute = attribute role { text }
  db.authorgroup.attlist =
    db.authorgroup.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.authorgroup =
    
    ## Wrapper for author information when a document has multiple authors or collabarators
    element authorgroup {
      db.authorgroup.attlist, (db.author | db.editor | db.othercredit)+
    }
}
div {
  db.collab.role.attribute = attribute role { text }
  db.collab.attlist =
    db.collab.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.collab =
    
    ## Identifies a collaborator
    element collab {
      db.collab.attlist,
      (db.person | db.personname | db.org | db.orgname)+,
      db.affiliation*
    }
}
div {
  db.authorinitials.role.attribute = attribute role { text }
  db.authorinitials.attlist =
    db.authorinitials.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.authorinitials =
    
    ## The initials or other short identifier for an author
    element authorinitials { db.authorinitials.attlist, db._text }
}
div {
  db.person.role.attribute = attribute role { text }
  db.person.attlist =
    db.person.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.person =
    
    ## A person and associated metadata
    element person {
      db.person.attlist,
      db.personname,
      (db.address
       | db.affiliation
       | db.email
       | db.uri
       | db.personblurb)*
    }
}
div {
  db.org.role.attribute = attribute role { text }
  db.org.attlist =
    db.org.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.org =
    
    ## An organization and associated metadata
    element org {
      db.org.attlist,
      db.orgname,
      (db.address | db.affiliation | db.email | db.uri | db.orgdiv)*
    }
}
div {
  db.confgroup.role.attribute = attribute role { text }
  db.confgroup.attlist =
    db.confgroup.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.confgroup =
    
    ## A wrapper for document meta-information about a conference
    element confgroup {
      db.confgroup.attlist,
      (db.confdates
       | db.conftitle
       | db.confnum
       | db.confsponsor
       | db.address)*
    }
}
div {
  db.confdates.role.attribute = attribute role { text }
  db.confdates.attlist =
    db.confdates.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.confdates =
    
    ## The dates of a conference for which a document was written
    element confdates { db.confdates.attlist, db._text }
}
div {
  db.conftitle.role.attribute = attribute role { text }
  db.conftitle.attlist =
    db.conftitle.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.conftitle =
    
    ## The title of a conference for which a document was written
    element conftitle { db.conftitle.attlist, db._text }
}
div {
  db.confnum.role.attribute = attribute role { text }
  db.confnum.attlist =
    db.confnum.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.confnum =
    
    ## An identifier, frequently numerical, associated with a conference for which a document was written
    element confnum { db.confnum.attlist, db._text }
}
div {
  db.confsponsor.role.attribute = attribute role { text }
  db.confsponsor.attlist =
    db.confsponsor.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.confsponsor =
    
    ## The sponsor of a conference for which a document was written
    element confsponsor { db.confsponsor.attlist, db._text }
}
div {
  db.contractnum.role.attribute = attribute role { text }
  db.contractnum.attlist =
    db.contractnum.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.contractnum =
    
    ## The contract number of a document
    element contractnum { db.contractnum.attlist, db._text }
}
div {
  db.contractsponsor.role.attribute = attribute role { text }
  db.contractsponsor.attlist =
    db.contractsponsor.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.contractsponsor =
    
    ## The sponsor of a contract
    element contractsponsor { db.contractsponsor.attlist, db._text }
}
div {
  db.copyright.role.attribute = attribute role { text }
  db.copyright.attlist =
    db.copyright.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.copyright =
    
    ## Copyright information about a document
    element copyright { db.copyright.attlist, db.year+, db.holder* }
}
div {
  db.year.role.attribute = attribute role { text }
  db.year.attlist =
    db.year.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.year =
    
    ## The year of publication of a document
    element year { db.year.attlist, db._text }
}
div {
  db.holder.role.attribute = attribute role { text }
  db.holder.attlist =
    db.holder.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.holder =
    
    ## The name of the individual or organization that holds a copyright
    element holder { db.holder.attlist, db._text }
}
db.cover.contentmodel =
  (db.para.blocks
   | db.extension.blocks
   | db.list.blocks
   | db.informal.blocks
   | db.publishing.blocks
   | db.graphic.blocks
   | db.technical.blocks
   | db.verbatim.blocks
   | db.bridgehead
   | db.remark
   | db.revhistory)
  | db.synopsis.blocks
div {
  db.cover.role.attribute = attribute role { text }
  db.cover.attlist =
    db.cover.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.cover =
    
    ## Additional content for the cover of a publication
    element cover { db.cover.attlist, db.cover.contentmodel+ }
}
db.date.contentmodel =
  xsd:date | xsd:dateTime | xsd:gYearMonth | xsd:gYear | text
div {
  db.date.role.attribute = attribute role { text }
  db.date.attlist =
    db.date.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.date =
    
    ## The date of publication or revision of a document
    element date { db.date.attlist, db.date.contentmodel }
}
div {
  db.edition.role.attribute = attribute role { text }
  db.edition.attlist =
    db.edition.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.edition =
    
    ## The name or number of an edition of a document
    element edition { db.edition.attlist, db._text }
}
div {
  db.editor.role.attribute = attribute role { text }
  db.editor.attlist =
    db.editor.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.editor =
    
    ## The name of the editor of a document
    element editor { db.editor.attlist, db.credit.contentmodel }
}
div {
  db.biblioid.role.attribute = attribute role { text }
  db.biblioid.attlist =
    db.biblioid.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.biblio.class.attribute
  db.biblioid =
    
    ## An identifier for a document
    element biblioid { db.biblioid.attlist, db._text }
}
div {
  db.citebiblioid.role.attribute = attribute role { text }
  db.citebiblioid.attlist =
    db.citebiblioid.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.biblio.class.attribute
  db.citebiblioid =
    
    ## A citation of a bibliographic identifier
    element citebiblioid { db.citebiblioid.attlist, db._text }
}
div {
  db.bibliosource.role.attribute = attribute role { text }
  db.bibliosource.attlist =
    db.bibliosource.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.biblio.class.attribute
  db.bibliosource =
    
    ## The source of a document
    element bibliosource { db.bibliosource.attlist, db._text }
}
div {
  db.bibliorelation.type.enumeration =
    
    ## The described resource pre-existed the referenced resource, which is essentially the same intellectual content presented in another format
    "hasformat"
    | 
      ## The described resource includes the referenced resource either physically or logically
      "haspart"
    | 
      ## The described resource has a version, edition, or adaptation, namely, the referenced resource
      "hasversion"
    | 
      ## The described resource is the same intellectual content of the referenced resource, but presented in another format
      "isformatof"
    | 
      ## The described resource is a physical or logical part of the referenced resource
      "ispartof"
    | 
      ## The described resource is referenced, cited, or otherwise pointed to by the referenced resource
      "isreferencedby"
    | 
      ## The described resource is supplanted, displaced, or superceded by the referenced resource
      "isreplacedby"
    | 
      ## The described resource is required by the referenced resource, either physically or logically
      "isrequiredby"
    | 
      ## The described resource is a version, edition, or adaptation of the referenced resource; changes in version imply substantive changes in content rather than differences in format
      "isversionof"
    | 
      ## The described resource references, cites, or otherwise points to the referenced resource
      "references"
    | 
      ## The described resource supplants, displaces, or supersedes the referenced resource
      "replaces"
    | 
      ## The described resource requires the referenced resource to support its function, delivery, or coherence of content
      "requires"
  db.bibliorelation.type-enum.attribute =
    
    ## Identifies the type of relationship
    attribute type { db.bibliorelation.type.enumeration }?
  db.bibliorelation.type-other.attributes =
    
    ## Identifies the type of relationship
    attribute type {
      
      ## The described resource has a non-standard relationship with the referenced resource
      "othertype"
    }?,
    
    ## A keyword that identififes the type of the non-standard relationship
    attribute othertype { xsd:NMTOKEN }
  db.bibliorelation.type.attribute =
    db.bibliorelation.type-enum.attribute
    | db.bibliorelation.type-other.attributes
  db.bibliorelation.role.attribute = attribute role { text }
  db.bibliorelation.attlist =
    db.bibliorelation.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.biblio.class.attribute
    & db.bibliorelation.type.attribute
  db.bibliorelation =
    
    ## The relationship of a document to another
    element bibliorelation { db.bibliorelation.attlist, db._text }
}
div {
  db.bibliocoverage.spacial.enumeration =
    
    ## The DCMI Point identifies a point in space using its geographic coordinates
    "dcmipoint"
    | 
      ## ISO 3166 Codes for the representation of names of countries
      "iso3166"
    | 
      ## The DCMI Box identifies a region of space using its geographic limits
      "dcmibox"
    | 
      ## The Getty Thesaurus of Geographic Names
      "tgn"
  db.bibliocoverage.spatial-enum.attribute =
    
    ## Specifies the type of spatial coverage
    attribute spatial { db.bibliocoverage.spacial.enumeration }?
  db.bibliocoverage.spatial-other.attributes =
    
    ## Specifies the type of spatial coverage
    attribute spatial {
      
      ## Identifies a non-standard type of coverage
      "otherspatial"
    }?,
    
    ## A keyword that identifies the type of non-standard coverage
    attribute otherspatial { xsd:NMTOKEN }
  db.bibliocoverage.spatial.attribute =
    db.bibliocoverage.spatial-enum.attribute
    | db.bibliocoverage.spatial-other.attributes
  db.bibliocoverage.temporal.enumeration =
    
    ## A specification of the limits of a time interval
    "dcmiperiod"
    | 
      ## W3C Encoding rules for dates and times—a profile based on ISO 8601
      "w3c-dtf"
  db.bibliocoverage.temporal-enum.attribute =
    
    ## Specifies the type of temporal coverage
    attribute temporal { db.bibliocoverage.temporal.enumeration }?
  db.bibliocoverage.temporal-other.attributes =
    
    ## Specifies the type of temporal coverage
    attribute temporal {
      
      ## Specifies a non-standard type of coverage
      "othertemporal"
    }?,
    
    ## A keyword that identifies the type of non-standard coverage
    attribute othertemporal { xsd:NMTOKEN }
  db.bibliocoverage.temporal.attribute =
    db.bibliocoverage.temporal-enum.attribute
    | db.bibliocoverage.temporal-other.attributes
  db.bibliocoverage.coverage.attrib =
    db.bibliocoverage.spatial.attribute
    & db.bibliocoverage.temporal.attribute
  db.bibliocoverage.role.attribute = attribute role { text }
  db.bibliocoverage.attlist =
    db.bibliocoverage.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.bibliocoverage.coverage.attrib
  db.bibliocoverage =
    
    ## The spatial or temporal coverage of a document
    element bibliocoverage { db.bibliocoverage.attlist, db._text }
}
div {
  db.legalnotice.role.attribute = attribute role { text }
  db.legalnotice.attlist =
    db.legalnotice.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.legalnotice.info = db._info.title.only
  db.legalnotice =
    
    ## A statement of legal obligations or requirements
    element legalnotice {
      db.legalnotice.attlist, db.legalnotice.info, db.all.blocks+
    }
}
div {
  db.othercredit.class.enumeration =
    
    ## A copy editor
    "copyeditor"
    | 
      ## A graphic designer
      "graphicdesigner"
    | 
      ## Some other contributor
      "other"
    | 
      ## A production editor
      "productioneditor"
    | 
      ## A technical editor
      "technicaleditor"
    | 
      ## A translator
      "translator"
  db.othercredit.class-enum.attribute =
    
    ## Identifies the nature of the contributor
    attribute class { db.othercredit.class.enumeration }?
  db.othercredit.class-other.attribute =
    
    ## Identifies the nature of the non-standard contribution
    attribute otherclass { xsd:NMTOKEN }
  db.othercredit.class-other.attributes =
    
    ## Identifies the nature of the contributor
    attribute class {
      
      ## Identifies a non-standard contribution
      "other"
    }
    & db.othercredit.class-other.attribute
  db.othercredit.class.attribute =
    db.othercredit.class-enum.attribute
    | db.othercredit.class-other.attributes
  db.othercredit.role.attribute = attribute role { text }
  db.othercredit.attlist =
    db.othercredit.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.othercredit.class.attribute
  db.othercredit =
    
    ## A person or entity, other than an author or editor, credited in a document
    element othercredit {
      db.othercredit.attlist, db.credit.contentmodel
    }
}
div {
  db.pagenums.role.attribute = attribute role { text }
  db.pagenums.attlist =
    db.pagenums.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.pagenums =
    
    ## The numbers of the pages in a book, for use in a bibliographic entry
    element pagenums { db.pagenums.attlist, db._text }
}
div {
  db.contrib.role.attribute = attribute role { text }
  db.contrib.attlist =
    db.contrib.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.contrib =
    
    ## A summary of the contributions made to a document by a credited source
    element contrib { db.contrib.attlist, db._text }
}
div {
  db.honorific.role.attribute = attribute role { text }
  db.honorific.attlist =
    db.honorific.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.honorific =
    
    ## The title of a person
    element honorific { db.honorific.attlist, db._text }
}
div {
  db.firstname.role.attribute = attribute role { text }
  db.firstname.attlist =
    db.firstname.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.firstname =
    
    ## The first name of a person
    element firstname { db.firstname.attlist, db._text }
}
div {
  db.surname.role.attribute = attribute role { text }
  db.surname.attlist =
    db.surname.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.surname =
    
    ## A family name; in western cultures the last name
    element surname { db.surname.attlist, db._text }
}
div {
  db.lineage.role.attribute = attribute role { text }
  db.lineage.attlist =
    db.lineage.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.lineage =
    
    ## The portion of a person's name indicating a relationship to ancestors
    element lineage { db.lineage.attlist, db._text }
}
div {
  db.othername.role.attribute = attribute role { text }
  db.othername.attlist =
    db.othername.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.othername =
    
    ## A component of a persons name that is not a first name, surname, or lineage
    element othername { db.othername.attlist, db._text }
}
div {
  db.printhistory.role.attribute = attribute role { text }
  db.printhistory.attlist =
    db.printhistory.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.printhistory =
    
    ## The printing history of a document
    element printhistory { db.printhistory.attlist, db.para.blocks+ }
}
div {
  db.pubdate.role.attribute = attribute role { text }
  db.pubdate.attlist =
    db.pubdate.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.pubdate =
    
    ## The date of publication of a document
    element pubdate { db.pubdate.attlist, db.date.contentmodel }
}
div {
  db.publisher.role.attribute = attribute role { text }
  db.publisher.attlist =
    db.publisher.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.publisher =
    
    ## The publisher of a document
    element publisher {
      db.publisher.attlist, db.publishername, db.address*
    }
}
div {
  db.publishername.role.attribute = attribute role { text }
  db.publishername.attlist =
    db.publishername.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.publishername =
    
    ## The name of the publisher of a document
    element publishername { db.publishername.attlist, db._text }
}
div {
  db.releaseinfo.role.attribute = attribute role { text }
  db.releaseinfo.attlist =
    db.releaseinfo.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.releaseinfo =
    
    ## Information about a particular release of a document
    element releaseinfo { db.releaseinfo.attlist, db._text }
}
div {
  db.revhistory.role.attribute = attribute role { text }
  db.revhistory.attlist =
    db.revhistory.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.revhistory.info = db._info.title.only
  db.revhistory =
    
    ## A history of the revisions to a document
    element revhistory {
      db.revhistory.attlist, db.revhistory.info, db.revision+
    }
}
div {
  db.revision.role.attribute = attribute role { text }
  db.revision.attlist =
    db.revision.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.revision =
    
    ## An entry describing a single revision in the history of the revisions to a document
    element revision {
      db.revision.attlist,
      db.revnumber?,
      db.date,
      (db.authorinitials | db.author)*,
      (db.revremark | db.revdescription)?
    }
}
div {
  db.revnumber.role.attribute = attribute role { text }
  db.revnumber.attlist =
    db.revnumber.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.revnumber =
    
    ## A document revision number
    element revnumber { db.revnumber.attlist, db._text }
}
div {
  db.revremark.role.attribute = attribute role { text }
  db.revremark.attlist =
    db.revremark.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.revremark =
    
    ## A description of a revision to a document
    element revremark { db.revremark.attlist, db._text }
}
div {
  db.revdescription.role.attribute = attribute role { text }
  db.revdescription.attlist =
    db.revdescription.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.revdescription =
    
    ## A extended description of a revision to a document
    element revdescription { db.revdescription.attlist, db.all.blocks* }
}
div {
  db.seriesvolnums.role.attribute = attribute role { text }
  db.seriesvolnums.attlist =
    db.seriesvolnums.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.seriesvolnums =
    
    ## Numbers of the volumes in a series of books
    element seriesvolnums { db.seriesvolnums.attlist, db._text }
}
div {
  db.volumenum.role.attribute = attribute role { text }
  db.volumenum.attlist =
    db.volumenum.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.volumenum =
    
    ## The volume number of a document in a set (as of books in a set or articles in a journal)
    element volumenum { db.volumenum.attlist, db._text }
}
div {
  db.issuenum.role.attribute = attribute role { text }
  db.issuenum.attlist =
    db.issuenum.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.issuenum =
    
    ## The number of an issue of a journal
    element issuenum { db.issuenum.attlist, db._text }
}
div {
  db.package.role.attribute = attribute role { text }
  db.package.attlist =
    db.package.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.package =
    
    ## A software or application package
    element package { db.package.attlist, db._text }
}
div {
  db.email.role.attribute = attribute role { text }
  db.email.attlist =
    db.email.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.email =
    
    ## An email address
    element email { db.email.attlist, db._text }
}
div {
  db.lineannotation.role.attribute = attribute role { text }
  db.lineannotation.attlist =
    db.lineannotation.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.lineannotation =
    
    ## A comment on a line in a verbatim listing
    element lineannotation { db.lineannotation.attlist, db._text }
}
div {
  db.parameter.class.enumeration =
    
    ## A command
    "command"
    | 
      ## A function
      "function"
    | 
      ## An option
      "option"
  db.parameter.class.attribute =
    
    ## Identifies the class of parameter
    attribute class { db.parameter.class.enumeration }
  db.parameter.role.attribute = attribute role { text }
  db.parameter.attlist =
    db.parameter.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.parameter.class.attribute?
  db.parameter =
    
    ## A value or a symbolic reference to a value
    element parameter { db.parameter.attlist, db._text }
}
db.replaceable.inlines = db._text | db.co
div {
  db.replaceable.class.enumeration =
    
    ## A command
    "command"
    | 
      ## A function
      "function"
    | 
      ## An option
      "option"
    | 
      ## A parameter
      "parameter"
  db.replaceable.class.attribute =
    
    ## Identifies the nature of the replaceable text
    attribute class { db.replaceable.class.enumeration }
  db.replaceable.role.attribute = attribute role { text }
  db.replaceable.attlist =
    db.replaceable.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.replaceable.class.attribute?
  db.replaceable =
    
    ## Content that may or must be replaced by the user
    element replaceable {
      db.replaceable.attlist, db.replaceable.inlines*
    }
}
div {
  db.uri.type.attribute =
    
    ## Identifies the type of URI specified
    attribute type { text }?
  db.uri.role.attribute = attribute role { text }
  db.uri.attlist =
    db.uri.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.uri.type.attribute
  db.uri =
    
    ## A Uniform Resource Identifier
    element uri { db.uri.attlist, db._text }
}
div {
  db.abbrev.role.attribute = attribute role { text }
  db.abbrev.attlist =
    db.abbrev.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.abbrev =
    
    ## An abbreviation, especially one followed by a period
    element abbrev {
      db.abbrev.attlist,
      (db._text | db.superscript | db.subscript | db.trademark)*
    }
}
div {
  db.acronym.role.attribute = attribute role { text }
  db.acronym.attlist =
    db.acronym.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.acronym =
    
    ## An often pronounceable word made from the initial (or selected) letters of a name or phrase
    element acronym {
      db.acronym.attlist,
      (db._text | db.superscript | db.subscript | db.trademark)*
    }
}
div {
  db.citation.role.attribute = attribute role { text }
  db.citation.attlist =
    db.citation.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.citation =
    
    ## An inline bibliographic reference to another published work
    element citation { db.citation.attlist, db.all.inlines* }
}
div {
  db.citerefentry.role.attribute = attribute role { text }
  db.citerefentry.attlist =
    db.citerefentry.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.citerefentry =
    
    ## A citation to a reference page
    element citerefentry {
      db.citerefentry.attlist, db.refentrytitle, db.manvolnum?
    }
}
div {
  db.refentrytitle.role.attribute = attribute role { text }
  db.refentrytitle.attlist =
    db.refentrytitle.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.refentrytitle =
    
    ## The title of a reference page
    element refentrytitle { db.refentrytitle.attlist, db.all.inlines* }
}
div {
  db.manvolnum.role.attribute = attribute role { text }
  db.manvolnum.attlist =
    db.manvolnum.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.manvolnum =
    
    ## A reference volume number
    element manvolnum { db.manvolnum.attlist, db._text }
}
div {
  db.citetitle.pubwork.enumeration =
    
    ## An article
    "article"
    | 
      ## A bulletin board system
      "bbs"
    | 
      ## A book
      "book"
    | 
      ## A CD-ROM
      "cdrom"
    | 
      ## A chapter (as of a book)
      "chapter"
    | 
      ## A DVD
      "dvd"
    | 
      ## An email message
      "emailmessage"
    | 
      ## A gopher page
      "gopher"
    | 
      ## A journal
      "journal"
    | 
      ## A manuscript
      "manuscript"
    | 
      ## A posting to a newsgroup
      "newsposting"
    | 
      ## A part (as of a book)
      "part"
    | 
      ## A reference entry
      "refentry"
    | 
      ## A section (as of a book or article)
      "section"
    | 
      ## A series
      "series"
    | 
      ## A set (as of books)
      "set"
    | 
      ## A web page
      "webpage"
    | 
      ## A wiki page
      "wiki"
  db.citetitle.pubwork.attribute =
    
    ## Identifies the nature of the publication being cited
    attribute pubwork { db.citetitle.pubwork.enumeration }
  db.citetitle.role.attribute = attribute role { text }
  db.citetitle.attlist =
    db.citetitle.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.citetitle.pubwork.attribute?
  db.citetitle =
    
    ## The title of a cited work
    element citetitle { db.citetitle.attlist, db.all.inlines* }
}
div {
  db.emphasis.role.attribute = attribute role { text }
  db.emphasis.attlist =
    db.emphasis.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.emphasis =
    
    ## Emphasized text
    element emphasis { db.emphasis.attlist, db.all.inlines* }
}
div {
  db._emphasis =
    
    ## A limited span of emphasized text
    element emphasis { db.emphasis.attlist, (db._text | db._emphasis)* }
}
div {
  db.foreignphrase.role.attribute = attribute role { text }
  db.foreignphrase.attlist =
    db.foreignphrase.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.foreignphrase =
    
    ## A word or phrase in a language other than the primary language of the document
    element foreignphrase {
      db.foreignphrase.attlist, (text | db.general.inlines)*
    }
}
div {
  db.phrase.role.attribute = attribute role { text }
  db.phrase.attlist =
    db.phrase.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.phrase =
    
    ## A span of text
    element phrase { db.phrase.attlist, db.all.inlines* }
}
div {
  db._phrase =
    
    ## A limited span of text
    element phrase { db.phrase.attlist, db._text }
}
div {
  db.quote.role.attribute = attribute role { text }
  db.quote.attlist =
    db.quote.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.quote =
    
    ## An inline quotation
    element quote { db.quote.attlist, db.all.inlines* }
}
div {
  db.subscript.role.attribute = attribute role { text }
  db.subscript.attlist =
    db.subscript.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.subscript =
    
    ## A subscript (as in H2
    ## O, the molecular formula for water)
    element subscript { db.subscript.attlist, db._text }
}
div {
  db.superscript.role.attribute = attribute role { text }
  db.superscript.attlist =
    db.superscript.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.superscript =
    
    ## A superscript (as in x^2, the mathematical notation for x multiplied by itself)
    element superscript { db.superscript.attlist, db._text }
}
div {
  db.trademark.class.enumeration =
    
    ## A copyright
    "copyright"
    | 
      ## A registered copyright
      "registered"
    | 
      ## A service
      "service"
    | 
      ## A trademark
      "trade"
  db.trademark.class.attribute =
    
    ## Identifies the class of trade mark
    attribute class { db.trademark.class.enumeration }
  db.trademark.role.attribute = attribute role { text }
  db.trademark.attlist =
    db.trademark.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.trademark.class.attribute?
  db.trademark =
    
    ## A trademark
    element trademark { db.trademark.attlist, db._text }
}
div {
  db.wordasword.role.attribute = attribute role { text }
  db.wordasword.attlist =
    db.wordasword.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.wordasword =
    
    ## A word meant specifically as a word and not representing anything else
    element wordasword { db.wordasword.attlist, db._text }
}
div {
  db.footnoteref.role.attribute = attribute role { text }
  db.footnoteref.label.attribute = db.label.attribute
  db.footnoteref.attlist =
    db.footnoteref.role.attribute?
    & db.common.attributes
    & db.linkend.attribute
    & db.footnoteref.label.attribute?
  db.footnoteref =
    
    ## A cross reference to a footnote (a footnote mark)
    [
      s:pattern [
        name = "Footnote reference type constraint"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:footnoteref"
          "\x{a}" ~
          "            "
          s:assert [
            test =
              "local-name(//*[@xml:id=current()/@linkend]) = 'footnote' and namespace-uri(//*[@xml:id=current()/@linkend]) = 'http://docbook.org/ns/docbook'"
            "@linkend on footnoteref must point to a footnote."
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element footnoteref { db.footnoteref.attlist, empty }
}
div {
  db.xref.role.attribute = attribute role { text }
  db.xref.xrefstyle.attribute = db.xrefstyle.attribute
  db.xref.endterm.attribute = db.endterm.attribute
  db.xref.attlist =
    db.xref.role.attribute?
    & db.common.attributes
    & db.common.req.linking.attributes
    & db.xref.xrefstyle.attribute?
    & db.xref.endterm.attribute?
  db.xref =
    
    ## A cross reference to another part of the document
    element xref { db.xref.attlist, empty }
}
div {
  db.link.role.attribute = attribute role { text }
  db.link.xrefstyle.attribute = db.xrefstyle.attribute
  db.link.endterm.attribute = db.endterm.attribute
  db.link.attlist =
    db.link.role.attribute?
    & db.common.attributes
    & db.common.req.linking.attributes
    & db.link.xrefstyle.attribute?
    & db.link.endterm.attribute?
  db.link =
    
    ## A hypertext link
    element link { db.link.attlist, db.all.inlines* }
}
div {
  db.olink.role.attribute = attribute role { text }
  db.olink.xrefstyle.attribute = db.xrefstyle.attribute
  db.olink.localinfo.attribute =
    
    ## Holds additional information that may be used by the applicatoin when resolving the link
    attribute localinfo { text }
  db.olink.targetdoc.attribute =
    
    ## Specifies the URI of the document in which the link target appears
    attribute targetdoc { xsd:anyURI }
  db.olink.targetptr.attribute =
    
    ## Specifies the location of the link target in the document
    attribute targetptr { text }
  db.olink.type.attribute =
    
    ## Identifies application-specific customization of the link behavior
    attribute type { text }
  db.olink.attlist =
    db.common.attributes
    & db.olink.targetdoc.attribute?
    & db.olink.role.attribute?
    & db.olink.xrefstyle.attribute?
    & db.olink.localinfo.attribute?
    & db.olink.targetptr.attribute?
    & db.olink.type.attribute?
  db.olink =
    
    ## A link that addresses its target indirectly
    element olink { db.olink.attlist, db.all.inlines* }
}
div {
  db.anchor.role.attribute = attribute role { text }
  db.anchor.attlist =
    db.anchor.role.attribute? & db.common.idreq.attributes
  db.anchor =
    
    ## A spot in the document
    element anchor { db.anchor.attlist, empty }
}
div {
  db.alt.role.attribute = attribute role { text }
  db.alt.attlist = db.alt.role.attribute? & db.common.attributes
  db.alt =
    
    ## A text-only annotation, often used for accessibility
    element alt { db.alt.attlist, (text | db.inlinemediaobject)* }
}
db.status.attribute =
  
  ## Identifies the editorial or publication status of the element on which it occurs
  attribute status { text }
db.toplevel.sections =
  ((db.section+, db.simplesect*) | db.simplesect+)
  | (db.sect1+, db.simplesect*)
  | db.refentry+
  | ((db.section | db.xi.include)+ | (db.simplesect | db.xi.include)+)
  | (db.refentry | db.xi.include)+
  | (db.refsect1 | db.xi.include)+
  | (db.sect1 | db.xi.include)+
db.toplevel.blocks.or.sections =
  (db.all.blocks+, db.toplevel.sections?) | db.toplevel.sections
db.recursive.sections =
  ((db.section+, db.simplesect*) | db.simplesect+)
  | db.refentry+
  | ((db.section | db.xi.include)+ | (db.simplesect | db.xi.include)+)
  | (db.refentry | db.xi.include)+
  | (db.refsect1 | db.xi.include)+
db.recursive.blocks.or.sections =
  (db.all.blocks+, db.recursive.sections?) | db.recursive.sections
db.divisions = db.part | db.reference | db.xi.include
db.components =
  (db.dedication
   | db.acknowledgements
   | db.preface
   | db.chapter
   | db.appendix
   | db.article
   | db.colophon)
  | db.xi.include
db.navigation.components =
  notAllowed | db.glossary | db.bibliography | db.index | db.toc
db.component.contentmodel =
  db.navigation.components*,
  db.toplevel.blocks.or.sections,
  db.navigation.components*
db.setindex.components = notAllowed | db.setindex
db.toc.components = notAllowed | db.toc
db.set.components = db.set | db.book
div {
  db.set.status.attribute = db.status.attribute
  db.set.role.attribute = attribute role { text }
  db.set.attlist =
    db.set.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.label.attribute?
    & db.set.status.attribute?
  db.set.info = db._info.title.req
  db.set =
    
    ## A collection of books
    [
      s:pattern [
        name = "Root must have version"
        "\x{a}" ~
        "          "
        s:rule [
          context = "/db:set"
          "\x{a}" ~
          "            "
          s:assert [
            test = "@version"
            "The root element must have a version attribute."
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element set {
      db.set.attlist,
      db.set.info,
      db.toc.components?,
      db.set.components+,
      db.setindex.components?
    }
}
div {
  db.book.status.attribute = db.status.attribute
  db.book.role.attribute = attribute role { text }
  db.book.attlist =
    db.book.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.label.attribute?
    & db.book.status.attribute?
  db.book.info = db._info
  db.book =
    
    ## A book
    [
      s:pattern [
        name = "Root must have version"
        "\x{a}" ~
        "          "
        s:rule [
          context = "/db:book"
          "\x{a}" ~
          "            "
          s:assert [
            test = "@version"
            "The root element must have a version attribute."
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element book {
      db.book.attlist,
      db.book.info,
      (db.navigation.components | db.components | db.divisions)*
    }
}
div {
  db.dedication.status.attribute = db.status.attribute
  db.dedication.role.attribute = attribute role { text }
  db.dedication.attlist =
    db.dedication.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.label.attribute?
    & db.dedication.status.attribute?
  db.dedication.info = db._info
  db.dedication =
    
    ## The dedication of a book or other component
    [
      s:pattern [
        name = "Root must have version"
        "\x{a}" ~
        "          "
        s:rule [
          context = "/db:dedication"
          "\x{a}" ~
          "            "
          s:assert [
            test = "@version"
            "The root element must have a version attribute."
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element dedication {
      db.dedication.attlist, db.dedication.info, db.all.blocks+
    }
}
div {
  db.acknowledgements.status.attribute = db.status.attribute
  db.acknowledgements.role.attribute = attribute role { text }
  db.acknowledgements.attlist =
    db.acknowledgements.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.label.attribute?
    & db.acknowledgements.status.attribute?
  db.acknowledgements.info = db._info
  db.acknowledgements =
    
    ## Acknowledgements of a book or other component
    [
      s:pattern [
        name = "Root must have version"
        "\x{a}" ~
        "          "
        s:rule [
          context = "/db:acknowledgements"
          "\x{a}" ~
          "            "
          s:assert [
            test = "@version"
            "The root element must have a version attribute."
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element acknowledgements {
      db.acknowledgements.attlist,
      db.acknowledgements.info,
      db.all.blocks+
    }
}
div {
  db.colophon.status.attribute = db.status.attribute
  db.colophon.role.attribute = attribute role { text }
  db.colophon.attlist =
    db.colophon.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.label.attribute?
    & db.colophon.status.attribute?
  db.colophon.info = db._info
  db.colophon =
    
    ## Text at the back of a book describing facts about its production
    [
      s:pattern [
        name = "Root must have version"
        "\x{a}" ~
        "          "
        s:rule [
          context = "/db:colophon"
          "\x{a}" ~
          "            "
          s:assert [
            test = "@version"
            "The root element must have a version attribute."
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element colophon {
      db.colophon.attlist, db.colophon.info, db.all.blocks+
    }
}
div {
  db.appendix.status.attribute = db.status.attribute
  db.appendix.role.attribute = attribute role { text }
  db.appendix.attlist =
    db.appendix.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.label.attribute?
    & db.appendix.status.attribute?
  db.appendix.info = db._info.title.req
  db.appendix =
    
    ## An appendix in a Book or Article
    [
      s:pattern [
        name = "Root must have version"
        "\x{a}" ~
        "          "
        s:rule [
          context = "/db:appendix"
          "\x{a}" ~
          "            "
          s:assert [
            test = "@version"
            "The root element must have a version attribute."
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element appendix {
      db.appendix.attlist, db.appendix.info, db.component.contentmodel
    }
}
div {
  db.chapter.status.attribute = db.status.attribute
  db.chapter.role.attribute = attribute role { text }
  db.chapter.attlist =
    db.chapter.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.label.attribute?
    & db.chapter.status.attribute?
  db.chapter.info = db._info.title.req
  db.chapter =
    
    ## A chapter, as of a book
    [
      s:pattern [
        name = "Root must have version"
        "\x{a}" ~
        "          "
        s:rule [
          context = "/db:chapter"
          "\x{a}" ~
          "            "
          s:assert [
            test = "@version"
            "The root element must have a version attribute."
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element chapter {
      db.chapter.attlist, db.chapter.info, db.component.contentmodel
    }
}
db.part.components =
  (db.navigation.components | db.components)
  | (db.refentry | db.reference)
  | db.xi.include
div {
  db.part.status.attribute = db.status.attribute
  db.part.role.attribute = attribute role { text }
  db.part.attlist =
    db.part.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.label.attribute?
    & db.part.status.attribute?
  db.part.info = db._info.title.req
  db.part =
    
    ## A division in a book
    [
      s:pattern [
        name = "Root must have version"
        "\x{a}" ~
        "          "
        s:rule [
          context = "/db:part"
          "\x{a}" ~
          "            "
          s:assert [
            test = "@version"
            "The root element must have a version attribute."
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element part {
      db.part.attlist, db.part.info, db.partintro?, db.part.components+
    }
}
div {
  db.preface.status.attribute = db.status.attribute
  db.preface.role.attribute = attribute role { text }
  db.preface.attlist =
    db.preface.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.label.attribute?
    & db.preface.status.attribute?
  db.preface.info = db._info.title.req
  db.preface =
    
    ## Introductory matter preceding the first chapter of a book
    [
      s:pattern [
        name = "Root must have version"
        "\x{a}" ~
        "          "
        s:rule [
          context = "/db:preface"
          "\x{a}" ~
          "            "
          s:assert [
            test = "@version"
            "The root element must have a version attribute."
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element preface {
      db.preface.attlist, db.preface.info, db.component.contentmodel
    }
}
div {
  db.partintro.status.attribute = db.status.attribute
  db.partintro.role.attribute = attribute role { text }
  db.partintro.attlist =
    db.partintro.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.label.attribute?
    & db.partintro.status.attribute?
  db.partintro.info = db._info
  db.partintro =
    
    ## An introduction to the contents of a part
    element partintro {
      db.partintro.attlist,
      db.partintro.info,
      db.toplevel.blocks.or.sections
    }
}
div {
  db.section.status.attribute = db.status.attribute
  db.section.role.attribute = attribute role { text }
  db.section.attlist =
    db.section.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.label.attribute?
    & db.section.status.attribute?
  db.section.info = db._info.title.req
  db.section =
    
    ## A recursive section
    [
      s:pattern [
        name = "Root must have version"
        "\x{a}" ~
        "          "
        s:rule [
          context = "/db:section"
          "\x{a}" ~
          "            "
          s:assert [
            test = "@version"
            "The root element must have a version attribute."
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element section {
      db.section.attlist,
      db.section.info,
      db.recursive.blocks.or.sections,
      db.navigation.components*
    }
}
div {
  db.simplesect.status.attribute = db.status.attribute
  db.simplesect.role.attribute = attribute role { text }
  db.simplesect.attlist =
    db.simplesect.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.label.attribute?
    & db.simplesect.status.attribute?
  db.simplesect.info = db._info.title.req
  db.simplesect =
    
    ## A section of a document with no subdivisions
    element simplesect {
      db.simplesect.attlist, db.simplesect.info, db.all.blocks+
    }
}
db.article.components = db.toplevel.sections
div {
  db.article.status.attribute = db.status.attribute
  db.article.class.enumeration =
    
    ## A collection of frequently asked questions.
    "faq"
    | 
      ## An article in a journal or other periodical.
      "journalarticle"
    | 
      ## A description of a product.
      "productsheet"
    | 
      ## A specification.
      "specification"
    | 
      ## A technical report.
      "techreport"
    | 
      ## A white paper.
      "whitepaper"
  db.article.class.attribute =
    
    ## Identifies the nature of the article
    attribute class { db.article.class.enumeration }
  db.article.role.attribute = attribute role { text }
  db.article.attlist =
    db.article.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.label.attribute?
    & db.article.status.attribute?
    & db.article.class.attribute?
  db.article.info = db._info.title.req
  db.article =
    
    ## An article
    [
      s:pattern [
        name = "Root must have version"
        "\x{a}" ~
        "          "
        s:rule [
          context = "/db:article"
          "\x{a}" ~
          "            "
          s:assert [
            test = "@version"
            "The root element must have a version attribute."
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element article {
      db.article.attlist,
      db.article.info,
      (db.navigation.components
       | db.appendix
       | db.acknowledgements
       | db.colophon)*,
      ((db.all.blocks+, db.article.components?)
       | db.article.components),
      (db.navigation.components
       | db.appendix
       | db.acknowledgements
       | db.colophon)*
    }
}
db.annotations.attribute =
  
  ## Identifies one or more annotations that apply to this element
  attribute annotations { text }
div {
  db.annotation.role.attribute = attribute role { text }
  db.annotation.annotates.attribute =
    
    ## Identifies one ore more elements to which this annotation applies
    attribute annotates { text }
  db.annotation.attlist =
    db.annotation.role.attribute?
    & db.annotation.annotates.attribute?
    & db.common.attributes
  db.annotation.info = db._info.title.only
  db.annotation =
    
    ## An annotation
    [
      s:pattern [
        name = "Element exclusion"
        "\x{a}" ~
        "          "
        s:rule [
          context = "db:annotation"
          "\x{a}" ~
          "            "
          s:assert [
            test = "not(.//db:annotation)"
            "annotation must not occur in the descendants of annotation"
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element annotation {
      db.annotation.attlist, db.annotation.info, db.all.blocks+
    }
}
db.xlink.from.attribute =
  
  ## Specifies the XLink traversal-from
  attribute xlink:from { xsd:NMTOKEN }?
db.xlink.label.attribute =
  
  ## Specifies the XLink label
  attribute xlink:label { xsd:NMTOKEN }?
db.xlink.to.attribute =
  
  ## Specifies the XLink traversal-to
  attribute xlink:to { xsd:NMTOKEN }?
div {
  db.extendedlink.role.attribute = attribute role { text }
  db.extendedlink.attlist =
    db.extendedlink.role.attribute?
    & db.common.attributes
    & 
      ## Identifies the XLink link type 
      [ a:defaultValue = "extended" ]
      attribute xlink:type {
        
        ## An XLink extended link
        "extended"
      }?
    & db.xlink.role.attribute?
    & db.xlink.title.attribute?
  db.extendedlink =
    
    ## An XLink extended link
    element extendedlink {
      db.extendedlink.attlist, (db.locator | db.arc)+
    }
}
div {
  db.locator.role.attribute = attribute role { text }
  db.locator.attlist =
    db.locator.role.attribute?
    & db.common.attributes
    & 
      ## Identifies the XLink link type 
      [ a:defaultValue = "locator" ]
      attribute xlink:type {
        
        ## An XLink locator link
        "locator"
      }?
    & db.xlink.href.attribute
    & db.xlink.role.attribute?
    & db.xlink.title.attribute?
    & db.xlink.label.attribute?
  db.locator =
    
    ## An XLink locator in an extendedlink
    element locator { db.locator.attlist, empty }
}
div {
  db.arc.role.attribute = attribute role { text }
  db.arc.attlist =
    db.arc.role.attribute?
    & db.common.attributes
    & 
      ## Identifies the XLink link type 
      [ a:defaultValue = "arc" ]
      attribute xlink:type {
        
        ## An XLink arc link
        "arc"
      }?
    & db.xlink.arcrole.attribute?
    & db.xlink.title.attribute?
    & db.xlink.show.attribute?
    & db.xlink.actuate.attribute?
    & db.xlink.from.attribute?
    & db.xlink.to.attribute?
  db.arc =
    
    ## An XLink arc in an extendedlink
    element arc { db.arc.attlist, empty }
}
db.sect1.sections =
  ((db.sect2+, db.simplesect*) | db.simplesect+)
  | (db.sect2 | db.xi.include)+
div {
  db.sect1.status.attribute = db.status.attribute
  db.sect1.role.attribute = attribute role { text }
  db.sect1.attlist =
    db.sect1.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.label.attribute?
    & db.sect1.status.attribute?
  db.sect1.info = db._info.title.req
  db.sect1 =
    
    ## A top-level section of document
    [
      s:pattern [
        name = "Root must have version"
        "\x{a}" ~
        "          "
        s:rule [
          context = "/db:sect1"
          "\x{a}" ~
          "            "
          s:assert [
            test = "@version"
            "The root element must have a version attribute."
          ]
          "\x{a}" ~
          "          "
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element sect1 {
      db.sect1.attlist,
      db.sect1.info,
      ((db.all.blocks+, db.sect1.sections